SynaLemma

Een redenering die u echt kunt controleren, omdat het model haar niet uitvoert.

Andere agentsystemen laten het taalmodel redeneren. SynaLemma is een semantische en redeneerlayer die andersom is opgebouwd: het model vertaalt uw vraag naar een regel, en een logische engine voert de redenering uit. De engine verifieert de regel formeel, leidt het antwoord af in de database die u al gebruikt en bewaart de regel, zodat elke stap kan worden gelezen en opnieuw uitgevoerd.

Architectuur

Het model doet een voorstel. De logische engine redeneert.

De meeste agentsystemen zetten het taalmodel in het midden en laten het zelf naar een antwoord redeneren. SynaLemma plaatst het aan de rand. Het model stelt een regel voor, en de engine voert elke join, recursie en optelling uit. Niets bereikt uw data of uw antwoord zonder via de engine te gaan.

De gebruikelijke opzet
  1. Uw vraag
  2. Taalmodel
  3. Geraden SQL
  4. Uw database
  5. Taalmodel
  6. Een plausibel antwoord
Het model redeneert in tekst. Zijn “uitleg” wordt achteraf geschreven en is geen verslag van hoe het antwoord is berekend, dus er valt niets opnieuw uit te voeren. Een log van de acties van de agent is een verslag, geen bewijs. Wat het onderzoek laat zien →
Buiten SynaLemma
Taalmodel Lokaal of gehost. Het stelt regels voor; de engine beslist.
Synalinks De agentStuurt het model stap voor stap aan en legt alles vast.
Synalog De logische engine
  • verifieert elke regel
  • voert de redenering uit
  • compileert de regel naar SQL
  • controleert het resultaat
Semantic Layers De kennisGeverifieerde regels, als bestanden in git.
Uw teams en agents De app, Slack of Teams, MCP en Agent2Agent.
Uw database Voert de SQL uit. Ter plaatse bevraagd.
Uw git-repository Geschiedenis, review, audit, herstel.
Taalmodel ⇄ Synalinks voorstel afgebakend verzoek
Synalinks ⇄ Synalog te verifiëren regel weigering met reden, of rijen
Synalog ⇄ Semantic Layers regel bewaard regel hergebruikt
Synalinks ⇄ Uw teams en agents het antwoord en de regel vraag
Synalog ⇄ Uw database geverifieerde SQL rijen
Semantic Layers ⇄ Uw git-repository elke wijziging is een commit

Het model vertaalt uw vraag naar een regel en formuleert het antwoord. Elke afleiding daartussen komt van de engine en kan opnieuw worden uitgevoerd.

  • Onderdeel van SynaLemma
  • Buiten, gekoppeld aan SynaLemma
  • Wat wordt doorgegeven, in de richting van de pijl
Logs en bewijzen

Een log is een verslag, geen bewijs.

De redenering die een taalmodel uitschrijft, is gewoon meer tekst die het heeft gegenereerd, en onderzoek laat steeds weer zien dat die kan verzwijgen wat het antwoord werkelijk heeft bepaald.

Het loggen van de acties van een agent heeft dezelfde grens: de log zegt welke tools zijn aangeroepen, niet of het antwoord klopt, en dezelfde vraag opnieuw stellen kan een ander pad volgen.

SynaLemma bewaart wel een log, maar alleen om fouten op te sporen. Het bewijs is de logische code: een Synalog-regel die de formele verificatie heeft doorstaan voordat hij werd uitgevoerd, die iedereen kan lezen, en die op dezelfde data opnieuw dezelfde rijen oplevert.

Wat het onderzoek laat zien

  1. Post-Hoc Reasoning in Chain of Thought: Decoding and Steering Pre-Committed Answers Cox et al., 2026 · preprint

    Het antwoord van het model valt al uit zijn interne toestand af te lezen voordat het een redenering schrijft, en wie die toestand verschuift, draait het antwoord vaak om: de redenering komt vaak na de beslissing.

  2. Two Regimes of Chain-of-Thought Unfaithfulness: Metric-Based Detection Fails Where Models Are Wrong Angdembay et al., 2026 · preprint

    Onbetrouwbare redeneringen gaan meestal samen met foute antwoorden, en juist daar doet geen enkele geteste detectiemethode het beter dan toeval.

  3. Reasoning Models Don't Always Say What They Think Chen et al., Anthropic, 2025

    Redeneermodellen gebruiken hints die ze hebben gekregen en zeggen dat vaak niet.

  4. From Agent Traces to Trust: A Survey of Evidence Tracing and Execution Provenance in LLM Agents Wang et al., 2026 · preprint

    Een log legt vast wat er gebeurde, maar laat niet per se zien of het bewijs een bewering ondersteunde: het zegt wat er gebeurde, niet wat waarvan afhing.

