A validation state you can trust
Every entry is valid, unverified, stale, or invalid — and when rot crosses 30%, the agent stops and asks before it works.
Free & open source — star it on GitHub
Keep you and your coding agent on the same page
One shared source of truth for you and your agent — the plan, the decisions, the docs — living in your git repo and flagging itself stale the moment the code moves. You steer the work; your agent builds from it; nothing drifts behind your back.
Free & open source · v0.3.0. Building team & cloud features — join the waitlist.
MCP server · Desktop app · CLI · Claude Code · Cursor · Zed
sync — workspace
Bad context is how you and your agent drift apart
An agent is only as aligned as what it reads. Point it at stale, scattered context on a large task and it heads off course — confidently, while you're looking the other way.
Pattern-matches stale text
It trusts whatever it finds, even when the code moved on months ago.
Hallucinates the gaps
Where docs are missing, it invents plausible-but-wrong context.
Re-introduces dead decisions
It re-litigates choices you already overturned, again and again.
How Sync is different
Not a memory system. A source of truth.
Memory engines help your agent remember. Sync makes sure what it remembers is still true — and stops it from shipping when it isn't. Knowledge lives as plain YAML in your repo, bound to the code it describes, reviewed before it lands, and flagged stale the moment a commit moves past it.
Sync git-native | Agent memory Mem0 · Letta · Zep | Rules files CLAUDE.md · .cursorrules | Wiki / Docs Notion · Confluence | |
|---|---|---|---|---|
| Lives in your repo, in git | ||||
| Structured & typed — the agent queries it precisely | ||||
| Flags itself stale when the code moves | ||||
| You review every write — no black box | ||||
| A plan you steer — goals, specs, priorities | ||||
| Captures the reasoning — decisions & constraints | ||||
| Local-first — nothing leaves your machine | ||||
| Shared with the team in pull requests |
Yes Partial No
Why Sync
One source of truth you and your agent share
Structured, versioned, and always current — so you and your agent (and the whole team) build the same thing, instead of you cleaning up after it drifts.
The flagship — staleness becomes a worklist
Knowledge that flags itself stale
Every entry is bound to the code it describes. The moment a commit moves past it, git marks it stale — pointing at the exact commit and files — so neither you nor your agent builds on something that quietly went wrong.
- Bound to the code; stale on the commit that moves past it
- valid · unverified · stale · invalid — never a guess
- A pre-push gate blocks shipping stale knowledge
.sync/decisions/d-3c2a4f.md
decision · d-3c2a4fvalid
Sessions are signed JWTs with a 15-minute expiry.
scope · src/auth/session.ts
Written as it works
Knowledge your agent writes
Specs, decisions, constraints, and observations get captured during coding, by the agent, in typed structure it can query precisely later — not prose nobody re-reads.
- Decisions with the reasoning attached
- Constraints the agent must respect
- Observations about how the system really behaves
agent · git-sync mcp
›Reading src/auth/* before changing it…
→ writing decision: token strategy
→ writing constraint: no PII in logs
knowledge written
decision · d-7af213valid
Use refresh-token rotation on every renew.
constraint · c-19b0e4valid
Never log raw tokens or PII — redact at the boundary.
Always know what's next
A roadmap that orders itself
Goals → milestones → specs, ranked by horizon, priority, and which specs your recent commits actually touched. This is the plan you point the agent at — what matters now rises to the top.
- Now / Next / Later horizons instead of fake deadlines
- The spec your last commit touched is flagged active
- Blocked work drops out of the queue automatically
roadmap · what's next
NowNextLater
Session & token flow
active · a1b2c3dSeat-based billing
Local semantic search
The most important part of big work
Stay in control of where the agent is heading
The hard part of a large task isn't typing the code — it's keeping the work pointed at the right outcome. Sync makes the agent's direction legible and steerable.
- Answer its open questions — your answers become canonical
- Overturn a decision or set a constraint once; it holds
- Nothing auto-commits — you review every agent write
you steer · the agent follows
agent
Planning to keep sessions server-side in Redis…
Server-side sessions or stateless JWT?open
you
Stateless JWT, 15-min expiry. No server session store.
agent
Adjusting plan → stateless JWT. Recording the decision.
You decide; it proceeds. Nothing auto-commits.
On your laptop, offline
Local, private search
Full-text search (BM25) plus optional on-device semantic embeddings, fused together, across every project. Find any decision in milliseconds — nothing leaves your machine.
- Results carry their validation state — fresh vs. stale
- Semantic matches surface what keyword search misses
- Embeddings run on-device via llama.cpp
⌘K · search
BM25 + on-device
Session & token flow
s-auth-flow
valid
Sessions are 15-minute JWTs
d-3c2a4f
stale
Refresh rotation cuts replay risk
o-55ad21
semanticvalid
From you to the whole team
Start solo, scale to the whole team
You start alone on the hard problem. Because the knowledge lives in git, it stops being your private context the moment you push — the whole team and their agents read and steer with the same fresh plan.
- A new teammate or agent onboards in seconds via MCP
- Everyone works the same plan and the same answers
- No tribal knowledge, no re-explaining
start solo · scale to the team
You wrotevalid
decision · d-3c2a4f — Token strategy
git push
AK
reads it
MR
reads it
JD
reads it
One developer writes it. The whole team — and their agents — read and steer with it.
And more
Built to keep your shared context honest
Backlinks & knowledge graph
Typed links — depends_on, supersedes, references — built from frontmatter, manual links, and body mentions.
Questions & inline comments
Discussion pinned to exact text. A human answer becomes the canonical, attributed part of the spec.
Multi-project workspaces
One window over many repos, with qualified KEY:id addressing and per-project health at a glance.
Git hooks do the work
Post-commit invalidation, a pre-push gate that blocks shipping stale knowledge, and structural link checks — no manual audits.
Closes the loop, in git
A spec describes the work, the agent implements against it, ticks acceptance criteria, records decisions — and git re-flags it when the code moves.
How it works
Up and running from the app
Everything happens in the desktop app — no terminal, no config files to hand-edit. Browse, steer, and connect your agent with a click. (Prefer the command line? A CLI ships too.)
- 01
Open the app
Download the Sync desktop app for macOS, Windows, or Linux. Nothing to configure — just open it.
- 02
Add your repo
Point Sync at a repository and it sets up the .sync/ knowledge base for you — committed alongside your code.
- 03
Connect your agent
Toggle on Claude Code, Cursor, or Zed from the app. Your agent reads and writes knowledge; you steer it visually.
Latest release v0.3.0 · macOS, Windows & Linux · free and open source
WorkspaceApi
Search…⌘K
2
Decisionvalid
Use queue-based ingestion for uploads
Decouples the API from processing so a slow worker never blocks a request. Supersedes the inline approach.
src/server/ingest.tslinked to 2 constraints
Constraintstale
Uploads must stay under 10 MB
The file it describes changed in the last commit — Sync flags it for review before your agent trusts it.
src/server/upload.tstouched 2h ago
sync v1.0 · a1b2c3dM1 read-only · v1
Be first when the team features land
Sync is free and open source today. We're building team and cloud features next — drop your email and we'll tell you first. No noise in between.
FAQ
Frequently asked questions
What is Sync?
+
Sync is an open-source, git-native source of truth that keeps you and your AI coding agent on the same page. It stores your project's plan and documentation — specs, decisions, constraints, observations, and more — as plain YAML files under `.sync/` in your repository, readable by both humans and agents. Because everything lives in git, Sync flags an entry as stale the moment the code it describes changes — so neither you nor your agent builds against the wrong thing.
How is it different from a wiki or Markdown docs?
+
Wikis and Markdown rot silently: nothing tells you when a page no longer matches the code. Sync tracks each entry against the files it describes and surfaces out-of-date knowledge as a worklist, so agents never pattern-match against stale information.
Isn't this just an agent memory system like Mem0, Letta, or Zep?
+
No. Memory engines accumulate facts automatically — an LLM extracts them, they pile up, and they're retrieved by similarity with no notion of whether a stored fact is still true (their own teams call staleness an open problem). Sync is the opposite: knowledge lives as plain YAML in your repo, bound to the code it describes, reviewed before it lands, and — the key part — it flags itself stale the moment a commit moves past that code, with a pre-push gate that blocks shipping knowledge your agent can no longer trust. You steer it; nothing is injected behind your back.
How does it keep me in control of the agent?
+
You set the plan the agent works against — goals, milestones, and specs ordered by priority. The agent files open questions; your answers become canonical. You overturn decisions and set constraints it must respect. Nothing is auto-committed, and a pre-push gate refuses to ship knowledge that has gone stale. You steer the direction; the agent follows.
Where is my data stored?
+
In your repository, in git. Sync writes plain YAML under `.sync/` — there is no SaaS backend and nothing is uploaded. Your knowledge is versioned, reviewable in pull requests, and travels with the code.
Which agents and editors work with Sync?
+
Any MCP-capable client — Claude Code, Cursor, Zed, Codex, OpenCode, and others — through the built-in MCP server. Sync also ships a desktop app and a CLI, so you can browse and edit knowledge however you work.
Is it free? What's the catch?
+
Sync is free and open source under the Functional Source License (FSL-1.1-MIT), which converts to MIT after two years. It runs entirely on your machine. Paid team and cloud features are coming later — join the waitlist to be first in line.
Get on the same page as your agent
Put your shared source of truth in git, let it flag itself stale as the code moves, and steer the work — you, your team, and your agents building the same thing.