Sync

Run a project whose code you don't write

Your agents write the code. Sync is where you keep it the thing you actually meant to build. You don't write the specs — an agent drafts them and you correct them. It builds against that spec on its own git branch, then hands the work back explained block by block, so you can see what it made and how it works. Nothing reaches main that you didn't accept.

Writing code stopped being the bottleneck. Knowing what your agents built, and standing behind it, is.

⬇ Download

macOS · Windows · Linux (AppImage) · Linux (.deb)

always the latest release · all releases · macOS build is Apple Silicon — Intel & other targets build from source

No account, no SaaS, no tokens to buy. Sync runs on the agent subscription you already pay for — Claude Code, Codex, or any model at all through OpenCode — as your own CLI, on your own machine. How that works →

How it works · Review that explains itself · What else is in it · Why one product and not four · Private by construction · FAQ

How it works

1. Describe the project — don't document it. Tell an agent what you're building, in your own words. It drafts what Sync keeps: the goals, the decisions, the constraints. You read what came out, comment where it misread you, and ask it to revise. The paperwork is its job; being right is yours.
2. Brainstorm the specs with it. Same loop, one level down. Give a direction, it writes the spec and the acceptance criteria, you comment, it revises. When the spec finally says what you meant, it stops being a note: it's the order every agent on the project is held to, in a form they can't skim past.
3. Hand it over. Agents receive the spec, the constraints and the decisions through Sync's built-in MCP server — a contract, not a wish. One agent can split the work across others. Any task can run in its own git worktree, so main is never touched.
4. Watch it, or don't. Supervision is optional. Open the run and follow your agents live, step into their chat, redirect a task mid-flight — or ignore all of it and let only their open questions reach you. Step 5 is the one that isn't optional.
5. Read the work, not the diff. The agent that wrote the code lays it out as explained blocks and hands it back (see below). You comment, commit what you trust, and merge. Nothing lands in main you didn't accept.
6. Keep the description honest. Agents record decisions and docs as they work. When the code changes, Sync uses git to flag every entry that rested on the changed file — immediately, as a worklist, not an audit. An agent that hits a stale entry has to stop and ask you instead of acting on it.

Everyday use is fully covered by the desktop app. There's a CLI as well, for CI/CD pipelines — otherwise no console required.

Review that explains itself

In human code review the expensive part isn't reading lines — it's reconstructing what the author meant from a pile of files. Here the author is an agent that built the thing minutes ago and knows exactly how it fits together. It gives you that structure for free.

Ask for a review, and the agent lays the diff out as blocks: minimal, self-contained units of intent — a block can span several files — each with a short note on what it is and why it's there. Above them sits an overview of how the blocks fit together, with a diagram when the shape is worth drawing. You read block by block, and the file list drops to what it should always have been: navigation.

Nothing hides behind the summary. The blocks are a view of the whole diff, never a selection from it: every hunk belongs to exactly one block, and anything the agent didn't account for shows up as unassigned, in red. The raw file-by-file diff is always one click away.

You can also hand the same diff to a review agent through a lens — spec (does this match what you asked for?) or codestyle (does this match how your repo writes code?). Comments anchor to the lines they're about and survive later edits.

And what you say in review doesn't evaporate when the branch merges. Your comments and corrections are distilled into a codestyle guide that lives in your repo — and every agent reads it once at the start of its session, before it writes a line. Correct it once; the next agent already knows.

That moves your attention off does this work at all — the running app answers that — and onto the part that actually needs you: the approach, and the quality of what was built.

What else is in it

Beyond the loop above:

• A team, not one agent. Several agents at once, each launched into your project and wired to its context; one of them can hand work to the others.
• Isolated runs. Any task in its own git worktree: agents in parallel, no collisions, main untouched until you land it.
• Project Hub & widgets. Roadmap, specs and questions as controls, plus widgets your agent writes to visualise the state of your project.
• Many projects at once. Switch from the side rail, or group several into a workspace and steer them as one.
• Search that works offline. Full-text and on-device semantic search across everything the project knows. No embedding API, no upload.
• Documentation in your language. Pick the language your agent writes docs in — any BCP-47 tag — so specs and decisions read naturally for your team.
• One binary. The desktop app, the MCP server and the CLI are the same executable. Install it and all three are there.

