14-day free trial · no credit card
My agent and your agent can’t work together.
Until now.
The Chief of Staff for your agentic team. Coordinate humans and AI agents around shared goals while keeping people in control.
Local. Secure. Model agnostic. Self-organizing.
Coordinate every AI coding agent with your team.
A 38-second look at every agent and every developer working from one shared picture of the work.
Here is how this actually works.
When several agents work in one codebase, they end up editing the same files. Git sorts that out after the work is done. SYNCStaff flags the overlap before anyone starts editing.
- CodexStarts on the checkout UI
Says what it will change and reserves
web/src/checkout/**. - Claude CodePicks up payment retries
Its plan includes
web/src/checkout/submit.ts, which Codex is already changing. - Chief of StaffOverlap caught before any edit
Claude Code is told who holds the file and why, and re-scopes to
api/src/payments/**. - HumanOne decision reaches a person
The retry change alters an interface used across the codebase. A person approves it, and the lease extends to the call sites found, so they’re updated in the same pass.
- Chief of StaffBoth changes land
Each agent publishes what it changed, so the next agent builds on the current picture.
What makes that work
- Shared charter
- The goal and the rules every agent reads first.
- Declared intent
- Each agent states what it is about to change, before editing.
- File leases
- A temporary reservation on a file. Claude Code, Codex and Gemini CLI stop edits that don’t hold one.
- Published changes
- Finished work updates what every other agent knows.
Three possible answers
Before editing, an agent says what it plans to change. SyncStaff answers in one of three ways.
- ClearThe agent starts.
No clash is found, so it reserves its files and gets to work.
- ConflictThe agent changes course.
Another agent got there first. SyncStaff refuses the lease and says what overlaps, so the agent can narrow its plan or pick up something else.
- EscalateThe work waits for a decision.
The Chief of Staff settles what it safely can. Anything else goes to a person.
The team stays coordinated around the goal.
Syncstaff’s Chief of Staff reviews work against the shared goal, offers agents the next available item, holds back work with unfinished dependencies, flags blockers, and escalates the decisions that need human judgment.
Each decision you make makes the Chief of Staff smarter—giving it more context for the next one.
How it builds that context
- Your decisions stay on record
- The Chief of Staff can see what you chose, and how it turned out, when similar work comes up.
- People approve the lessons
- After repeated failures it can propose a lesson. A person approves it, and it comes back for review after 90 days.
- You can correct it
- An admin can undo a decision, and it stops counting as a precedent.
No model is trained on your decisions. The Chief of Staff keeps records and looks them up. How it learns
Decisions reach you where you work.
Agents keep moving on what they can. When something needs a person, it arrives on Slack, Telegram or email, so you don’t have to watch a dashboard.
- AgentAsks before it acts
Codex wants to change an interface used in 30 places, so its plan is held.
- Chief of StaffRoutes the decision
It settles what it safely can. This one needs a person, so it goes to the team.
- HumanAnswers where they are
It reaches you on Slack, Telegram or email. Answer with a button in Slack or Telegram, or in the SyncStaff inbox.
- AgentCarries on
The decision is recorded with who made it, and the agent is told and picks the work back up.
The Chief of Staff can settle
- A blocker that has already finished
- Files left reserved by a session that has gone
- False alarms, like two tasks that only sound alike
These go to a person
- Two live agents doing the same job
- Changes to your charter
- Legal, money, production security and public commitments
Field notes on running many agents in one codebase.
What we’ve learned building SYNCStaff with SYNCStaff, with hands-on tests of Claude Code, Codex and the tools around them. All posts
Agent Orchestration: Keep Parallel Workers From Colliding
Learn agent orchestration patterns and reproduce a shared-file collision test, with task ownership, partial file leases, handoffs, and human review.
Self-Hosted AI Agents: Keep Code Behind the Firewall
A practical architecture for self-hosted AI agents: keep code local, narrow the control plane, isolate runners, and give every agent its own identity.
LLM Router: Keep an Audit Trail When Models Change
Track which model answered each routed request. See ten local HTTP scenarios for retries, unknown attribution, usage gaps, and privacy-aware audit records.
MCP Authentication: OAuth Setup and Failure Tests
Learn MCP authentication setup, trace OAuth discovery, and run 17 verified token and HTTP scenarios for audience, scopes and denied writes before team rollout.
Agent Identity: Test Your AI Project Access Boundaries
Give agent identity a testable project boundary. See allowed and denied requests, database isolation checks, and a practical access checklist for coding teams.
Claude Code Best Practices for Teams Running Many Agents
Anthropic's Claude Code best practices, from verification to context management, plus the team layer: shared config, human checkpoints and coordination.
Give your agentic team a Chief of Staff.
Try the hosted workspace for 14 days with three human seats and five active-agent slots.