SynaLemma

Reasoning you can truly audit, because the model does not do it.

Other agent systems rely on the language model to reason. SynaLemma is a semantic and reasoning layer built the other way around: the model translates your question into a rule, and a logic engine does the reasoning. It verifies the rule formally, derives the answer in the database you already run, and keeps the rule, so every step can be read and replayed.

Architecture

The model proposes. The logic engine reasons.

Most agent systems put the language model in the middle and let it reason its way to an answer. SynaLemma puts it at the edge. The model proposes a rule, and the engine performs every join, recursion and total. Nothing reaches your data or your answer without going through the engine.

The usual setup
  1. Your question
  2. Language model
  3. SQL it guessed
  4. Your database
  5. Language model
  6. A plausible answer
The model reasons in text. Its “explanation” is written after the fact and is not a record of how the answer was computed, so there is nothing to replay. A log of the agent's actions is a record, not a proof. What the research shows →
Outside SynaLemma
Language model Local or hosted. It proposes rules; the engine decides.
Synalinks The agentDrives the model step by step and traces everything.
Synalog The logic engine
  • verifies every rule
  • does the reasoning
  • compiles the rule to SQL
  • checks the result
Semantic Layers The knowledgeVerified rules, as files in git.
Your teams and agents The app, Slack or Teams, MCP and Agent2Agent.
Your database Runs the SQL. Queried in place.
Your git repository History, review, audit, restore.
Language model ⇄ Synalinks proposal constrained request
Synalinks ⇄ Synalog rule to verify refusal and its reason, or rows
Synalog ⇄ Semantic Layers rule kept rule reused
Synalinks ⇄ Your teams and agents the answer and its rule question
Synalog ⇄ Your database verified SQL rows
Semantic Layers ⇄ Your git repository every change is a commit

The model translates your question into a rule and words the answer. Every inference in between is the engine's, and can be replayed.

  • Part of SynaLemma
  • Outside, connected to it
  • What is passed, in the direction of the arrow
Traces and proofs

A trace is a record, not a proof.

A language model's written reasoning is more text it generated, and research keeps finding that it can leave out what actually drove the answer.

Logging an agent's actions has the same limit: the log says which tools were called, not whether the answer holds, and running the same question again can take another path.

SynaLemma does keep a trace, but only for debugging. The proof is the logic code: a Synalog rule that passed the formal verifier before it ran, that anyone can read, and that gives the same rows when rerun on the same data.

What the research shows

  1. Post-Hoc Reasoning in Chain of Thought: Decoding and Steering Pre-Committed Answers Cox et al., 2026 · preprint

    The model's answer can be read from its internal state before it writes any reasoning, and shifting that state often flips the answer: the reasoning often comes after the decision.

  2. Two Regimes of Chain-of-Thought Unfaithfulness: Metric-Based Detection Fails Where Models Are Wrong Angdembay et al., 2026 · preprint

    Most unfaithful reasoning comes with wrong answers, and there no tested detection method does better than chance.

  3. Reasoning Models Don't Always Say What They Think Chen et al., Anthropic, 2025

    Reasoning models use hints they were given and often do not say so.

  4. From Agent Traces to Trust: A Survey of Evidence Tracing and Execution Provenance in LLM Agents Wang et al., 2026 · preprint

    A log records what happened, but may not show whether the evidence supported a claim: it says what happened, not what depended on what.

Anatomy

Three engines and one product, all written by us.

Each layer has one job and passes the next layer something it can check. Three of them are open source; the fourth is the product that assembles them.

The product

  1. SynaLemma The harness

    What your team uses: Lemma, the assistant; tables, concepts and rules you can read and edit; the graph of what depends on what; roles, history, and the channels you already talk in.

Open source · Apache-2.0

  1. Synalinks The agent

    Drives the model step by step: searches existing definitions, decomposes the question, writes rules, calls tools. Outputs are held to a schema, the model can be swapped, and every step is traced.

  2. Synalog The logic

    Verifies each rule before any SQL exists, compiles it to the SQL dialect of your database, and checks what its result must satisfy against your data.

  3. Semantic Layers The knowledge

    Where definitions live: one readable file per table, concept or rule, in a git repository. A layer is reviewed like code and can be installed in another project.

Outside SynaLemma

  • Your database tables unchanged, real names, nothing copied
  • Your model local or hosted, replaceable
  • Part of SynaLemma
  • Outside, connected to it
The product

What your team sees.

The loop

