Echt controleerbare redenering

Uw AI maakt indruk in de demo.
Niemand kan zeggen of het antwoord klopt.

De meeste agentsystemen laten het taalmodel redeneren en vragen u het resultaat te vertrouwen. SynaLemma geeft die taak aan een logische engine. Het model schrijft een regel; de engine verifieert die, berekent het antwoord in uw eigen database en toont u elke stap.

Gebouwd door SynaLinks, een team van AI-engineers opgeleid bij het CNRS, dat elke laag zelf heeft geschreven, van de logische engine tot de agent.

SynaLemma factory

Welke eindproducten liggen stil als Shenzhen VoltPack uitvalt?

Alle vier: Urban S1, Cargo C2, Trekking T3 en Folding F1. Elke fiets heeft een van de twee accupacks nodig, en beide packs gebruiken het managementbord en de behuizing die VoltPack levert.

@SupplierExposure ✓ gevalideerd
## De assemblages die stilvallen als een leverancier uitvalt,
## over alle niveaus van de stuklijst.
@OrderBy(SupplierExposure, "supplier_id", "assembly_id");
SupplierExposure(supplier_id:, assembly_id:) distinct :-
  Supplies(supplier_id:, part_id: component),
  Requires(assembly_id:, component_id: component);
  • geverifieerd voordat hij werd opgeslagen
  • uitgevoerd op Suppliers, Parts, BillOfMaterials
Voorbeelddata van een fictieve fabriek. De regel is echte Synalog.
Team gevestigd in de Europese Unie
Draait op uw servers, met het model van uw keuze
Gebouwd op onze open-source engines onder Apache-2.0
Het probleem

Stel drie AI-agents dezelfde vraag en u krijgt drie verschillende cijfers.

Neem een eenvoudige vraag: hoeveel voorraad van een component is beschikbaar? Elke agent schrijft geldige SQL en geeft een ander cijfer terug, omdat elke agent moest raden wat “beschikbaar” betekent. Telt gereserveerde voorraad mee? En inkomende bestellingen? Welke locatie, en op welke datum? Uw fabriek heeft die punten jaren geleden vastgelegd, maar de agent heeft geen toegang tot die antwoorden.

Er gaat niets zichtbaar mis. De agent geeft zijn cijfer met volle overtuiging, iemand neemt er een beslissing op, en niemand kan nagaan hoe het is berekend. Dit is de belangrijkste reden waarom AI-projecten blijven steken tussen demo en productie. Een groter model heeft hetzelfde probleem, omdat het dezelfde definities raadt.

AgentBeschouwt als beschikbare voorraad…Antwoord
Eerstewat op voorraad ligt1.240
Tweedeop voorraad, min wat gereserveerd is voor werkorders870
Derdeop voorraad min gereserveerd, plus nog niet ontvangen inkooporders2.070
Illustratief voorbeeld: één vraag, drie plausibele queries.

De agents hebben uw definities nodig, één keer vastgelegd in een vorm die een machine moet toepassen en een mens kan controleren. SynaLemma bouwt die laag en houdt haar actueel.

BestandenSQL-databaseSpreadsheetsBedrijfskennis
Uw data, waar ze staan
SynaLemma
  1. Een definitie zoeken
  2. De regel schrijven
  3. Hem verifiëren
  4. Hem uitvoeren op uw tabellen
  5. Antwoorden met bronvermelding
Een verdedigbaar antwoord
  • Het cijfer
  • De geciteerde regel
  • Leesbaar voor uw team
  • Herbruikbaar
En de regel blijft
Wat er verandert

Bij andere agents redeneert het model. Hier doet de logische engine dat.

Wanneer een agent “zijn redenering uitlegt”, leest u tekst die het model achteraf heeft gegenereerd. Die tekst is geen verslag van hoe het antwoord is berekend, dus een audit ervan zegt u weinig. In SynaLemma vertaalt het model uw vraag naar een regel, en een logische engine berekent het antwoord uit die regel in stappen die u opnieuw kunt uitvoeren.

Agentsystemen die het model laten redeneren SynaLemma
Wie redeneert Het taalmodel, in tekst die niemand opnieuw kan uitvoeren Een logische engine, op basis van regels die u kunt lezen en opnieuw uitvoeren
Het auditspoor Een transcript van wat het model zegt dat het deed Een keten van benoemde regels, tot aan de bronrijen
Verbanden tussen tabellen Joins die bij elke vraag opnieuw met de hand worden geschreven Een kennisgraaf afgeleid uit uw tabellen, zonder grafendatabase
Hoe een definitie veranderde Niemand weet wat de prompt vorig kwartaal was Elke wijziging is een git-commit met auteur en datum, en kan worden teruggedraaid
Wat een kengetal betekent Bij elke vraag opnieuw geraden Eén keer vastgelegd als benoemde regel, door iedereen hergebruikt
Voordat het antwoordt Er wordt niets gecontroleerd De regel wordt formeel geverifieerd en daarna op uw echte tabellen uitgevoerd
Als het fout is Een verkeerd cijfer, zonder waarschuwing De regel wordt geweigerd met de reden, of een assertie toont de rijen die haar schenden
Twee keer dezelfde vraag Twee antwoorden die kunnen verschillen Zodra de regel bestaat, hetzelfde resultaat, welk model er ook is aangesloten
Uw bestaande systemen Een nieuwe pipeline en een kopie van de data Draait op de databases die u al hebt, ter plaatse bevraagd
De honderdste vraag Dezelfde redenering, opnieuw betaald in tokens Een regel die al bestaat, uitgevoerd als SQL
Wat u krijgt

