sync-legacy

<div align="center"> # 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. [](https://github.com/sync-buzz/sync/actions/workflows/ci.yml) [](./LICENSE) [](#connect-any-agent) [](https://github.com/sync-buzz/sync/stargazers) <p align="center"> <a href="https://www.youtube.com/watch?v=4XVi9kT12rU"> <img src="https://img.youtube.com/vi/4XVi9kT12rU/maxresdefault.jpg" alt="Sync desktop app — your agent drafts the plan, you correct it, and accept its work block by block" width="900"> </a> </p> <p align="center">_{▶ <a href="https://www.youtube.com/watch?v=4XVi9kT12rU">Watch the demo</a>}</p> ### ⬇ Download **[macOS](https://github.com/sync-buzz/sync/releases/latest/download/Sync_macOS_aarch64.dmg)** · **[Windows](https://github.com/sync-buzz/sync/releases/latest/download/Sync_Windows_x64-setup.exe)** · **[Linux (AppImage)](https://github.com/sync-buzz/sync/releases/latest/download/Sync_Linux_x86_64.AppImage)** · **[Linux (.deb)](https://github.com/sync-buzz/sync/releases/latest/download/Sync_Linux_x86_64.deb)** _{always the latest release · [all releases](https://github.com/sync-buzz/sync/releases/latest) · macOS build is Apple Silicon — Intel & other targets [build from source](#build-from-source)} <br> **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 →](#private-by-construction)} <br> [How it works](#how-it-works) · [Review that explains itself](#review-that-explains-itself) · [What else is in it](#what-else-is-in-it) · [Why one product and not four](#why-this-is-one-product-and-not-four) · [Private by construction](#private-by-construction) · [FAQ](#faq) </div> --- ## 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](#review-that-explains-itself)). 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 <!-- TODO(owner): review demo video/GIF goes here — blocks + overview diagram + red unassigned. --> 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. | What you need | What you'd use today | Why it breaks with agents | |---|---|---| | **Say what to build** | Jira, Linear | A ticket is written for a human to interpret — and you have to write it. An agent needs a spec it can't skim past, and it can draft that one itself for you to correct. | | **Run the work** | Terminals, agent runners | Runs agents in parallel — but has nothing to hold them accountable to. | | **A gate before `main`** | GitHub PR | Built for a diff a human wrote and can explain. Nobody explains an agent's diff to you. | | **Remember the decisions** | Notion, Confluence, `CLAUDE.md` | Rots silently. The agent then builds on a lie, confidently. | 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](#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: ```sh 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](#-download). For Intel Macs and other targets, build it yourself. **Prerequisites:** [Rust](https://rustup.rs) (the pinned toolchain installs automatically from `rust-toolchain.toml`), [Node.js](https://nodejs.org) 20.19+, the [Tauri CLI](https://v2.tauri.app/reference/cli/) (`cargo install tauri-cli --locked`), and the [Tauri system dependencies](https://tauri.app/start/prerequisites/) for your platform. ```sh 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: ```sh 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](https://github.com/sync-buzz/sync/issues). 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](./LICENSE) — Functional Source License, reverting to MIT two years after each release. Free for all non-competing use.