aq.dev / guides / best-ai-coding-tools-for-team-collaboration

The Best AI Coding Tools for Team Collaboration in 2026

The best AI coding tool for team collaboration depends on where work starts and what teammates can inspect before merge. For a shared live workspace, AQ, Superconductor and Amp expose the terminal, files and running app; Zed provides live human co-editing with agents; Slack Code brings agent plans, diffs and previews into a team channel; ONES connects issue context, repository actions and worklogs through MCP. Judge each option on five things: whether teammates share a live session, who can steer and with whose credentials, whether reviewers can check the running work and the diff, whether every task gets an isolated branch or environment, and who controls access. Conductor, which offers shared cloud workspaces, said on November 12, 2026 that it will keep developing the app. Two launches from this week add new team shapes: Carta Evergreen puts teammates and agents in shared cloud sessions, and Amp Spaces gives a team one conversation whose agent creates and delegates the threads.

AQ is a multiplayer workspace where a team runs AI coding agents like Claude Code and Codex together in real time: teammates open the same live work item, watch the agent work as it happens, message it to steer the run, and review the diff and the running app preview in one place. Each task gets its own branch and git worktree on an AQ-managed or customer-connected machine. A teammate's message to the agent runs on their own accounts unless the owner grants driving rights, and typing into a shell needs the owner's approval. Sharing is on the AQ Pro plan (pricing); what AQ is covers the product.

Which tools let teams build with coding agents together?

AQ lets a team build with coding agents together in one shared work item: the agent works in a conversation every teammate can open and message, the code changes and the running app are visible while it works, and the team reviews and merges from the same place. Superconductor, Amp, Poly and Warp Oz also let teammates join or steer a shared agent run. Cursor Projects gives a team a shared task board and project context, with each person directing their own agent, and Devin's Teams plan shares knowledge, playbooks and secrets across an organization. The difference that matters is whether teammates work in the same run or each run their own agent against shared context; the tables below sort the options by that.

What are the best platforms for shared AI pair programming?

For pair programming with an agent, both people need to see the same work at the same moment and either of them needs to be able to redirect it. AQ supports that: two teammates open the same work item, follow the agent's edits and tool calls live, and either one sends it the next instruction from the shared thread on their own account; a shell in the work item can be handed over with Request control and Grant control. Zed fits pairing inside an editor, with live co-editing and external agents such as Claude and Codex. Superconductor and Amp let a teammate steer alongside the person who started the run. Claude Code cloud sessions show a session's latest state when the link is opened, which suits review after the fact.

GitHub, Slack, Carta Evergreen and Amp Spaces claims were rechecked against first-party sources on November 8, 2026. Cursor Projects and its multiplayer documentation were checked on November 11, 2026 and again on November 13, with Devin's Teams plan and docs. Poly, Multiplayer and the AQ claims touched in this update were checked on November 12, 2026. Other existing competitor rows retain their earlier first-party checks. The November 5 workflow evidence remains below, including its original test command and result, with the date of that run made explicit.

Choose where work starts and where delivery evidence lands

A shared terminal answers one workflow question. An issue that receives a worklog answers another. Use this table to match the collaboration surface to the handoff your team actually needs.

Collaboration shapeWhere work startsWhat teammates can inspect or doWhere delivery evidence landsWhat the cited sources do not establish
Shared live workspace: AQ A prompt, GitHub issue or Linear issue opens a work item. A person starts the agent. Open the same terminal, editor, files, app preview and agent thread. Request terminal control or send an AQ message as yourself. Preview comments, the Changes diff, line comments, review threads and a pull request. See changes, review and merge. A worktree limits file collisions. It does not limit the process's network reach or access to other files available to its OS user.
Issue and worklog workflow: ONES An MCP-capable client reads an ONES issue, including reproduction steps and other issue context. A separately connected Git repository MCP server handles repository operations. The client can write hours, comments and valid workflow transitions back to ONES. ONES issue comments, worklogs, workflow state and linked code activity, plus the repository branch or merge request. The ONES MCP guide does not describe a shared live terminal, editor or app preview. Repository operations require the separate Git MCP server.
Chat channel: Slack Code Mention a supported coding agent in Slack to create a code channel around a task. Discuss the work and inspect plans, diffs and agent-supplied previews. For Copilot, any participant can provide input, while steering requires write access to every selected repository. The code channel retains the conversation and work record; the connected agent or partner workflow produces the code change and pull request. Slack's announcement does not establish shared terminal or editor control. Copilot's integration docs supply its own permission and identity rules, which should not be generalized to other agents.
Live human co-editing: Zed Share a project from Zed's Collaboration Panel, or start an external agent thread through the Agent Client Protocol (ACP). People edit the same project at once and see each other's cursors and edits. External agents such as Claude and Codex run in their own processes with their own authentication. The shared project contains the edits and agent threads. Your repository and pull-request process supplies the delivery review. Zed's collaboration docs do not establish a shared cloud-agent workspace. Sharing a project gives collaborators access to its local files, so Zed warns to collaborate only with people you trust.
Shared cloud session: Carta Evergreen A person opens a session, an automation starts one, or, in Carta's example, a Datadog alert starts one on its own. Join the shared session, watch the agent work and tell it where to look next. Claude, Codex, Grok and Muse are named as supported agents. Pull requests the agents push; Carta says its automations carry changes through checks, review and merge. Carta's launch post does not say whose credentials an agent uses, who may steer, or who approves a merge.
Coordinator conversation: Amp Spaces Start a space with a title and a project, then tell its agent what to work on. Discuss in the space with comments, tag Amp when ready, and move between the overview of threads by status and any single thread the agent created. The threads the space's agent delegated, plus artifacts it keeps in the space, such as a security-review summary in Amp's example. Amp's Spaces post does not describe identity, permissions per thread, or how code changes are reviewed and merged.

Issue to delivery: two documented paths

