Open source

The two engines of SynaLemma are open source

Synalinks 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

  • 1.4k GitHub stars
  • 180k PyPI downloads
  • Apache-2.0 licence
Synalinks

A neuro-symbolic framework for applications built on language models

  • Neuro-symbolic
  • Agents
  • RAG
  • In-context RL
  • Embedded sandbox
  • Knowledge graphs
  • Structured output
  • Python

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.

★ 467 125k downloads
A program, built and trained the Keras way
program.py
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

Turning raw tables into structured, verified knowledge

  • Logic engine
  • Datalog
  • Knowledge graphs
  • Compiles to SQL
  • Formal verification

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.

★ 19 55k downloads
A bill of materials through every level, with its assertions
concepts/requires.l
---
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

Synalinks expertise, packaged for coding agents

  • Agent Skills
  • SKILL.md
  • Claude Code
  • Codex
  • OpenCode
  • pi
  • Runnable examples
  • Reference docs

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.

★ 911
Our research

Six subjects, one thread: making AI systems measurable and defensible

Six areas of applied research, from neuro-symbolic reasoning to evaluating AI systems.

  • In-context optimization

    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.

    • In-context RL
    • Evolutionary optimizers
    • Quality-diversity
  • Evaluating AI systems

    How you know a system answers correctly, and that it hasn't degraded since yesterday.

    • Metrics
    • Automated judges
    • Regression testing
  • Neuro-symbolic reasoning

    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.

    • Structured output
    • Logic
    • Verification
  • Knowledge graphs

    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.

    • KG extraction
    • GraphRAG
    • Local & global search
  • Agents and confined execution

    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.

    • Sandboxing
    • Confinement
    • Agent tooling
  • Self-evolving programs

    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.

    • Self-distillation
    • Synthetic data
    • Symbolic filtering
The product

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 demo
Community

Built in the open, with a community around it

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