Opbouw

Drie engines en één product, allemaal door ons geschreven.

Elke layer heeft één taak en geeft de volgende layer iets wat die kan controleren. Drie ervan zijn open source; de vierde is het product dat ze samenbrengt.

Het product

  1. SynaLemma De harness

    Wat uw team gebruikt: Lemma, de assistent; tabellen, concepten en regels die u kunt lezen en bewerken; de graaf van wat waarvan afhangt; rollen, geschiedenis en de kanalen waarin u al communiceert.

Open source · Apache-2.0

  1. Synalinks De agent

    Stuurt het model stap voor stap aan: zoekt bestaande definities, splitst de vraag op, schrijft regels en roept tools aan. De output wordt aan een schema gehouden, het model kan worden vervangen en elke stap wordt vastgelegd.

  2. Synalog De logica

    Verifieert elke regel voordat er SQL bestaat, compileert hem naar het SQL-dialect van uw database en toetst aan uw data waaraan zijn resultaat moet voldoen.

  3. Semantic Layers De kennis

    Waar definities staan: één leesbaar bestand per tabel, concept of regel, in een git-repository. Een layer wordt gereviewd zoals code en kan in een ander project worden geïnstalleerd.

Buiten SynaLemma

  • Uw database tabellen ongewijzigd, echte namen, niets gekopieerd
  • Uw model lokaal of gehost, vervangbaar
  • Onderdeel van SynaLemma
  • Buiten, gekoppeld aan SynaLemma
Het product

Wat uw team ziet.

De cyclus

Wat er gebeurt tussen uw vraag en het antwoord.

  • Zoeken

    De agent zoekt in de layer naar een definitie die de vraag al beantwoordt. Een layer van duizenden definities gaat nooit in zijn geheel in de context van het model: alleen wat overeenkomt.

  • Schrijven

    Als er geen passende definitie is, schrijft de agent er een, voortbouwend op de concepten die er al zijn in plaats van te beginnen bij ruwe tabellen.

  • Verifiëren

    De regel gaat door de formele verifier. Als hij niet klopt, wordt hij geweigerd met de reden, en er wordt niets opgeslagen tenzij de hele layer nog consistent is.

  • Uitvoeren

    De geverifieerde regel wordt gecompileerd naar SQL en uitgevoerd in uw database. Zijn asserties worden op dezelfde data gecontroleerd.

  • Antwoorden

    Pas dan antwoordt de assistent, met de rijen die de uitvoering opleverde en een verwijzing naar de regel, die u kunt openen.

  • Bewaren

    De regel wordt in de layer gecommit met auteur en datum. De volgende vraag gaat ervan uit.

Geverifieerd met logica

Twee controles. Geen van beide wordt door een model gedaan.

Een tweede model vragen het eerste te controleren voegt alleen een extra mening toe. SynaLemma controleert in plaats daarvan met logica. Het is het eerste en enige AI-systeem dat zijn eigen regels schrijft, ze formeel verifieert en hun resultaten toetst aan wiskundige uitspraken.

De definitie, voordat ze draait

De formele verifier van Synalog onderzoekt elke regel voordat er SQL wordt gegenereerd, zonder dat er een database aan te pas komt: variabelen die nooit worden gebonden, onveilige negatie en aggregatie, negatie door recursie heen, recursie zonder basisgeval of grens, onbekende kolommen, functies en predicaten. Meer dan vijftien klassen fouten, allemaal tegelijk gerapporteerd. Een regel die niet klopt, wordt nooit opgeslagen en nooit uitgevoerd.

Het resultaat, getoetst aan uw data

