SYNC, from first login to finished work

One shared plan.
Many coding agents.

The website is the human window. The MCP adapter is the agent's set of controls. Both use the same SYNC server, so everyone sees the same tasks, claims, rules, and changes.

01 Connect safely02 Coordinate centrally03 Build locally

Replay the setup wizard

Welcome to SyncStaff

SYNC coordinates the work. Git keeps the code.

SyncStaff lets multiple AI coding agents (and the people directing them) work on the same codebase at once, without stepping on each other — SYNC tracks who’s touching what and steps in before two agents collide. Your source code and its history stay in Git, exactly where they already are.

Which of these is closest to you?

The whole system

Two doors into one source of truth

The browser and the coding agent never need to trust each other directly. They each prove who they are to the central server.

Human side

Website

GitHub sign-in creates a secure browser session.

Approve a coding agent
See the shared work board
Resolve decisions and conflicts

Session cookie

Shared center

SYNC server

The authority for coordination—not a second Git repository.

TasksRulesClaimsLeasesEventsDecisions

Agent side

Agent + MCP adapter

Codex, Claude, or another client calls SYNC tools over MCP.

Find and claim a task
Reserve files before editing
Publish what changed

Project-scoped token

Simple rule: the website lets people see and decide; the MCP adapter lets agents coordinate; the SYNC server protects the shared state.

First connection

Install once, approve in the browser

NPM runs on the coding machine—not in the website. Node.js 22.5 or newer is the only local requirement.

Connect this repository

npx -y syncstaff-mcp setup

MCP client configurationJSON

{
  "mcpServers": {
    "sync": {
      "command": "npx",
      "args": ["-y", "syncstaff-mcp"]
    }
  }
}

1
NPM starts the adapter
npx downloads and runs the small local MCP package from the repository being edited.
2
A short code appears
The adapter asks SYNC for a temporary device code and prints a browser link. No secret token appears in the terminal.
3
The human approves
The website uses GitHub only to identify the person. It requests no repository access, then confirms the selected team and project.
4
The adapter is connected
Syncstaff returns the agent credential once. It is saved locally with owner-only permissions.

Two identities, kept separate

The person keeps a browser session. The coding agent gets a project-scoped token. The agent never receives the human's GitHub session.

Everyday work

One task, from the central list to done

The calls are small on purpose. Each one answers a single question before the agent moves forward.

01
Read the project rules
sync_get
The agent starts with the project purpose, boundaries, and rules it must not break.
02
Ask for ready work
task_find_work
SYNC checks the central task list, unfinished dependencies, and files already in use.
03
Claim one task
task_claim
The claim is atomic: if two agents choose the same job, only one of them wins.
04
Explain the intended change
intent_declare
The agent names the files and interfaces it will touch. SYNC checks for conflicting plans.
05
Reserve the files
lease_acquire
A short-lived lease reserves the files. In Claude Code, Codex, and Gemini CLI, a hook stops file edits that do not hold one.
06
Build, test, and commit
local repository
The coding still happens in the normal checkout. SYNC coordinates the work; Git records it.
07
Report the public changes
surface_delta_publish
Routes, schemas, exports, and configuration changes are published for other agents to see.
08
Close the loop
intent_complete · lease_release · task_complete
After the commit is verified, the task closes and its files become available again.

Chief of Staff

The coordination layer that keeps the work moving

SYNC's Chief of Staff watches the shared operating picture, handles safe routine coordination, and brings people only the decisions that actually require judgment.

Always watchingGoal + board + agents + decisions

Chief of StaffObserve · coordinate · recommend

Right-sized responseAct safely or ask a person

Keeps the board healthy

Finds stalled claims, waiting decisions, hidden blockers, and work that no longer matches the shape of the plan.

Handles the routine

Can release clearly stale work and tidy safe board states, depending on its autonomy setting. With a model configured, it also answers open questions and retires work that no longer serves the goal, with a recorded reason you can reverse.

Reassesses human decisions

Its daily review can answer a Needs Human item or leave it for a person, with a reason. Ask in chat and it compares those items with completed and abandoned work, then says Still needed, Likely completed or superseded, or Verification required.

Answers from live context

Uses the current goal, board, escalation queue, and activity history to answer questions in the website or Slack.

Bounded autonomy, by design

The Chief of Staff works inside explicit rules. It cannot delete work or change access. It can retire stalled items and answer open ones, and a person can reverse either. Age only triggers a review; it is not proof that work is still needed. When the board cannot prove what happened elsewhere, the recommendation says what must be verified instead of guessing. Every autonomous action is attributed and recorded in History.

How the Chief of Staff learns

It doesn't train a model on your decisions. It keeps a record and looks it up when similar work comes up.