Why this is one product and not four

Running a project on agents takes four tools today. None of them was built for a workforce that reads instructions literally and writes faster than you can read.

Sync is one loop instead of four tools, because an agent workforce needs a machine-readable order going in and a mandatory gate coming out — and because at agent speed, the record of the project has to repair itself.

Private by construction

Sync has no SaaS, no account, no telemetry and no server to upload to. Everything it keeps — your specs, decisions, docs, review comments, the codestyle guide — is plain files inside your own repository, under your own git.

It isn't an AI vendor either. Sync never holds or proxies model credentials: your agent runs as your CLI, under your login, on your machine, on the subscription you already pay for. Claude Code, Codex, OpenCode, Antigravity — what you pay and to whom stays between you and your provider, exactly as it already is in your terminal. Sync adds no third party to that: your code goes only where your agent itself sends it, and if you point OpenCode at a model running on your own hardware, it doesn't leave the machine at all.

FAQ

Why not just use pull requests? A PR shows you the lines and leaves the meaning to you — it was designed for a diff whose author is a colleague you can ask. Nobody explains an agent's diff to you, and the agent that wrote it is the one thing that could. Sync makes it do that, and keeps the gate: nothing lands that you didn't accept.

Why not Jira plus a coding agent? That's two of the four tools above, wired by hand. The ticket isn't something an agent can be held to, nothing ties the acceptance criteria to the diff you're reviewing, and the decisions you made last month live somewhere the next agent won't read. The value isn't in any one of the four — it's in them being one loop.

Is this an agent orchestrator? No. Sync does dispatch work across agents, but that's the step you're allowed to ignore — and a product can't be the part you don't look at. What it sells is the other end: a spec agents are accountable to, and a gate you can't skip.

Do I need an API key? What does the AI cost me? No key, and nothing extra. Sync runs the agent CLI you already have, under your own login, on your existing subscription. See Private by construction.

Connect any agent

The Sync binary is the MCP server, installed automatically with the app. The Welcome wizard wires up Claude Code, Codex, OpenCode, Antigravity, Zed and Cursor for you instantly.

Claude Code, Codex, OpenCode and Antigravity also run inside Sync, in its built-in terminal. Zed and Cursor are GUI editors — Sync registers its MCP server with them and you keep driving them in their own window.

For anything else, point your client at it:

claude mcp add sync -- git-sync mcp

Once connected, your agent reads your specs, constraints and decisions, reports progress against them, and files a question when it hits ambiguity — all under your control.

Build from source

Prebuilt installers cover macOS (Apple Silicon), Windows, and Linux — see Download. For Intel Macs and other targets, build it yourself.

Prerequisites: Rust (the pinned toolchain installs automatically from rust-toolchain.toml), Node.js 20.19+, the Tauri CLI (cargo install tauri-cli --locked), and the Tauri system dependencies for your platform.

git clone https://github.com/sync-buzz/sync.git
cd sync
npm --prefix web install

# Desktop app installer → target/release/bundle/ (the frontend is built automatically)
cargo tauri build

The frontend is embedded in the binary, so to build just the unified CLI + MCP binary, build the web assets first, then compile:

npm --prefix web run build
cargo build --release   # → target/release/git-sync

Status & contributing

Sync is in Alpha — actively developed, with rapid improvements and occasional breaking changes to the internal data model.

Hit a rough edge? Open an issue. Issues and pull requests are warmly welcome.

Support the project

Sync is built in the open, by a very small team. A star helps more than you'd think. If you'd like to chip in, donations in ETH go to:

0xa477BE9eCdE8464b1d4b07944Eb121D6869b3220

License

FSL-1.1-MIT — Functional Source License, reverting to MIT two years after each release. Free for all non-competing use.