synix

 ███████╗██╗   ██╗███╗   ██╗██╗██╗  ██╗
 ██╔════╝╚██╗ ██╔╝████╗  ██║██║╚██╗██╔╝
 ███████╗ ╚████╔╝ ██╔██╗ ██║██║ ╚███╔╝
 ╚════██║  ╚██╔╝  ██║╚██╗██║██║ ██╔██╗
 ███████║   ██║   ██║ ╚████║██║██╔╝ ██╗
 ╚══════╝   ╚═╝   ╚═╝  ╚═══╝╚═╝╚═╝  ╚═╝

Programmable memory for AI agents.

Get started in 60 seconds

uvx synix init my-project
cd my-project
cp .env.example .env              # add your API key
# add your source data to ./sources/
uvx synix build
uvx synix release HEAD --to local
uvx synix search "your query" --release local

That's it. You get episode summaries, monthly rollups, a core memory document, and full-text search — with every insight traced back to its source.

What just happened

Synix processed your sources through a pipeline — a directed graph of transforms you define in Python:

1. Sources — raw data was parsed from ./sources/
2. Episodes — each source got an LLM-generated summary (1:1)
3. Monthly rollups — episodes were grouped by month and synthesized (N:M)
4. Core memory — all rollups were compressed into a single document (N:1)
5. Search index — everything was indexed for full-text search

The template gave you a working pipeline. When you need to change it — different prompts, different grouping, different layers — you edit pipeline.py. Same tool, no migration.

The problem Synix solves

Memory is harder than it looks. You won't get it right the first time — nobody does. The question is what happens when you need to change it.

Every agent memory tool — Mem0, Letta, Zep, LangMem — gives you one flat bucket. Same storage, same rules, same lifecycle for everything your agent knows. When memory breaks, it breaks silently — contradictions, stale context, hallucinated recall. And when you realize your memory architecture is wrong, you're looking at a migration or starting over.

Synix lets you program how memory works — define the layers, write the prompts, control the lifecycle. Change your memory architecture and only affected layers rebuild. Trace any output back to the source that produced it. Your memory system grows with your needs — start simple, course-correct as you learn what works, and never pay for the wrong first guess.

How your agent uses the output

After synix release, your agent queries memory at inference time:

import synix

project = synix.open_project("./my-project")
mem = project.release("local")

# Search memory
results = mem.search("return policy", limit=5)
for r in results:
    print(f"[{r.layer}] {r.label} ({r.score:.2f})")

# Or load core memory as flat context
context = mem.flat_file("context-doc")
# → inject into your agent's system prompt

Synix runs offline. Your agent reads the output at runtime. They're decoupled — Synix doesn't need to be running while your agent serves requests.

Agent integration: For always-on memory, run synix serve — a knowledge server with bucket-based ingestion, search, and auto-builds over MCP HTTP. The Claude Code plugin auto-injects context on session start and pushes transcripts on session end.

Other options: Full MCP server for direct pipeline control, CLI for automation, or direct SQLite access to search.db. See the Integration Guide.

Customize everything

The template gave you a default pipeline. Open pipeline.py to see what's inside:

from synix import FlatFile, Pipeline, SearchSurface, Source, SynixSearch
from synix.ext import CoreSynthesis, EpisodeSummary, MonthlyRollup

pipeline = Pipeline("agent-memory")
pipeline.source_dir = "./sources"
pipeline.llm_config = {
    "provider": "anthropic",
    "model": "claude-haiku-4-5-20251001",
}

transcripts = Source("transcripts")
episodes = EpisodeSummary("episodes", depends_on=[transcripts])
monthly = MonthlyRollup("monthly", depends_on=[episodes])
core = CoreSynthesis("core", depends_on=[monthly])

memory_search = SearchSurface(
    "memory-search",
    sources=[episodes, monthly, core],
    modes=["fulltext"],
)

pipeline.add(transcripts, episodes, monthly, core, memory_search)
pipeline.add(SynixSearch("search", surface=memory_search))
pipeline.add(FlatFile("context-doc", sources=[core]))

Change a prompt → only downstream artifacts rebuild. Add new sources → only new episodes process. Swap MonthlyRollup for TopicalRollup → source parsing and episodes stay cached. No migrations.

This means you can A/B test your memory architecture. Try topic-based rollups instead of monthly, compare the outputs, keep what works. Every experiment is just a rebuild — not a rewrite.