The AtScale alternative where the agent never writes SQL
SynaLemma answers questions on your business data with rules that are proved before they run, then compiled to SQL. The agent never writes SQL, and the same question always gives the same SQL.
SynaLemma vs AtScale: key differences
-
The agent never writes SQL
The agent writes rules, not SQL. The engine checks every rule, then writes SQL that only reads your tables: no raw SQL and no injection, formally proved.
-
Every rule proved before it runs
A symbolic verifier proves each rule well-formed, safe and terminating. An invalid rule is rejected with the reason, before any SQL runs.
-
Assertions that name the faulty rows
Keys, references, totals or transitivity are written in first-order logic. The engine searches the whole table and returns the rows that break them.
-
Graph questions on your SQL databases
Hierarchies, bills of materials and supply chains are recursive rules, verified to terminate and compiled to SQL on PostgreSQL, BigQuery, Databricks, Trino, Presto, DuckDB and SQLite. No graph database, no migration.
-
Same question, same SQL
The same question always compiles to the same SQL, and every figure cites the rule it came from. Your team can read, correct or lock that rule.
-
Sovereign by construction, not by contract
Data, rules and model stay on your infrastructure. The engine compiles the SQL, so a small open model is enough, with no per-token fees. The Synalog engine is open source, under Apache-2.0.
Example: a recursive query with assertions
A bill of materials at any depth, with two assertions. The data contains a cycle; the engine reports it before any answer is returned.
# The bill of materials, read from the database.
Component(assembly:, part:, quantity:) :- bom(assembly:, part:, quantity:);
# A part is inside an assembly directly, or inside one of its parts.
@Recursive(Contains, 20);
@Assert(Contains,
transitive: "∀ a b c, Contains a b → Contains b c → Contains a c",
no_cycle: "∀ a, ¬ Contains a a");
Contains(assembly:, part:) distinct :- Component(assembly:, part:);
Contains(assembly:, part:) distinct :-
Contains(assembly:, part: sub),
Component(assembly: sub, part:);SynaLemma vs AtScale at a glance
| Criterion | SynaLemma | AtScale |
|---|---|---|
| How an agent answers | It writes a rule; the engine proves it and compiles the SQL | The agent writes a SQL SELECT and sends it to the MCP server |
| What checks the definitions | Every rule proved well-formed, safe and terminating before it runs | SML syntax validation and the Design Center model validator |
| Checks on the data | Assertions in first-order logic that return the rows breaking them | Built-in key and hierarchy checks; no user-written assertions |
| Hierarchies and multi-hop chains | Native recursion at any depth, verified to terminate | Level-based hierarchies; no parent-child in the SML reference |
| Definitions written in | Synalog, an open-source logic language with a compiler | SML, a YAML format, or the Design Center editor |
| Joins | Any join the rule states, as far as the question needs | Fact datasets to dimensions; many-to-many through a bridge table |
| Language model | The one you choose: a small open model is enough, no per-token fees | The client's model, such as ChatGPT, Claude or Gemini |
| Deployment | On-premises, on your infrastructure | Your infrastructure: Kubernetes with Helm, or a Linux installer |
Why teams look for an AtScale alternative
-
SQL written by the agent
The MCP run_query tool validates and executes a SELECT that the agent writes from the question (MCP tools).
-
Level-based hierarchies
SML hierarchies are fixed levels, each a subdivision of the one above; recursive parent-child chains are not in the reference (SML dimensions).
-
Validation, not proof
The SML CLI checks syntax and the model validator checks keys and hierarchies; no user-written assertions on the data are documented (SML).
AtScale alternative: FAQ
What is the best AtScale alternative for AI agents?
SynaLemma. The agent writes rules instead of SQL, every rule is proved before it runs, assertions name the faulty rows, and recursion is native. A small open model on your own hardware is enough.
Does AtScale support recursive hierarchies?
The SML reference describes level-based hierarchies only. In Synalog, recursion is native: an org chart or a bill of materials is followed to any depth, and termination is verified.
Who writes the SQL when an agent queries AtScale?
The agent. It writes a SQL SELECT against the semantic model and sends it to the run_query tool. In SynaLemma, the agent writes a rule that is verified, then compiled to SQL by the engine.
Can SynaLemma run with a local model?
Yes. A small open model on your own hardware is enough, because the engine compiles the SQL.
Sources
- SML on GitHub
- SML reference: dimensions
- SML reference: models
- AtScale docs: MCP tools reference
- AtScale docs: supported AI applications
- AtScale docs: Kubernetes installation
- Synalog on GitHub (Apache-2.0)
Checked against each product's public documentation on the review date. To report an error: contact@synalinks.com.
Other comparisons
Bring a question your current stack can't answer.
In 30 minutes, we show SynaLemma answering it, with the rule behind the number and the checks it passed.