Een assertie legt vast waaraan een resultaat moet voldoen, los van hoe het wordt berekend: een onderdeel komt één keer voor, een voorraad is nooit negatief, te late leveringen zijn nooit meer dan het aantal leveringen. Ze wordt geschreven in eerste-ordelogica (∀, ∃, →, sommen en vergelijkingen) als Lean-propositie, de notatie van de stellingbewijzer Lean. Synalog compileert een zoektocht naar tegenvoorbeelden naar SQL en voert die uit op uw database. In SynaLemma verschijnt een geschonden assertie bij de regel, met de rijen die haar schenden één klik verderop.

Een geschonden assertie noemt wat haar schendt: hier twee leveranciers onder het afgesproken serviceniveau
counterexamples
✗ OnTimeDelivery.meets_service_level is violated:
  ∀ s r d t, OnTimeDelivery s r d t → t ≥ 0.6
  2 counterexamples:
+-------------------+------+----+-------+
| s                 | r    | d  | t     |
+-------------------+------+----+-------+
| Shenzhen VoltPack | high | 34 | 0.588 |
| Hsinchu Controls  | high | 47 | 0.553 |
+-------------------+------+----+-------+
Deterministisch

Zelfde regel, zelfde SQL.

Vraag een taalmodel twee keer om dezelfde query en de SQL kan verschillen. In SynaLemma schrijft het model nooit SQL: de engine compileert die uit een regel. Zodra een definitie bestaat, krijgt elke vraag die haar gebruikt dezelfde query, wie de vraag ook stelt.

01

Gecompileerd, niet gegenereerd

Synalog compileert elke regel naar het SQL-dialect van uw database. Dezelfde regel geeft bij elke uitvoering dezelfde query, in elk kanaal, voor iedereen, mens of agent.

02

Hergebruikt voordat er geschreven wordt

De agent doorzoekt de layer voordat hij iets schrijft. Een vraag die een bestaande definitie dekt, wordt door die definitie beantwoord, niet door een nieuwe poging.

03

Vergrendeld zodra vastgesteld

Is uw team het eens over een definitie, vergrendel haar dan: geen agent kan haar nog wijzigen. Speel elk antwoord opnieuw af vanuit zijn regel en krijg dezelfde rijen uit dezelfde data.

Wat kan variëren: hoe de assistent het antwoord verwoordt, en de regel die hij voorstelt voor een vraag die nog geen definitie dekt. Die regel wordt geverifieerd en aan u getoond, en eenmaal bewaard ligt hij vast.

Beheerd

Elke toegang afgebakend, elke wijziging vastgelegd.

Een AI auditen betekent meestal logs lezen van wat een model zei. In SynaLemma audit u twee exacte registraties: de afleiding, gemaakt door de logische engine, en de geschiedenis van de regels, bijgehouden in git, de tool die softwareteams al gebruiken om elke wijziging te volgen. En niemand, mens of agent, bereikt uw data anders dan via die regels, met de rechten van zijn rol.

01

Van het antwoord naar de rijen

Elk cijfer verwijst naar zijn regel en naar de rij waar het vandaan komt. Elke regel noemt de concepten waarop hij voortbouwt, en elk concept de tabellen die het leest. Volg de keten, of voer elke schakel opnieuw uit.

02

Van de regel naar zijn geschiedenis

Een semantische en redeneerlayer is een git-repository: één bestand per tabel, concept en regel. Elke wijziging is een commit die aan de auteur wordt toegeschreven, of dat nu een persoon, Lemma of een andere agent is, met het verschil en een weg terug.

03

Afgebakend, en gereviewd zoals code

Vier rollen en rechten per persoon, en Lemma krijgt alleen de tools van wie de vraag stelt. Wat was deze definitie op de dag dat dat cijfer werd gerapporteerd? Wie heeft haar gewijzigd, en wanneer? Vergelijk twee versies, herstel er een, of laat een wijziging door dezelfde review gaan als alle andere code.

De geschiedenis legt uw definities vast en hoe die veranderden, niet uw data: de rijen blijven in uw database.

Uw bestaande systemen

Werkt op de systemen die u al gebruikt.

Een klassieke semantische layer is een modelleringsproject dat maanden duurt en kort na oplevering al verouderd is. SynaLemma schrijft de layer terwijl er vragen worden gesteld, bovenop uw bestaande databases.

