# AQ

> AQ is the multiplayer coding harness where teams chat, build and run bots with every AI coding agent, like Claude Code and Codex: shared live terminals, review and merge, app previews and standing jobs, in your own cloud.

AQ (aq.dev) is built by BetterLeap, Inc. Teams bring their own code (connect a GitHub repository, import an existing project, or start a new one in AQ), run agent CLIs (Claude Code, Codex, Cursor, Kimi Code, Grok, Antigravity, Devin, Muse Code, Command Code, OpenCode, and more) in isolated git worktrees on their own infrastructure, and collaborate in shared live workspaces: terminals, a code editor, and app previews that teammates can join from a link.

What you can do in AQ:

- Work items: one task, one isolated branch and worktree, on a machine dedicated to your team. Drive it with any agent CLI in a terminal tab, with AQ's built-in agent, or both, and review the diff, comment on lines, and merge from the Changes panel.
- AQ's built-in agent: a coding agent that is a conversation in the workspace. It runs on the subscriptions you already connected (Claude Code, Codex, Cursor, and others) or on AQ models: choose a model yourself (each shows its per-token price before you pick it) or Auto, which chooses one for each turn and says why.
- Chats: a conversation with no branch of its own. It opens your repositories on demand, runs queries and reports, and turns a plan into work items when you say go.
- Bots: a chat with a standing job. A bot wakes on a schedule, on a Linear label, or when a pull request's checks fail or a review comment arrives, does the job in its own thread, asks you before acting where you told it to, and stops at a monthly spend cap.
- Pages: an agent publishes a report, dashboard, or chart as a page with a stable address, a bot can keep it current on every wake, and a guest link shares it with people outside the team.
- Crews: a lead agent plans the work, you approve the plan, and it delegates build, test, review, and research to other agents, with review routed to a different vendor than the author where one is connected.
- Integrations: connect Gmail, Google Calendar, Slack, Linear, Granola, Sentry, Mercury, Vanta, and Stripe accounts once, and agents use them with per-tool Allow, Ask, or Off permissions.
- Memory and secrets: shared rules and notes every agent can search, and organization or personal secrets injected as environment variables and never shown in transcripts.
- Genie: a personal assistant bot for each person that prepares a morning briefing and drafts replies from your mail and calendar, without sending anything on its own.

Pricing: a Free plan for one person (a personal sandbox machine AQ creates, nothing to install), and an AQ Pro plan at $50 per user per month (promotional; standard $200) with unlimited seats, sharing, your own cloud, and a dedicated AQ-managed, always-on VM.

Every page listed below also ships a plain-Markdown version: replace the URL's trailing slash with `.md` (https://aq.dev/docs/api/ becomes https://aq.dev/docs/api.md).

## Docs