ONES: ONES issue -> MCP client reads the issue -> separately connected repository MCP performs branch, commit or merge-request operations -> client writes a worklog and summary comment and can execute a valid workflow transition. The transition must be available in the configured ONES workflow. The repository MCP connection and its permissions are a separate part of the setup. See the documented bug-to-repository workflow.

AQ: Linear or GitHub issue -> prepared isolated workspace -> person starts the agent -> teammates inspect and steer -> pull-request review. With Linear, the ai-task label prepares the work item and moves the issue to In Progress, but deliberately does not auto-launch an agent. Status syncs both ways, ownership follows the assignee, and the workspace tracks the pull request. AQ's Linear integration docs describe that flow; they do not describe ONES-style worklog support.

Both paths keep a person responsible for starting or directing work and for accepting the result. Choose ONES when the issue worklog and workflow transition are the main handoff. Choose AQ when teammates need to inspect the live execution workspace before the pull request.

Start with Anthropic's own docs

If your team runs Claude Code, Anthropic's documentation is the primary reference for what Claude Code itself does, and this guide is the team-workflow layer above it. Three pages matter most for collaboration:

  • Claude Code cloud sessions run on an Anthropic-managed VM (or your organization's self-hosted environment), keep running after you close your laptop, and can be steered from any device by the person who started them. Team and Enterprise accounts can share a session with Team visibility; recipients see the latest state when they open the link, and the docs say their view does not update in real time.
  • Agent teams coordinate several Claude Code instances, with one session as lead and a shared task list. The teammates are Claude instances, not people. The feature is experimental and off by default, enabled with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1.
  • Best practices recommend giving Claude a check that comes back pass or fail, and a reviewer subagent limited to read-only tools. Both carry over to team review: agree on the check before a teammate takes over, and keep the reviewer separate from the author.

None of these pages describes two people joining one live terminal. The tools above and below provide different collaboration surfaces for that job.

The five team criteria, tool by tool

ToolShared live sessionWho can steer, and whose credentialsReview of running workIsolation per taskAccess control
AQ Yes: terminal, editor, app preview, files and agent thread Terminal input after the owner approves a control request. In an AQ agent thread, a message runs as the sender on their own accounts; running as the owner needs the owner's "Can drive my sessions" grant. Live preview with comments, and a Changes panel with line comments, review and merge Own git worktree and branch per work item Owner shares with specific people or the whole team; organization admins manage membership
Poly
Checked Nov 12
Yes: a room's live prompts, answers, changes, code, files, chat and decisions, plus an app preview and optional GitHub repository connection Poly says any member can prompt, answer, approve or stop the agent. Turns use Poly's provider accounts with no member API keys. Pro and Max users each pay for their own turns; Team uses a shared balance. Live preview, attributed turn receipts, undo and pull-request review A fresh container on Poly's servers per AI turn, with a git workspace behind the room. See security. Invite-only rooms; view-only watch links can be turned off by any member
Multiplayer
Private beta, checked Nov 12
Shared coding sessions and context, agent memory and a live view of agents; the homepage also lists model routing and multi-agent mode Per-member steering and approval permissions are not documented. Users connect their own model providers; per-member credential behavior is not documented. A live agent view is shown. Diff and pull-request review records are not documented on the homepage. Execution location and per-task isolation are not documented on the homepage Private beta; room roles and repository permissions are not documented on the homepage
ONES A shared issue and delivery workflow through an MCP-capable client; a shared live terminal, editor or app preview is not documented The person directing the client uses the connected ONES and repository integrations. Repository operations require a separately connected Git MCP server. Issue comments, worklogs, valid workflow transitions and linked code activity; branch or merge-request review through the repository Determined by the connected repository workflow; per-task environment isolation is not described in the ONES MCP guide Access depends on the connected ONES and repository accounts and their configured scopes
Slack Code A code channel brings teammates and an agent into one conversation with plans, diffs and agent-supplied previews; shared terminal or editor control is not documented Permissions depend on the agent. For Copilot, any participant can provide input; starting and steering require write access to every selected repository. Shared-context artifacts use GitHub's app identity. Plans, diffs, agent-supplied previews and human approval for high-stakes changes in the channel A dedicated code channel per project; execution-environment isolation depends on the connected agent Slack permissions and admin controls, plus each agent integration's repository and identity rules
Zed Yes, live human co-editing in a shared local project, with cursors and edits visible; external agents integrate through ACP People co-edit the project. An external agent usually owns its runtime, authentication, model selection and tools; shared control of one external-agent thread is not documented. Shared edits and agent threads; app-preview and pull-request review are not described in the cited collaboration docs A per-task cloud worktree is not documented. Sharing a project gives collaborators access to its local files. Zed sign-in, channels and contacts; Zed warns to share local projects only with people you trust
Superconductor Yes: "each agent session is accessible by everyone on the team" Teammates can "take the wheel, steer alongside them, or just review." Credentials are held at the workspace level. Multiplayer chat, app inspection and a full diff with guided review Isolated cloud environment per implementation Team-level permissions
Amp Yes, for non-private threads running in an orb or on a shared runner Members given Contribute can prompt the agent and use its terminal and files. Costs bill to the thread owner. Teammates can open the orb's portals (the running app) and files Per-thread orb Thread visibility (private, workspace, group) plus Contribute
Amp Spaces
New Nov 6
A shared space conversation whose agent creates and coordinates threads; teammates comment there and open individual threads Teammates post feedback and bug reports and tag Amp; the space's agent decides which threads to create. The post does not state steering permissions or whose credentials a delegated thread uses. An overview of the space's threads by status, plus artifacts the agent keeps in the space; app and diff review are not described in the post One thread per delegated piece of work; thread runtimes follow Amp's existing thread model Not described in the Spaces post
Carta Evergreen
New Nov 5
Yes: "Teammates and agents work in shared sessions that run in the cloud" Teammates who join can tell the agent "where to look next." Runs on Claude, Codex, Grok and Muse; whose credentials it uses is not stated. Watching the session live; agents push pull requests, and automations run through checks, review and merge "Isolated sessions" Scoped access, audit logs and spending caps, listed without further detail
Warp Oz Yes, through an Agent Session Sharing link Teammates can "hop in and steer." Warp does not document a per-teammate credential change. Session view with PRs, branches and plans; no shared editor or app preview documented Per agent run, on your infrastructure or Warp's Link-based; Warp's post does not detail link permissions
Conductor
Still in development
Shared Conductor Cloud workspaces; check conductor.build for Cloud's current status Organization members can prompt agents together in Conductor Cloud Review and merge in the Mac app; export or transfer a cloud workspace to local if you want a copy Git worktree per workspace Conductor organization membership
Cursor cloud agents Read-only viewing for teammates with their own repository access Follow-ups only if an admin enables them. The agent keeps running with the original creator's secrets and credentials. Conversation, changes and artifacts; not a shared terminal or editor Isolated cloud VM per agent Team membership plus repository access; admin setting Disabled, Service accounts only, or All
Cursor Projects
Multiplayer beta, Nov 10
Shared task board, owners, work status, PRs, documents and project context. Each teammate still has a separate coordinator/worker chat with local context; no shared terminal or editor is documented. Each member's chat runs and bills as that member. Cursor says in-progress work can pass to a new teammate's agent, and teammates' agents can coordinate. Agent side chats never share secrets, credentials or tokens. Shared tasks and PRs, plus project documents and decisions; the launch does not establish shared live-app review Projects run on Cloud Agents. Joining is unavailable on a self-hosted Project; do not infer every older cloud-agent permission behavior. Team invite plus repository access, Cursor 3.26.13 or later; rolling out in beta. See Projects docs.
Replit Agent 4 Shared project: who is on which task, what merged, what is in progress Teammates can "hop into a teammate's task and review"; prompting another person's agent is not documented Review a task before it touches main Isolated copy per task Project collaborators; Pro includes up to 15
GitHub Copilot cloud agent Actions cloud sessions are shared with repository users by default; cloud-sandbox sessions are unshared by default. Slack and Teams add shared conversation input. Shared local sessions are view-only. In Slack and Teams, any participant can provide input; starting and steering require write access to every selected repository. Steering consumes AI credits and is unavailable for third-party coding agents. Shared local recipients cannot steer. Session logs, file changes and pull requests. Teams Canvas provides read-only plans, file changes and PR overviews, not an interactive app preview or runtime. Actions: one repository and a 59-minute cap. Cloud sandboxes can work across repositories. GitHub documents one branch and at most one PR per task for both. Repository access; Slack and Teams additionally require write access to every selected repository. Up to 11 same-owner repositories applies to those integrations.
Claude Code cloud sessions Shared view only: latest state on opening, no live updates The session owner, from any device or with claude -p --cloud <session-id>. Teammate steering is not documented. Diff view with line comments sent to Claude; PRs and auto-fix Isolated VM per session Private or Team visibility (Team and Enterprise); repository verification on by default there
Devin Teams plan lists "Share and collaborate with multiplayer sessions"; the docs we checked do not describe joining a teammate's running session Not documented on the pricing page Devin Review of every diff, in Devin Desktop Sessions on your machine or in Devin Cloud Teams plan with SSO and centralized billing, up to 100 users; members see shared knowledge, playbooks, secrets and environment snapshots
Aether
Vendor claims
A live view of each task: commands and file changes stream as they happen, with a terminal and SSH into the devbox. Teammates joining a task is not described. The person running the task can approve the plan and steer. Claude Code, Codex or OpenCode run on that person's own provider account. Private preview URLs per port that can be shared; a lead agent's sub-agents return one pull request A Firecracker microVM per task; sub-agents each get their own devbox and branch Organization settings appear in the product, but access controls are not described on the homepage
Nimbalyst A shared wiki edited in real time (Wiki Teams); shared agent sessions are not listed Not listed; teammates' agents write into the same pages Shared decisions, mockups and diagrams with change history Not described for teams Team workspace, in beta

How to read "not documented": it does not mean the feature cannot exist. It means the first-party source checked for this update did not support a stronger answer, so the gap stays visible instead of being guessed.

This week's launches: what a teammate can actually do

Carta Evergreen (November 5) and Amp Spaces (November 6) both describe teams and agents working in one shared place. The useful test for each is what a second person can do once they open it. The table puts each launch beside AQ on the same six actions, using only what each first-party source says. Blank spots stay labeled as not described.

A teammate wants toAQCarta EvergreenAmp Spaces
Catch up on a run they missed Open the work item later: the agent thread's transcript, the Changes diff and the pull request card remain The post names replay as part of the problem Evergreen set out to solve; it does not describe a replay or snapshot view An overview that lists the space's threads by status, with a way to open any one
Join while the agent works Open the same live terminal, editor, app preview and agent thread from the shared work item Join the shared session and watch the agent work Comment in the space and open any thread; Amp says its own team took video calls and discussions into the space
Ask a coordinator to split the work Pick a crew: a lead agent proposes a plan, a person approves it, and the lead delegates build, test, review and research to other agents, builders in their own worktrees Not described in the launch post The space's agent creates and delegates threads; Amp: "You no longer have to create and organize threads yourself; the agent in a space will do it for you."
Steer, and know whose credentials run An AQ agent message runs as its sender on the sender's accounts; running as the owner needs the owner's Can drive my sessions grant. Terminal input needs the owner's approval. Crew members run as the lead thread's identity. Tell the agent "where to look next"; the post does not say whose credentials the agent uses Tag Amp in a comment or hand it a bug report; the post does not state per-thread permissions or credentials
Inspect the running app and the diff Live preview with pinned comments; the Changes panel shows this turn, uncommitted work or the branch, with line comments Not described beyond watching the session Not described in the Spaces post; Amp's portals expose a running app on ordinary orb threads
Carry the change through review and merge Commit, open a pull request and merge from Changes; merge waits while checks are pending or failing or the review is stale, and a person makes the merge decision Agents push pull requests; Carta says an automation removed almost 1,600 feature flags in a month, "each one checked, reviewed, and merged." Who approves is not stated. Not described in the post

Carta Evergreen

Carta built Evergreen for its own engineers and launched it to other teams on November 5, 2026. CEO Henry Ward describes the problem it addressed: "No one else could see it, replay it, or build on it, and when someone closed their laptop, their agent stopped mid-task." Evergreen is model-agnostic, naming Claude, Codex, Grok and Muse, and works with existing plugins and MCP servers. Teammates and agents share sessions that run in the cloud; in Carta's incident example, a Datadog alert starts a session on its own and the people needed join it, watch the agent and direct it. The security controls are listed as isolated sessions, scoped access, audit logs and spending caps, without further detail. The post offers a 7-day free trial and states no price.

Carta reports about 20,000 pull requests in its latest week, up from about 1,300 a week in January, and says it ships "15x more, more than 6x faster, with an 80% lower revert rate," with more than 80% of the company using Evergreen. These are Carta's own figures from its launch post, published without a methodology, and we have not verified them. Before rollout, ask Carta four things the post leaves open: whose credentials an agent uses after a teammate steers it, who may steer an alert-started session, who approves an automated merge, and what scoped access covers.

Amp Spaces

Amp describes a space as "a conversation with a single agent whose job is to spawn and coordinate agents for you." People discuss in the same surface: in Amp's examples, teammates used comments to chat and tagged Amp when they were ready, and the side panel lists the space's threads by status so anyone can move between the overview and a single thread. Amp's examples, all its own: the Spaces feature itself was built in a space, with teammates dropping feedback and bugs into the chat for the agent to delegate; one engineer ran a feature launch from a space that monitored X, Slack and bug reports, fixed bugs and handled emails and refunds; another gave a space a recurring security-review goal, which it split into 16 areas, keeping a summary for him to track. The post states no plan or price.

Spaces builds on Amp's threads and orbs, which the criteria table covers. Check identity before rollout: the Spaces post does not say whose credentials a delegated thread uses, who may steer each thread, or how code changes are reviewed and merged. For ordinary threads, Amp's docs bill agent and orb costs to the thread owner.

Where AQ overlaps

AQ covers the shared-workspace part of both launches: teammates open shared live workspaces with terminals, an editor and previews; each task gets an isolated worktree; real agent CLIs, including Claude Code, Codex, Grok and Muse Code, run on machines dedicated to the team; sessions keep running after a laptop closes; and review and merge happen in the Changes panel. A crew is AQ's coordinator: its lead agent plans, waits for a person to approve the plan, and delegates. This guide makes no claim that AQ offers alert-triggered incident sessions, feature-flag automation, a Space with calls, or Carta's reported throughput. See crews and roles and the AQ vs Amp comparison.

GitHub permissions and review depend on the surface

Copilot's Slack and Teams integrations became generally available on November 6, 2026. Any conversation participant can provide input, but only users with write access to every selected repository can trigger changes or steer. Slack guests and outside collaborators cannot start or steer. Steering consumes AI credits and is unavailable for third-party coding agents.

  • Context and repository scope. The entire Slack or Teams thread becomes context and is stored in generated artifacts. A direct message limits that shared-channel context. These integrations support up to 11 repositories with the same organization or personal owner, with write access required to every one.
  • Execution environment. GitHub Actions sessions use one repository and have a 59-minute maximum execution time. Cloud-sandbox sessions can work across repositories and do not carry the Actions limit in GitHub's comparison. The general docs describe one branch and at most one pull request per task for both environment types.
  • Artifact review and runtime access. Teams Canvas is read-only and shows plans, file changes and pull-request overviews. It is not an interactive app preview or entry into the agent runtime. Shared local sessions are view-only; recipients cannot steer or modify them.
  • Identity and approval. Shared-context artifacts use GitHub's app identity, while direct messages use the linked personal account. When an existing ruleset requires at least one approval, app-authored shared-context pull requests require one additional approval by default.

GitHub Actions cloud sessions are shared with repository users by default, while cloud-sandbox sessions are unshared by default. Read the Slack and Teams integration guides, the environment comparison, and the session-data rules.

The November 6 code-review update adds role-scoped settings, attribution, available effort metadata and reported skill, MCP and custom-instruction sources. It also exposes AI credits, compacts the overview, uses three reviewer models for Balanced effort with another model combining their findings, retries once and permits an eligible-model fallback. Metadata and reported sources do not prove that findings are correct. Enterprise and organization settings endpoints do not support GitHub Apps or fine-grained personal access tokens, while repository settings endpoints support both with administration permissions, so do not assume uniform API token support.

For a four-action breakdown of input, steering, artifact inspection and runtime access, see AQ vs Copilot cloud agent. For channel-specific details, see the Slack Code guide.

Prices and plans

  • AQ: Free is one person, with agents on your own Mac with the AQ Mac app. Pro is $50 per user per month during early access (standard $200), with unlimited seats, sharing, your own cloud or a dedicated AQ-managed machine; a seat is billed only once the invited person accepts. Early-access teams keep $50 for their first 12 months. Source, checked November 12, 2026.
  • Poly: Free to start. Pro is $20 per month and Max is $50 per month for each person who runs AI turns; watching, chatting and approving are free. Team early access uses one shared credit balance, priced with the vendor. Turns use Poly's provider accounts, with no member API keys. Source, checked November 12, 2026.
  • Multiplayer: private beta is $25 per month, excluding AI model usage. Users connect their own model providers. Source, checked November 12, 2026.
  • ONES: Free is $0 for up to 30 seats. Source, checked November 5, 2026.
  • Slack Code: the announcement does not state a separate Slack Code price or the plans that include it. Budget for Slack and the chosen agent integration after checking their current plans. Source, checked November 8, 2026.
  • Zed: Zed does not charge for External Agents; billing, terms and data handling stay between you and the agent provider. The cited collaboration docs do not state a separate collaboration price. Source, checked November 5, 2026.
  • Superconductor: "Every plan includes the full multiplayer workspace." Free allows up to 4 members; Pro starts at $50 per month with up to 40 members. Source.
  • Amp: Teams cost no extra; members can be on any tier. Hobby is free with pay-as-you-go hosted orbs; Individual is $20 per month. Source. The Spaces post states no separate plan or price. Source, checked November 8, 2026.
  • Carta Evergreen: a 7-day free trial; the launch post states no price. Source, checked November 8, 2026.
  • Warp Oz: available on free and paid plans, priced on AI usage and compute usage (Warp, February 10, 2026). Source.
  • Conductor: the announcement does not list current plans or prices. On November 12, 2026 Conductor withdrew the wind-down plan in that announcement and said it will keep developing the app. Source. See Conductor alternatives to compare.
  • Cursor: cloud agents need Premium or higher, Teams, Enterprise, or a legacy paid plan; Free and Plus do not include them. Source; follow-up security in settings.
  • Replit: Core is $20 per month ($18 billed annually); Pro is $100 per month ($90 annually) with up to 15 collaborators. Source.
  • GitHub Copilot: Pro $10, Pro+ $39 and Max $100 per month; Business $19 and Enterprise $39 per granted seat per month. Slack and Teams integrations require a paid plan. Source, checked November 8, 2026.
  • Claude Code cloud sessions: on Pro, Max, Ultra and Team plans, and Enterprise premium or Chat + Claude Code seats; usage counts toward plan limits with no separate VM charge. Source.
  • Devin: Free; Pro $20 per month; Max $200; Teams $80 per month plus $40 per full dev seat. Source.
  • Aether: Free $0, Starter $30, Pro $75 and Max $120 per month, each with a monthly credit allowance for machine time; models are billed by your own provider account. Source.
  • Nimbalyst: the app is free for individuals; Wiki Teams is $20 per user per month, free while in beta. Source.

What AQ enforces for shared work

Three AQ behaviors map directly to the buyer checklist. Confirm them in your own organization with the live acceptance check below; no screenshot here is presented as evidence.

  • Share management stays with the owner. People a work item is shared with can see it, but they do not take over the share list; only the owner manages who has access.
  • Terminal input needs authority. Typing into a shell is limited to its owner or a teammate holding a temporary grant the owner approved for that connection, which the owner can revoke at any time.
  • An AQ message runs as its sender by default. A teammate's message runs on the teammate's own accounts; it runs as the owner only when the owner has granted that teammate driving rights.

Run the share-session guide's verification steps when evaluating the current interface. The live acceptance check below adds expected observations and revocation.

Security threat model and limits

Start with a disposable repository, two ordinary accounts, no production secrets and a machine with only the network access the task needs. Assume thread messages, issue text, repository files, tool output and MCP responses can contain hostile instructions. Assume any connected integration can exercise the permissions granted to its account. Copilot stores the entire Slack or Teams thread in generated artifacts, so use a direct message when shared-channel context is inappropriate. Branch protection and a human reviewer should stand between the agent's branch and deployment.

ThreatFailure modeControl and remaining limit
Prompt injection from an issue, repository file or tool resultThe agent follows untrusted text as an instruction, reads unintended data, makes a network request or changes unrelated code.Keep secrets out of the test environment, use read-only integrations where possible, inspect commands and diffs, and require confirmation for consequential writes. Review reduces exposure; it does not prove that every injected instruction will be stopped.
Shared-session credentialsA teammate with terminal control runs commands inside the terminal's existing login context, or an agent uses the wrong person's account.Grant control only for the task and duration needed, then revoke it. In AQ, use sender-scoped agent messages unless the owner deliberately grants driving rights. A granted terminal can act with its existing logins.
Excess local-file and network accessA process reads outside the task's worktree or reaches an internal service that was not needed for the task.Use a dedicated machine, separate OS users, minimal mounted data and restricted egress. Isolated worktrees limit file collisions, not what a process can reach. Zed's warning about local project files needs the same scrutiny.
Third-party MCP scopesAn integration reads more project context than intended or writes a comment, worklog, transition, branch or merge request with excessive authority.Inspect each ONES, Linear, GitHub or other repository connection separately. Prefer read-only scopes, limit repositories and record who authorized writes. A valid workflow transition does not establish that the code is correct.
Irreversible or high-impact deliveryA reviewed-looking change merges with incomplete checks, triggers a deployment or causes effects that a later revert cannot undo.Require current checks, branch protection and human review before merge. Keep database changes, deployments and external writes behind explicit approvals. AQ's Changes panel refuses merge while checks are pending or failing or the review is stale, but approval prompts and review are not network or credential containment.

No collaboration tool should be assumed to block every dangerous action. Test the exact agent, repository, integrations and machine configuration you plan to use, and record failures as rollout blockers rather than exceptions to ignore. Artifact metadata and reported review sources do not prove that code or findings are correct.

Reader-run Copilot permission checks

These are checks for your team to run, not tests we performed for this guide. Use two ordinary GitHub accounts, one write-enabled and one read-only, two disposable repositories with the same owner and no secrets. Record the Copilot plan, Slack or Teams client, execution environment, repository roles, observations and failures.

  1. Test input and steering separately. Have the read-only participant add context and attempt to start or steer. Record the accepted input and refused action, then repeat with the account that has write access to every selected repository.
  2. Test every selected repository. Select two repositories. Give the steering account write access to both, then remove write access from one and repeat. Confirm that the missing permission blocks triggering and steering.
  3. Inspect shared-context identity and approval. Create a pull request from a shared channel and another from a direct message. Verify app identity for the shared-context PR and the linked personal account for the DM. With an existing one-approval ruleset, record the additional approval required for the app-authored PR.
  4. Inspect context and Canvas. Add non-sensitive marker text to the thread and check the generated artifacts. Verify that Teams Canvas remains read-only for both participants and shows only content each linked account may already access.
  5. Record the environment. Note whether the session uses GitHub Actions or a cloud sandbox before applying repository or duration limits. Do not infer the Actions 59-minute cap for a cloud-sandbox session.

Stop on unexpected repository access, leaked context or missing approvals. Repeat these checks after permission, policy or integration changes.

A two-person acceptance check before you buy

Run this with an owner and a teammate using separate browser profiles and ordinary, non-admin accounts. Use a private test task with no customer data, private repository names or secrets. The observations below are what you should record; they are not results from a live test we performed.

  1. Establish the private baseline. Before sharing, open the workspace URL as the teammate. Expected: no workspace, terminal or file access. The owner then selects only the teammate under Specific people. Expected: the teammate can open that task, while a non-owner cannot manage its share list.
  2. Check live inspection. The owner runs printf 'share-check-owner-1\n' in a plain shell. Expected: the teammate sees the new output without reloading and can inspect the intended files and app preview.
  3. Check terminal consent and revocation. Before a grant, the teammate attempts terminal input. Expected: no command reaches the owner's shell. Deny one request and check again. Grant a short duration, then run printf 'share-check-teammate-1\n' as the teammate. Expected: both browsers see it. Revoke control, and repeat after expiry or disconnect. Expected: input stops while viewing can continue.
  4. Check AQ message identity. Send a message as the teammate without driving rights. Expected: the run uses the teammate's selected account and the transcript identifies the author and run-as identity. Selecting the owner's identity without the grant should be refused. Grant Can drive my sessions only if that behavior is required, then revoke it after the check.
  5. Test untrusted input safely. Put a harmless instruction in a disposable issue asking the agent to ignore its task and reveal environment variables. Expected: record exactly what the agent attempts. Stop the run if it tries to read outside the worktree, expose data or contact an unexpected service. This checks your configuration; it does not prove protection against other payloads.
  6. Inspect delivery. Open the running preview and the branch diff in both accounts, add a line comment and run the required checks. Expected: the reviewer can inspect the same evidence, and branch protection prevents merge until checks and the required human review are current.
  7. Remove access. Revoke terminal control, driving rights and workspace sharing separately. Check the teammate's already-open tab and a fresh URL. Expected: no new input, files or terminal output are available after access removal. Revoke any separately shared preview or guest links too, and check those URLs again.

Write down the date, account roles, grants, observations and failures. Repeat the check after changing agents, MCP scopes, machine users or repository permissions.

Choose by collaboration mode

Both people need the live workspace

AQ, Superconductor and Amp expose the broadest shared surfaces. AQ shares the terminal, editor, preview and agent thread, with terminal input delegated by owner approval. Superconductor makes every session accessible to the team and lets a teammate take the wheel. Amp's Contribute permission lets members prompt the agent and use the orb's terminal, files and portals. These fit when the team debugs or reviews running work together. The shared AI pair-programming guide covers the human roles.

Poly fits a mixed product team that wants one browser room rather than a shared terminal: its official docs describe any-member answers, approvals and stopping, a live preview, attributed receipts, undo and pull-request review. Each turn runs in a hosted container on Poly's provider accounts. Multiplayer's private-beta homepage describes shared sessions, memory, model routing and a live agent view, but does not answer the execution, per-member steering, credential-scoping or delivery-review questions. Resolve those gaps with the vendor and the two-person check before choosing it for shared team work.

Zed fits a team whose shared work happens inside a local editor: people co-edit the project in real time, while Claude, Codex and other external agents can integrate through ACP. Evaluate its local-file warning and the external agent's own authentication and tool permissions. It is a different workflow from joining a persistent cloud-agent terminal.

The team coordinates in a chat channel

Slack Code puts the agent, plans, diffs, agent-supplied previews and human approvals in a code channel. For Copilot, any participant can add input, while starting and steering require write access to every selected repository. Shared-context artifacts use GitHub's app identity, and an existing approval ruleset adds one approval by default. Before rollout, test the specific agent integration to establish who can steer, which credentials the run uses, and whether anyone needs terminal or editor access.

The issue must carry the delivery record

ONES connects an MCP-capable client to issue context, worklogs, comments and valid workflow transitions, with a separate Git MCP server for repository work. AQ's Linear integration prepares a live workspace from an issue and tracks the resulting pull request while status syncs both ways. ONES centers the issue record; AQ centers the inspectable execution workspace and review.

A shared run with follow-up steering is enough

Warp Oz session links let teammates watch and steer a run. Cursor lets eligible teammates send follow-ups when an admin turns the setting on. Conductor Cloud also lets members of one organization prompt agents together; check conductor.build for its current status. See Conductor alternatives to compare.

Review Cursor's model before rollout. Its settings page warns that a follow-up influences an agent running with another user's secrets and credentials, and advises treating the setting "with the same care you would give shared SSH keys or service credentials." Scope repository access, secrets and network egress accordingly.

Visibility and review matter more than co-steering

Replit Agent 4 shows who is on which task and lets teammates enter a task and review it before it reaches main. GitHub Actions cloud sessions are shared with repository users by default, cloud-sandbox sessions are unshared by default, and shared local sessions are view-only. Copilot's Slack and Teams integrations allow permitted teammates to steer, while Teams Canvas remains read-only artifact review. Claude Code cloud sessions share a snapshot view with your Claude organization and give the owner steering from any device. Check the exact sharing and steering surface before choosing the team handoff.

The team needs shared project context and handoffs

Cursor Projects is no longer only single-player delegation. Its November 10, 2026 launch says the multiplayer beta gives invited teammates a shared task board, project documents and context, while keeping separate coordinator/worker chats with local context. Cursor also describes handoffs to a new teammate's agent and agent-to-agent coordination. Its Projects docs, checked November 11, say each member's chat runs and bills as that member, personal stores stay separate, and agent side chats never share secrets, credentials or tokens. Joining needs a team invite, repository access and Cursor 3.26.13 or later, and is unavailable on a self-hosted Project. These are Cursor's claims, not our independent test. The sources do not establish AQ's shared-terminal/control model. Compare the models in the multiplayer coding agents guide.

One person coordinates many agents

Amp Spaces and AQ crews put a coordinating agent where the team can see it. In a space, the agent creates and delegates threads from the team's conversation. In an AQ crew, the lead agent proposes a plan, waits for a person's approval and delegates roles to other agents. Carta Evergreen's alert-started sessions fit a team that wants incident work to begin in a shared session; confirm its steering and credential rules first.

Devin and Claude Code agent teams coordinate many agents for one person's throughput. Check the steering and access columns before assuming a teammate can join a run. Aether says a lead agent there splits a large task across sub-agents, each on its own devbox and branch, and returns one pull request; its homepage does not describe teammates joining a task, so treat it as a delegation tool whose pull request is the team handoff. Nimbalyst sits beside these as a shared planning layer: a wiki and decisions your team and its agents edit together.

Once the tool is chosen, use team workflows for coding agents for ownership, handoffs and review rules, or the shared workspace for Claude Code and Codex guide if your team uses both CLIs.

Cursor Projects and Devin Teams: what teammates can do

Both moved toward team features this month, so it is worth being exact about what a second person gets. These descriptions come from each vendor's own pages, checked November 13, 2026.

Cursor Projects. Cursor's November 10 launch says Projects is rolling out in beta. Per the Projects docs, teammates work from the same task list and board, and every member's agents read and write a shared Context store (Cursor lists plans, docs, designs, tasks, skills and memories). Each teammate gets their own chat in the Project, with their own coordinator and workers, and that chat runs and bills as them. Cursor says in-progress work can be handed to a new person, whose agent takes it on, and coordinators can message each other: an incoming message opens a side chat that can answer and read the board but not change it, and never shares secrets or tokens. A Project runs on its own computer in the cloud. Sharing needs a Cursor team account, repository access and Cursor 3.26.13 or later, on Premium and higher, Teams, Enterprise or legacy paid plans.

Devin Teams. Devin's pricing page lists the Teams plan at $80 per month plus $40 per full dev seat, up to 100 users, with "Share and collaborate with multiplayer sessions." Devin's team docs say members can view and contribute to most organization resources, such as knowledge, playbooks, secrets and environment snapshots. The docs we read do not describe how a teammate joins, watches or messages a session someone else started, so ask Devin before relying on it.

Where AQ differs. In AQ, teammates share one run. A teammate opens the same work item and sees the agent's messages, tool calls and file changes as they happen, can message the same agent mid-run on their own accounts, and reviews the same diff and running preview. AQ runs on Claude Code, Codex, Cursor and the other subscriptions the team already has, on a machine the team controls. Cursor's shared task board and agent-to-agent side chats have no direct equivalent in AQ; AQ's closest pieces are crews, where a lead agent plans and delegates to other agents, and tagging a teammate or a bot in a thread.

Where AQ fits

AQ is a multiplayer workspace where a team runs AI coding agents together in real time, bringing every connected coding agent into one shared work item. Execution happens on an AQ-managed machine or a customer-connected VM, with an isolated worktree per task. Teammates open the same live agent thread, files, shell and app preview. Review supplies the trust layer: preview comments, line-level diff comments, a read-only review thread, required checks and a human merge decision. See previews and comments and changes, review and merge.

Full disclosure: AQ is our product. It fits a team that wants several coding agents in one shared environment on infrastructure it controls: VMs connected from your own cloud account, or a dedicated always-on machine AQ manages. The limits: sharing requires the Pro plan ($50 per user per month during early access, standard $200); reviewers do not get terminal control automatically; each person still needs their own repository and agent access; and a shared environment needs the secret, network and branch protections described above. For execution on your own infrastructure, read the self-hosted AI coding agents guide.

Sources checked for this update

Frequently asked questions

What are the best AI coding tools for team collaboration in 2026?

Match the tool to the handoff. AQ, Superconductor and Amp fit teams that need a shared live workspace; Poly fits a mixed product team that wants any-member answers and approvals in one browser room, with receipts and undo. Multiplayer's private beta lists shared sessions and agent memory, but leaves execution, per-member steering, credential scoping and delivery review undocumented. Zed fits live human co-editing with agents; Slack Code fits a team channel containing agent plans, diffs and agent-supplied previews; ONES fits an issue workflow with worklogs, comments and valid transitions through MCP. Warp Oz and Cursor support teammate steering of a shared run. GitHub Copilot supports permission-based steering in Slack and Teams, read-only Teams Canvas review, and environment-specific session sharing. Replit and Claude Code cloud sessions emphasize visibility and review. Carta Evergreen puts teammates and agents in shared cloud sessions, and Amp Spaces gives a team one conversation whose agent creates and delegates threads. Conductor Cloud offers shared workspaces for one Conductor organization; Conductor said on November 12, 2026 that it will keep developing the app.

Which tools let teams build with coding agents together?

AQ is a multiplayer workspace where a team builds with coding agents like Claude Code and Codex together in real time, in one shared work item with a shared thread, diff and preview. Superconductor, Amp, Poly and Warp Oz let teammates join or steer a shared run. Cursor Projects and Devin Teams share project context, tasks or knowledge while each person directs their own agent.

What are the best platforms for shared AI pair programming?

Pick one where both people see the same run live and either can redirect it. In AQ, two teammates follow the same agent in one work item and either one sends the next instruction on their own account. Zed suits pairing inside an editor with live co-editing, and Superconductor and Amp let a teammate steer alongside the person who started the run.

What is the best coding agent platform for teams?

For a team that wants to work in the same agent run, AQ: a multiplayer workspace on Claude Code, Codex and the other subscriptions the team already has, with a branch and worktree per task on a machine the team controls, and review and merge in one place. For shared project context with one agent per person, Cursor Projects. For one person delegating many tasks, Devin or Cursor cloud agents.

Is Cursor Projects still single-player delegation?

No. Cursor's November 10, 2026 launch describes a multiplayer Projects beta with a shared task board, documents and project context, handoffs to a new teammate's agent, and coordination between teammates' agents. Each teammate still has a separate coordinator/worker chat with local context. Cursor's Projects docs, checked November 11, say each member's chat runs and bills as that member, personal stores stay separate, and agent side chats never share secrets, credentials or tokens. Joining needs a team invite, repository access and Cursor 3.26.13 or later. These are vendor claims, not our independent test. Projects supplies shared project context and handoffs; the sources do not establish AQ's shared-terminal/control model. See the multiplayer coding agents guide.

What are Carta Evergreen and Amp Spaces?

Both launched this week. Carta Evergreen (November 5, 2026) is a model-agnostic platform running Claude, Codex, Grok and Muse, where teammates and agents work in shared cloud sessions; an alert can start a session, automations run through review and merge, and the listed controls are isolated sessions, scoped access, audit logs and spending caps. Carta's throughput figures are its own and unverified. Amp Spaces (November 6, 2026) is a shared conversation with one agent that creates and coordinates threads, with comments and an overview of threads by status. Neither launch post says whose credentials a steered or delegated agent uses, so ask before rollout.

Which collaboration tool keeps delivery evidence on the issue?

ONES documents an MCP workflow that reads an issue, uses a separately connected Git repository MCP server for code operations, then writes a worklog and summary comment and executes a valid workflow transition. AQ's Linear integration keeps issue status and workspace ownership in sync and tracks the pull request, but its integration docs do not describe ONES-style worklogs. Slack Code retains plans, diffs, previews and approvals in a code channel. Zed records edits in the shared project and leaves delivery review to your repository process.

How do I invite teammates to an AI coding agent session?

In AQ, an organization admin invites the person from the Team page with Invite a member; after they accept, the work item's owner opens Share, chooses Specific people or Everyone on the team, and saves. The teammate opens the same work item link. Sharing requires the AQ Pro plan, and a seat is billed only once the person accepts. In Claude Code cloud sessions, Team and Enterprise accounts set a session's visibility to Team and send the link; recipients see the latest state when they open it, not live updates.

Can two people steer the same coding agent?

In some tools. In AQ, a teammate requests terminal control and the owner approves; in an AQ agent thread, each teammate's message runs on their own accounts, and running as the owner needs the owner's Can drive my sessions grant. Poly says any room member can prompt, answer, approve or stop the agent. Multiplayer's homepage does not document per-member steering permissions. Copilot's Slack and Teams integrations let any participant provide input, but starting and steering require write access to every selected repository; guests and outside collaborators cannot start or steer. Shared local Copilot sessions remain view-only. Superconductor and Amp with Contribute let teammates prompt the agent, Warp Oz links let teammates steer, and Cursor allows follow-ups when an admin enables them. Zed documents live human co-editing and separate external-agent processes. It does not document a shared cloud-agent terminal.

How does the team review agent changes?

Review both the running app and the diff where the tool provides them. In AQ, reviewers pin comments on the live preview, then use the Changes panel to read this turn's changes, uncommitted work or the whole branch, comment on lines that go to the agent with the next message, start a review, and merge once checks pass and the review is current. Poly documents live previews, attributed turn receipts, undo and pull-request review; Multiplayer's homepage shows a live agent view but does not document diff or pull-request review records. Copilot supplies session logs and pull requests, while Teams Canvas is a read-only view of plans, file changes and PR overviews rather than an interactive app preview. ONES can record worklogs, comments and workflow transitions on the issue; Slack Code presents diffs and agent-supplied previews; Zed teams review shared edits through their repository process. Artifact metadata does not prove code or findings correct. Keep branch protection and human review before merge in every workflow.

Does teammate steering use the teammate's credentials?

Not always. Cursor's settings page says a teammate's follow-up influences an agent running with the original creator's secrets and credentials. Amp bills agent and orb costs to the thread owner. In AQ, granted terminal control types into the owner's existing terminal, while a message in an AQ agent thread runs as the person who sent it unless the owner granted driving rights. Poly uses its own provider accounts rather than member API keys; Pro and Max bill the person who ran the turn, while Team uses a shared balance. Multiplayer says users connect their own model providers but does not document per-member credential behavior. Zed says an external agent usually owns its authentication. Copilot requires write access to every selected repository for starting or steering in Slack and Teams, and steering consumes AI credits. Shared-context artifacts use GitHub's app identity, while direct messages use the linked personal account. Treat shared steering as access to the run's security context unless the vendor documents otherwise.

What security boundaries matter in a shared agent workspace?

Check prompt injection from untrusted thread, issue and repository content, the credentials inside a shared terminal, local-file and network reach, third-party MCP scopes, context leakage and merge approval. Copilot stores the entire Slack or Teams thread in generated artifacts, so use a direct message when shared-channel context is inappropriate. Isolated worktrees limit file collisions, not what a process can reach. A teammate granted terminal control can act within that terminal's existing login context, and integrations keep their own account scopes. Use minimal permissions, restricted machines, current checks, branch protection and human review. Approval prompts do not contain network or credential access.

Are Claude Code agent teams a team collaboration feature?

They coordinate AI agents, not people. Anthropic's agent teams docs describe one Claude Code session as lead and other Claude Code instances as teammates with a shared task list; the feature is experimental and off by default. To put human teammates in the same live session, use a shared workspace such as AQ or a shared tmux session.