Geen ETL, geen tweede datawarehouse

Regels worden gecompileerd naar SQL en draaien waar de data staat. Op een database die u beheert, declareert SynaLemma de tabellen die u kiest en wijzigt die nooit. Een account met alleen leesrechten volstaat.

Tabellen zoals ze zijn

Oude schema's houden hun echte tabel- en kolomnamen, inclusief spaties en accenten. De layer geeft ze een betekenis zonder ze aan te raken.

Een kennisgraaf, zonder grafendatabase

Entiteiten en relaties worden gemodelleerd over uw relationele tabellen. De graaf is virtueel: hij wordt gecompileerd naar SQL.

Vragen die in SQL lastig zijn

Stuklijsten over alle niveaus, rapportagelijnen, “welke assemblages vallen stil als deze leverancier uitvalt”: recursie tot een diepte die u vastlegt, zodat ze altijd eindigt, en redeneren in de tijd.

Databases waarmee SynaLemma verbinding maakt
  • PostgreSQL
  • BigQuery
  • Databricks
  • Trino
  • Presto
  • DuckDB
  • SQLite

En uw bestanden: CSV, Excel, JSON, JSONL, Parquet.

In het product

Alles wat uw team krijgt.

De layer is van u. Alles wat de assistent schrijft, kan door een persoon worden gelezen, gecorrigeerd en vergrendeld.

Lemma, de assistent

Vragen

  • Elk cijfer met een klikbare bronvermelding, tot aan de rij waar het vandaan komt.
  • U volgt haar werk stap voor stap: wat zij zocht, schreef en uitvoerde.
  • Voorgestelde vragen op basis van uw eigen layer.
  • Spraakberichten, getranscribeerd op uw server.
  • Zij doet eerst een voorstel voordat zij een open verzoek uitvoert, en vraagt door wanneer een vraag dubbelzinnig is.
  • “Uitleggen” en “Corrigeren” bij elke regel, met één klik.
Tabellen

Uw data

  • Importeer CSV-, Excel-, JSON-, JSONL-, Parquet- en SQLite-bestanden met slepen en neerzetten.
  • Koppel een database en kies welke tabellen u beschikbaar stelt.
  • Kopieer in één keer tabellen uit een andere database, zonder iets naar de bron te schrijven.
  • Een spreadsheeteditor met getypeerde kolommen, sorteren, zoeken, ongedaan maken en opnieuw uitvoeren.
  • Exporteer elke tabel of elk resultaat naar CSV of Excel.
  • Vergrendel de rijen van een tabel, of bescherm de structuur.
Concepten, regels, geheugen

Uw kennis

  • Elke regel als stroomdiagram voor wie geen code leest, en als code voor wie dat wel doet.
  • Bewerk een regel ter plaatse: hij wordt bij het opslaan geverifieerd, en bij een weigering staat de reden erbij.
  • Gevalideerd, niet gevalideerd, vergrendeld: de status van elke definitie is zichtbaar.
  • Geheugen: de graaf van wat waarvan afhangt, over tabellen, concepten en regels heen.
  • Asserties met hun status, en de rijen die ze schenden.
  • Geschiedenis met verschillen, en herstel naar elke versie.
Herbruikbare kennis

Layers

  • Installeer een kant-en-klare layer vanuit een git-repository of een zip. Er wordt niets bewaard tenzij het tegen uw database verifieert.
  • Werk in meerdere layers tegelijk.
  • Exporteer een layer als gewone bestanden: geen verbinding, geen geheimen, geen rijen.
  • Een layer is een map die draait met de open-source tooling van Synalog, met of zonder ons.
Buiten de app

Agents en automatisering

  • Een MCP-server geeft Claude Code, Codex, Cursor, VS Code Copilot of Windsurf dezelfde tools die Lemma gebruikt.
  • Een Agent2Agent-endpoint laat een andere agent Lemma rechtstreeks bevragen.
  • Slack, Microsoft Teams, Discord, Telegram of WhatsApp, via een bot die van u is.
  • Loops: dezelfde vraag volgens een schema, zoals een tekortenoverzicht op maandag of een dagelijkse kwaliteitscontrole, gepost in een chat.
  • Een plug-in-SDK om uw eigen pagina's en functies toe te voegen.
