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.
- Without hallucinations
- Mathematically verified
- Same rule, same result
- No data movement
- Sovereign by construction
- Governed like code
- 1.4k GitHub stars
- 180k PyPI downloads
- Apache-2.0 open-source engines
- Team trained at LAAS-CNRS
- Based in the European Union
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% |
SynaLemma writes the definition once, verifies it, and every answer uses that same rule.
From a question to a verified answer
- adjustable permissions
- scoped access
- Lemma limited to your role
- reuses before writing
- answers through its rules
- asks when it's ambiguous
- respects locks
- entities, relationships and rules, versioned in git
- every change verified before it is saved
- compiled to SQL
- each answer cites its rule
-
PostgreSQL
-
MySQL
-
ClickHouse
-
BigQuery
-
Databricks
-
DuckDB
-
Trino
-
Presto
-
SQLite
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
Connect your database
PostgreSQL, MySQL, ClickHouse, BigQuery, Databricks, Trino, Presto, DuckDB, SQLite, or files. Queried in place, nothing migrated.
- 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
Get the answer and its rule
Every figure cites the rule it came from. Your team can read, correct or lock it.
Five properties, one logic layer
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
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
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
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
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
Order(order_id:, amount:) :- orders(order_id:, amount:);
Cleanup(order_id:) :-
Order(order_id:),
order_id == SqlExpr("0; DROP TABLE orders; --", {}); 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
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 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.