# SynaLemma: the logic layer for AI agents · SynaLinks

> https://synalinks.com/en/

AI answers you can verify

# The logic layer for AI agents

Describe your business ontology in plain language, right on your tables. Your teams and agents get answers from rules that are formally verified, compiled deterministically to SQL and governed like code, on your own infrastructure.

[Book a demo](https://calendar.app.google/RMMAPbHYroAgiokb7)

*   Without hallucinations
*   Mathematically verified
*   Same rule, same result
*   No data movement
*   Sovereign by construction
*   Governed like code

![SynaLemma asked how many licit Bitcoin transactions are tainted by illicit funds, hop by hop](/video/synalemma_promotion.jpg?v=7)  Watch in 30 seconds

*   1.4k GitHub stars
*   180k PyPI downloads
*   Apache-2.0 open-source engines
*   Team trained at LAAS-CNRS
*   Based in the European Union

01.The problem

## Ask three AI agents the same question, get three different numbers

Each agent writes valid SQL and guesses what “fraud rate” means. Nothing fails visibly, and nobody can trace the figure.

Agent

Decides the fraud rate is…

Answer

First

the share of payments disputed as fraud

8.19%

Second

the share of euro volume disputed as fraud

9.88%

Third

the same, leaving out payments the processor refused

10.62%

Real figures on Adyen's public DABstep data: Crossfit\_Hanna's fraud rate in January 2023, three plausible queries.

SynaLemma writes the definition once, verifies it, and every answer uses that same rule.

02.How it works

## From a question to a verified answer

Outside SynaLemma

SynaLemma · the logic layer for AI agents, governed and deterministic

**People** Ask in the app, or in Slack and Teams through a channel an admin sets up.

*   
*   
*   

**Your AI agents** Claude Code, Codex, Cursor, Copilot or Windsurf over MCP: they search and run your verified rules.

*   
*   
*   
*   
*   

**Your team** Manages the layer's lifecycle like code, and locks settled definitions.

**Access control** Everyone crosses it

*   adjustable permissions
*   scoped access
*   Lemma limited to your role

**Lemma** The agentWrites the rules as questions come in.

*   reuses before writing
*   answers through its rules
*   asks when it's ambiguous
*   respects locks

![Synalog](/brand/synalog-light.svg)

**Your ontology** Formally verified, deterministic logic

*   entities, relationships and rules, versioned in git
*   every change verified before it is saved
*   compiled to SQL
*   each answer cites its rule

**Your databases** Queried in place, never changed. Nothing is migrated.

*    PostgreSQL
*    MySQL
*    ClickHouse
*    BigQuery
*    Databricks
*    DuckDB
*    Trino
*    Presto
*    SQLite

People ⇄ Access control question the answer and its rule

Your AI agents ⇄ Access control MCP call verified result

Your team ⇄ Access control reviewed changes

Access control ⇄ Lemma the question the answer

Access control ⇄ Your ontology the token's tools verified result

Access control ⇄ Your ontology authorized change

Lemma ⇄ Your ontology rule or query verified result

Your ontology ⇄ Your databases compiled SQL rows

No one, person or agent, queries your databases except through verified rules.

*   Part of SynaLemma
*   Outside, connected to it
*   What is passed, in the direction of the arrow

1.  1
    
    ### Connect your database
    
    PostgreSQL, MySQL, ClickHouse, BigQuery, Databricks, Trino, Presto, DuckDB, SQLite, or files. Queried in place, nothing migrated.
    
2.  2
    
    ### Ask a question
    
    The analyst reuses an existing rule or writes a new one. The engine verifies it and runs it on your tables.
    
3.  3
    
    ### Get the answer and its rule
    
    Every figure cites the rule it came from. Your team can read, correct or lock it.
    

03.The product

## Five properties, one logic layer

01 Semantic 02 Reasoning 03 Verified 04 Deterministic 05 Governed

### One definition per business term

A fraud rate, a cross-border payment, a high-risk merchant: each is written once, as an entity or a rule on your tables, and every person and agent uses it.

*   Built on your tables as they are, nothing copied
*   A knowledge graph of what depends on what
*   Grows from the first question, no modelling project first

[See the use cases →](/en/use-cases)

![The logic layer as a graph: tables, the entities and relationships built on them, and the rules built on those](/screenshots/memory.png)

### The logic engine reasons, not the model

The model turns your question into a rule. The engine does every join, recursion and total, in the databases you already run.

*   Graph questions without a graph database: money flows, ownership chains, hierarchies
*   Recursion verified to terminate
*   No ETL, no second database, no migration

[How the engine reasons →](/en/synalemma)

![A recursive rule that follows Bitcoin funds hop by hop from illicit transactions, with its assertions and its result](/screenshots/rules.png)

### Every rule is proved before it runs

A symbolic verifier checks every rule, and assertions in first-order logic check your data.

*   Well-formed, safe and terminating, or rejected with the reason
*   Assertions return the rows that break them
*   Checked by logic, not by a second model

[How verification works →](/en/synalemma#verified)

![An assertion that fails: SynaLemma lists the two merchants whose payments go through a country none of their banks operates in](/screenshots/counterexamples.png)

### Same rule, same SQL

The model never writes the query. The engine compiles it from a rule, so once a definition exists, every question that uses it gets the same query, for every person and agent.

*   SQL compiled by the engine, not generated per question
*   Existing rules reused before a new one is written
*   Settled definitions locked, so no agent can change them

[Why the answer holds →](/en/synalemma#deterministic)

![A SynaLemma answer that names the rule it came from, MerchantUnexpectedAcquirerCountry](/screenshots/conversation.png)

### Every access scoped, every change on record

The agent writes rules, not SQL, and only with the rights of the person asking. Every change to a definition is a reviewed commit.

*   Declared tables only, never changed; raw SQL refused before it runs
*   Four roles and per-person permissions, Lemma limited to the asker's role
*   Every change a commit with its author, reviewable and reversible

[Audit, roles and review →](/en/synalemma#governed)

A rogue rule, refused before it runs

cleanup.l Copy

```
Order(order_id:, amount:) :- orders(order_id:, amount:);

Cleanup(order_id:) :-
  Order(order_id:),
  order_id == SqlExpr("0; DROP TABLE orders; --", {});
```

$ synalog cleanup.l verify

Unsafe SqlExpr in rule 'Cleanup': raw SQL bypasses verification and portability

04.Delivery

## Deployed on your infrastructure, by certified partners

*   Certified partners deploy it and settle each definition with your teams
*   Installed on your infrastructure, with the model you choose
*   Sovereign by construction, not by contract: no per-token fees, rules in your own git
*   Support, maintenance and evolution by the team that builds it

[The partner programme →](/en/partners)

05.Who it's for

## For companies that stand behind their numbers

*   ### Fraud and payment teams
    
    Fraud rates, disputes, fee tiers and money flows, one definition each.
    
*   ### Regulated sectors
    
    Every figure traces back to a rule and the tables it read.
    
*   ### Stalled AI pilots
    
    Something the people who sign off can read and check.
    

[See the use cases →](/en/use-cases)

Get started

## See SynaLemma answer one of your own questions

A free 30-minute demo on a question your teams disagree on, with the answer and the rule it used.

[Book a demo](https://calendar.app.google/RMMAPbHYroAgiokb7)
