SynaLemma is built on these engines
Our commercial product puts them to work on your business data: answers that cite the rule behind every number, on your servers, with the model you choose.
Book a demoSynalinks for the agent, Synalog for the logic: both Apache-2.0 and developed in public. Because the code is public, anyone can check how SynaLemma's engines verify a rule and compute an answer.
This page is technical. For your business, it means that the engines under SynaLemma can be inspected by anyone, and that your rules remain readable outside our product. See SynaLemma
Synalinks is a framework for building, training, and deploying language-model applications (RAG pipelines, autonomous agents, and self-evolving reasoning systems) with a clean, declarative API inherited from Keras. It brings deep-learning discipline to AI systems: compose components, optimize their instructions against real metrics without touching model weights, run agent code in an embedded sandbox, and deploy the result as an API or an MCP server. Developed under the supervision of François Chollet, the author of Keras.
Why it matters for you: SynaLemma's assistant is built on it, so its outputs are held to a schema and its instructions are optimized against measured results.
import synalinks
class Question(synalinks.DataModel):
question: str
class Answer(synalinks.DataModel):
answer: str
lm = synalinks.LanguageModel(model="ollama/qwen3.8:27b", supports_reasoning=True)
inputs = synalinks.Input(data_model=Question)
outputs = await synalinks.ChainOfThought(data_model=Answer, language_model=lm)(inputs)
program = synalinks.Program(inputs=inputs, outputs=outputs)
program.compile(reward="exactmatch", optimizer="randomfewshot")
await program.fit(x=x_train, y=y_train, epochs=3) Synalog is a logic language of the Datalog family, written in Rust, that compiles to seven SQL dialects. A formal verifier refuses a badly built rule before any SQL is generated, and assertions in first-order logic, written in Lean's notation, search your data for counterexamples. Knowledge graphs over your tables, bounded recursion, reasoning over time: nothing is copied, everything runs in your database.
Why it matters for you: your business rules become code that is verified before it runs, and every answer traces back to the data that produced it, which is what a customer or a regulator will ask you to show.
---
name: Requires
description: An assembly requires a component, directly or inside a sub-assembly, at any level of the bill of materials.
---
import concepts.contains.Contains;
@Assert(Requires,
no_cycle: "∀ a, ¬ Requires a a",
transitive: "∀ a b c, Requires a b → Requires b c → Requires a c",
includes_direct: "∀ a c q, Contains a c q → Requires a c");
@Recursive(Requires, 20);
@OrderBy(Requires, "assembly_id", "component_id");
Requires(assembly_id:, component_id:) distinct :- Contains(assembly_id:, component_id:);
Requires(assembly_id:, component_id:) distinct :-
Requires(assembly_id:, component_id: middle), Contains(assembly_id: middle, component_id:);
Synalinks Skills is a library of skills in the open SKILL.md format that
teaches coding agents to write idiomatic Synalinks: scannable
guides, runnable scripts, and deep-dive references covering the framework end to end.
Without that guidance, a model mixes syntaxes and produces plausible-looking but
broken code. With it, coding agents write Synalinks the way our team does.
Why it matters for you: turning know-how into instructions a machine follows is what SynaLemma does with your teams' definitions.
Six areas of applied research, from neuro-symbolic reasoning to evaluating AI systems.
Improving an AI system without retraining a single weight: its instructions and examples are optimized against a measurable reward, the way you'd train a model.
How you know a system answers correctly, and that it hasn't degraded since yesterday.
Constraining a language model with structure and logic: outputs that are valid by construction, reasoning you can inspect, and conclusions that trace back to their premises rather than to a statistical hunch.
Turning documents into graphs a system can use, then querying those graphs: local search for precise questions, global search for questions that span an entire corpus.
An agent that writes and runs code is useful, and dangerous. We work on confining it: filesystem isolation, restricted system calls, controlled network access, capabilities granted explicitly rather than by default.
Pipelines where the model produces its own examples, the symbolic layer verifies them and discards what doesn't hold, and only what survives feeds the next step.
Our commercial product puts them to work on your business data: answers that cite the rule behind every number, on your servers, with the model you choose.
Book a demoOur frameworks are Apache-2.0 and developed in public. Star the repos, open an issue, or join the conversation. To use these engines on your own data, start with SynaLemma.