Controle

Beheer

  • Vier rollen (beheerder, editor, analist, lezer) en rechten per persoon. Lemma krijgt alleen de tools die de rol van de vraagsteller toestaat.
  • Organisaties, elk met eigen opslag.
  • Kies het model uit een catalogus, test de verbinding, wissel wanneer u wilt. Lokale modellen: geen API-sleutel, geen kosten per token.
  • Elke agentstap, toolaanroep en modelaanroep vastgelegd, aan uw kant.
  • Inloggegevens en tokens versleuteld opgeslagen.
  • Interface in het Engels, Frans, Nederlands, Italiaans en Spaans.
Soevereiniteit

Soeverein door ontwerp, niet door contract.

De meeste beloften van soevereiniteit gaan over een hostinglocatie. Die van SynaLemma gaat over de architectuur: de layer is zo gebouwd dat een klein open model volstaat, zodat het hele systeem, van het model tot de definities, binnen uw eigen muren draait. Kiest u toch een gehost model, dan gaan uw vragen en de data-uittreksels die nodig zijn om ze te beantwoorden naar die provider, en nergens anders heen.

Uw model

Een open model op uw eigen hardware (Ollama, vLLM, LM Studio). Het model stelt alleen regels voor: de engine redeneert, een weigering zegt precies wat er moet worden verbeterd en de context blijft klein, dus een klein model volstaat. Algemene agentharnassen zijn afgestemd op de grootste propriëtaire modellen.

Uw gegevens

Ter plekke bevraagd, via een account dat alleen hoeft te lezen: geen kopie, geen pipeline, geen cloud ertussen. Inloggegevens worden versleuteld opgeslagen en spraakberichten worden op uw server getranscribeerd.

Uw regels

Gewone bestanden in een open taal, in uw eigen git-repository. Ze draaien ook met alleen de opensourcetools: stopt u met ons, dan blijven uw definities bij u.

Uw basis

Engines gepubliceerd onder Apache-2.0, geschreven door een team in de Europese Unie, en door gecertificeerde partners op uw infrastructuur geïmplementeerd.

Vergelijkingen

Wat SynaLemma onderscheidt van de alternatieven.

Ook andere projecten geven data een semantische layer. Het verschil zit in wat die layer kan uitdrukken, en in wat hem controleert.

Hoe verhouden SynaLemma en Synalog zich tot NVIDIA Auto-Ontology?

Beide plaatsen een semantische layer tussen AI-agents en uw databases. Ze verschillen in wat die layer is en in wat hem controleert.

In Auto-Ontology is de layer een woordenlijst van termen, kolomkoppelingen en SQL-fragmenten die in een database zijn opgeslagen. Op het moment van de vraag wordt hij opgehaald en als richtlijn aan een taalmodel gegeven, en het model schrijft voor elk antwoord nieuwe SQL. Een tweede aanroep van het model beoordeelt daarna of die SQL klopt. Een probabilistisch systeem dat een ander controleert, biedt geen garantie: beide kunnen op dezelfde manier fout zitten.

In SynaLemma is de layer een Synalog-programma: concepten en regels die deterministisch naar SQL compileren. De controle gebeurt door een symbolisch systeem, niet door een model. Voordat er SQL wordt uitgevoerd, bewijst de verifier dat elke regel welgevormd en veilig is en eindigt, en weigert hij elke regel die dat niet is. Asserties in eerste-orde logica worden op uw data gecontroleerd, en een assertie die faalt, komt terug met haar tegenvoorbeelden. Dezelfde regel compileert altijd naar dezelfde query, en elk antwoord is via benoemde regels terug te volgen tot uw tabellen.

Synalog kan ook uitdrukken wat een lijst SQL-fragmenten niet kan: regels die op andere regels voortbouwen, recursie (hiërarchieën, ketens over meerdere stappen), relaties tussen concepten en redeneren over tijd. Juist die strengheid maakt verificatie zinvol: een losjes getypeerd YAML-bestand heeft te weinig structuur om met een bewijs iets te zeggen.