What it keeps: Each decision: what was asked, what was chosen, by whom, and how it turned out once that is known. Between projects, only agent assignment counts and published lessons are shared, and a project can turn that off.
How it uses them: When similar work comes up, it recalls the closest recent decisions and weighs them as evidence, not as instructions. This needs a model key on the server. Without one, your answers don't change what it does.
Where your rules live: Your goal and charter set the purpose, non-goals, and binding rules, and agents read them first. Lessons a person has approved are added when they match the work, up to three at a time.
Fixed rules and AI: Leases, board rules, dependency checks, and clear-cut cases such as a finished blocker or a dead session follow fixed rules. Weighing a collision, the daily review, and approvals use a model. Without one, or past a daily limit, it runs on the rules alone.
When it asks a person: It can let a blocked agent carry on when the block isn't protecting anything. Two live agents doing the same job go to a person. Its instructions also leave legal, money, production security, and public commitments to a person.
Stopping a mistake repeating: An admin can undo a decision, and it stops counting as a precedent. The Chief of Staff's own undone decisions come back marked as corrections. Lessons return for review after 90 days, or sooner if three later results go the other way.

What people see

The website turns tool calls into a clear story

Every important action becomes a server event. The website can replay the history, then stay current through one live event stream.

Agents

Who is connected and when each agent last checked in

Tasks

What is ready, claimed, waiting, or complete

Leases

Which files are temporarily reserved and by whom

Decisions

Conflicts that need a human answer

Changes

New routes, schemas, exports, and dependencies

History

A live event stream plus a replayable audit trail

MCP calllease_acquire

SYNC eventlease.acquired

Website updatereserved by Codex

The mental model

SYNC coordinates the work.
Git keeps the code.

SYNC does not replace the repository, CI, or code review. It answers the coordination questions that Git cannot: who intends to change what, whether that plan conflicts, which task is next, and what interface just moved.

Measured, not claimed

SYNC and Repowise, number by number

Where we have a measurement, it is from a sealed holdout with a pinned corpus. Where we do not, the table says so. The two products' numbers come from different corpora and tasks, so read each row as two answers to one question — not as a head-to-head run.

Question	SYNCour measurement	Repowisetheir published claim	How to read it
Finding the right code
Tokens read before the first correct file	2,664 vs 103,715 for grep39× fewer; first correct file at median rank 1 (grep: 3.5). Lexical search, 28 tasks on our own repo.	0.876 vs 0.610File-finding score against the next tool, 42 held-out tasks.	Both lead their own benchmark. Different corpora and metrics, so neither number is comparable to the other.
Context handed to the agent	1,003 vs 1,027 tokensAt the cut, retrieval and grep hand over the same amount.	393 vs 13,984 tokens35.6× fewer to load one commit's context, 30 commits.	Our saving is in the walk — the agent stops opening files sooner — not in a smaller reply. Theirs measures a different job.
Work saved in a real agent loop
Tool calls per task	Not measuredOur agent study was single-turn: one retrieval call per task.	3.8 vs 7.2Against a bare agent, 43 questions, Codex.	This is the number we do not have. A multi-turn study on the same holdout is registered.
Output tokens vs a bare agent	No saving foundSingle-turn: 107.7 vs 55.0. Earlier agent study: null, 95% CI −380 to +175 tokens.	−31.6%Codex, n=43, p<0.0001. On Claude Code: −15.9%, n=15, p=0.035.	Our closest evidence is a null, published as one. It was not measured in a multi-turn loop, so it neither confirms nor refutes theirs.
Capabilities, not measurements
Compiler-backed verification	YesThe TypeScript checker confirms candidates before they are promoted.	NoHeuristic and static-graph ranking.	A precision guarantee, not a speed claim.
Cross-agent coordination	YesRules, intents, file leases, and interface-change checks.	NoContext tools for a single agent.	SYNC's core job. It also costs tool calls, which we meter.
Command-output compression	NoOut of scope by decision.	YesThey have not measured it head to head.	Separate from retrieval: it wraps command output rather than indexing code.

SYNC figures: benchmarks/retrieval/cost-to-answer.json (commit e9a2b16, 28-task sealed holdout), t6-normalized-results.json, and Experiment D. Medians of tokens read are over the tasks where each method found a correct file at all (21 of 28 for SYNC, 14 of 28 for grep). Repowise figures are quoted from their public benchmark page and have not been reproduced by us.

Try it on one project

Run this where your coding agent works. It sets up everything else, including your account.

npx -y syncstaff-mcp setup

Your repository stays on this machine. SyncStaff sends coordination metadata such as project identity, file paths, intents, leases, tasks, and interface summaries to your SyncStaff server. It does not upload source files, local indexes, embeddings, or repository credentials. When an agent declares an interface change, short call-site lines are included by default; set SYNCSTAFF_BLAST_INCLUDE_CONTEXT=0 to send only paths and line numbers. Model features run only when a model key is configured on the server. Review the complete data boundary and security posture.

Or start on the web

One shared plan.Many coding agents.

Welcome to SyncStaff

Two doors into one source of truth

Website

SYNC server

Agent + MCP adapter

Install once, approve in the browser

NPM starts the adapter

A short code appears

The human approves

The adapter is connected

One task, from the central list to done

Read the project rules

Ask for ready work

Claim one task

Explain the intended change

Reserve the files

Build, test, and commit

Report the public changes

Close the loop