Sync is the harness your AI coding agents run inside — the context, rules, plan, and review surface a human actually controls, all bound to your code. You define the project: its specs, constraints, decisions, and roadmap. Sync holds every agent accountable to it, flags context the moment it drifts out of date, and lets you run any task on its own branch so nothing reaches main until you approve it.
Generation is solved. The work now is verification — and that is what a harness is for.
macOS · Windows · Linux (AppImage) · Linux (.deb)
always the latest release · all releases · macOS build is Apple Silicon — Intel & other targets build from source
What's new · Features · Why Sync? · How it works · Connect an agent
0.5 — review the work, not just the output.
Generation is solved; the work now is verification. 0.5 builds out the part of the harness you actually steer — a place to go through your agent's changes block by block, commit only what you trust, and isolate any run you choose on its own branch until it's earned its place in main.
- Block-by-block review. The Changes surface groups the diff into reviewable blocks. Approve and commit each one straight to git, with the real commit SHA read back from git. Diffs are anchored to a frozen base, so the review never shifts under you while the code keeps moving.
- Review agents with lenses. Hand the diff to a review agent through a spec lens (does it match what you specified?) or a codestyle lens (does it match how your repo writes code?). Comments anchor to the lines they're about and survive later edits.
- Any task on its own branch. Launch a task in its own git worktree — an isolated branch that can't touch
mainuntil you land it. It's opt-in per task; isolated runs go in parallel without collisions, and you land the one you're happy with in a single step.
See the latest release notes for the full list.
- Structured agent context. Specs, constraints, and decisions become machine-readable context your agent reads before it writes — so its code aligns with your architecture instead of drifting from it.
- Automatic staleness gates. When code changes, its context can fall out of date. Sync flags stale decisions, constraints, and docs and makes the agent pause for your input instead of acting on stale assumptions.
- Project Hub & multi-project management. Roadmap, specs, and milestones aren't just notes — they're controls. Switch projects from the side rail, or group several into a workspace and steer them as one.
- Built-in agent terminal. Run agents inside Sync — multiple terminals side by side, each launched into your project and wired to its context.
- Custom widgets. Agents author widgets that visualize project state and let you interact with it through the Project Hub.
- 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.
Without a plan to work against, agents drift: architecture erodes, decisions are forgotten, regressions creep in. Memory files and wikis store text, not control — they can't hold an agent accountable to your project. Sync is a control layer above your editor and agent, bound to your code and self-validating. Put more agents to work and it coordinates them: run each on its own branch, and review and land their work from one place.
| Aspect | 🚀 Sync (agent harness) | 📝 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 to code changes | None / manual | Manual audits required |
| Agent behavior | Must respect rules; asks for approval when stale | Reads notes, but often ignores them | Usually not accessible to the agent |
| Experience | Visual Project Hub, widgets, direct oversight | Plain text editing | External web interface |
Sync isn't a memory system — it's a control layer. It keeps your decisions and docs in sync with the code, but its job is governance and quality control, not note-taking.
- Define the guardrails. Open your project — or group several into a workspace — in the Sync desktop app, and define your specs, goals, and constraints.
- Launch your agent. The app includes a built-in MCP (Model Context Protocol) server. Connect Claude Code, Cursor, Zed, or any compatible tool in one click, and run it inside Sync's built-in terminal. You can launch any task in its own isolated git worktree, so several agents work in parallel without touching
main. - Watch and steer. As the agent works, it interacts with your project through Sync — reading constraints, updating the roadmap, building widgets, and filing open questions when it hits ambiguity.
- Review and approve. Walk the agent's changes block by block in the Changes surface and commit only what you trust, straight to git. Review its proposed decisions and answer its questions in the Project Hub. Nothing lands in
mainuntil you say so.
Sync offers a CLI for CI/CD pipelines, but everyday use is fully covered by the desktop interface — no console required.
The Sync binary is the MCP server, installed automatically with the app. The Welcome wizard wires up Claude Code, Cursor, Zed, OpenCode, and Codex for you instantly.
For anything else, point your client at it:
claude mcp add sync -- git-sync mcpOnce connected, your agent can read your project's rules, update its status, and interact with the widget system — all under your control.
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 buildThe 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-syncLocal-first by construction. Everything lives inside your repository. No SaaS, no account, no telemetry, no uploading your codebase to a third party.
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.
FSL-1.1-MIT — Functional Source License, reverting to MIT two years after each release. Free for all non-competing use.