Synalog is een echte programmeertaal en vraagt meer leerwerk dan een YAML-bestand. U hoeft het niet zelf te schrijven: het analyse-harness van SynaLemma schrijft en onderhoudt de regels, en de verifier controleert dat werk voordat het uw data bereikt. Wij hebben dat harness zelf geoptimaliseerd, met machine learning en ons opensourceframework Synalinks, zodat de analist draait op lokale modellen op uw eigen hardware, zonder kosten per token. Zonder een harness dat zo is afgestemd, vallen teams terug op frontiermodellen en betalen ze voor elke vraag. En omdat antwoorden uit gecompileerde regels komen in plaats van uit SQL die per vraag wordt gegenereerd, komt een kleiner model verder.

Lees de volledige vergelijking

Hoe verhouden SynaLemma en Synalog zich tot Apache Ossie?

Ze lossen verschillende problemen op. Ossie is een bestandsformaat: een leveranciersneutrale YAML-specificatie, in incubatie bij de Apache Software Foundation, om datasets, metrics en joins uit te wisselen tussen BI- en analysetools. Het voert geen query's uit. Elke tool die een Ossie-bestand leest, bepaalt zelf hoe het in SQL wordt omgezet, en de SQL voor elke database wordt met de hand in het bestand geschreven.

Synalog is een taal met een compiler. Eén programma compileert naar SQL voor PostgreSQL, BigQuery, Databricks, Trino, Presto, DuckDB en SQLite, en dezelfde regel compileert altijd naar dezelfde query.

Het verschil zit in wat elk kan uitdrukken. In de kernspecificatie van Ossie (een conceptspecificatie voor ontologieën voegt afgeleide concepten en recursieve relaties toe) kan een metric niet naar een andere metric verwijzen, een veld niet naar een ander veld, kan een dataset niet op een andere dataset voortbouwen, en is elke relatie een veel-op-een foreign key. Tijd is een vlag op een kolom. In Synalog bouwen regels voort op andere regels, zodat definities zich opstapelen in plaats van herhaald te worden. Het kan ook recursie aan (hiërarchieën, ketens over meerdere stappen), relaties tussen concepten en redeneren over tijd.

Het zit ook in wat er gecontroleerd kan worden. Een Ossie-bestand kan worden gevalideerd tegen zijn schema en zijn verwijzingen. Een Synalog-programma wordt gecontroleerd door een symbolische verifier, die voordat er SQL wordt uitgevoerd bewijst dat elke regel welgevormd en veilig is en eindigt. Asserties in eerste-orde logica worden op uw data gecontroleerd, met tegenvoorbeelden wanneer ze falen. Voor agents biedt Ossie hints in vrije tekst (ai_context) die een model kan lezen. De analist van SynaLemma schrijft Synalog-regels, en de verifier controleert ze voordat ze uw data raken.

SynaLemma is er voor definities die door agents moeten worden berekend, geverifieerd en uitgebreid, niet alleen uitgewisseld tussen tools.

Lees de volledige vergelijking

Hoe verhouden SynaLemma en Synalog zich tot semantic web-tools (RDF, OWL, SHACL)?

Beide beschrijven wat data betekent met concepten en relaties, en beide redeneren erover. Ze zijn gebouwd voor verschillende taken. Het semantic web beschrijft een domein zodat ontologieën kunnen worden gepubliceerd, gedeeld en tussen organisaties gekoppeld. Synalog beschrijft operationele ontologieën: alleen de concepten en relaties die uw data werkelijk bevat, elk gedefinieerd vanuit uw tabellen en daaruit berekend.

Dat verandert de logica. OWL werkt onder een open-wereldaanname: een feit dat in de graaf ontbreekt, is onbekend, niet onwaar, dus OWL alleen kan niet controleren dat elke bestelling een klant heeft. SHACL bestaat om dat gat te vullen, als tweede taal die de data valideert. Synalog is gesloten-wereld, zoals uw database: wat niet in de data staat, is onwaar. Regels, query's en beperkingen worden in één taal geschreven, en asserties controleren uw data rechtstreeks, met tegenvoorbeelden wanneer ze falen.