What happens between your question and the answer.

  • Search

    The agent searches the layer for a definition that already answers the question. A layer of thousands of definitions never goes into the model's context whole: only what matches does.

  • Write

    If none fits, it writes one, building on the concepts already there instead of starting from raw tables.

  • Verify

    The rule goes through the formal verifier. If it does not check, it is refused with the reason, and nothing is saved unless the whole layer still holds together.

  • Run

    The verified rule is compiled to SQL and executed in your database. Its assertions are checked on the same data.

  • Answer

    Only then does the assistant answer, quoting the rows the run returned and citing the rule, which you can open.

  • Keep

    The rule is committed to the layer with its author and date. The next question starts from it.

Verified by logic

Two checks. Neither is done by a model.

Asking a second model to check the first one only adds another opinion. SynaLemma checks with logic instead. It is the first and only AI system that writes its own rules, verifies them formally, and checks their results against mathematical statements.

The definition, before it runs

Synalog's formal verifier examines every rule before any SQL is generated, with no database involved: variables that are never bound, unsafe negation and aggregation, negation through recursion, recursion without a base case or a bound, unknown columns, functions and predicates. More than fifteen classes of error, all reported at once. A rule that does not check is never saved and never run.

Its result, against your data

An assertion states what a result must satisfy, independently of how it is computed: a part appears once, a stock is never negative, late deliveries never exceed deliveries. It is written in first-order logic (∀, ∃, →, sums and comparisons) as a Lean proposition, the notation of the Lean theorem prover. Synalog compiles a search for counterexamples to SQL and runs it on your database. In SynaLemma a broken assertion shows on the rule, with the rows that break it one click away.

A violated assertion names what breaks it: here, two suppliers under the agreed service level
counterexamples
✗ 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 |
+-------------------+------+----+-------+
Deterministic

Same rule, same SQL.

Ask a language model for the same query twice and the SQL can differ. In SynaLemma the model never writes SQL: the engine compiles it from a rule. Once a definition exists, every question that uses it gets the same query, whoever asks.

01

Compiled, not generated

Synalog compiles each rule to the SQL dialect of your database. The same rule gives the same query on every run, in every channel, for every person and agent.

02

Reused before written

The agent searches the layer before writing anything. A question an existing definition covers is answered by that definition, not by a new attempt.

03

Locked when settled

Once your team agrees on a definition, lock it and no agent can change it. Replay any answer from its rule and get the same rows from the same data.

What can vary: how the assistant words the answer, and the rule it proposes for a question no definition covers yet. That rule is verified and shown to you, and once kept, it is fixed.

Governed

Every access scoped, every change on record.

Auditing an AI usually means reading logs of what a model said. In SynaLemma you audit two exact records: the derivation, made by the logic engine, and the history of the rules, kept in git, the tool software teams already use to track every change. And no one, person or agent, reaches your data except through those rules, with the rights of their role.

01

From the answer to the rows

Each figure cites its rule and the row it came from. Each rule names the concepts it builds on, and each concept the tables it reads. Follow the chain, or run any link of it again.

02

From the rule to its history

A semantic and reasoning layer is a git repository: one file per table, concept and rule. Every change is a commit attributed to its author, whether a person, Lemma or another agent, with the difference and a way back.

03

Scoped, and reviewed like code

Four roles and per-person permissions, and Lemma only gets the tools of the person asking. What was this definition on the day that figure was reported? Who changed it, and when? Compare two versions, restore one, or put a change through the same review as any other code.

The history records your definitions and how they changed, not your data: the rows stay in your database.

Your existing systems

Works on the systems you already run.

A classic semantic layer is a modelling project that takes months and is out of date soon after delivery. SynaLemma writes the layer as questions are asked, on top of your existing databases.

No ETL, no second warehouse

Rules compile to SQL and run where the data is. On a database you operate, SynaLemma declares the tables you choose and never changes them. A read-only account is enough.

Tables as they are

Old schemas keep their real table and column names, spaces and accents included. The layer gives them a meaning without touching them.

A knowledge graph, without a graph database

Entities and relationships are modelled over your relational tables. The graph is virtual: it compiles to SQL.

Questions SQL makes hard

Bills of materials through every level, reporting chains, “which assemblies stop if this supplier fails”: recursion to a depth you declare, so it always terminates, and reasoning over time.

Databases SynaLemma connects to
  • PostgreSQL
  • BigQuery
  • Databricks
  • Trino
  • Presto
  • DuckDB
  • SQLite

And your files: CSV, Excel, JSON, JSONL, Parquet.