Wat de architectuur u oplevert.

01 · Vertrouwen

Antwoorden berekend op uw data.

Elke regel draait op uw echte tabellen voordat de assistent antwoordt.

Het antwoord citeert de rijen die de uitvoering opleverde, dus niets komt uit het geheugen van het model. SynaLemma draait op uw servers met het model van uw keuze, en de assistent blijft binnen wat de rol van de vraagsteller toestaat.

02 · Controleerbare redenering

Een redenering die u opnieuw kunt uitvoeren.

De logische engine maakt elke afleiding, en elke afleiding kan opnieuw worden uitgevoerd.

Elk antwoord citeert zijn regels, tot aan de rij waar een cijfer vandaan komt. Uw team kan een regel openen, lezen, opnieuw uitvoeren, aanpassen of vergrendelen. De regels zijn bestanden in een git-repository, dus elke wijziging is een commit die vastlegt wie haar maakte (een persoon of de assistent), wat er veranderde en wanneer.

03 · Robuustheid

Formeel geverifieerd voordat het draait.

Het eerste en enige AI-systeem dat zijn eigen regels schrijft, ze formeel verifieert en hun resultaten toetst aan wiskundige uitspraken.

Elke regel gaat door een formele verifier voordat er SQL bestaat, en meer dan vijftien klassen fouten worden geweigerd met de reden erbij. Daarna legt u in eerste-ordelogica vast waaraan een resultaat altijd moet voldoen, en de engine zoekt in uw data naar tegenvoorbeelden. Als een regel verandert, wordt alles wat erop voortbouwt gemarkeerd totdat het opnieuw is uitgevoerd. Als u van model wisselt, blijven de regels zoals ze zijn.

04 · Kosten

Sluit aan op wat u al gebruikt.

Geen ETL, geen tweede datawarehouse, geen grafendatabase om aan te schaffen.

Regels worden gecompileerd naar SQL en draaien in de database die u al hebt, op tabellen die hun echte namen houden. Zo worden legacysystemen meegenomen zonder migratieproject. Een definitie wordt één keer uitgewerkt en daarna hergebruikt, wat de tokens bespaart die een model zou besteden om haar opnieuw uit te werken. SynaLemma draait ook met open modellen op uw eigen hardware.

Een voorbeeld

De regel achter een antwoord.

Elk antwoord verwijst naar een definitie zoals deze. Ze is kort genoeg om te worden gelezen door wie verantwoordelijk is voor het cijfer, en precies genoeg om door een machine te worden geverifieerd.

  • De eerste regels leggen als wiskundige uitspraken vast wat altijd waar moet zijn: één rij per leverancier, en nooit meer te late leveringen dan leveringen.
  • Daarna beschrijft de regel hoe het resultaat wordt berekend, op basis van de inkooporders.
  • Als de data een uitspraak tegenspreekt, toont SynaLemma de rijen die haar schenden in plaats van een verkeerd percentage te rapporteren.
  • De definitie is een tekstbestand in uw git-repository, dat wordt gereviewd zoals alle andere code.
Een definitie, zoals ze wordt opgeslagen
factory/rules/SupplierDeliveries.l
---
name: SupplierDeliveries
description: Purchase orders per supplier, and how many were late.
keywords: [supplier, delivery, late, on time]
---
import tables.PurchaseOrders.PurchaseOrders;

@Assert(SupplierDeliveries,
  one_row_per_supplier: "∀ s a b c d, SupplierDeliveries s a b → SupplierDeliveries s c d → a = c",
  late_within_total:    "∀ s a b, SupplierDeliveries s a b → b ≤ a");
@OrderBy(SupplierDeliveries, "supplier_id");
SupplierDeliveries(supplier_id:, deliveries? += 1, late? += is_late) distinct :-
  PurchaseOrders(supplier_id:, is_late:);

Een definitie uit een industriële laag. De uitspraken zijn geschreven in de notatie van de stellingbewijzer Lean en worden getoetst aan uw data. Een uitspraak klopt wanneer de zoektocht naar een tegenvoorbeeld niets oplevert. Dit is een controle op de data die u hebt, en bewijst niets over data die het systeem niet heeft gezien.

Hoe het werkt