Het verandert ook de stack. Een semantic web-implementatie combineert meestal RDF voor de data, OWL voor de ontologie, SHACL voor validatie en SPARQL voor query's, plus een triplestore of een mappingtaal zoals R2RML om relationele tabellen te bereiken. Synalog is één taal die naar SQL compileert en draait op de databases die u al hebt.

Eenvoudiger betekent niet minder redeneren. Eén Synalog-programma kan recursie, aggregatie, negatie en redeneren over tijd combineren, en een symbolische verifier bewijst voordat het draait dat elke regel welgevormd en veilig is en eindigt. OWL-reasoners classificeren concepten; ze berekenen niet de totalen, gemiddelden en rangschikkingen die de meeste zakelijke vragen nodig hebben.

Synalog is ook gebouwd voor agents. De programma's zijn kort genoeg om door een model te worden geschreven en leesbaar genoeg om door een mens te worden nagekeken, en de analist van SynaLemma schrijft ze terwijl de vragen binnenkomen, elk gecontroleerd door de verifier voordat het uw data raakt. Semantic web-ontologieën worden meestal vooraf gemodelleerd, door specialisten: een project dat vaak maanden, niet zelden jaren, en een flink budget kost voordat de eerste vraag is beantwoord. Met SynaLemma groeit de layer vanaf de eerste vraag.

SynaLemma beantwoordt vragen over uw eigen data, met antwoorden die u kunt verifiëren, zonder voorafgaand modelleringsproject.

Lees de volledige vergelijking

Hoe verhouden SynaLemma en Synalog zich tot Cube?

Cube is een semantische layer en API, in YAML of JavaScript: cubes, views, measures, dimensies en joins, met caching en pre-aggregaties op veel databases. Net als Synalog compileert het query's vanuit zijn model voordat ze het datawarehouse bereiken, dus daar zit het verschil niet. Het zit in wat het model kan uitdrukken, en in wat het controleert.

In Cube is elke join een LEFT JOIN, en hiërarchieën zijn niveaus om in te zoomen, geen recursie. Rapportagelijnen, stuklijsten of afhankelijkheden over meerdere stappen passen niet in het model: daarvoor is een met de hand geschreven recursieve SQL-query nodig, zo moeilijk om goed te krijgen dat bijna niemand hem schrijft. In Synalog is graaftraversal onderdeel van de taal: een basisgeval en een recursieve stap, waarvan is geverifieerd dat ze eindigen, en die op elke engine draaien.

Cube controleert dat een model compileert, en de eigen documentatie waarschuwt dat een model dat compileert toch foute resultaten kan opleveren. De antwoorden van de agent worden gemeten met evaluaties tegen referentiequery's. Synalog bewijst dat elke regel welgevormd en veilig is en eindigt, en controleert de data met asserties in logica, met tegenvoorbeelden wanneer ze falen.

De AI-agent van Cube is onderdeel van Cube Cloud en schrijft Cube SQL op basis van uw vraag, standaard met gehoste modellen; een eigen model gebruiken is een optie van het Enterprise-abonnement. De analist van SynaLemma draait op een klein open model, op uw eigen infrastructuur.

SynaLemma is gebouwd voor de vragen die een dashboard-API met caching niet kan beantwoorden: de vragen die redeneren vereisen, met antwoorden die u kunt verifiëren.

Lees de volledige vergelijking

Hoe verhouden SynaLemma en Synalog zich tot de dbt Semantic Layer?

De dbt Semantic Layer, gebouwd op MetricFlow, definieert metrics in YAML bovenop dbt-modellen en compileert metric-query's naar SQL. De verschillen zitten in de uitdrukkingskracht, in de controles en in wat een agent kan bereiken.

MetricFlow biedt een vaste set metrictypen (simple, ratio, derived, cumulative, conversion), zonder eigen aggregaties, en joins van hooguit twee stappen. Recursie is er niet. In Synalog bouwen regels voort op andere regels zonder vaste catalogus, gaan joins zo ver als de vraag vereist, en is graaftraversal onderdeel van de taal, met geverifieerde beëindiging.

dbt valideert dat de semantische configuratie consistent is en dat de gegenereerde SQL draait, en dbt-tests kunnen tabellen controleren op sleutels, nullwaarden en verwijzingen. Synalog bewijst dat elke regel welgevormd en veilig is en eindigt voordat hij draait, en de asserties, in logica geschreven in een andere notatie dan de regels, gelden voor elke regel, ook recursieve en afgeleide: transitiviteit, totalen, geldigheidsperiodes.