In the product

Everything your team gets.

The layer belongs to you. Anything the assistant writes can be read, corrected and locked by a person.

Lemma, the assistant

Ask

  • Every figure cited with a clickable mention, down to the row it came from.
  • You watch her work, step by step: what she searched, wrote and ran.
  • Suggested questions drawn from your own layer.
  • Voice messages, transcribed on your server.
  • She proposes before acting on an open request, and asks when a question is ambiguous.
  • “Explain” and “Fix” on any rule, in one click.
Tables

Your data

  • Import CSV, Excel, JSON, JSONL, Parquet and SQLite files, by drag and drop.
  • Connect a database and choose which tables to expose.
  • Copy tables from another database in one go, writing nothing on the source.
  • A spreadsheet editor with typed columns, sort, search, undo and redo.
  • Export any table or result to CSV or Excel.
  • Lock a table's rows, or protect its structure.
Concepts, Rules, Memory

Your knowledge

  • Each rule shown as a flowchart for those who do not read code, and as code for those who do.
  • Edit a rule in place: it is verified on save, and a refusal says why.
  • Validated, not validated, locked: the state of every definition is visible.
  • Memory: the graph of what depends on what, across tables, concepts and rules.
  • Assertions with their status, and the rows that break them.
  • History with differences, and a restore to any version.
Reusable knowledge

Layers

  • Install a ready-made layer from a git repository or a zip. Nothing is kept unless it verifies against your database.
  • Work across several layers at once.
  • Export a layer as plain files: no connection, no secrets, no rows.
  • A layer is a folder that runs with the open-source Synalog tooling, with or without us.
Beyond the app

Agents and automation

  • An MCP server gives Claude Code, Codex, Cursor, VS Code Copilot or Windsurf the same tools Lemma uses.
  • An Agent2Agent endpoint lets another agent ask Lemma directly.
  • Slack, Microsoft Teams, Discord, Telegram or WhatsApp, through a bot you own.
  • Loops: the same question on a schedule, a Monday shortage review or a daily quality check, posted to a chat.
  • A plugin SDK to add your own pages and features.
Control

Administration

  • Four roles (admin, editor, analyst, viewer) and per-person permissions. Lemma is only given the tools the asking person's role allows.
  • Organisations, each with its own storage.
  • Pick the model from a catalogue, test the connection, switch at will. Local models: no API key, no per-token cost.
  • Every agent step, tool call and model call traced, on your side.
  • Credentials and tokens stored encrypted.
  • Interface in English, French, Dutch, Italian and Spanish.
Sovereignty

Sovereign by construction, not by contract.

Most sovereignty promises are a hosting location. SynaLemma's is its architecture: the layer is built so a small open model is enough, so the whole system, from the model to the definitions, runs inside your walls. If you choose a hosted model instead, your questions and the data excerpts needed to answer them go to that provider, and nowhere else.

Your model

An open model on your own hardware (Ollama, vLLM, LM Studio). The model only proposes rules: the engine reasons, a refusal says exactly what to fix and the context stays small, so a small model is enough. General-purpose agent harnesses are tuned for the largest proprietary models.

Your data

Queried in place, through an account that only needs to read: no copy, no pipeline, no cloud in between. Credentials are stored encrypted, and voice messages are transcribed on your server.

Your rules

Plain files in an open language, in your own git repository. They also run with the open-source tooling alone: if you stop working with us, your definitions stay with you.

Your stack

Engines published under Apache-2.0, written by a team based in the European Union, and deployed by certified partners on your infrastructure.

Compared with

How SynaLemma differs from the alternatives.

Other projects also give data a semantic layer. What differs is what that layer can express, and what checks it.

How do SynaLemma and Synalog compare to NVIDIA Auto-Ontology?

Both put a semantic layer between AI agents and your databases. They differ in what that layer is and in what checks it.

In Auto-Ontology, the layer is a glossary of terms, column mappings and SQL snippets stored in a database. At question time it is retrieved and handed to a language model as guidance, and the model writes new SQL for every answer. A second model call then judges whether that SQL is correct. One probabilistic system checking another gives no guarantee: both can be wrong in the same way.

In SynaLemma, the layer is a Synalog program: concepts and rules that compile deterministically to SQL. Checking is done by a symbolic system, not a model. Before any SQL runs, the verifier proves that every rule is well-formed, safe and terminates, and rejects any rule that isn't. Assertions written in first-order logic are checked against your data, and a failed one comes back with its counterexamples. The same rule always compiles to the same query, and every answer traces back through named rules to your tables.