Drie stappen van uw database naar een geverifieerd antwoord.

  1. 1

    Sluit aan wat u hebt

    Koppel SynaLemma aan de database die u al gebruikt (PostgreSQL, BigQuery, Databricks, Trino, Presto, DuckDB, SQLite) of zet uw bestanden erin (CSV, Excel, JSON, JSONL, Parquet). Databases worden ter plaatse bevraagd: tabellen houden hun echte namen en er wordt niets gemigreerd.

  2. 2

    Stel een vraag

    Lemma, de assistent, zoekt eerst naar een definitie die al bestaat. Is die er niet, dan schrijft zij een nieuwe regel, verifieert die en voert hem uit op uw data. Pas daarna antwoordt zij, met vermelding van de regel.

  3. 3

    Bewaar wat is geleerd

    De regel wordt opgeslagen met een naam en een beschrijving. De volgende vraag bouwt erop voort, en uw team kan hem controleren, corrigeren of vergrendelen.

Implementatie

SynaLemma wordt geleverd met toegewezen engineers.

We hebben gemerkt dat de tool alleen niet volstaat, zeker niet voor bedrijven zonder eigen AI-expertise. Daarom werken een of meer forward-deployed engineers uit het team dat SynaLemma bouwt, afhankelijk van de omvang van uw project, samen met uw team, in een afgebakende rol binnen het platform.

  • Zij leggen elke definitie vast met de mensen die verantwoordelijk zijn voor het cijfer.
  • Zij bepalen welke data moet worden gekoppeld, wat elke kolom betekent en wat ontbreekt.
  • Zij verifiëren elke regel, met kennis van zowel de logica als uw bedrijf.
  • Zij houden al het werk binnen uw laag en bouwen geen maatwerksysteem ernaast.
  • De licentie en hun werk dekken het onderzoek, het onderhoud en de doorontwikkeling van het systeem.
Hoe we het implementeren
Waarom wij

Wij hebben elke laag van het systeem zelf geschreven.

De meeste AI-producten combineren het model van een ander met het framework van een ander. Wij schreven het framework waarop de agent draait, de logische engine die zijn regels verifieert, het formaat waarin de kennis wordt opgeslagen, en het product dat deze drie samenbrengt. Weinig teams hebben elke laag tussen de database en het model gebouwd. Omdat wij dat wel hebben gedaan, zijn de onderdelen op elkaar afgestemd en kunnen we u precies vertellen wat het systeem doet en waar de grenzen liggen.

  • 1,4k GitHub-sterren
  • 1k PyPI-downloads per maand
  • Apache-2.0 open-source engines
De harness

SynaLemma

Het product dat uw team gebruikt. Het laat de drie engines op uw data draaien en voegt de assistent, de regeleditor, de afhankelijkheidsgraaf, rollen en Slack of Teams toe. Een commercieel product onder een betaalde licentie, geïmplementeerd op uw infrastructuur.

Ontdek SynaLemma
De agent

Synalinks

Het framework waarmee de assistent is gebouwd. Het houdt de output aan een schema, geeft agents tools en een ingebouwde sandbox, en optimaliseert instructies op basis van gemeten resultaten zonder de gewichten van het model aan te raken. Ontwikkeld onder supervisie van François Chollet, de auteur van Keras. Open source, Apache-2.0.

Bekijk op GitHub
De logica

Synalog

Een logische taal met een formele verifier, geschreven in Rust en gecompileerd naar zeven SQL-dialecten. Waaraan een resultaat moet voldoen, wordt vastgelegd als een Lean-propositie, de notatie van de stellingbewijzer Lean, en getoetst aan uw data. Open source, Apache-2.0.

Bekijk op GitHub
De kennis

Semantic Layers

Het formaat waarin uw definities worden opgeslagen, met één leesbaar bestand per concept of regel in een git-repository. De geschiedenis van uw redenering wordt gereviewd en geaudit zoals code, en een laag wordt geïnstalleerd vanuit een git-repository. Open source, Apache-2.0.

Bekijk op GitHub

Het model vertaalt en de logische engine redeneert. Die taakverdeling maakt de redenering controleerbaar en het model vervangbaar.

Bekijk de open-source engines
Voor wie

Voor bedrijven die achter hun cijfers moeten kunnen staan.

Wanneer een verkeerd cijfer kan leiden tot een productiestop of een mislukte audit, moet u weten waar elk cijfer vandaan komt.

Industriële operaties

Supply chain, inkoop, productie en kwaliteit. Stuklijsten, voorraad, te late leveringen en defecten krijgen elk één definitie, gedeeld door planners, inkopers en de agents die hen ondersteunen.

Gereguleerde sectoren

Zorg, lucht- en ruimtevaart, energie, financiële sector. Elk cijfer is terug te voeren op een regel en op de tabellen die die regel las, en dat is precies wat een auditor wil zien.

Teams met een vastgelopen AI-pilot

De demo werkte, maar niemand wilde ervoor tekenen. SynaLemma geeft de mensen die moeten goedkeuren iets wat zij kunnen lezen en controleren.

Aan de slag

Zie hoe SynaLemma een van uw eigen vragen beantwoordt.

De demo duurt dertig minuten en is gratis. Neem een vraag mee waarover uw teams het oneens zijn, en wij tonen u het antwoord van SynaLemma en de regel die het gebruikte. Als het past, volgt een gereedheidsanalyse, waarna forward-deployed engineers met uw team aan de slag gaan.