- [AQ Docs: how the multiplayer agent workspace works](https://aq.dev/docs/): How AQ works: workspaces as isolated git worktrees, real agent CLIs in persistent sessions, multiplayer access, live previews with comments, Linear and GitHub integration, and runners in your own cloud.
- [AI Coding Agent Workspaces: Isolation and Lifecycle](https://aq.dev/docs/workspaces/): A coding agent workspace is the isolated checkout and session state one AI task runs inside. How Cursor, Devin, Codex Cloud, Conductor, and AQ each isolate and manage it.
- [Live Previews and Feedback for AI Coding Agents](https://aq.dev/docs/previews-and-comments/): How to see what an AI coding agent actually built: run its dev server, tunnel it, or use preview deployments, and route comments back to the agent as prompts.
- [Linear Integration for AI Coding Agents](https://aq.dev/docs/linear-integration/): Five ways to run coding agents from Linear issues: open-in-tool handoffs, the MCP server, cloud agent delegation, Linear coding sessions, and label-driven workspaces.
- [Runners and Infrastructure: Where Coding Agents Run](https://aq.dev/docs/runners-and-infrastructure/): A runner is the machine where an AI coding agent executes: your code, credentials, and shell live there. Where each platform runs agents, and how AQ does it.
- [What is AQ? The multiplayer coding harness at aq.dev](https://aq.dev/docs/what-is-aq/): AQ (aq.dev) is the multiplayer coding harness: teams run AI coding agents like Claude Code and Codex together in shared live workspaces, in their own cloud.
- [AQ API Documentation: REST, Webhooks, and MCP](https://aq.dev/docs/api/): The AQ API is AQ's REST, MCP, and webhook surface: create workspaces, read events, PRs, and previews, run AQ's built-in agent, and react via signed webhooks.
- [AQ MCP Server: Connect Claude, ChatGPT, or Cursor to AQ](https://aq.dev/docs/mcp/): Connect any MCP client to AQ's hosted MCP server at https://aq.dev/mcp: one URL, browser sign-in, and your agent can create workspaces, run AQ's built-in agent, and read results.
- [Security and Isolation: How AQ Runs Coding Agents](https://aq.dev/docs/security-and-isolation/): Safe AI agent use comes down to custody: where agents execute, whose credentials they hold, and who can see sessions. The questions to ask, and AQ's answers.
- [AQ Docs: chats](https://aq.dev/docs/chat/): How AQ chats work: a conversation with full tools and no branch, repositories opened as the chat's own copy, secrets, and handing code changes to work items.
- [AQ Docs: bots](https://aq.dev/docs/bots/): How AQ bots work: a standing job, schedule and event wakes, rules for starting work, a monthly spend cap, bots tied to a work item, and Settings, Bots.
- [AQ Docs: crews and roles](https://aq.dev/docs/crews/): How AQ crews work: roles, the built-in Ship, Review and Fix crews, the plan gate, delegation into worktrees, independent review, and Settings, Crews.
- [AQ Docs: Genie, your assistant](https://aq.dev/docs/genie/): How Genie works in AQ: one assistant thread per person, the morning briefing, mail and calendar wakes, drafts not sends, consent cards, and voice where enabled.
- [AQ Docs: memory across coding agents](https://aq.dev/docs/memory/): How AQ memory works: shared AGENTS.md rules in every agent, each CLI's own memory read into searchable notes, personal by default, editable, shareable.
- [AQ Docs: secrets](https://aq.dev/docs/secrets/): How AQ secrets work: personal and organization secrets as environment variables, request cards, scrubbing from transcripts and commits, and imports.
- [AQ Docs: changes, review and merge](https://aq.dev/docs/changes/): How review works in AQ: the Changes panel scopes, line comments that ride your next message, review threads, the pull request card, and when merge waits.
- [AQ Docs: AQ on your phone](https://aq.dev/docs/mobile/): How AQ works on a phone: the mobile web app with Home, Work, Genie and You, threads, previews and terminals, and the iPhone app in beta with push.

## Concepts

- [What are multiplayer coding agents?](https://aq.dev/multiplayer-coding-agents/): Multiplayer coding agents are AI coding agents whose sessions are shared live places a team can enter together: watch, steer, and review one run, instead of receiving diffs from single-player tools.
- [AQ features: chat, build, bots, crews and review](https://aq.dev/features/): Everything AQ does: chats, work items and bots on every coding agent, crews with independent review, live previews, integrations, memory, phone and machines.
- [AQ product: Chat, Build and Bots on every coding agent](https://aq.dev/product/): AQ's product pages: chat with agents, build in isolated worktrees, run bots on a schedule, crews with independent review, Genie, phone, integrations and models.
- [AQ Chat: ask about your code, data and tools](https://aq.dev/product/chat/): AQ Chat is a conversation with an AI agent that can run queries, read your repositories and connected accounts, and answer with tables, charts and pages.
- [AQ Build: a worktree per task, any agent, merged](https://aq.dev/product/build/): AQ Build gives every task its own git worktree, branch and live preview. Run Claude Code, Codex and the rest side by side, review the diff, and merge.
- [AQ Bots: give an AI agent a standing job](https://aq.dev/product/bots/): An AQ bot wakes on a schedule, a Linear label, a failing check, a review comment, new mail or an upcoming meeting, does its job, and has a monthly cap.
- [AQ Crews: a team of agents with independent review](https://aq.dev/product/crews/): An AQ crew is a team of AI agents for a kind of work: a Lead plans, you approve, builders work in their own worktrees, and a separate agent reviews the work.
- [Review and merge AI agent code in AQ](https://aq.dev/product/review/): AQ shows exactly what an agent changed, lets you comment on any line, runs an independent review, and merges only when checks pass and the review is current.
- [Genie: your personal AI assistant in AQ](https://aq.dev/product/genie/): Genie is your personal assistant in AQ: a morning briefing, what needs you from mail and meetings, and your AQ work. It drafts, and it never sends without you.
- [AQ on your phone: run coding agents from anywhere](https://aq.dev/product/mobile/): AQ works on any phone: start a chat, a build or a bot, answer an agent, review the preview and open a terminal. The iPhone app in beta adds push and a Live Activity.
- [AQ integrations: Linear, GitHub, Slack, Gmail and more](https://aq.dev/product/integrations/): Connect Linear, GitHub, Slack, Gmail, Google Calendar, Granola, Sentry, Mercury, Vanta and Stripe once, and every AQ agent can use them with Allow, Ask or Off per tool.
- [AQ models and Auto: the right model for every turn](https://aq.dev/product/models/): Use your own Claude, ChatGPT, Cursor and other subscriptions unmetered, or AQ models with prices shown up front. Auto routes each turn and shows why.
- [Live Links: Share the Running Workspace, Not a Recording](https://aq.dev/live-links/): A Live Link in AQ opens the work itself: the live agent terminal, the editor, and the running app. Not a transcript, not a replay, not a screenshot.
- [The Self-Review Problem in AI-Assisted Coding](https://aq.dev/self-review-problem/): In 79% of agent-generated PRs, one developer both reviews and modifies the contribution: no second set of eyes. What the self-review problem is and what actually fixes it.

## Who it's for

- [AQ for Engineering Managers: See Agent Work as It Happens](https://aq.dev/for/engineering-managers/): AQ gives engineering managers live visibility into every AI coding agent on the team: open the actual session, review the real diff, click the preview, track the PRs.
- [AQ for Startups: Credits and Support for Founders](https://aq.dev/startups/): Apply to AQ for Startups for six to twelve months of platform credits, cloud coding workspaces, and hands-on support for your founding team.
- [AQ for Startups: Ship With Agents, Skip the Infra Team](https://aq.dev/for/startups/): AQ lets a small startup run AI coding agents like a much bigger team: parallel workspaces, live previews for founder feedback, free on your own VM.
- [AQ for Remote Teams: Agent Sessions That Cross Timezones](https://aq.dev/for/remote-teams/): AQ gives distributed teams one shared place for AI coding agents: sessions that survive laptop close, live handoffs across timezones, and reviews without a meeting.
- [AQ for Agencies: Client-Ready Agent Work, Demoable Anytime](https://aq.dev/for/agencies/): AQ helps agencies run AI coding agents across client projects: private workspaces per engagement, live previews clients can comment on, and custody you can put in a contract.

## Use cases

- [Reviewing AI Agent Code: See the Session, Not Just the Diff](https://aq.dev/use-cases/ai-agent-code-review/): How teams review AI-written code in AQ: open the workspace behind the PR, read the real diff, click the live preview, and send review comments back to the agent.
- [Debugging an Agent Session Together, Live](https://aq.dev/use-cases/debugging-together/): When an AI coding agent gets stuck, AQ lets a teammate open the same live session: same terminal, same files, same preview. Either person can prompt or interrupt the agent.
- [Onboarding Engineers by Watching Real Agent Sessions](https://aq.dev/use-cases/onboarding-engineers/): New engineers ramp faster in AQ by watching live agent sessions: how seniors prompt, how the codebase behaves, and where work actually happens, all from the workspace list.
- [From Linear Issue to PR: Running a Sprint With Coding Agents](https://aq.dev/use-cases/linear-to-pr/): How teams turn Linear issues into agent workspaces in AQ: label an issue, open the workspace, drive the agent, and watch status and PRs sync back to the board.

## Guides

- [Run Multiple Claude Code Sessions in Parallel](https://aq.dev/guides/run-multiple-claude-code-sessions-in-parallel/): The fastest way to run multiple Claude Code sessions in parallel: one git worktree per task locally, or one isolated workspace per task on a platform.
- [Run Multiple AI Coding Agents in Parallel (2026)](https://aq.dev/guides/run-multiple-ai-coding-agents-in-parallel/): Run Claude Code, Codex, and other agent CLIs in parallel: one isolated git worktree per task, separate ports and data, and sessions that outlive your laptop.
- [Git Worktrees for AI Coding Agents](https://aq.dev/guides/git-worktrees-for-ai-coding-agents/): A git worktree gives each AI coding agent its own working directory and branch from one repo. Here is how to use them, the gotchas, and how to automate them.
- [Share a Claude Code Session With Your Team](https://aq.dev/guides/share-a-claude-code-session-with-your-team/): Claude Code share links are read-only. To share a live session, use tmux over SSH or a multiplayer workspace where teammates join the same terminal and preview.
- [Linear Coding Agent Workflow: Issue to PR](https://aq.dev/guides/linear-coding-agent-workflow/): A Linear coding agent workflow: label an issue ai-task, a workspace appears for the team, a human starts the agent, and the PR is tracked back to the issue.
- [How to Review Pull Requests From AI Coding Agents](https://aq.dev/guides/reviewing-pull-requests-from-ai-agents/): How to review AI agent pull requests: inspect the run behind the diff, read test and CI changes first, check behavior live, and keep a second human in the loop.
- [Self-Hosted AI Coding Agents: Every Option Compared](https://aq.dev/guides/self-hosted-ai-coding-agents/): Self-host AI coding agents five ways as of October 2026: a VM with tmux, OpenHands, Coder Agents, Cursor or Warp Oz self-hosted workers, or AQ in your own cloud.
- [Bring Your Own Cloud (BYOC) for AI Coding Agents](https://aq.dev/guides/bring-your-own-cloud-for-coding-agents/): Bring your own cloud (BYOC) means AI coding agents and dev environments run on compute in your own cloud account. What it covers, who offers it as of October 2026, and what to ask vendors.
- [Self-Hosted AI Coding Agent Setup: Step by Step (2026)](https://aq.dev/guides/self-hosted-ai-coding-agent-setup/): Step-by-step self-hosted AI coding agent setup: VM sizing, SSH and Tailscale, installing Claude Code and Codex, headless login, and tmux persistence.
- [Keep Claude Code Running After Closing Your Laptop](https://aq.dev/guides/keep-claude-code-running-after-closing-laptop/): To keep Claude Code running after closing your laptop, run it inside tmux on a remote server or as a Claude Code cloud session: how each option works, as of October 2026.
- [Keep Codex Running After Closing Your Laptop](https://aq.dev/guides/keep-codex-running-after-closing-laptop/): Closing your laptop kills a local Codex CLI session, and codex resume only restores the transcript. Here is how tmux, mosh, Codex cloud, and AQ each keep work going.
- [Keep Muse Code Running After Closing Your Laptop](https://aq.dev/guides/keep-muse-code-running-after-closing-laptop/): Closing your laptop stops Muse Code and its subagents; the event log only recovers the session, it does not keep it working. How tmux, CI runs, and AQ fix that.
- [Keep Cursor CLI Running After Closing Your Laptop](https://aq.dev/guides/keep-cursor-cli-running-after-closing-laptop/): Closing your laptop kills a local Cursor CLI session, and agent resume only restores the chat. How tmux, mosh, Cloud Agents, and AQ keep the work going.
- [Run Claude Code on a Cloud VM: Full Setup Guide (2026)](https://aq.dev/guides/run-claude-code-on-a-cloud-vm/): Provision a small Linux VM, install Claude Code, sign in over SSH, and keep sessions alive with tmux. A complete setup guide with hardening and costs.
- [Run Codex on a Cloud VM: Full Setup Guide (2026)](https://aq.dev/guides/run-codex-on-a-cloud-vm/): Provision a small Linux VM, install Codex CLI, sign in headlessly with device auth or SSH port forwarding, and keep sessions alive with tmux.
- [Run Cursor CLI on a Cloud VM: Full Setup Guide (2026)](https://aq.dev/guides/run-cursor-cli-on-a-cloud-vm/): Provision a small Linux VM, install Cursor CLI with one command, sign in headlessly with NO_OPEN_BROWSER or an API key, and keep agent sessions alive with tmux.
- [Codex Background Agents and the Agents Dashboard](https://aq.dev/guides/codex-background-agents-and-the-agents-dashboard/): How to run Codex tasks in the background and in parallel as of September 2026: the codex agents dashboard, codex queue, subagents, rollout token budgets, and Codex cloud.
- [Codex Cloud Tasks, Explained](https://aq.dev/guides/codex-cloud-tasks-explained/): Codex Cloud runs coding tasks on OpenAI-managed VMs from reusable published environments (relaunched September 29, 2026). What runs where, what persists, and what it costs.
- [Claude Code Agent Teams vs Parallel Sessions (2026)](https://aq.dev/guides/claude-code-agent-teams/): What Claude Code agent teams are, how the shared task list works, what teams cost in tokens, and when plain parallel worktree sessions are the better choice.
- [Claude Code Agent View and Background Sessions (2026)](https://aq.dev/guides/claude-code-agent-view-and-background-sessions/): Agent view (claude agents) is one screen for Claude Code background sessions: dispatch, monitor, reply. What survives a laptop close, what a reboot kills, and where a cloud workspace fits.
- [Claude Code Projects, Explained](https://aq.dev/guides/claude-code-projects-explained/): Claude Code Projects (beta, Sep 2026) is a coordinator conversation that runs parallel cloud sessions with shared memory. What it is, what it is not, and where teams fit.
- [Claude Cloud Sessions Explained: Start, Steer, Resume](https://aq.dev/guides/claude-code-cloud-sessions-explained/): A Claude cloud session is Claude Code running on a cloud VM that keeps working after your laptop closes. How to start one, steer it, resume it, and its limits.
- [Context Windows for Coding Agents (2026 Guide)](https://aq.dev/guides/context-windows-for-coding-agents/): A context window is a coding agent's working memory. How Claude Code, Codex, and Cursor compact it, 2026 model limits, and the habits that keep sessions sharp.
- [How to Run Claude Code From Your Phone (2026 Guide)](https://aq.dev/guides/run-claude-code-from-your-phone/): Three ways to drive Claude Code and other coding agents from a phone: official remote-control features, a DIY SSH and tmux stack, or a phone-native IDE like Lunel.
- [AI Coding Agents for Agencies: A Client-Work Playbook (2026)](https://aq.dev/guides/ai-coding-agents-for-agencies-and-client-work/): How agencies and dev shops run coding agents across client projects: isolation per client, showing live work to non-technical clients, and keeping AI costs out of your margin.
- [Share a Dev Environment with Your Team: 2026 Guide](https://aq.dev/guides/share-a-dev-environment-with-your-team/): Two ways to share a dev environment: commit the recipe (devcontainer.json, Nix) or share the running instance (Live Share, tmux, a team server). How to pick.
- [How to Review an AI Coding Session (Not Just the Diff)](https://aq.dev/guides/how-to-review-an-ai-coding-session/): How to review an AI coding agent's session: preserve the brief, keep the transcript retrievable, check five layers, and put a second person on agent PRs.
- [Agent Sessions Are the New Pair Programming](https://aq.dev/guides/agent-sessions-are-the-new-pairing/): Juniors used to ramp by pairing with seniors. Now the judgment worth learning lives in AI agent sessions. How to make watching real sessions a team practice.
- [The Session Review Checklist for AI Agent Code](https://aq.dev/guides/session-review-checklist/): A copy-paste checklist for reviewing AI coding sessions: concrete reviewer questions across five layers, from the original brief to the running result.
- [Rolling Out Session Review on an Engineering Team](https://aq.dev/guides/rolling-out-session-review/): A leader's playbook for making AI agent sessions reviewable by policy: when a second person is required, how to keep it lightweight, and what to measure.
- [Reviewing Claude Code Sessions: A Practical Guide](https://aq.dev/guides/reviewing-claude-code-sessions/): How to view, list and export Claude Code sessions, where transcripts live and how long they last, what a session record can prove, and what a second reviewer can and cannot reach.
- [How to Safely Run AI Coding Agents on Your Own Repos](https://aq.dev/guides/safe-ai-coding-agents-on-your-own-repos/): Run AI coding agents on your own repositories safely: least-privilege tokens, branch protection, isolated git worktrees, secrets hygiene, and real PR review.
- [AI Coding Agents With Your Own Keys (2026 Guide)](https://aq.dev/guides/ai-coding-agents-with-your-own-keys/): What bring-your-own-keys means for AI coding agents: subscription logins vs API keys vs platform credits, per-user vs shared keys, and options for teams.
- [AI Coding Agents for Product Managers (2026 Guide)](https://aq.dev/guides/coding-agents-for-product-managers/): The tools that let product managers preview live AI-generated UI changes: prompt-to-app platforms, Vercel and Netlify preview deployments, and live previews from the agent's own checkout, compared as of September 2026.
- [Get Your Whole Team Building with AI Agents](https://aq.dev/guides/get-your-whole-team-building-with-ai-agents/): Roll out AI coding agents in a sequence: one repo, one agent, and volunteers in the open, then one shared workspace, a review policy, then everyone.
- [Rolling Out AI Coding Agents to Your Team](https://aq.dev/guides/rolling-out-coding-agents-to-your-team/): A staged rollout plan for AI coding agents: guardrails and policy first, a pilot on real work, team norms and training, then measuring quality, not volume.
- [Best Tools for Coding Collaboration With AI Agents (2026)](https://aq.dev/guides/best-ai-coding-tools-for-team-collaboration/): The best tools for coding collaboration compared by live visibility, teammate steering, shared workspace surfaces, execution location, and current price.
- [Manage Claude Code Sessions Across a Team (2026)](https://aq.dev/guides/manage-claude-code-sessions-across-a-team/): Claude Code sessions live on one machine, under one account. How teams manage them anyway: naming conventions, worktree isolation, persistence, visibility, and handoff.
- [Add Linear MCP to Claude Code: Setup Guide (2026)](https://aq.dev/guides/add-linear-mcp-to-claude-code/): Connect Linear to Claude Code in one command: add https://mcp.linear.app/mcp over HTTP, authenticate with /mcp, and drive issues from your terminal.
- [MCP Servers for Coding Agents, Explained (2026)](https://aq.dev/guides/mcp-servers-for-coding-agents-explained/): An MCP server gives a coding agent extra tools over a standard protocol. How Claude Code, Codex, Cursor, and OpenCode configure them, how teams share one setup, and the security rules.
- [Coding Agent Permission Modes Explained (2026)](https://aq.dev/guides/coding-agent-permission-modes-explained/): A permission mode sets which actions a coding agent takes without asking. How trust, plan, auto, accept-edits, and full-auto work in Claude Code, Codex, Cursor, Devin CLI, and OpenCode.
- [How to Run Multiple Claude Code Accounts (2026)](https://aq.dev/guides/run-multiple-claude-code-accounts/): Run multiple Claude Code accounts with separate config directories (CLAUDE_CONFIG_DIR), per-OS-user logins on shared machines, and per-user accounts for teams.
- [Conductor Alternatives for Windows and Linux (2026)](https://aq.dev/guides/conductor-alternatives-for-windows-and-linux/): Conductor is a Mac-only app as of August 2026. How Windows and Linux developers get the same parallel-agent workflow: Emdash, Claude Code Desktop, DIY, and AQ.
- [Designers Building With AI Coding Agents (2026)](https://aq.dev/guides/designers-building-with-ai-coding-agents/): The solutions that support engineers and designers building with AI in 2026: prompt-to-app tools (Figma Make, v0, Lovable), agent CLIs (Claude Code, Codex, Cursor), and shared team workspaces.
- [Connect Linear to Codex: MCP Setup Guide (2026)](https://aq.dev/guides/connect-linear-to-codex/): Connect Linear to Codex in one command: codex mcp add linear --url https://mcp.linear.app/mcp, sign in with OAuth, and drive Linear issues from your terminal.
- [Connect Meta Muse to AQ: Ship Code From Muse](https://aq.dev/guides/connect-meta-muse-to-aq/): Connect Meta Muse to AQ through a custom REST connector, then dispatch coding work to real repositories, coding CLIs, team review, previews, and pull requests.
- [Carry Context Between Claude Code and Codex](https://aq.dev/guides/carry-context-between-claude-code-and-codex/): What actually transfers when you switch between Claude Code and Codex mid-task: repo state and instruction files move, sessions do not. The reliable handoff recipe.
- [How to Resume and Search Claude Code Sessions](https://aq.dev/guides/resume-and-search-claude-code-sessions/): Claude Code saves every conversation. Resume with --continue or --resume, search the session picker, catch up with /recap, and know when transcripts expire.
- [Shared AI Pair Programming: A Practical Guide](https://aq.dev/guides/shared-ai-pair-programming/): How to pair program when one side is an AI coding agent: the human navigates, the agent drives, and the session stays visible to a second human. Full guide.
- [Shared Workspaces for Claude Code and Codex (2026)](https://aq.dev/guides/shared-workspace-for-claude-code-and-codex/): What a shared workspace for Claude Code and Codex actually means: shared memory, mirrored views, or one live session. Mosaic, Conductor, Tutti VM, Nimbalyst, and AQ compared.
- [How to Choose a Coding Harness (2026)](https://aq.dev/guides/how-to-choose-a-coding-harness/): Choosing a coding harness comes down to four questions: model access, how much harness you want, how the pairing performs on your repo, and who sees the work.
- [Executable Specs as Guardrails for AI Coding Agents](https://aq.dev/guides/executable-specs-for-ai-coding-agents/): How executable specs (BDD scenarios, failing tests, spec files) steer AI coding agents, how agents game them, and what still needs human judgment.
- [Connect Grok Bot to AQ to Ship Code](https://aq.dev/guides/connect-grok-bot-to-aq/): Connect Grok Bot to AQ over MCP so it can create a workspace on your repository, run a coding agent, and return a pull request for team review.
- [Grok 4.6 for Coding Agents: What Changed](https://aq.dev/guides/grok-4-6-for-coding-agents/): Grok 4.6 shipped August 12, 2026 as a post-training upgrade aimed at long-running agents. Benchmarks, pricing, early caveats, and how to run it with your team.
- [Grok 4.7 for Coding Agents: What Changed](https://aq.dev/guides/grok-4-7-for-coding-agents/): Grok 4.7 shipped September 21, 2026: a larger base model tuned for many-hour agent runs, at Grok 4.6 prices. Benchmarks, the token-cost catch, and how to run it with your team.
- [DeepSeek V4 Pro for Coding Agents: What to Know](https://aq.dev/guides/deepseek-v4-pro-for-coding-agents/): DeepSeek V4 Pro went GA on August 13, 2026: open MIT weights, 1M context, big agentic gains, and a first-party price increase days later. The full picture.
- [GLM-5.3 for Coding Agents: What to Know](https://aq.dev/guides/glm-5-3-for-coding-agents/): Z.ai released GLM-5.3 on August 14, 2026: same base as GLM-5.2, all gains from post-training, record open-model benchmark claims, and weights due in two weeks.
- [MiMo-V2.6 for Coding Agents: What to Know](https://aq.dev/guides/mimo-v2-6-for-coding-agents/): Xiaomi released MiMo-V2.6 on September 22, 2026: a 1.02T-parameter MIT-licensed flagship that tops the open-weights rankings. Specs, pricing, and how to run it in agent CLIs.
- [GPT-6.1 Sol for Coding Agents: What to Know](https://aq.dev/guides/gpt-6-1-sol-for-coding-agents/): OpenAI released GPT-6.1 Sol on September 29, 2026: near-Astra agentic coding at $2/$10 per million tokens. Specs, independent benchmarks, and how to run it in Codex and other agent CLIs.
- [Claude Fable 5 for Coding Agents: What to Know](https://aq.dev/guides/claude-fable-5-for-coding-agents/): Claude Fable is Anthropic's Mythos-class tier above Opus: $10/$50 per million tokens, 1M context, and the current version is Fable 5.1. Specs, safeguard routing, and how to run it in Claude Code and other agent CLIs.
- [SWE-2 for Coding Agents: What to Know](https://aq.dev/guides/swe-2-for-coding-agents/): Cognition released SWE-2 on September 10, 2026: post-trained from Kimi K3, a 92.8 on Terminal-Bench 2.1, and a 64 percent cost claim worth reading carefully.
- [How Many Coding Agents Can One Developer Run?](https://aq.dev/guides/how-many-coding-agents-can-one-developer-run/): Most developers plateau at two to four concurrent coding agent sessions. The ceiling is attention and review bandwidth, not compute. Here is how to raise it.
- [AI Code Review Noise: How to Filter It (2026)](https://aq.dev/guides/ai-code-review-noise/): AI code review noise is accurate but unnecessary comments. How to filter it: severity thresholds, blocking vs non-blocking rules, and a written product contract.
- [Why Parallel Claude Code Sessions Collide (and Fixes)](https://aq.dev/guides/why-parallel-claude-code-sessions-collide/): Parallel Claude Code sessions collide on files, ports, databases, and branches. The fix is a ladder: worktrees, per-session resources, locks, then visibility.
- [AI Agent Says Tests Passed? How to Verify Agent Work](https://aq.dev/guides/verify-ai-coding-agent-work/): Did your coding agent actually run the tests it says passed? Read the real commands in the transcript, rerun the tests yourself, and compare the diff to the claim.
- [Keep AGENTS.md and CLAUDE.md in Sync Across Agent CLIs](https://aq.dev/guides/keep-agents-md-and-claude-md-in-sync/): One AGENTS.md now works as the rules file for Claude Code, Codex, Cursor, OpenCode, Copilot, Grok, Kimi, and Antigravity. The per-CLI read paths, verified October 2026, and when you still need the import or symlink bridge.
- [Get Notified When Claude Code Finishes or Needs You](https://aq.dev/guides/get-notified-when-claude-code-finishes/): Set up alerts for when a coding agent finishes or waits on input: Claude Code notification hooks, the terminal bell, Codex notify, tmux flags, and phone push.
- [Can a Coding Harness Get Your Account Banned?](https://aq.dev/guides/coding-harness-ban-risk/): Yes: reusing subscription OAuth inside third-party coding tools triggered real bans in 2026. Whose credentials your harness holds, and how to stay safe.
- [Keep Secrets Out of AI Coding Agent Prompts](https://aq.dev/guides/keep-secrets-out-of-coding-agent-prompts/): What actually leaves your machine when a coding agent runs, and the four layers that keep secrets and production data out of prompts.
- [Coding Agent Harness Directory (2026)](https://aq.dev/guides/coding-agent-harness-directory/): A directory of coding agent harnesses as of August 2026: lab CLIs, open-source harnesses, parallel-agent desktop apps, cloud platforms, and what shut down.
- [A Coding Workspace for Any Agent CLI: 2026 Options](https://aq.dev/guides/coding-workspace-for-any-agent-cli/): Which AI coding workspace supports any agent CLI? What that has to mean (own login, own config, isolation per session), and the 2026 options compared honestly.
- [What AI Code Review Can and Cannot Catch](https://aq.dev/guides/what-ai-code-review-can-and-cannot-catch/): AI code review catches mechanical bugs and known vulnerability patterns. It cannot observe runtime behavior, unstated intent, or its own biases. Here is the line.
- [Build vs Buy: Your Team's AI Coding Harness](https://aq.dev/guides/build-vs-buy-ai-coding-harness/): Ramp's in-house agent made build-vs-buy a live question. Most of the advantage comes from where the harness runs, not who built it. How to decide in 2026.
- [Always-On Coding Agents: Laptop, VM, or Vendor Cloud](https://aq.dev/guides/always-on-coding-agents/): An always-on coding agent needs a machine that never sleeps. Compare a kept-awake laptop, a VM you own, and vendor sandboxes like Codex cloud, honestly.
- [Best Cloud Coding Agents in 2026, Compared](https://aq.dev/guides/best-cloud-coding-agents/): The cloud coding agents worth using in 2026: Claude Code on the web, Codex cloud, Cursor cloud agents, Copilot coding agent, Jules, Devin, and AQ, compared honestly.
- [Team Workflows for Coding Agents (2026 Guide)](https://aq.dev/guides/team-workflows-for-coding-agents/): A team workflow for coding agents answers four questions: who runs which agent, where agents run, who watches live sessions, and who reviews the result.
- [Overnight Coding Agent Runs: Setup and Guardrails](https://aq.dev/guides/overnight-coding-agent-runs/): How to set up AI coding agents to work while you sleep: a machine that stays awake, no-prompt configuration, infrastructure guardrails, and a morning review.
- [Move Claude Code Between Laptop and Cloud (2026)](https://aq.dev/guides/move-claude-code-between-laptop-and-cloud/): What moves with a Claude Code workflow and what stays behind: git, CLAUDE.md, credentials, session history, and the teleport command, as of August 2026.
- [How to Hand Off a Coding Agent Session](https://aq.dev/guides/hand-off-a-coding-agent-session/): Handing off a coding agent session means transferring context, code state, and live control. What Claude Code, Codex, and Cursor support, plus a manual playbook.
- [Monitor Multiple Coding Agent Sessions Without Babysitting](https://aq.dev/guides/monitor-multiple-coding-agent-sessions/): How to watch many AI coding agent sessions at once: the four states that matter, push notifications, tmux alert flags, vendor dashboards, and team visibility.
- [How to Steer a Coding Agent Mid-Run (2026)](https://aq.dev/guides/steer-coding-agents-mid-run/): Steering a coding agent mid-run means correcting a live session without killing it. The exact queue, interrupt, and rewind mechanics in Claude Code, Codex, and Cursor.
- [OpenClaw 2.0: Multiplayer Agents, and What Teams Need](https://aq.dev/guides/openclaw-2-0-multiplayer-agents/): OpenClaw 2.0 shipped Aug 30, 2026 with multiplayer agent sessions. What's in the release, where its trust model stops, and what coding teams need instead.
- [Event-Driven Coding Agents: Triggers and Guardrails](https://aq.dev/guides/event-driven-coding-agents/): An event-driven coding agent starts from a webhook, schedule, or CI failure, not a prompt. The trigger patterns shipping in 2026 and the guardrails they need.
- [Are You Benchmarking the Model or the Harness?](https://aq.dev/guides/benchmarking-the-model-or-the-harness/): Coding agent benchmark scores measure a model plus its harness, and the same model can swing 20 points between harnesses. How to read leaderboards fairly.
- [A/B Test a New Coding Model on Your Own Repo](https://aq.dev/guides/ab-test-a-new-coding-model-on-your-own-repo/): Run the same prompt on the new model and your current one in two isolated git worktrees, diff the branches, and score with your own tests: a ten minute playbook.
- [Model Routing for Coding Agents, Explained](https://aq.dev/guides/model-routing-for-coding-agents-explained/): Model routing means the harness picks the model per request instead of you. Which coding tools route automatically as of October 2026, and when to pin a model.
- [Coding Agent Token Costs for Teams: A 2026 Guide](https://aq.dev/guides/coding-agent-token-costs-for-teams/): What AI coding agents actually cost to run for a team in 2026: current token prices, why input tokens dominate the bill, and the four levers teams use to cut it.
- [The Harness Tax: Does the Coding Harness Matter? (2026)](https://aq.dev/guides/the-harness-tax/): The harness tax is what a coding agent spends on its own scaffolding. 2026 benchmarks show harnesses converge on success and diverge on cost. What to do about it.
- [Limit What a Coding Agent Can Destroy](https://aq.dev/guides/limit-what-a-coding-agent-can-destroy/): Contain a coding agent's blast radius: one git worktree per agent, a branch it can only trash itself, OS sandboxing, scoped credentials, and real undo paths.
- [How to Share Agent Skills Across a Team (2026)](https://aq.dev/guides/share-agent-skills-across-a-team/): Three working patterns for sharing agent skills: commit project skills to the repo, sync personal skills with dotfiles tooling, or run a dedicated sync tool.
- [Slack Code Channels for Coding Agents, Explained](https://aq.dev/guides/slack-code-channels-for-coding-agents/): Slack Code gives teams dedicated channels to plan, review, and approve coding agent work. How code channels work, which agents connect, and their limits.
- [Cloudflare OS Agent Workspaces, Explained](https://aq.dev/guides/cloudflare-os-agent-workspaces-explained/): Cloudflare OS is an open-source agent workspace on Workers: persistent state, files, and a sandboxed runtime where agents run code. What it is and is not.
- [What Is OpenAI Dots? Always-On Agents, Explained](https://aq.dev/guides/openai-dots-explained/): OpenAI Dots are always-on personal agents in ChatGPT, each with its own cloud computer. What a dot is, how it codes through Codex, and what stays personal.
- [Connect an OpenAI Dot to AQ: MCP Setup Guide](https://aq.dev/guides/connect-openai-dot-to-aq/): Connect an OpenAI dot to AQ over MCP so it can create work on your team's repositories, run the coding agent you choose, and return reviewed pull requests.
- [Claude Code Usage Limits Explained (October 2026)](https://aq.dev/guides/claude-code-usage-limits-explained/): Claude Code has a five-hour session limit and a weekly limit, plus a separate weekly Fable limit on Max. What draws them down, the wrap-up allowance, /usage, usage credits, and your options at the limit.
- [Codex Usage Limits Explained (2026)](https://aq.dev/guides/codex-usage-limits-explained/): Codex draws from your ChatGPT plan: a five-hour window plus a weekly cap, shared with ChatGPT Work. What each plan includes, how resets and credits work, and your options at the limit.
- [How Do Coding Agents Remember? Memory Explained (2026)](https://aq.dev/guides/coding-agent-memory-explained/): Coding agents remember through instruction files (AGENTS.md, CLAUDE.md, rules) plus notes they write themselves. What persists where in Claude Code, Codex, Cursor, and OpenCode.
- [Coding Agent Checkpoints Explained (October 2026)](https://aq.dev/guides/coding-agent-checkpoints-explained/): What checkpoints in coding agents are, what Claude Code, Cursor, OpenCode, Codex, and Antigravity can rewind as of October 2026, and what no checkpoint undoes.
- [Can Claude Code and Codex Share Memory? (October 2026)](https://aq.dev/guides/shared-memory-across-coding-agents/): Not natively: every vendor memory is per person, per tool, and per machine. A repo AGENTS.md is the only context that crosses agents, and history crosses nothing.
- [How Does a Team Share Context with AI Coding Agents?](https://aq.dev/guides/team-memory-for-coding-agents/): Teams share agent context in three layers: repo instruction files, personal memory, and team memory per repository. What belongs in each, as of October 2026.
- [Coding Agent Sandboxes, Explained](https://aq.dev/guides/coding-agent-sandboxes-explained/): A coding agent sandbox is an isolated environment where an AI agent runs commands without touching your machine. Containers, microVMs, and VMs compared for October 2026.
- [Secure Cloud Dev Workspaces for Coding Agents](https://aq.dev/guides/secure-cloud-dev-workspace-for-coding-agents/): What makes a cloud dev workspace secure for coding agents: isolation, credential custody, network egress, and an audit trail, with a dated vendor checklist.
- [What to Do When Claude Code or Codex Is Down](https://aq.dev/guides/what-to-do-when-claude-code-or-codex-is-down/): Check status.claude.com or status.openai.com first, rule out a usage limit, then keep working: your code is local, and another CLI can pick up the same checkout.
- [Subagents in Coding Agents, Explained](https://aq.dev/guides/subagents-in-coding-agents-explained/): What subagents are, how Claude Code, Codex, Cursor and Devin spawn and scope them as of October 2026, when parallelism helps, and when it multiplies cost.
- [Coding Agent Hooks, Explained](https://aq.dev/guides/coding-agent-hooks-explained/): Hooks run your scripts inside a coding agent's loop to enforce rules: how Claude Code, Codex, Cursor and OpenCode configure them, as of October 2026.
- [Prompt Caching for Coding Agents, Explained](https://aq.dev/guides/prompt-caching-for-coding-agents-explained/): Prompt caching lets the model provider reuse the unchanged start of each request, cutting cached input to 5-10% of list price. What breaks it in agent loops, as of October 2026.
- [Subscription vs API Credits for Coding Agents (2026)](https://aq.dev/guides/subscription-vs-api-credits-for-coding-agents/): Claude usage credits vs API credits, Codex plan limits vs an API key, paid resets, Fable on Max: which meter a coding agent run lands on, verified October 28, 2026.
- [Porting a Large Codebase With Coding Agents](https://aq.dev/guides/porting-a-large-codebase-with-coding-agents/): How teams port large codebases with AI coding agents in 2026: a conformance harness against the original, one git worktree per module, long persistent runs, and honest cost accounting.

## Agents

- [Run Claude Code with your team in the cloud (AQ)](https://aq.dev/agents/claude-code/): AQ runs Claude Code in shared cloud workspaces: always-on sessions your whole team can watch, join, and steer, on your own VM, with your own subscription.
- [Run Codex with your team in the cloud (AQ)](https://aq.dev/agents/codex/): AQ runs OpenAI's Codex CLI in shared cloud workspaces: persistent sessions your team can watch, join, and steer, on your own VM, with your ChatGPT plan.
- [Run OpenCode with your team in the cloud (AQ)](https://aq.dev/agents/opencode/): AQ runs OpenCode, the open source AI coding agent, in shared cloud workspaces: live sessions your team can watch, join, and steer on your own VM.
- [Run the Cursor agent CLI with your team in the cloud (AQ)](https://aq.dev/agents/cursor/): AQ runs Cursor's agent CLI in shared cloud workspaces: persistent sessions your team can watch and steer, on your own machine, with your own Cursor plan.
- [Run Kimi Code with your team in the cloud (AQ)](https://aq.dev/agents/kimi/): AQ runs Moonshot's Kimi Code CLI in shared cloud workspaces: persistent sessions your team can watch and steer, on your own machine, with your own Kimi plan.
- [Run the Grok CLI with your team in the cloud (AQ)](https://aq.dev/agents/grok/): AQ runs xAI's Grok CLI in shared cloud workspaces: persistent sessions your team can watch and steer, on your own machine, with your own xAI plan.
- [Run Command Code with your team in the cloud (AQ)](https://aq.dev/agents/command-code/): AQ runs the Command Code CLI in shared cloud workspaces: persistent sessions your team can watch and steer, on your own machine, signed in with your own key.
- [Muse Code CLI: Usage, Linux, and 1.4.13 (2026)](https://aq.dev/agents/muse-code/): Muse Code CLI guide for usage, Linux setup, permissions, model selection, and Meta's verified 1.4.13 changes.
- [Devin CLI with your team: run it in AQ (2026)](https://aq.dev/agents/devin-cli/): How AQ runs Devin CLI, Cognition's terminal coding agent: one-click connect with your own Devin account, always-on cloud sessions, isolated worktrees, and live sharing.
- [Antigravity CLI: Google's agy Agent, Explained (2026)](https://aq.dev/agents/antigravity/): Antigravity CLI (the agy command) is Google's terminal coding agent and the replacement for Gemini CLI, which stopped serving individual users on June 18, 2026.

## Comparisons

- [AQ vs Conductor: parallel coding agents for teams (2026)](https://aq.dev/compare/aq-vs-conductor/): Conductor runs parallel coding agents locally on one Mac. AQ runs the same CLIs in shared cloud workspaces your whole team can enter. Compared, July 2026.
- [AQ vs Warp Oz: agent fleets vs shared workspaces (2026)](https://aq.dev/compare/aq-vs-warp-oz/): Warp Oz orchestrates fleets of cloud agent runs you dispatch and review. AQ gives teams live shared agent workspaces on their own infra. Compared, July 2026.
- [AQ vs Cursor Cloud Agents: where agents run (2026)](https://aq.dev/compare/aq-vs-cursor-cloud-agents/): Cursor Cloud Agents return merge-ready PRs from VMs in Cursor's cloud. AQ runs agent CLIs in live shared workspaces on your own infra. Compared, July 2026.
- [AQ vs Superconductor: multiplayer coding agents (2026)](https://aq.dev/compare/aq-vs-superconductor/): AQ and Superconductor both run coding agents your whole team can work with. The big difference: AQ runs on infrastructure you control. Compared, July 2026.
- [AQ vs Claude Code on the web (2026)](https://aq.dev/compare/aq-vs-claude-code-web/): Both run Claude Code on your existing subscription. Claude Code on the web delegates to Anthropic's cloud; AQ is a live team workspace on yours. July 2026.
- [AQ vs GitHub Copilot cloud agent (2026)](https://aq.dev/compare/aq-vs-copilot-cloud-agent/): Copilot's cloud agent runs 59-minute delegated jobs teammates can watch but not steer. AQ is a live multiplayer workspace on your infra. Compared, July 2026.
- [AQ vs HumanLayer: team coding agents compared (2026)](https://aq.dev/compare/aq-vs-humanlayer/): HumanLayer teams collaborate on design docs around agent sessions; AQ teams share the live session itself: terminal, editor, preview. Compared, July 2026.
- [AQ vs Superset: agent orchestration compared (2026)](https://aq.dev/compare/aq-vs-superset/): Superset is a Mac code editor for orchestrating 100+ coding agents; AQ is a browser platform where teams share live agent sessions. Compared, July 2026.
- [AQ vs Emdash: open source vs multiplayer (2026)](https://aq.dev/compare/aq-vs-emdash/): Emdash is a free, open source desktop app for running coding agents in parallel. AQ is a team platform with shared live sessions. Compared, July 2026.
- [AQ vs Replit: bring your own agent vs platform credits (2026)](https://aq.dev/compare/aq-vs-replit/): Replit bills AI work through platform credits with effort-based pricing. AQ runs Claude Code and Codex on the subscriptions you already pay for, with no per-token markup. Compared, July 2026.
- [AQ vs Lovable: your own agent vs credits per message (2026)](https://aq.dev/compare/aq-vs-lovable/): Lovable meters AI building through credits, priced per task. AQ runs Claude Code and Codex on the subscriptions you already pay for, on real repositories, with no markup. Compared, July 2026.
- [AQ vs Xirp: agentic development environments (2026)](https://aq.dev/compare/aq-vs-xirp/): Spotify's Xirp and AQ both run coding agents in parallel worktrees. The difference: live multiplayer on machines you control vs a macOS app with Portal context.
- [AQ vs Amp: multiplayer by default vs orbs (2026)](https://aq.dev/compare/aq-vs-amp/): Amp runs its own agent in ephemeral Amp-managed orbs that wake on schedules and events. AQ gives teams persistent shared workspaces in their own cloud.
- [AQ vs qm: YC's open-source agent harness (2026)](https://aq.dev/compare/aq-vs-qm/): qm is YC's MIT-licensed company-wide agent harness you deploy and operate yourself. AQ is a finished multiplayer coding workbench for engineering teams.
- [AQ vs Orca: agent fleets, solo or multiplayer (2026)](https://aq.dev/compare/aq-vs-orca/): Orca and AQ both run fleets of coding agents in parallel worktrees. The difference: a free single-user desktop app vs a multiplayer cloud harness for teams.
- [AQ vs Herdr: agent runtime or multiplayer harness (2026)](https://aq.dev/compare/aq-vs-herdr/): Herdr is the open-source runtime that keeps coding agents alive in your terminal. AQ puts the whole team in the same live session in a browser. How to choose.
- [AQ vs Hoplite: dispatched PRs or live sessions (2026)](https://aq.dev/compare/aq-vs-hoplite/): Hoplite dispatches coding agents into cloud sandboxes that come back with PRs. AQ puts the team inside the same live session on your own VM. How to choose.
- [AQ vs Tutti VM: shared room or shared machine (2026)](https://aq.dev/compare/aq-vs-tutti-vm/): Tutti VM syncs local coding agents into a shared cloud Room. AQ runs agents on an always-on VM the whole team works in. An honest comparison for 2026.
- [AQ vs Factory: Droids or your own CLIs, live (2026)](https://aq.dev/compare/aq-vs-factory/): Factory runs its own Droid agents on platform-metered models. AQ runs the CLIs your team already subscribes to, live and together on your own VM. How to choose.
- [AQ vs Mosaic: shared memory or shared machine (2026)](https://aq.dev/compare/aq-vs-mosaic/): Mosaic syncs your team's AI coding sessions into shared memory. AQ runs the live session itself on an always-on machine the whole team is inside. Compared for 2026.
- [AQ vs Multica: the board or the room (2026)](https://aq.dev/compare/aq-vs-multica/): Multica is an open-source board that assigns issues to coding agents and hands the result back for review. AQ puts the team inside the live session. Compared for 2026.
- [AQ vs Zed Delta: sync layer or shared machine (2026)](https://aq.dev/compare/aq-vs-zed-delta/): Zed's Delta syncs agent conversations and code into threads on DeltaDB. AQ runs the live session itself on an always-on machine in your own cloud. Compared for 2026.
- [AQ vs Amika: build the factory or move in (2026)](https://aq.dev/compare/aq-vs-amika/): Amika sells VM infrastructure (Rigs) to build your own agent setup. AQ is the finished team workspace: live session, editor, preview, PR. Compared for 2026.

## Alternatives

- [Terragon alternatives for background coding agents (2026)](https://aq.dev/alternatives/terragon/): Terragon shut down in January 2026. The closest replacements: AQ for teams on their own infra, Conductor for free local Mac use, OpenHands for open source.
- [Warp Oz Alternatives for Team Agent Orchestration (2026)](https://aq.dev/alternatives/warp-oz/): The closest Warp Oz alternatives for team agent orchestration: AQ, Cursor cloud agents, Copilot Agent HQ, OpenHands, Emdash, and more. Compared August 2026.
- [vibe-kanban alternatives for AI coding agents (2026)](https://aq.dev/alternatives/vibe-kanban/): vibe-kanban is formally sunsetting; Bloop shut down in April 2026. Alternatives: AQ for teams, Conductor on Mac, Emdash and OpenHands for open source.
- [Conductor alternatives for Windows, Linux, and teams](https://aq.dev/alternatives/conductor/): Conductor's app is Mac-only as of October 2026. The best alternatives for Windows, Linux, and teams: AQ, Orca, vibe-kanban, OpenHands, Cursor, and more, compared honestly.
- [Crystal Alternatives After Its 2026 Deprecation](https://aq.dev/alternatives/crystal/): Crystal was deprecated in February 2026. Compare its successor Nimbalyst with Conductor, Claude Squad, Vibe Kanban, plain git worktrees, and AQ.
- [cmux alternatives for the web, Linux, and teams](https://aq.dev/alternatives/cmux/): cmux is a free, open-source macOS terminal for parallel coding agents. Alternatives for Linux, Windows, the browser, and teams: tmux tools, cloud agents, AQ.
- [Cline alternatives: forks, terminals, cloud, and teams](https://aq.dev/alternatives/cline/): Cline is the open-source coding agent in your IDE, terminal, and desktop. Alternatives by need: Kilo Code, OpenCode, Roomote, cloud agents, and AQ for teams.
- [Xirp alternatives for Windows, Linux, and teams](https://aq.dev/alternatives/xirp/): Xirp is Spotify's macOS-only agentic development environment. Alternatives for Windows, Linux, the browser, and teams: Vibe Kanban, tmux, cloud agents, AQ.
- [Orca (ADE) alternatives for teams and cloud sessions](https://aq.dev/alternatives/orca/): Orca runs 30+ coding agents in parallel worktrees, free and MIT-licensed, but it is a single-user desktop app. Alternatives for teams and cloud: AQ, Conductor, more.
- [Devin alternatives for teams that want control (2026)](https://aq.dev/alternatives/devin/): The best Devin alternatives for a small engineering team: AQ (real CLIs on your infra), OpenHands, Cursor cloud agents, GitHub Agent HQ, Factory, Jules.
- [Nimbalyst alternatives: teams, cloud, live sessions](https://aq.dev/alternatives/nimbalyst/): Nimbalyst is a free visual workspace for Claude Code and Codex, but agents run on your machine and Teams shares documents, not sessions. Alternatives compared.
- [OpenHands alternatives for teams and self-hosters](https://aq.dev/alternatives/openhands/): OpenHands is the broadest open source coding agent platform, but you operate it and sessions stay per user. Honest alternatives: AQ, OpenCode, Devin, DIY.
- [Solo (soloterm) alternatives for teams and the cloud](https://aq.dev/alternatives/soloterm/): Solo is a desktop meta-harness for coding agents on one machine. Alternatives when sessions must survive the laptop or a team needs in: tmux, cmux, cloud agents, AQ.
- [GitHub Agent HQ alternatives for running agents (2026)](https://aq.dev/alternatives/github-agent-hq/): The best GitHub Agent HQ alternatives in 2026: AQ (live sessions on your own cloud), Cursor cloud agents, Warp Oz, OpenHands, or a plain VM with tmux.

## Launches

- [Devin CLI, now in AQ](https://aq.dev/launches/devin-cli/): Devin's CLI runs in AQ as a terminal tab beside Claude Code and Codex, on your own Devin account, with shared live sessions.
- [Hinoki is now on AQ](https://aq.dev/launches/hinoki/): AQ is the first platform to offer Hinoki. Scan a diff or a whole codebase, inspect evidence-backed findings, prepare fixes.

## Glossary

- [What is an agent fleet? | AQ Glossary](https://aq.dev/glossary/agent-fleet/): An agent fleet is many AI coding agents run as one operated group: dispatched centrally, isolated per task, visible in one place, and reviewed before merge.
- [What Is Agent Memory? Coding Agent Memory Explained](https://aq.dev/glossary/agent-memory/): Agent memory is everything a coding agent carries between sessions: instruction files, self-written notes, session history, and retrieval. What each harness persists in 2026.
- [What Is Agent Steering? Mid-Run Agent Input Explained](https://aq.dev/glossary/agent-steering/): Agent steering means sending a follow-up instruction to a running coding agent without cancelling it. Which harnesses accept mid-run input as of October 2026.
- [What Are Agent Skills? SKILL.md Explained](https://aq.dev/glossary/agent-skills/): Agent skills are folders of instructions (SKILL.md) that coding agents like Claude Code, Codex, Cursor, and OpenCode load on demand. Definition, spec, adoption.
- [What Is AGENTS.md? File Locations, Local Files and Loading](https://aq.dev/glossary/agents-md/): AGENTS.md gives coding agents project instructions. Find global and nested files, check AGENTS.local.md support, and verify what Codex or Claude Code loaded.
- [What is agent orchestration? | AQ Glossary](https://aq.dev/glossary/agent-orchestration/): Agent orchestration is coordinating multiple AI coding agents across isolated environments: assigning work, isolating changes, tracking runs, reviewing output.
- [Background agents vs cloud agents | AQ Glossary](https://aq.dev/glossary/background-agents-vs-cloud-agents/): Background agents and cloud agents are substantially the same idea: an AI coding agent that runs asynchronously in an isolated environment and returns a PR.
- [Agentic Development Environment (ADE): Definition | AQ](https://aq.dev/glossary/agentic-development-environment/): An agentic development environment (ADE) is a workspace built around AI coding agents rather than a human editor. Warp coined the term in June 2025.
- [Agentic Development Lifecycle (ADLC): Definition | AQ](https://aq.dev/glossary/agentic-development-lifecycle/): The agentic development lifecycle (ADLC) keeps the SDLC's phases but hands execution to AI coding agents, with humans setting intent and reviewing outcomes.
- [Multiplayer Agents: Definition and Examples | AQ](https://aq.dev/glossary/multiplayer-agents/): Multiplayer agents are AI agents that multiple people work with in one shared live session. How the term differs from multi-agent systems, with 2026 examples.
- [What Is a Coding Harness? Definition | AQ](https://aq.dev/glossary/coding-harness/): A coding harness is the software wrapped around a language model that turns it into a working coding agent: system prompt, tools, context, and loop. Definition, examples, and how it differs from the model.
- [What is a software factory? | AQ Glossary](https://aq.dev/glossary/software-factory/): In 2026 a software factory is a continuous loop that turns a queue of tracked tasks into merged code by running AI coding agents. Definition, history, examples.
- [Vibe Coding vs Agentic Coding: The Difference | AQ](https://aq.dev/glossary/vibe-coding-vs-agentic-coding/): Vibe coding accepts AI-generated code without reading it; agentic coding delegates goals to autonomous agents under real review. Definitions, origins, differences.
- [What is Session Review? (vs Code Review)](https://aq.dev/glossary/session-review/): Session review is reviewing an AI coding agent's working session (the brief, corrections, dead ends, and behavior) rather than only the diff it produced. Definition and practice.
- [What is a Harness of Harnesses?](https://aq.dev/glossary/harness-of-harnesses/): A harness of harnesses is a development environment that runs multiple AI coding harnesses (Claude Code, Codex, OpenCode) side by side under one shared layer. Definition and criteria.

## Pricing

- [AQ Pricing: free solo sandbox, or $50/user/month](https://aq.dev/pricing/): AQ has two plans. Free: a personal sandbox machine AQ creates for you, solo, nothing to install. Pro: $50 per user per month (promotional, standard $200) with your whole team, sharing, your own cloud, and an always-on machine.

## Legal

- [AQ Terms of Service](https://aq.dev/terms/): The Terms of Service governing access to and use of the AQ platform and services, provided by Betterleap Inc. Last updated October 9, 2026.

## FAQ

### What is a multiplayer coding workspace?

A shared environment where AI coding agents and human teammates work in the same live session: everyone sees the same terminal, code editor, and running app preview, and anyone with access can watch, type, or review. It contrasts with single-player agent tools, where agents run on one person's machine and teammates only see the resulting pull request.

### How do teams run Claude Code or Codex together in AQ?

Each AQ workspace is an isolated git worktree on a VM the team controls, with the real CLI (Claude Code, Codex, and others) running in tmux and streamed live to the browser. Teammates open the same workspace URL and share the terminal, editor, and preview; work can also arrive automatically by labeling a Linear issue "ai-task".

### Does AQ replace Claude Code, Codex, or other coding agents?

No. AQ is a harness around the agent CLIs you already subscribe to. Agents like Claude Code and Codex authenticate with each user's own Claude, OpenAI, and GitHub sign-ins, and AQ does not mark up that usage.

### Where do AQ's agents actually run?

On a machine dedicated to your team alone: a personal sandbox VM AQ creates for you (Free plan), VMs you connect from your own cloud, or a dedicated AQ-managed, always-on VM (AQ Pro plan). Never a shared multi-tenant execution tier.

### Which coding agent CLIs does AQ support?

Claude Code, Codex, Cursor, Kimi Code, Grok, Antigravity, Devin, Muse Code, Command Code, OpenCode, and Pi, plus plain shells, all running as real terminal sessions. Most CLIs use each user's own subscription sign-in; OpenCode and Pi can run on AQ's built-in inference gateway instead.

### What does AQ cost?

There is a Free plan for one person: AQ creates a personal sandbox machine for you, nothing to install. The AQ Pro plan is $50 per user per month (promotional; the standard price is $200) with unlimited seats, sharing, VMs you connect from your own cloud, and a dedicated AQ-managed, always-on VM. Model usage comes from each user's existing subscriptions, unmetered, or from AQ's built-in agent on AQ models with credits included per Pro seat.

### How is model usage billed in AQ?

Your own subscriptions stay unmetered: AQ never marks up usage on the Claude, OpenAI, Cursor or other accounts your team connects. AQ credits: the AQ Pro plan includes $10 per seat per month. Beyond that, every named model shows its own per-token price in the composer before you pick it. The same prices apply to AQ models used in OpenCode, Pi or Grok terminals.

### What is AQ's built-in agent?

It is AQ's own coding agent, called AQ in the product: a conversation inside a workspace, next to the terminal tabs. It runs on the subscriptions your team already connected (Claude Code, Codex, Cursor, and others) or on AQ models, where you choose a model or let Auto choose one for each turn and say why.

### What are chats and bots in AQ?

A chat is a conversation with no branch of its own: it reads your repositories, runs queries and reports, and turns a plan into work items. A bot is a chat with a standing job that wakes on a schedule, a Linear label, or a pull request event, does the job in its own thread, and asks before acting where you told it to.

### What are Pages in AQ?

A page is a report, dashboard, or chart an agent publishes from a work item, chat, or bot. It keeps a stable address, a bot can refresh it on every wake, and a guest link shares it with people outside the team.

### Can several agents work on one task together in AQ?

Yes, as a crew. A lead agent proposes a plan, you approve it, and the lead delegates building, testing, review, and research to other agents, each in its own thread you can open, steer, or stop. Review is routed to a different vendor than the author when one is connected.

### How is AQ different from single-player agent apps like Conductor, Superset, or Emdash?

Those tools run parallel agents on one person's machine, which works well solo. AQ moves the same worktree-per-agent model onto shared infrastructure and makes the workspace itself multiplayer, so a teammate can open a live session mid-run, take over the terminal, or review the running app instead of imagining it from a diff.

### Can people outside the team review an agent's work in AQ?

Yes. Each workspace can serve a live dev-server preview with shareable guest links, and comments pinned on the preview can be sent to the agent as prompts, so designers, product managers, or clients can review from a link, with no seat on the team and no local checkout.