Synalog can also express what a list of SQL snippets cannot: rules built on other rules, recursion (hierarchies, multi-hop chains), relationships between concepts, and reasoning over time. That strictness is what makes verification meaningful: a loosely typed YAML file has too little structure for a proof to say anything.

Synalog is a real programming language, and it takes more to learn than a YAML file. You don't have to write it: SynaLemma's analyst harness writes and maintains the rules, and the verifier checks its work before it reaches your data. We optimized that harness ourselves, using machine learning and our open-source framework Synalinks, so the analyst runs on local models on your own hardware, without per-token fees. Without a harness tuned like this, teams fall back on frontier models and pay for every question. And because answers come from compiled rules rather than SQL generated per question, a smaller model goes further.

Read the full comparison

How do SynaLemma and Synalog compare to Apache Ossie?

They solve different problems. Ossie is a file format: a vendor-neutral YAML specification, incubating at the Apache Software Foundation, for exchanging datasets, metrics and joins between BI and analytics tools. It does not run queries. Each tool that reads an Ossie file decides how to turn it into SQL, and SQL for each database is written by hand in the file.

Synalog is a language with a compiler. One program compiles to SQL for PostgreSQL, BigQuery, Databricks, Trino, Presto, DuckDB and SQLite, and the same rule always compiles to the same query.

The difference shows in what each can express. In Ossie's core specification (a draft ontology specification adds derived concepts and recursive relationships), a metric cannot reference another metric, a field cannot reference another field, a dataset cannot build on another dataset, and every relationship is a many-to-one foreign key. Time is a flag on a column. In Synalog, rules build on other rules, so definitions accumulate instead of being repeated. It also handles recursion (hierarchies, multi-hop chains), relationships between concepts, and reasoning over time.

It also shows in what can be checked. An Ossie file can be validated against its schema and its references. A Synalog program is checked by a symbolic verifier, which proves before any SQL runs that every rule is well-formed, safe and terminates. Assertions written in first-order logic are checked against your data, with counterexamples when they fail. For agents, Ossie offers free-text hints (ai_context) for a model to read. SynaLemma's analyst writes Synalog rules, and the verifier checks them before they touch your data.

SynaLemma is for definitions that need to be computed, verified and extended by agents, not just exchanged between tools.

Read the full comparison

How do SynaLemma and Synalog compare to semantic web tools (RDF, OWL, SHACL)?

Both describe what data means with concepts and relationships, and both reason over them. They are built for different jobs. The semantic web describes a domain so that ontologies can be published, shared and linked between organizations. Synalog describes operational ontologies: only the concepts and relationships your data actually contains, each one defined from your tables and computed from them.

That changes the logic. OWL works under an open-world assumption: a fact missing from the graph is unknown, not false, so OWL alone cannot check that every order has a customer. SHACL exists to fill that gap, as a second language that validates the data. Synalog is closed-world, like your database: what is not in the data is false. Rules, queries and constraints are written in one language, and assertions check your data directly, with counterexamples when they fail.

It also changes the stack. A semantic web deployment usually combines RDF for the data, OWL for the ontology, SHACL for validation and SPARQL for queries, plus a triple store or a mapping language such as R2RML to reach relational tables. Synalog is a single language that compiles to SQL and runs on the databases you already have.

Simpler does not mean less reasoning. One Synalog program can combine recursion, aggregation, negation and reasoning over time, and a symbolic verifier proves that every rule is well-formed, safe and terminates before it runs. OWL reasoners classify concepts; they do not compute the totals, averages and rankings that most business questions need.

Synalog is also built for agents. Its programs are short enough for a model to write and readable enough for a person to review, and SynaLemma's analyst writes them as questions are asked, each one checked by the verifier before it touches your data. Semantic web ontologies are usually modelled up front, by specialists: a project that commonly takes months, often years, and a large budget before the first question is answered. With SynaLemma, the layer grows from the first question.

SynaLemma answers questions about your own data, with answers you can verify, and no modelling project first.

Read the full comparison

How do SynaLemma and Synalog compare to Cube?

Cube is a semantic layer and API, in YAML or JavaScript: cubes, views, measures, dimensions and joins, with caching and pre-aggregations on many databases. Like Synalog, it compiles queries from its model before they reach the warehouse, so that is not where they differ. They differ in what the model can express, and in what checks it.

