--- title: "How to coordinate AI coding agents across a team's machines · Cork" description: "Coordinate AI coding agents across a team's machines: shared agent instructions, branch and PR rules, CI gates, live signals, and what built-in tools cover." canonical: "https://corkcli.com/blog/coordinate-ai-coding-agents-across-team" last_updated: "2026-11-14" published: "2026-10-03" author: "Kevin Vera" --- # How to coordinate AI coding agents across a team's machines Coordinate AI coding agents across a team's machines: shared agent instructions, branch and PR rules, CI gates, live signals, and what built-in tools cover. By Kevin Vera · October 3, 2026 · [Guides](https://corkcli.com/blog/c/guides) · 7 min read To coordinate AI coding agents across a team's machines, you need three layers: shared rules every agent loads (an `AGENTS.md` in the repo, plus committed hook and MCP config), a landing process that tests each change against everything that landed before it (small PRs, required status checks, branches kept up to date or a merge queue), and a live signal between machines so an agent knows what other people's agents are changing right now. The first two are standard git and CI practice. The third is where most teams have a gap, because agent tools coordinate one person's sessions, not a whole team's. ## Why it gets harder across machines On one laptop, you can see every terminal. You know your two agents are both in the billing module, and you can pause one. Across five people, each running two or three agents, nobody sees the whole picture: - Alice's agent renames a function at 10:02. Bob's agent, on another machine, writes three new call sites to the old name at 10:05. Both pass their own tests. - Two agents fix the same flaky test in different ways. - An agent spends ten minutes rediscovering how the auth flow works, which a teammate's agent mapped out yesterday. None of these is a git conflict. Git only sees them when branches meet, and some (like duplicated work) it never sees. ## Layer 1: shared rules every agent loads Start by making every agent, on every machine, start from the same instructions and the same guardrails. Commit them to the repo so they travel with `git pull`. - **Instructions.** `AGENTS.md` at the repo root is read by Codex and Cursor, and Claude Code reads it when there is no `CLAUDE.md` (or you import it with `@AGENTS.md`). Put build and test commands, conventions and "do not touch" areas there. - **Agent hooks.** Claude Code reads hooks from `.claude/settings.json`, which "can be committed to the repo." Codex reads `/.codex/hooks.json`, loaded once the project's `.codex/` layer is trusted. Cursor reads `.cursor/hooks.json`. - **Shared tools.** Claude Code's project-scoped MCP servers live in `.mcp.json` at the repo root: `claude mcp add --transport http --scope project ` writes it, and the docs say to "commit this file to version control so your team shares the same MCP tools." Cursor reads `.cursor/mcp.json`. - **Ownership.** A `CODEOWNERS` file maps paths to reviewers, and GitHub requests them automatically. ## Layer 2: a landing process built for many small changes Agents produce more, smaller changes than people do. Your merge process should assume that. 1. **One branch per agent task.** Use [git worktrees](https://corkcli.com/blog/git-worktrees-parallel-ai-coding-agents) on each machine so local agents do not write to the same files: `git worktree add ../app-task-a -b task-a`, or `claude --worktree task-a` in Claude Code. 2. **Small PRs, merged often.** The longer a branch lives, the more it drifts from what other agents are landing. 3. **Required status checks.** In GitHub branch protection, required checks must pass before merging, and the strict option means "the branch must be up to date with the base branch before merging." That forces each change to be tested against teammates' work. 4. **A merge queue for busy branches.** GitHub describes it as a way to automate merges "into a busy branch and ensuring the branch is never broken by incompatible changes." This layer catches broken combinations. It catches them late, though: after the agents have finished, often after the person has moved on. ## Layer 3: a live signal between machines The missing piece is knowing, during the work, what other agents are touching. Teams try a few things: - **A chat channel or issue claims.** People post "taking the billing refactor." It helps, but agents do not post, and people forget. - **Built-in agent messaging.** Claude Code's cross-session messaging lets Claude message "your other Claude Code sessions on this machine," and with Remote Control your own sessions on other machines and in the cloud. It is scoped to one person's Claude sessions, and messages are plain text that Claude sends when it decides to. Agent teams coordinate teammates inside one lead session. Neither reaches a colleague's Codex or Cursor agent. - **Locking files by convention.** Some teams assign directories to people for a sprint. That avoids collisions by avoiding parallel work, which gives up much of what agents offer. What a real live signal needs: it should work across tools (Claude Code, Codex, Cursor), across people, at the level of functions rather than whole files, and without each agent spending tokens to ask. ## A working setup, step by step 1. Commit `AGENTS.md`, agent hook config and project MCP config to the repo. 2. On each machine, run agents in worktrees or separate checkouts, one branch per task. 3. Turn on required status checks with the up-to-date rule, and a merge queue if your main branch is busy. 4. Add a [coordination layer](https://corkcli.com/blog/coordination-layer-ai-coding-agents) for live awareness across machines and tools. 5. Review weekly: which collisions still reached CI, and what rule or instruction would have caught them earlier? ## How Cork helps Cork is the coordination layer for [multiplayer coding agents](https://corkcli.com/blog/multiplayer-coding-agents): it keeps Claude Code, Codex and Cursor agents, on one machine or across a team's machines, from overwriting each other on one codebase, and hands each agent what the others already learned. Across machines is the paid plan. With it, agents on teammates' machines see each other: - **Live awareness:** when an agent on any teammate's machine changes code yours depends on (a rename, a new signature), your agent hears it on its next step. - **[Write gate](https://corkcli.com/blog/write-gate):** an edit against code another agent is changing right now is held until your agent has their version. - **[Semantic lint](https://corkcli.com/blog/semantic-lint):** a teammate's rename or signature change becomes a lint rule your agents are checked against. - **Briefing and shared knowledge:** each agent gets the signatures, callers and recent changes of the code it is about to touch, and the paid plan adds shared knowledge across the team, prompts matched to code by meaning, and 90-day history. - **Landing:** `git push` becomes one step that rebases onto teammates' commits, reruns the tests and pushes. Cork does not run agents or host machines; your agents keep running where they already run. The paid plan bills agent hours, not seats: $20 a month per unit of 100 hours, pooled across the workspace, graduated to $17 (units 11 to 50) and $15 (51 and up), with 15% off a year. In Cork's published benchmark (12 Claude Code agents at once on one repository, hard tasks), agents with Cork used 53% fewer tokens than the same agents without it. Install on each machine with: ```bash curl -fsSL https://corkcli.com/install.sh | sh ``` ## Frequently asked questions ### Can Claude Code agents on different computers talk to each other? Your own sessions can, through cross-session messaging over Remote Control, which needs a claude.ai sign-in. Sessions belonging to different people are not covered by that feature; you need a shared tool or service for that. ### Do git worktrees solve conflicts between teammates' agents? No. Worktrees isolate files on one machine while agents work. Changes from different people still meet at merge time, so you still need up-to-date checks, a merge queue, or live coordination. ### What should go in a shared AGENTS.md for a team? Build and test commands, architecture in brief, conventions an agent would not guess, areas not to touch, and how to land a change. Keep it short; Codex stops reading project instruction files at 32 KiB by default. ### How do I share MCP servers with my whole team? In Claude Code, add the server with `--scope project` so it is written to `.mcp.json`, and commit that file. In Cursor, commit `.cursor/mcp.json`. ## Sources - - - - - - - - - - - - - - ## Related reading - [Multiplayer AI coding for remote teams](https://corkcli.com/blog/multiplayer-ai-coding-remote-teams): How remote teams run AI coding agents on one codebase: shared agent instructions, async handoffs, ownership, landing rules, and cross-machine awareness. - [Parallel AI coding agents on a team: how to split who works on what](https://corkcli.com/blog/split-work-parallel-ai-coding-agents-team): How a team splits work across parallel AI coding agents: slice by code ownership, name shared files, one branch per agent, small tasks, and live coordination. - [Codex hooks and Cursor hooks: how to use them for team coordination](https://corkcli.com/blog/codex-cursor-hooks-team-coordination): How Codex and Cursor hooks work as of October 2026, where the config lives, how to block or brief an agent, and how to use hooks to coordinate a team's agents. - [Shared memory for coding agents: notes anchored to code](https://corkcli.com/blog/shared-memory-coding-agents-anchored-notes): Give AI coding agents shared memory: instruction files, path-scoped rules, auto memory, and notes anchored to functions so the right agent reads them. [All articles](https://corkcli.com/blog.md) · [Cork in Markdown](https://corkcli.com/index.md) · [llms.txt](https://corkcli.com/llms.txt) This page in HTML: https://corkcli.com/blog/coordinate-ai-coding-agents-across-team