Andere agentsystemen laten het taalmodel redeneren. SynaLemma is een harness 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.
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.
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.
Het model vertaalt uw vraag naar een regel en formuleert het antwoord. Elke afleiding daartussen komt van de engine en kan opnieuw worden uitgevoerd.
Elke laag heeft één taak en geeft de volgende laag iets wat die kan controleren. Drie ervan zijn open source; de vierde is het product dat ze samenbrengt.
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.
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.
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.
Waar definities staan: één leesbaar bestand per tabel, concept of regel, in een git-repository. Een laag wordt gereviewd zoals code en kan in een ander project worden geïnstalleerd.
Uw model · lokaal of gehost, vervangbaar
De agent zoekt in de laag naar een definitie die de vraag al beantwoordt. Een laag van duizenden definities gaat nooit in zijn geheel in de context van het model: alleen wat overeenkomt.
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.
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 laag nog consistent is.
De geverifieerde regel wordt gecompileerd naar SQL en uitgevoerd in uw database. Zijn asserties worden op dezelfde data gecontroleerd.
Pas dan antwoordt de assistent, met de rijen die de uitvoering opleverde en een verwijzing naar de regel, die u kunt openen.
De regel wordt in de laag gecommit met auteur en datum. De volgende vraag gaat ervan uit.
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 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.
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.
✗ 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 |
+-------------------+------+----+-------+
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.
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.
Een semantische laag 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.
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.
Een klassieke semantische laag is een modelleringsproject dat maanden duurt en kort na oplevering al verouderd is. SynaLemma schrijft de laag terwijl er vragen worden gesteld, bovenop uw bestaande databases.
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.
Oude schema's houden hun echte tabel- en kolomnamen, inclusief spaties en accenten. De laag geeft ze een betekenis zonder ze aan te raken.
Entiteiten en relaties worden gemodelleerd over uw relationele tabellen. De graaf is virtueel: hij wordt gecompileerd naar SQL.
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.
En uw bestanden: CSV, Excel, JSON, JSONL, Parquet.
De laag is van u. Alles wat de assistent schrijft, kan door een persoon worden gelezen, gecorrigeerd en vergrendeld.
SynaLemma wordt geïmplementeerd op uw infrastructuur. Met een lokaal model verlaat er niets uw omgeving. Met een gehost model gaan uw vragen en de data-uittreksels die nodig zijn om ze te beantwoorden naar de provider die u hebt gekozen, en nergens anders heen.
Open modellen op uw eigen hardware (Ollama, vLLM, LM Studio) of de provider waarmee u al een contract hebt. De regels zijn er niet van afhankelijk.
Ter plaatse bevraagd, via een account dat alleen leesrechten nodig heeft. Database-inloggegevens worden versleuteld opgeslagen. Spraakberichten die in de app worden opgenomen, worden op uw server getranscribeerd.
Gewone bestanden in een open taal, op engines die onder Apache-2.0 zijn gepubliceerd. Ze draaien ook met alleen de open-source tooling.
Nee. SynaLemma wordt geleverd met een of meer toegewezen forward-deployed engineers, afhankelijk van de omvang van uw project, uit het team dat het bouwt. Zij werken samen met uw team om het te implementeren, uw data te verwerken en uw definities met uw experts te schrijven en te verifiëren.
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.
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.
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.
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.
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.
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.
In een gratis demo van dertig minuten tonen wij u het antwoord van SynaLemma en de regel die het gebruikte.
