--- title: "Multiplayer AI coding for remote teams · Cork" description: "How remote teams run AI coding agents on one codebase: shared agent instructions, async handoffs, ownership, landing rules, and cross-machine awareness." canonical: "https://corkcli.com/blog/multiplayer-ai-coding-remote-teams" last_updated: "2026-11-14" published: "2026-10-03" author: "Kevin Vera" --- # Multiplayer AI coding for remote teams How remote teams run AI coding agents on one codebase: shared agent instructions, async handoffs, ownership, landing rules, and cross-machine awareness. By Kevin Vera · October 3, 2026 · [Guides](https://corkcli.com/blog/c/guides) · 7 min read Multiplayer AI coding for remote teams means several people, each running one or more AI coding agents on their own machine, working on the same codebase at the same time, often across time zones. It works when the team shares three things that agents cannot pick up from a hallway: the same instructions (checked into the repo), the same picture of who is changing what (visible across machines, not only per laptop), and the same landing rules (rebase, test, merge in order). The agent tools handle a lot within one machine; most of the gaps are between machines. ## What changes when the team is remote In an office, people avoid collisions informally: "I'm in the billing code this afternoon." Remote teams lose that, and agents make the gap wider: - **Agents multiply the number of writers.** Four people with three agents each is twelve writers on one repo. - **Each tool's coordination stops at one machine or one account.** Claude Code's agent teams are scoped to one session ("You can't create additional named teams or share a team across sessions"). Cross-session messaging reaches your own sessions, including ones on your other machines through Remote Control, but not a teammate's. - **Time zones turn handoffs into archaeology.** The person who knows why an agent changed `retry.ts` is asleep when the next person's agent touches it. ## Step 1: check the agent instructions into the repo Every agent on every machine should start from the same rules. Put them in the files the tools read automatically and commit them: - `CLAUDE.md` for Claude Code (it can also read an `AGENTS.md`). - `AGENTS.md` for Codex, which reads it from the repository root down to the working directory and stops adding files at 32 KiB by default. - Shared hooks and settings in `.claude/settings.json`, `.cursor/hooks.json`, or `.codex/` so guardrails apply on every machine, not only the one where someone set them up. What belongs there for a remote team: ```markdown ## Team rules for agents - Check `gh pr list --state open` before starting; do not start work an open PR covers. - Ownership: billing/ is @payments, web/ is @frontend. Do not edit another team's directory without a linked issue. - Commit at each green test run. Rebase on origin/main before pushing. - Never `git push --force`. Use `--force-with-lease` only on your own branch. - Write the "why" of non-obvious changes in the PR description. ``` Personal preferences go in each person's user-level files, not the shared ones. ## Step 2: make ownership visible Remote teams need ownership written down, because nobody can lean over and ask. Two mechanisms work together: - **CODEOWNERS** routes reviews: "Code owners are automatically requested for review when someone opens a pull request that modifies code that they own." That holds whether a person or an agent opened the pull request. - **An issue per piece of work, assigned before work starts.** Agents can check and claim issues with the `gh` CLI, as in the instructions above. Claims are what stop two time zones from fixing the same bug overnight. ## Step 3: write handoffs for the next time zone Agent context dies with the session; the next person's agent starts fresh. Make every handoff durable: - **Pull request descriptions carry the reasoning.** Ask agents to write what they changed, why, what they tried that failed, and what is left. - **Long-lived knowledge goes into the instruction files.** If an agent spent an hour learning that the payment retry path is idempotent only for card payments, that is one line in `CLAUDE.md` or `AGENTS.md` that saves the next agent the hour. - **Unfinished work is an issue, not a stale branch.** A branch named `agent/try-2` tells the morning shift nothing. ## Step 4: land in order, with the tests Distributed teams merge around the clock, so landing has to be safe without anyone watching: ```bash git fetch origin git rebase origin/main # full test suite git push ``` With several people's agents opening pull requests, a merge queue moves this to the server. GitHub's merge queue checks that each pull request passes required checks "when applied to the latest version of the target branch and any pull requests already in the queue," which catches two agents from two continents that each passed alone and break together. ## Step 5: see the whole team's agent activity Per-person dashboards do not show a team. For usage and cost, Claude Code can export OpenTelemetry metrics tagged with `user.email`, and with `OTEL_METRICS_INCLUDE_REPOSITORY=true` (v2.1.269 or later) the repository too: ```bash export CLAUDE_CODE_ENABLE_TELEMETRY=1 export OTEL_METRICS_EXPORTER=otlp export OTEL_EXPORTER_OTLP_ENDPOINT=https://otel.example.com:4317 export OTEL_METRICS_INCLUDE_REPOSITORY=true export OTEL_RESOURCE_ATTRIBUTES="team.id=payments" ``` That answers "who is running agents, where, and at what cost." It does not answer the question remote teams need answered in the moment: is someone else's agent changing the code mine is about to change? ## Where the tools stop | Need | Within one machine | Across a remote team | |---|---|---| | Isolate edits | Worktrees, `claude --worktree` | Separate clones (already true) | | Tell other agents what changed | Cross-session messaging, agent teams | Not covered by the agent tools | | Avoid editing the same code | File ownership, local hooks | CODEOWNERS and issues, after the fact | | Catch breaking renames | Tests after rebase | Tests after rebase, merge queue | The right column is where remote multiplayer coding loses time: conflicts and broken renames are found at merge time, hours after the agents that caused them finished. ## How Cork helps Cork fills the right column. Cork is the [coordination layer](https://corkcli.com/blog/coordination-layer-ai-coding-agents) for 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. For a remote team specifically (the paid plan adds teammates' machines): - **Live awareness across machines:** when a teammate's agent in another time zone renames a function yours depends on, 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. - **Briefing and shared knowledge:** each agent starts with the exact signatures, callers and recent changes of the code it is about to touch, and `remember` notes anchored to code are there for the next person's agent. - **Agent messaging:** any agent can message whoever is working on a given function, which turns an overnight handoff into a message the right agent receives. - **Landing and team dashboard:** `git push` becomes rebase, rerun tests, push; the dashboard shows the repo's activity. The paid plan bills agent hours, not seats: $20 a month per unit of 100 hours, pooled across the workspace, with 15% off a year, and includes 90-day history. In Cork's 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 it once for every repo on the machine: ```bash curl -fsSL https://corkcli.com/install.sh | sh ``` ## Frequently asked questions ### What is multiplayer AI coding? Several developers, each running AI coding agents, working on the same codebase at the same time. The coordination problem is the same as for human teams, with more writers moving faster. ### Can Claude Code agents on different people's machines talk to each other? Not through Claude Code itself. Cross-session messaging reaches your own sessions, including on your other machines through Remote Control, and agent teams live inside one session. Teammates' agents need a shared channel such as a coordination layer. ### How should remote teams share instructions for AI agents? Commit them: `CLAUDE.md` for Claude Code, `AGENTS.md` for Codex and other agents, and shared hook settings in each tool's project config. Keep personal preferences in user-level files. ### How do remote teams avoid AI agent merge conflicts? Claim work before starting, split ownership by directory, rebase and test before landing, use a merge queue, and add live cross-machine awareness so agents see each other's changes before merge time. ## Sources - - - - - - - ## Related reading - [How to coordinate AI coding agents across a team's machines](https://corkcli.com/blog/coordinate-ai-coding-agents-across-team): 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. - [How to coordinate Cursor and Claude Code on the same codebase](https://corkcli.com/blog/coordinate-cursor-and-claude-code-same-codebase): Run Cursor and Claude Code on one repo without clobbered edits: shared AGENTS.md instructions, worktrees, shared MCP servers, hooks, and a coordination layer. - [How to run multiple Claude Code agents on one repo without conflicts](https://corkcli.com/blog/run-multiple-claude-code-agents-one-repo): Run several Claude Code agents on one repository safely: worktrees, subagents, agent teams, cross-session messaging, and a clean landing routine, step by step. - [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/multiplayer-ai-coding-remote-teams