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.

  • 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
  • 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.

AgentDecides the fraud rate is…Answer
Firstthe share of payments disputed as fraud8.19%
Secondthe share of euro volume disputed as fraud9.88%
Thirdthe same, leaving out payments the processor refused10.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
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
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

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 →
The logic layer as a graph: tables, the entities and relationships built on them, and the rules built on those

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 →
A recursive rule that follows Bitcoin funds hop by hop from illicit transactions, with its assertions and its result

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 →
An assertion that fails: SynaLemma lists the two merchants whose payments go through a country none of their banks operates in

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 →
A SynaLemma answer that names the rule it came from, MerchantUnexpectedAcquirerCountry

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 →
A rogue rule, refused before it runs
cleanup.l
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 →
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 →
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.