In Cube, every join is a LEFT JOIN, and hierarchies are levels for drilling down, not recursion. Reporting chains, bills of materials or dependencies over several hops have no place in the model: they need a recursive SQL query written by hand, so hard to get right that almost no one writes it. In Synalog, graph traversal is part of the language: a base case and a recursive step, verified to terminate, that run on every engine.

Cube checks that a model compiles, and its own documentation warns that a compiling model can still return wrong results. Its agent's answers are measured with evals against reference queries. Synalog proves that every rule is well-formed, safe and terminates, and checks the data against assertions written in logic, with counterexamples when they fail.

Cube's AI agent is part of Cube Cloud and writes Cube SQL from your question, with hosted models by default; using your own model is an Enterprise plan option. SynaLemma's analyst runs on a small open model, on your own infrastructure.

SynaLemma is built for the questions a cached dashboard API cannot answer: the ones that need reasoning, with answers you can verify.

Read the full comparison

How do SynaLemma and Synalog compare to the dbt Semantic Layer?

The dbt Semantic Layer, built on MetricFlow, defines metrics in YAML on top of dbt models and compiles metric queries to SQL. The differences are in expressiveness, in checks, and in what an agent can reach.

MetricFlow offers a fixed set of metric types (simple, ratio, derived, cumulative, conversion), with no custom aggregations, and joins of at most two hops. There is no recursion. In Synalog, rules build on other rules with no fixed catalogue, joins go as far as the question needs, and graph traversal is part of the language, verified to terminate.

dbt validates that the semantic configuration is consistent and that the generated SQL runs, and dbt tests can check tables for keys, nulls and references. Synalog proves that every rule is well-formed, safe and terminates before it runs, and its assertions, written in logic in a different notation from the rules, apply to any rule, recursive and derived ones included: transitivity, totals, validity periods.

dbt's MCP server gives agents governed metric queries, but also text-to-SQL and SQL execution that does not block write statements. SynaLemma's analyst has one path to your data: the verified layer, and a read-only account is enough. The Semantic Layer APIs also require a paid dbt platform plan; SynaLemma runs on your infrastructure with a small open model.

SynaLemma goes beyond looking metrics up: it reasons over your data, with answers you can verify.

Read the full comparison

In short. Every rule is formally verified before it runs, and your data is checked against assertions written in logic, with counterexamples when they fail. Graph questions need no graph database: traversal, recursion and multi-hop chains are part of the language, and they compile to SQL on the databases you already have. And because the SQL is compiled by the engine, not generated by a language model, a small open model is enough, so the whole system runs on your own infrastructure.

All comparisons, including Looker →

Frequently asked

What we get asked first.

We have no AI expertise in house. Is that a problem?

No. SynaLemma is deployed by certified partners: integrators and consultancies whose engineers work alongside your team to install it, connect your data, and write and verify your definitions with your experts. Your own team can also be certified.

Is the model not still reasoning when it writes the rule?

It decides what to ask the engine: which concepts to combine, and how. That decision is written down as a rule you can read, and the engine, not the model, derives every row from it. If the decision is wrong, it is wrong in a place you can see, correct once, and lock.

Is SynaLemma open source?

The three engines it is built on (Synalinks, Synalog, Semantic Layers) are open source under Apache-2.0. SynaLemma itself, the product that assembles them, is proprietary and sold under a commercial licence. Your rules are files in the open format, so they are never locked in.

Which databases does it work with?

PostgreSQL, BigQuery, Databricks, Trino, Presto, DuckDB and SQLite, queried in place: your tables stay where they are. And files: CSV, Excel, JSON, JSONL and Parquet. One rule compiles to the SQL dialect of whichever engine it runs on.

Which language models?

Any model that supports tool calling, chosen from a catalogue in the settings: open models served locally through Ollama, vLLM or LM Studio, or hosted providers such as Mistral, Anthropic, OpenAI or Google. Changing model does not change the rules. Everything except the conversation itself works with no model at all.

What if the model writes a wrong rule?

A structurally wrong rule is refused by the verifier. A rule that contradicts an assertion is flagged with the rows that break it. And because the rule is readable, the person who owns the number can see it and correct it. That is not possible when the answer is a paragraph of prose.

Does it replace our dashboards?

No. SynaLemma draws no charts: answers are numbers, tables and the rules behind them. It gives the definitions behind your dashboards one place to live, and lets people and agents ask questions in plain language against them.

See it run

Bring a question your teams disagree on.

In a free thirty-minute demo, we show you SynaLemma's answer and the rule it used.