Multiplayer Takeover: Teammate Sessions Are Documented Twice, Handing Back Is Unsolved

Teammate takeover of agent work appears in exactly two public sources: Ramp's in-house Inspect writeup and GitHub Next's Ace research prototype. Every mainstream vendor takeover mechanism is single-player by construction, built on the assumption that the human picking up the agent is the human who started it. The return trip is in worse shape. A KAIST-led study in March 2026 found that an agent resuming after a human edit cannot tell whether the edit was feedback or unrelated parallel work, and concurrent human action turned up in 31.8% of turn-level interactions. The solo half, one person pulling their own agent's work, is set by the four-transfer standard, which this page extends in two directions the vendor docs do not cover: teammate B taking over teammate A's session, and the agent resuming after a human touches the work.

Every vendor mechanism resolves "the human" to "the task creator"

Claude Code's teleport enforces it most literally: pulling a cloud session into your terminal requires the same claude.ai account that started it, the same repo, and a clean git state. Cursor pushes the agent's branch "to your repo for handoff" and lets you take its remote desktop, then "release control back to the agent." Codex moves "your thread and code" between your checkouts. GitHub Copilot's coding agent leaves the most team-readable artifact, a branch and a draft PR anyone can see, but a teammate gets the code only: per the four-transfer table, its conversation is readable, not resumable, and the environment and process state never transfer. The teammate is back to "let me reconstruct what the bot was doing."

The single-player assumption is not an oversight. It is inherited from the laptop model. When the agent ran on your machine with your token, "your agent" was the only possible case. Cloud sessions removed the technical barrier and the products kept the assumption. The result is that agent sessions are private property in tools that are otherwise built for shared work. Your teammate can read your PR but not your agent's reasoning, your dead ends, or the constraint you gave it in turn three that explains the odd design choice in the diff.

Ramp's Inspect proves the team case ships, in-house

Ramp's Inspect writeup (January 2026) is the one shipping exception, and it is internal tooling rather than a product anyone can buy. Inspect sessions are explicitly multiplayer: "Send your session to any colleague, and they can help take it home." The same session can be driven from Slack, the web interface, a Chrome extension, hosted VS Code, and pull request comments, and "all changes are synced to the session, so you never lose your work while switching around." Ramp also states the authorship rule that makes this governance-relevant: "Each person's prompt that causes code changes should be attributed to them."

That is real teammate-takeover evidence, but it is not a complete published standard. Ramp describes a sandboxed VM on Modal, synced changes across clients, manual edits in hosted VS Code, and per-prompt authorship metadata. It does not spell out the four-transfer bar, the process-state semantics, or the exact audit record when one person edits manually and another hands back to the agent.

Ace transfers all four axes by sharing one cloud workspace

GitHub Next's Ace, demoed publicly by Maggie Appleton in April 2026, is the cleanest prototype of teammate takeover as a shared workspace, and its mechanics map directly onto the four transfers. Each session is a multiplayer chat backed by a microVM in the cloud on its own git branch. A teammate entering your session gets the branch, the environment, and the conversation at once: "I just jump into their session, and see what they're up to. Including their whole prompting history with an agent to understand how they arrived at the current state of things." Process state is shared because everyone uses the same cloud computer: "We can all see the same preview, we can all write terminal commands and see shared outputs."

Prompting is multiplayer too. "I initially kicked off this session, but we can both prompt the agent," and the agent reads the whole team conversation as input. Sessions outlive laptops: "I can close my laptop and work can continue."

The caveat is maturity. Ace is a research prototype entering technical preview with a few thousand testers, not a shipping product. Appleton's framing of why it exists is the team-sport thesis stated flat: "Alignment has always been a bottleneck. But agents have made the cost of not being aligned as a team much higher."

The reverse seam: agents misread a third of human edits

Takeover has a return direction. You step in, fix something, and hand back. What does the agent do with your change?

It guesses, and it guesses badly. A KAIST-led study, "When to Hand Off, When to Work Together" (arXiv, March 2026), put humans in shared workspaces with visible agent execution. Study 1 (N=10) found that visibility naturally prompted mid-task intervention, and that "agents lacked the collaborative context awareness needed to distinguish user feedback from independent parallel work." An agent resuming after your edit cannot tell whether you corrected it or did something it should leave alone. This is not a rare edge case: in Study 2, concurrent human action appeared in 31.8% of 214 turn-level interactions. The authors built CLEO, a design probe that classifies concurrent user actions as feedback versus independent work and adapts execution accordingly. That is the missing capability built and tested once, in a design domain rather than code. No coding product ships it. The closest shipping mechanisms are Cursor's "release control back to the agent" and Imbue Sculptor's live bidirectional sync, which transport the human's changes without interpreting them.

Both gaps reduce to the same attribution gap

If the agent cannot distinguish your correction from your contribution, neither can the audit record, unless the environment marks the seam explicitly: who acted, from which turn, on whose initiation. That makes multiplayer takeover a compliance property, not a convenience feature, and it is why this page leans on the same machinery as attribution and the audit record of a takeover. A managed substrate that mints a per-session token scoped to the task creator and writes an append-only external session-event log can stamp the seam by construction; the published record does not yet show any vendor doing this for the teammate-handback case, so the claim is about what the architecture makes possible, not about a shipped feature.

The field has shipped many takeover buttons for your own agent, one in-house teammate model at Ramp, one research prototype in Ace, and no complete public answer for handing back to the agent. The mixed-initiative literature described this negotiation of control in Eric Horvitz's 1999 CHI paper. Twenty-seven years later, coding platforms hold pieces of it.