De MCP-server van dbt geeft agents beheerde metric-query's, maar ook text-to-SQL en SQL-uitvoering die schrijfopdrachten niet blokkeert. De analist van SynaLemma heeft één weg naar uw data: via de geverifieerde layer, en een account met alleen leesrechten volstaat. De API's van de Semantic Layer vereisen bovendien een betaald abonnement op het dbt-platform; SynaLemma draait op uw infrastructuur met een klein open model.

SynaLemma gaat verder dan metrics opvragen: het redeneert over uw data, met antwoorden die u kunt verifiëren.

Lees de volledige vergelijking

Kortom. Elke regel wordt formeel geverifieerd voordat hij draait, en uw data wordt gecontroleerd met asserties in logica, met tegenvoorbeelden wanneer ze falen. Graafvragen hebben geen grafendatabase nodig: traversal, recursie en ketens over meerdere stappen maken deel uit van de taal, en compileren naar SQL op de databases die u al hebt. En omdat de SQL door de engine wordt gecompileerd, niet door een taalmodel gegenereerd, volstaat een klein open model, zodat het hele systeem op uw eigen infrastructuur draait.

Alle vergelijkingen, ook met Looker →

Veelgestelde vragen

Wat ons als eerste wordt gevraagd.

We hebben geen eigen AI-expertise. Is dat een probleem?

Nee. SynaLemma wordt geïmplementeerd door gecertificeerde partners: integrators en adviesbureaus waarvan de engineers naast uw team werken om het te installeren, uw data te koppelen, en uw definities met uw experts te schrijven en te verifiëren. Uw eigen team kan ook gecertificeerd worden.

Redeneert het model niet toch wanneer het de regel schrijft?

Het beslist wat het aan de engine vraagt: welke concepten het combineert, en hoe. Die beslissing wordt vastgelegd als een regel die u kunt lezen, en de engine, niet het model, leidt er elke rij uit af. Als de beslissing fout is, zit de fout op een plek die u kunt zien, één keer kunt corrigeren en kunt vergrendelen.

Is SynaLemma open source?

De drie engines waarop het is gebouwd (Synalinks, Synalog, Semantic Layers) zijn open source onder Apache-2.0. SynaLemma zelf, het product dat ze samenbrengt, is propriëtair en wordt verkocht onder een commerciële licentie. Uw regels zijn bestanden in het open formaat, dus ze zitten nooit vast.

Met welke databases werkt het?

PostgreSQL, BigQuery, Databricks, Trino, Presto, DuckDB en SQLite, ter plaatse bevraagd: uw tabellen blijven waar ze zijn. En bestanden: CSV, Excel, JSON, JSONL en Parquet. Eén regel wordt gecompileerd naar het SQL-dialect van de engine waarop hij draait.

Welke taalmodellen?

Elk model dat tool calling ondersteunt, gekozen uit een catalogus in de instellingen: open modellen die lokaal draaien via Ollama, vLLM of LM Studio, of gehoste providers zoals Mistral, Anthropic, OpenAI of Google. Een ander model verandert de regels niet. Alles behalve het gesprek zelf werkt ook zonder model.

Wat als het model een verkeerde regel schrijft?

Een structureel verkeerde regel wordt door de verifier geweigerd. Een regel die een assertie tegenspreekt, wordt gemarkeerd met de rijen die haar schenden. En omdat de regel leesbaar is, kan de persoon die verantwoordelijk is voor het cijfer hem zien en corrigeren. Dat kan niet wanneer het antwoord een alinea proza is.

Vervangt het onze dashboards?

Nee. SynaLemma tekent geen grafieken: antwoorden zijn cijfers, tabellen en de regels erachter. Het geeft de definities achter uw dashboards één vaste plek, en laat mensen en agents er vragen over stellen in gewone taal.

Zie het in actie

Neem een vraag mee waarover uw teams het oneens zijn.

In een gratis demo van dertig minuten tonen wij u het antwoord van SynaLemma en de regel die het gebruikte.