A roadmap your agent reads
Set milestones, define specs, and the agent pulls what's next from your plan — not its own guess. Blocked work drops out of the queue. You see progress in real time.
Free & private — star it on GitHub
Take AI agents under absolute control
Sync is the project-management and quality-control layer your AI agents work against. Define your specs, rules, decisions, and roadmap once — Sync holds every agent accountable to them, so they build against your architecture instead of hallucinating or repeating past mistakes. When the code moves, stale context gets flagged and the agent has to stop and ask.
From install to results in one step. Runs entirely on your machine — nothing is ever uploaded. Currently in alpha · v0.6.13. Building team & cloud features — join the waitlist.
MCP server · Desktop app · Built-in terminal · Claude Code · Cursor · Zed · Codex · OpenCode
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.
Get started in seconds
Three steps to agent control
No mandatory terminal commands, no git clone, no long configuration files. Everything happens in the desktop app or with a single click.
- 01
Install the desktop app
Download Sync for macOS, Windows, or Linux. One binary, no dependencies — just open it.
- 02
Open your project folder
Point Sync at any local repository. It sets up the .sync/ knowledge base automatically — no manual config.
- 03
Connect your favorite agent
The Welcome wizard wires up Claude Code, Cursor, Zed, Codex, or OpenCode instantly — and you can run them right inside Sync's built-in terminal. No config files.
Latest release v0.6.13 · 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 · alpha · a1b2c3dM1 read-only · v1
How Sync is different
Built to govern agents, not just feed them text
AI coding agents are powerful, but without a plan to work against they cause architectural drift, forgotten decisions, and regressions. Memory files and wikis can hold context — they aren't built to keep an agent accountable to your project. Sync is: a mission-control layer above your editor and agent.
Sync Project management & quality control | Memory systems e.g. Cursor rules | Documentation Confluence · Notion | |
|---|---|---|---|
| Primary goal | Control agent results & enforce quality | Provide simple text context to the agent | Human-readable knowledge sharing |
| Structure | Strict, agent-readable constraints & widgets | Free-form text files | Unstructured text, tables, images |
| Staleness tracking | Automatic — tied tightly to code changes | None / manual | Manual audits required |
| Agent behavior | Must respect the rules; asks for approval when context goes stale | Reads notes, but often ignores them | Usually can't access it seamlessly |
| User experience | Visual Project Hub, widgets, direct oversight | Simple text editing | External web interface |
Sync works as a highly effective memory system too — but its real power is governance and quality control.
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.
Automated quality gates
Knowledge that flags itself stale
Every entry is bound to the code it describes. When a commit moves past it, Sync marks it stale — pointing at the exact commit and files — and makes the agent stop and ask for your input instead of silently building on old data.
- Bound to the code; flagged stale on the commit that moves past it
- valid · unverified · stale · invalid — never a guess
- Forces the agent to pause and ask before trusting stale context
.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.
Project Hub — roadmap, specs, milestones
A roadmap your agent works against
Goals → milestones → specs, used not as notes but as control elements. This is the plan you point the agent at — it pulls what's next from your roadmap and codes against it, instead of its own guess.
- Goals, milestones, and specs ranked by priority
- The agent codes against the roadmap, not its own plan
- Blocked work drops out of the queue automatically
roadmap · what's next
NowNextLater
Session & token flow
active · a1b2c3dSeat-based billing
Custom widget API
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 and approve 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.
Run agents where you steer them
A built-in terminal for your agents
Launch your agents right inside Sync — multiple terminals side by side, each opened into your project and wired to its context through the built-in MCP server. No separate console window, no context switching.
- Multiple agent sessions running in parallel
- Each launched into your project, wired to its context
- Powered by the built-in MCP server — no extra setup
terminal · 2 agents running
claude-codecursorinside Sync
$ git-sync mcp · connected
→ reading roadmap · 3 specs in scope
→ respecting constraint: uploads < 10 MB
✎ filed open question → awaiting your answer
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.
Project Hub & Widgets
Your mission control for AI agents
Not just notes — a task tracker agents actually work against, with a visual dashboard that shows exactly what's happening in your project right now.
Widgets you or your agent build
Add widgets to visualize project health, open questions, stale entries, or any metric. Your agent can create dashboards too — turning Sync into a living operations console.
And more
Built to keep your shared context honest
A validation state you can trust
Every entry is valid, unverified, stale, or invalid — so neither you nor your agent ever builds on context that quietly went wrong.
Speaks your language
Choose the language your agent writes docs in. Ready-made presets, plus any BCP-47 tag — so specs, decisions, and docs read naturally for your team.
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
Switch between projects from the side rail, or group several into a curated workspace and steer them as one.
Tied tightly to your code
Every entry is bound to the files it describes. When the code changes, Sync re-checks the affected knowledge and flags what drifted — no manual audits.
Built-in quality gates
We don't pretend AI never gets it wrong
Projects change. Files move. APIs get renamed. Left unchecked, your agent keeps trusting context that quietly went stale — and it won't tell you. Sync's staleness engine ensures it has to.
Flags stale context automatically
When a commit touches files a spec or decision describes, Sync marks it stale — pointing at the exact commit and drifted files. No manual audit.
Forces the agent to stop and ask
Instead of silently building on old data, the agent has to surface what went stale and ask you to re-validate it — shutting down the #1 hallucination path.
You review and approve
Nothing is auto-committed. You review the agent's proposed decisions and answer its questions in the Project Hub — you're always in the driver's seat.
Who is it for
For anyone who ships code with AI
Whether you're building solo or leading a team, Sync makes your relationship with agents predictable — and keeps you in charge.
Founders & indie hackers
Delegate routine to agents, keep the architect role. Set the direction once — the agent builds against your plan, not its guess.
Developers
Stop repeating instructions to your agent. Write a spec once, link it to the code, and every session gets the canonical version — reasoning included.
Product managers
Write specs the AI actually reads and executes — not prose that dies in Notion. Link acceptance criteria to milestones. Watch progress happen.
And not just software. Because your agent authors custom widgets, the Project Hub adapts to whatever you're building:
Trading & automation botsLanguage learningResearch & knowledge basesContent & writingPersonal projects
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 the project-management and quality-control layer your AI agents work against. You define the project — its specs, rules, decisions, and roadmap — and Sync holds every agent accountable to it, so they follow your architecture and constraints instead of hallucinating or repeating past mistakes. Everything lives in your repository; there is no cloud, no account, and no telemetry.
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, and your agent usually can't access them seamlessly anyway. Sync stores structured, agent-readable specs and constraints, ties each one to the files it describes, and flags it stale when those files change — so the agent never pattern-matches against out-of-date information.
Isn't this just a memory system for agents?
+
You can use Sync as a highly effective memory system — but that's not the point. Memory tools pass raw text to the agent and hope it's still true. Sync's job is governance: it ties every spec, decision, and constraint to the code it describes, makes the agent respect them, flags them stale when the code changes, and forces it to stop and ask for your approval before acting on old data. The power is control and quality, not just recall.
How does it keep me in control of the agent?
+
You set the plan the agent works against — goals, milestones, and specs ranked by priority. As it works, the agent reads your constraints, updates the roadmap, and files open questions when it hits ambiguity; your answers become canonical. You overturn decisions and set constraints it must respect. Nothing is auto-committed — you review and approve every change. You steer the direction; the agent follows.
Where is my data stored?
+
In your repository. Sync writes plain files under `.sync/` — there is no SaaS backend, no account, 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. The Welcome wizard wires up Claude Code, Cursor, Zed, OpenCode, and Codex for you instantly — and you can run them right inside Sync's built-in terminal. For anything else, point your client at the binary with `claude mcp add git-sync -- git-sync mcp`. Sync ships as a desktop app and a CLI, and the binary itself is the MCP server.
Is it ready to use?
+
Sync is currently in alpha. It's usable today and improving fast, but the internal data model can still change between releases. Hit a rough edge? Open an issue on GitHub — issues and pull requests are warmly welcome.
Is it free? What's the catch?
+
Sync is free and open source under the Functional Source License (FSL-1.1-MIT), which reverts to MIT two years after each release — free for all non-competing use. It runs entirely on your machine. Paid team and cloud features are coming later — join the waitlist to be first in line.
Stop hoping. Start knowing.
Sync is free and open source. Nothing is uploaded — everything lives in your repo, on your machine. Your agent works from reviewed context that matches your architecture, and you approve every change.