# AgentsRoom

> Your IDE for AI coding agents. The visual alternative to CMUX for running multiple AI agents with Claude, Codex, Antigravity CLI, OpenCode, Aider, Grok Build, and Mistral Vibe.

AgentsRoom is a desktop app (macOS, Windows and Linux) with a mobile companion (iOS/Android) that lets you run dozens of AI coding agents across all your projects at once. Supports Claude (Anthropic), Codex (OpenAI), Antigravity CLI (Google), OpenCode, Aider, Grok Build (xAI), and Mistral Vibe (Mistral AI). Each agent can use a different provider, and every agent runs 100% locally through the CLI of your choice, so your code never leaves your disk. Desktop-to-mobile sync is end-to-end encrypted. Think WhatsApp, but for your AI dev team.

## Supported AI Providers

| Provider | CLI | Models | Key Strength |
|----------|-----|--------|-------------|
| Claude Code | Anthropic | Opus, Sonnet, Haiku | Complex reasoning, session resume |
| Codex CLI | OpenAI | GPT-4.1, o3, o4-mini | Full-auto mode, sandboxed execution |
| Antigravity CLI | Google | Gemini 3 Pro, Flash | Agentic platform, free tier, Gemini 3 |
| OpenCode | Open Source | Any OpenAI/Anthropic/local | Multi-backend, YAML config |
| Aider | Open Source | Any (multi-provider) | Git integration, architect/editor pattern |
| Grok Build | xAI | Grok Build 0.1, Grok 4 | 256K context, native MCP, AGENTS.md/CLAUDE.md discovery |
| Mistral Vibe | Mistral AI | Mistral Medium 3.5, Devstral | European models, auto-approve mode, AGENTS.md/CLAUDE.md discovery |

## How it works

1. Create a project pointing to a real folder on your machine
2. Add agents with specialized roles (each gets its own system prompt and focus areas)
3. Pick a provider per agent (Claude, Codex, Antigravity CLI, OpenCode, Aider, Grok Build, or Mistral Vibe)
4. Send prompts. AgentsRoom spawns real CLI processes.
5. Watch the output stream live, get notified when done, give new instructions
6. Monitor progress from your phone via the companion app

## 14 built-in agent roles

1. **DevOps** - CI/CD, infra, deployment. Example: "Set up CI to run tests on every PR"
2. **Fullstack** - End-to-end features. Example: "Add Stripe checkout flow with webhook handling"
3. **Frontend** - UI/UX, components. Example: "Refactor the Header with the new design tokens"
4. **Backend** - API, database, performance. Example: "Add rate limiting to the auth endpoints"
5. **Architect** - System design, refactoring. Example: "Split the monolith into 3 bounded contexts"
6. **QA** - Tests, edge cases, quality. Example: "Write unit tests for the payment module"
7. **Marketing** - Copy, SEO, landing pages. Example: "Rewrite the pricing page copy for conversion"
8. **PM** - Specs, priorities, coordination. Example: "Write the spec for the notification system"
9. **Security** - Audit, vulnerabilities. Example: "Audit the auth flow for OWASP top 10"
10. **Mobile** - iOS, Android, React Native. Example: "Add offline support with local SQLite cache"
11. **Git** - Version control, branching, merges. Example: "Rebase feature branch and resolve conflicts"
12. **SEO** - Search optimization, structured data. Example: "Add JSON-LD schema to all product pages"
13. **i18n** - Localization, translations. Example: "Translate the app to Japanese and Korean"
14. **Custom** - Any role you define with a custom system prompt

## Features

### Multi-Project Multi-Agent (visual cockpit)
https://agentsroom.dev/features/multi-project-multi-agent
The flagship visual cockpit of AgentsRoom: run Claude Code, Codex CLI, Antigravity CLI, OpenCode, Aider, Grok Build and Mistral Vibe AI agents in parallel across multiple projects, all from a single window. Every project lives in a sidebar grouped by zone (Work, Personal, Side Projects, Freelance, Learning, plus any custom zone). Every agent has a fixed role (DevOps, Frontend, Backend, QA, Architect, Mobile, Security, PM, Marketing, SEO, i18n, Git, Fullstack, Custom) with a stable color, an avatar, a system prompt and a default model. Each agent runs in its own isolated xterm.js PTY session that persists across project switches with full scrollback. Live animated status: yellow pulsing dot when thinking, green when done, pulsing red when waiting on input, gray when idle. Per-project counters show working agents, done agents, stuck agents in real time. The project's left border adopts the role color of the currently thinking agent and an animated shimmer slides in a loop, so activity is visible from the corner of your eye. Native macOS notifications, Mac dock badge, push notifications on iOS and Android via the AgentsRoom end-to-end encrypted relay. Optional git worktree isolation per agent for conflict-free parallel work on the same repo. Multi-provider in parallel inside the same project (Claude on DevOps, Codex on Frontend, Antigravity on QA, no shell gymnastics). Drag-and-drop zones to organize repos by client, team or priority. The visual replacement for 12 anonymous iTerm2/Warp/Ghostty/Kitty/Alacritty/WezTerm/Hyper/Tabby/tmux/zellij tabs, the multi-agent multiplexer that does not require a config file, the multi-project AI coding IDE for solo developers and small teams that ship faster with parallel AI agents. AI agent fleet manager, AI coding swarm dashboard, AI coding war room, agentic IDE, color-coded agent dashboard, run multiple Claude Code sessions side by side. Alternative to CMUX, AMUX, Muxy, Conductor, Superconductor, Orca, Jean, JC and Devin AI for parallel multi-project AI coding.

### Split View (multi-pane agents, side by side)
https://agentsroom.dev/features/split-view
A multi-pane split view that tiles the workspace so you can watch several AI coding agents at the same time, side by side, in one window. Drag one agent's terminal onto another pane and drop it on an edge, iTerm2 style: left or right splits into side-by-side columns (horizontal split), top or bottom stacks into rows (vertical split). The targeted half highlights during the drag to show where the pane will land. The split is N-way with no hard-coded maximum, so two, three, four panes and beyond fit as your screen and agent count allow. The whole layout shares one orientation that you flip between horizontal columns and vertical stacked rows with a single click in the toolbar. Each pane keeps its agent's role color, avatar and animated live status (thinking, done, needs input, idle), and the focused pane gets a focus ring in its role color while inactive panes dim slightly. Pane groups and their orientation are saved per project and restored on relaunch, with stale agents filtered out cleanly; clicking a different agent keeps your previous split alive in the background. The same split system applies to dev command terminals (dev server, build, tests) with a right-click Split Horizontal / Split Vertical. Provider-agnostic across Claude Code, Codex CLI, Antigravity CLI, OpenCode and Aider, so you can mix providers side by side in the same split. The visibility layer for parallel multi-agent work: a tiling window manager for AI agents and a split-screen alternative to iTerm2, tmux, Zellij, Warp, WezTerm, Kitty and Ghostty split panes, built so every pane is an identifiable agent instead of an anonymous shell. Keywords: split view, split screen, multi-pane, split panes, side by side agents, watch multiple AI agents at once, drag and drop split, horizontal split, vertical split, tiling terminal for AI agents, run multiple Claude Code sessions side by side, agent visibility dashboard, persistent split layout.

### Commit Context (agent conversation gist per commit)
https://agentsroom.dev/features/commit-context
Commit Context attaches the full AI agent conversation behind each commit as an unlisted gist and links it from the commit message with an Agent-Conversation trailer, so the reasoning behind every change is never lost. AI agents have no memory between sessions, which makes context the scarce resource, not code: the why behind a change, the constraints, the dead ends and the decisions usually die when the terminal closes. With a checkbox under the commit panel (on by default), AgentsRoom captures the conversation of the agent or agents behind the commit (including sub-agent threads), redacts common secrets like API keys, tokens and .env values on a best-effort basis, uploads it as a readable Markdown conversation with a downloadable raw transcript behind an unlisted link, and appends the gist URL to the commit message. The next AI agent or teammate opens that link from git history and recovers the full context: prompts, reasoning, tools run, files edited. The upload never blocks the commit, the link travels with the repo through clone, push and fetch, and you can also create gists by hand on gist.agentsroom.dev the way you would on a public code gist host. This is context engineering applied to git: keep the conversation, attach it to the commit, hand it to the next agent for smooth context handoff, clearer multi-agent collaboration and a project that stays coherent. Provider-agnostic: works with Claude Code, Codex, Antigravity CLI, OpenCode, Aider, Grok Build and Mistral Vibe. Keywords: commit context, agent conversation per commit, share agent conversation, agent context handoff, AI agent memory, context for AI agents, commit conversation, attach conversation to commit, AI agent gist, create a gist, unlisted gist, code provenance, decision log for code, context is the new code.

### Agent Notifications
https://agentsroom.dev/features/agent-notifications
Unread notifications and status alerts for AI agents. Includes unread badges per session, WhatsApp-style message previews, desktop notifications, macOS dock badges, and mobile push notifications. Know when an agent finishes a task or needs your input without watching the terminal.

### Prompt Library
https://agentsroom.dev/features/prompt-library
Built-in prompt manager for saving, organizing, and reusing prompts per project.

### Linked Prompts (Prompt Chaining)
https://agentsroom.dev/features/linked-prompts
Link any prompt to one or more other prompts in the library. When you copy or send a linked prompt, AgentsRoom appends all attached prompts automatically, each titled with a markdown H1. Transitive chains, cycle detection, order control. The first prompt library with native prompt inheritance. Prompts are stored as JSON files in `.agentsroom/prompts.json` (git-committed) with personal prompts gitignored. Supports drag-and-drop organization, cloud backup, and one-click sending to agents.

### Skills Library
https://agentsroom.dev/features/skills-library
Trigger-based modular procedures (skills) for AI coding agents. Save the procedures your agents repeat — code review checklists, migration patterns, accessibility audits, framework conventions — and attach them to backlog tasks or specific agents. The right skill loads exactly when relevant, no manual context juggling. Claude SKILL.md format natively, with universal export to Cursor, Codex, Windsurf and Aider on demand. Stored per-project in `.claude/skills/` (git-committed when shared with the team) or globally in the AgentsRoom skills library. Synced across desktop and mobile through the end-to-end encrypted relay. Folder organization, drag-and-drop, attach UI on every backlog ticket, optional inclusion toggle per agent run. The first cross-runtime skills library for AI coding workflows.

### Agent Status Tracking
https://agentsroom.dev/features/agent-status-tracking
Real-time monitoring dashboard showing individual agent statuses: Thinking, Done, Needs Input, Idle. Includes project-level indicators with counts of working and completed agents, hover previews, and sidebar badges to track multiple agents across all your projects.

### Dynamic Island (floating always-on-top agent status)
https://agentsroom.dev/features/dynamic-island
A floating, always-on-top status indicator for your AI coding agents that stays visible above every other app. The Dynamic Island plays a different animation depending on the global agent state (idle, active, needs input), so you know what your Claude Code, Codex and Antigravity agents are doing without bringing AgentsRoom to the front. When an agent finishes its turn, a notification surges next to the island for a few seconds with the agent name and project; one click brings AgentsRoom forward and opens that exact agent's terminal in that exact project, the same one-click routing shared with native macOS notifications. A clickable history list catches the finishes you missed and resets when AgentsRoom regains focus. The island can be dragged anywhere on screen including a second monitor, anchored to six edge positions, hidden or configured from a right-click menu, and hides itself automatically when every agent is idle. Ambient agent monitoring for multi-agent and parallel AI development.

### Context Canary (context drift and degradation early warning)
https://agentsroom.dev/features/context-drift-detection
An early-warning system that detects when an AI coding agent is losing context, before it starts hallucinating. Long agent sessions degrade through context rot: as the context window fills up, the model quietly drops small instructions a turn or two before it invents files, APIs or decisions that never existed. AgentsRoom turns that into a visible alarm using a built-in canary. Every agent already writes a one-line status at the end of each turn (the summary shown in the sidebar and in mobile push notifications); when an agent stops updating that status for two consecutive turns, AgentsRoom raises a warning banner above the terminal. The banner offers a one-click restart on a fresh, clean context and a tip to type /compact to summarize the conversation, then clears itself automatically when the agent starts reporting again. The canary reuses a signal the agents already produce, so there is nothing to set up and nothing to remember. It is provider-agnostic and works with Claude Code, Codex, Antigravity CLI and other agents, which makes it ideal for monitoring a whole fleet of parallel AI agents where nobody can re-read every reply in real time. Keywords: context rot, context drift detection, lost in the middle, when to restart claude session, compact conversation, AI agent hallucination, AI agent degradation, context window, AI agent monitoring.

### Adaptive Mode (smart model routing for cost-effective AI coding)
https://agentsroom.dev/features/adaptive-mode
Smart model routing that suggests the most cost-effective AI model for the task before you send your first message. AgentsRoom reads your prompt, estimates how demanding the task really is, and recommends the cheapest model in your provider's lineup that can still do it well: a light model like Claude Haiku for a typo fix, a rename, a translation, a short test or a summary; the balanced Claude Sonnet for a pull-request review, a new endpoint, complex debugging or a refactor; the flagship Claude Opus for system architecture, a security audit, a large legacy refactor or deep performance work. It is provider-agnostic and routes within Claude, Codex and Antigravity, validating each suggestion against the models that provider actually offers, and telling you when your current model is already optimal. One click applies the recommendation: it live-switches a running session and saves the choice to the agent for next launch. Adaptive Mode runs once per conversation so it never nags you, and it is on by default. The economic point: smaller models cost a fraction of the flagship, so right-sizing the model for each task burns far less of your plan's usage budget per task, which means more tasks per day on the same plan. Keywords: adaptive mode, adaptive model, smart model routing, AI model selection, choose the right model, cost-effective model, cheapest model for the task, AI cost optimization, cut token cost, reduce AI costs, Claude Haiku Sonnet Opus, Codex model routing, Antigravity model routing, more tasks per day.

### Scheduled Tasks (cron-style scheduling for AI coding agents)
https://agentsroom.dev/features/scheduled-tasks
A cron-style scheduler for AI coding agents that runs recurring agent sessions and development workflows without writing a single cron expression. Create a scheduled task on any project with a name, a prompt, a frequency (every N minutes, hourly, daily, weekly or monthly) and the agent to spawn (role, provider, model); when the time comes, AgentsRoom launches a background agent in that project and feeds it your prompt as its first message. Schedule a Claude Code or Codex session to review pull requests every morning at 8, scan crash logs every night, check dependencies every Monday, generate a weekly changelog, analyze production logs daily, summarize git history weekly, or run a QA pass after every deploy. It uses a simple in-app plus catch-up execution model: tasks fire while AgentsRoom is open, and a run missed because the app was closed is caught up automatically on the next launch. Every automatic start sends a native desktop notification and a mobile push, each task keeps a reopenable run history so you can inspect what the agent did, a Run now button fires a task on demand, and any task can be enabled or disabled in one click. Provider-agnostic across Claude Code, Codex, Antigravity CLI and other agents, with the task list synced per project to your account. A cron alternative and task scheduler built for developers and recurring AI development workflows, and a complement to tmux and cmux that automates the launch of commands and agents at predefined times. Keywords: scheduled tasks, scheduled task, scheduled agent, scheduled AI agent, scheduled coding agent, scheduled CLI tasks, scheduled terminal commands, scheduled terminal session, scheduled CLI session, scheduled CLI workflow, recurring agent tasks, recurring development tasks, AI agent scheduling, agent scheduler, cron for AI agents, cron alternative, cron jobs for developers, automated terminal workflow, terminal automation, schedule Claude Code, scheduled Claude Code session, schedule code reviews, schedule dependency updates, nightly AI agent, daily AI agent, tmux alternative, cmux alternative.

### Vibe Coding Review
https://agentsroom.dev/features/vibe-coding-review
Side-by-side diff viewer for reviewing AI-generated code changes. Features word-level diffs, syntax highlighting, keyboard navigation, file list with color-coded status (added, deleted, modified), and AI-generated commit messages.

### Per-Agent Review
https://agentsroom.dev/features/per-agent-review
Filtered code review interface that isolates changes by individual AI agent. Shows per-agent tabs, file tracking to see which agent modified what, scoped commits per agent, filtered keyboard navigation, and attribution to track which agent made which modifications.

### Mobile-Desktop Sync
https://agentsroom.dev/features/mobile-desktop-sync
Real-time encrypted sync between the desktop app and the mobile companion (iOS and Android). Start AI agents from your phone, type in the terminal remotely, send saved prompts, preview dev servers through the built-in localhost tunnel, and monitor agent status with push notifications. All communication uses X25519 key exchange and XSalsa20-Poly1305 encryption.

### Scratchpad (Prompt Draft Editor)
https://agentsroom.dev/features/scratchpad
Built-in prompt draft editor and mini text editor pinned to the AgentsRoom footer for composing long, complex prompts for Claude Code and other AI coding agents without typing directly into the terminal. Write, relisten, reread, revise and iterate on your prompt in a dedicated textarea (compact popover or near-fullscreen expanded mode), then send the whole block to the focused agent terminal in a single atomic bracketed paste (`\x1b[200~…\x1b[201~`) so newlines, indentation and special characters are preserved instead of triggering premature execution. Your draft is persisted to localStorage (`agentsroom-scratchpad-content`) so it survives app quit, Mac reboot, project switch and window close. Includes native macOS dictation support (opens Keyboard > Dictation settings), one-click "Save as prompt" to promote a working draft into the project Prompt Library (`.agentsroom/prompts.json`), direct access to the Prompt Library without losing the current draft, Cmd+Enter keyboard shortcut to fire the prompt to the active terminal (prioritizes the focused AI agent, falls back to the active dev command), a "Sent" confirmation indicator, and smart terminal targeting via `useFocusedTerminal()`. Local-first, zero cloud sync, feature-flag controllable. A prompt composer, AI prompt notepad, scratch buffer, text staging area and prompt draft manager built for developers working with Claude, Codex, OpenCode, Antigravity CLI, Aider, Grok Build and Mistral Vibe. Replaces external editors like Notes, Obsidian, VS Code or TextEdit for writing structured multi-paragraph AI prompts.

### Message Queue (stack messages, send them in order)
https://agentsroom.dev/features/message-queue
A message queue built into the AgentsRoom composer for AI coding agents. Instead of sending every prompt immediately, you stack several messages above the composer and send them to the agent in the order you choose, one at a time, so you stop overloading the agent with one giant mega-prompt and keep a clear view of the tasks still to come. Click Queue instead of Send and the message parks above the input as a compact card; the composer clears for the next idea. Every queued message gets a short title summarized by AI (via the AgentsRoom backend, no model key needed on your side), shown in bold with a one-line preview and a count of attached files. Screenshots and dropped files stay attached to each queued message, so nothing has to be re-attached at send time. Reorder the queue by drag and drop, reopen a card to edit it back in the composer, send any message on demand, or remove it. The queue is per agent, persists across app restarts (localStorage), and stays inert: the mobile companion, region screenshots and the Chrome extension always target the live composer, so the queue never competes for that. A prompt queue, message stacking, staged messages, draft queue and ordered task queue for developers working with Claude, Codex, OpenCode, Antigravity CLI, Aider, Grok Build and Mistral Vibe. Manual send keeps you in control of what goes out and when.

### Dev Terminals
https://agentsroom.dev/features/dev-terminals
Per-project terminal manager and process launcher built into AgentsRoom, a modern alternative to iTerm2, Terminal.app, Warp, Ghostty, Kitty, Alacritty, WezTerm, Hyper and Tabby for project work. Every command (backend, frontend, mobile bundler, Docker, worker, database, microservices) is saved per project in .agentsroom/commands.json, launched in one click, and runs in a real xterm.js pseudo-TTY with live status tracking (running, starting, stopped, crashed). Detachable terminal window for a second monitor, so your logs stay visible while you code in the main window. AI-powered command generation via Claude scans package.json, Dockerfiles and Makefiles to auto-fill your entire command list with correct paths, framework categories and icons (30+ frameworks supported). Unique feature: launch terminal commands remotely on your Mac from the iOS or Android mobile app over 4G/5G through the end-to-end encrypted relay, with live output streamed back to the phone. Works seamlessly with the built-in localhost live preview tunnel so you can start a server from mobile, then open it in your phone's browser from anywhere.

### Backlog Task Board
https://agentsroom.dev/features/backlog-task-board
Visual kanban board for orchestrating AI agent tasks with a drag-and-drop workflow. Create tasks in TODO, drag them to In Progress to automatically spawn an agent, and track completion across Pending and Done columns. Each task can be assigned to a specific agent role, include image attachments, and maintains a live link to the running agent terminal.

### Agent Teams (Multi-Agent Workflow Orchestration)
https://agentsroom.dev/features/teams
Visual multi-agent workflow editor for AI coding agents. Chain Claude Code, Codex CLI, OpenCode, Antigravity CLI, Aider, Grok Build and Mistral Vibe agents on roles like Dev, QA, PM, Security and DevOps using an n8n-style React Flow canvas (the same engine behind n8n, Make, Pipedream and Retool). Every node is an agent with its own provider, model and step instructions. Edges can carry conditional flag checks (e.g. qaPassed equals true) to enable branching, feedback loops and retries with a configurable max-cycles guard. When an agent finishes its step, AgentsRoom builds a structured handoff payload (feature summary, git diff, changed files, touched areas, risks, test hints, flags), appends a note to a shared NOTES.md scratchpad in the workspace, and spawns the next agent with that payload as its starting context. Inter-agent communication is exposed through a dedicated MCP server (agentsroom-team) that gives every agent a robust set of tools (team_get_context, team_read_notes, team_post_note, team_read_inbox, team_ask, team_read_timeline, team_read_diff, team_complete_step). These tools survive Claude context compaction because MCP tools are re-injected at every turn, and a UserPromptSubmit hook reminds the agent of new notes before each user message. NOTES.md and state.json are append-only and atomic, so they survive crashes, restarts and Mac reboots. Three seed templates ship with the app: Dev to QA, Dev to QA with feedback loop, Dev to Security to QA. Run a team on any backlog ticket in one click. Ephemeral agents per run, auto-destroyed on dismiss. Global teams in ~/.agentsroom/teams or project-scoped teams committed to the room. The AI dev team workflow editor for Claude Code, Codex, Antigravity, Aider, Grok Build and Mistral Vibe, the multi-agent orchestrator that finally lets your AI agents work like a real engineering crew.

### Customize Agents (Custom and Community AI Coding Agents)
https://agentsroom.dev/features/customize-agents
Build, share and install AI coding agents. AgentsRoom ships 14 built-in agent roles (DevOps, Fullstack, Frontend, Backend, Architect, QA, Marketing, PM, Security, Mobile, Git, SEO, i18n and a Custom role you define), plus specialist agents from The Agency and community agents shared by other developers. Create your own custom agent with its own name, description, vibe, category and system prompt, stored at your account level and available in every project, with a server-generated avatar and an auto-translated name and description. Share any agent with a teammate in a single drag through the in-app chat (they import it in one click), or publish it to the community: after a moderation review it appears in the Community tier of the Add Agent picker and on the /agents page, credited to your public pseudonym, with creator badges as unique installs grow and a top-creators leaderboard. The same chat sharing also carries prompts, skills, dev commands and SSH connection metadata (never secrets). A global agent search spans built-in roles, The Agency specialists and community agents at once. Provider-agnostic: every agent works with Claude Code, Codex CLI, OpenCode, Antigravity CLI, Aider, Grok Build and Mistral Vibe. The custom AI agent builder and community agent marketplace for AI coding: build your own coding agent, share agents with your team, and level up together.

### Browser Automation (Agentsroom Browser MCP)
https://agentsroom.dev/features/browser-automation
Browser automation for AI coding agents. AgentsRoom embeds a real Chromium browser inside every project room (Electron WebContentsView, persistent per-project session for cookies and localStorage, isolated by partition) plus the AgentsRoom Browser MCP server (agentsroom-browser) that exposes the browser to your AI agents through the Model Context Protocol. Tools shipped today: browser_navigate, browser_click, browser_type, browser_screenshot, browser_evaluate, browser_wait_for, browser_get_state, browser_get_logs, browser_go_back, browser_go_forward, browser_reload. After every page-changing action, an inline base64 PNG screenshot (capped at 1.6 MB) is appended to the tool response so the agent visually verifies its move, which is the single biggest reliability win for agentic browser automation. Console logs (log, warn, error) are queryable so the QA agent can detect React hydration warnings, useEffect issues, network 404s, CORS failures and runtime exceptions that unit tests would miss. The bridge between the MCP subprocess and the Electron browser runs on 127.0.0.1 only, on an OS-assigned port, authenticated with a 32-byte hex token regenerated at every desktop boot. Smart URL handling: localhost:3000 becomes http://localhost:3000 instead of triggering a 'cannot open application' dialog. Auto-targets the localhost tunnel preview, a detected dev server, or https://localhost:3000 by default. Wired into Agent Teams so a QA node spawns with browser access automatically. Works with Claude Code, Codex CLI, OpenCode, Antigravity CLI, Aider, Grok Build and Mistral Vibe through the standard MCP protocol. Use cases: end-to-end smoke tests, regression tests, visual regression QA, console error hunting, form validation testing, accessibility audit, design QA against Figma, live preview tunnel verification, customer bug reproduction from public backlog tickets. Roadmap: a native AgentsRoom Browser as a first-class browser feature, plus React Native MCP and Electron MCP servers so AI agents can also drive mobile apps and desktop apps for end-to-end testing. The Playwright MCP / Puppeteer MCP / Selenium / Cypress alternative for AI coding agents that need a real, persistent, debuggable browser, not a fresh headless instance on every tool call.

### Public Remote Backlog (Feedback-Driven AI Development)
https://agentsroom.dev/features/public-backlog
Expose your AgentsRoom project backlog as a public, unlisted or restricted feedback portal wired directly to your Claude Code, Codex CLI, OpenCode, Antigravity CLI, Aider, Grok Build and Mistral Vibe agents. Clients, users or external contributors submit bugs, feature requests and questions, upvote tickets that matter to them, leave comments in a visible thread, and track progress on an optional read-only roadmap view (Planned / In development / Shipped with customizable status labels). Every ticket lands in the same backlog your AI agents execute against — drag it to In Progress and a Claude agent starts coding immediately with the client's exact wording as its prompt. Includes a 3 KB embeddable JavaScript widget for any website, an AgentsRoom Chrome extension that files tickets from any web page with one click (with selected text auto-captured as context, works for both public backlogs and the signed-in user's own projects), magic-link authentication for restricted backlogs, branded automatic client emails (in-progress, resolved, team reply, hourly digest, invitation), a 30-day redirect on slug rename to preserve backlinks, a custom subdomain `{slug}.backlog.agentsroom.dev`, and per-client notification preferences. Feedback-driven AI development, AI-powered client portal for agencies and freelancers, Canny / Featurebase / Fider / UserVoice alternative for teams building with AI coding agents.

### Ticket Scoping (Frame Fuzzy Feedback Into a Product-Faithful Mockup)
https://agentsroom.dev/features/ticket-scoping
Turn a fuzzy user feedback ticket into a framed, validated request before any code is written. One click on a feedback ticket spawns a temporary Product Manager AI agent that explores your project's codebase, understands the real product it targets (mobile app, website, desktop app or dashboard) and its visual identity, then builds a single self-contained HTML mockup that faithfully reproduces that product with the requested change applied in context, not a generic wireframe. The mockup is published through the backlog_publish_mockup MCP tool and the preview link comes back to you for review; by default it is not sent to the reporter, so you decide whether to share it. Scoping is deliberately a validation step: it never starts the task, never moves the ticket to In Progress, never sends a work-started notification, never writes files and never commits. A two-way conversation lives on the same ticket, you comment on the backlog and the message lands in the reporter's in-app feedback chat, they reply and it returns as a comment, one thread and one source of truth. The natural extension of the public remote backlog and the feedback chat, it bridges a vague user suggestion and exactly the right build. Works with Claude, Codex and Antigravity. Keywords: ticket scoping, backlog scoping, scope a feature request, turn feedback into a mockup, AI mockup from feedback, Product Manager AI agent, feature validation, requirements clarification, feedback-driven development, backlog refinement.

### Multi-Provider Support
https://agentsroom.dev/features/multi-provider
Run AI coding agents with 7 different providers side by side: Claude (Anthropic), Codex (OpenAI), OpenCode, Antigravity CLI (Google), Aider, Grok Build (xAI) and Mistral Vibe (Mistral AI). Each agent can use a different provider and model. Switch provider mid-conversation while keeping full context thanks to automatic handoff summaries that include modified files, session activity and work progress.

### Claude Multi-Account (multiple Claude Code logins)
https://agentsroom.dev/features/claude-multi-account
Run multiple Claude Code accounts in the same IDE: a Work account, a Personal account, a client account, all signed in simultaneously. Pin one Claude account per project so every agent in that project inherits it, then override per agent when needed (cascade: agent override > project pin > global default > system ~/.claude). Sign-in is fully embedded: AgentsRoom spawns a mini PTY running the official `claude` CLI with the right `CLAUDE_CONFIG_DIR`, you complete OAuth in the browser, and the status badge flips to "Signed in" the moment the credentials file lands on disk. Each account is an isolated directory containing its own OAuth tokens, session metafiles, JSONL transcripts and project history (no shared state, no cross-leakage). Compatible with CCS (Claude Code Switcher) profiles: point an account at `~/.ccs/instances/<name>` and reuse its credentials directly, no re-login required. Token usage tracking and per-agent file attribution work across all accounts thanks to a multi-directory scan that finds the right session metafile by PID. CCS / Claude Code Switcher alternative built directly into the AgentsRoom IDE, with per-project pinning, per-agent override, in-app sign-in and live signed-in status, none of which exist in shell-based switchers.

### Codex Multi-Account (multiple Codex CLI logins)
https://agentsroom.dev/features/codex-multi-account
Run multiple Codex CLI accounts in the same IDE: a Work account, a Personal account, a client account, all signed in simultaneously. Pin one Codex account per project so every agent in that project inherits it, then override per agent when needed (cascade: agent override > project pin > global default > system ~/.codex). Sign-in is fully embedded: AgentsRoom spawns a mini PTY running the official codex login CLI with the right CODEX_HOME, you complete OAuth in the browser, and the status badge flips to "Signed in" the moment the credentials file lands on disk. Each account is an isolated directory containing its own auth tokens, session data and configuration. The unified Multiple Accounts panel in AgentsRoom Settings manages both Claude and Codex accounts side by side under the same UI, with Claude/Codex tabs to switch between the two. Multiple Codex accounts AND Claude accounts in the same window: a Codex Work agent, a Codex Personal agent and a Claude agent can all run in the same project.

### Restore Agents and Terminals
https://agentsroom.dev/features/restore-session
On quit, AgentsRoom can save a snapshot of your session and restore agents and terminals on the next launch. Reopens every AI agent (Claude, Codex, Antigravity, OpenCode, Aider, Grok), every dev terminal, every long-running dev server and every working directory exactly as you left them. Pick up where you left off the next morning in a single click, with zero config.

### Claude Code Token Usage (per-session token meter)
https://agentsroom.dev/features/claude-code-token-usage
Per-session Claude Code token usage tracker built into every agent terminal. Live token counter that turns red on heavy consumption, click-to-open session monitor with input tokens, output tokens, cache reads, cache writes, cache hit rate, message count, tool uses, models routed and ready-made tips to lower your Claude Code token usage. Reads ~/.claude/projects/ JSONL transcripts directly, no proxy on the API.

### Localhost Tunnel (Live Preview)
https://agentsroom.dev/features/localhost-tunnel
Built-in localhost tunnel that exposes any local dev server as a public HTTPS URL. Choose a custom subdomain (e.g. my-app.preview.agentsroom.dev), and share your work-in-progress with anyone, instantly, without deploying. Supports WebSocket passthrough for Vite HMR, Next.js hot reload, and Expo Metro bundler.

### AgentsRoom MCP (agent-pilotable IDE)
https://agentsroom.dev/features/agentsroom-mcp
Four MCP servers (Backlog MCP, Terminal Commands MCP, Prompt Library MCP, Browser MCP) that expose the AgentsRoom IDE itself to Claude Code, Codex CLI, Antigravity CLI, OpenCode, Aider, Grok Build and Mistral Vibe. Agents can read and update the project backlog (and reply to public backlog tickets), list and run saved dev commands (and create new ones in the Terminal Commands list), reuse or save prompts to the Prompt Library, and drive the embedded browser to test their own work. Every action keeps a manual UI path : MCP only adds the option to automate. Local-first, loopback-only bridge with a per-boot hex auth token. The unique edge that turns AgentsRoom from an IDE into an agent-controllable IDE.

### Agent Delegation (Dev to QA test handoff)
https://agentsroom.dev/features/agent-delegation
Dev to QA agent delegation through a single MCP tool call. The dev agent (Claude Opus, Codex) calls run_qa_test on the AgentsRoom Test Runner MCP, an ephemeral QA agent spawns on a cheaper model (Claude Haiku, Codex mini, GPT-4 mini), runs the test via the Browser MCP, returns a pass or fail verdict and is destroyed. Token cost optimization, context isolation, cross-provider. Browser tests today, Electron tests via the AgentsRoom Electron MCP library, React Native tests on the roadmap.

### Project Statistics (time, prompts and cost per project)
https://agentsroom.dev/features/project-statistics
Per-project statistics for your AI coding agents: time spent per project, prompts, time per agent, agents opened, tokens and cost, with a per-day activity chart and a per-agent breakdown table. Secondary feature, but a useful project analytics and time tracking view for project management, client billing and cost control.

### Sketch (draw and annotate, send visual feedback to AI agents)
https://agentsroom.dev/features/sketch
Sketch is a drawing canvas built into the AI agent composer. Open a blank canvas to sketch a mockup, a wireframe or a diagram, or open a screenshot to annotate it: circle a visual bug, draw an arrow, highlight a region, add text. The drawing is exported as a PNG and attached to the message sent to your AI coding agent (Claude Code, Codex), so the agent sees the problem instead of parsing a paragraph of description. Annotation is reachable from composer thumbnails and the file preview. Sketches stay local on your machine, the canvas never leaves the terminal, and it works with any provider whose model accepts an image input.

### Screenshot to Agent (capture a screen region and send it to your AI agents)
https://agentsroom.dev/features/screenshot-to-agent
Screenshot to Agent captures a region of your screen and attaches it straight into the AI agent composer. Two entry points run the same capture: a screenshot button in the composer, and a configurable global keyboard shortcut (Cmd+Shift+2 by default, Ctrl+Shift+2 on Windows and Linux) that works from anywhere, even when AgentsRoom is in the background. It uses your operating system's native region picker (screencapture on macOS, the Snip overlay on Windows, grim, spectacle, gnome-screenshot, maim, scrot or flameshot on Linux), so the screenshot is auto-attached to the focused agent's message as a thumbnail with no external screenshot tool, no saving a PNG to disk and no dragging the file into the window. Captures are stored locally in your home folder and cleaned up automatically. The shortcut is fully customizable and can be disabled in settings. Provider-agnostic, it sends a plain PNG so any model that accepts image input (Claude Code, Codex) can read it. Desktop feature on macOS, Windows and Linux. The fastest way to give an AI coding agent visual context: capture a UI bug, a chart, a terminal output or a design reference and send it in one shortcut.

### Voice Dictation (dictate prompts to your AI agents)
https://agentsroom.dev/features/voice-dictation
Voice dictation built into the agent composer: dictate your prompts to your AI coding agents instead of typing them. Click the microphone button, speak, and the speech-to-text transcription is inserted into the draft at the caret, ready to review and send with Enter (nothing is sent automatically). On desktop, transcription runs server-side on your choice of model: GPT-4o Transcribe (default), GPT-4o mini Transcribe, or OpenAI Whisper (whisper-1), across 16 spoken languages plus automatic language detection, with a live voice waveform visualizer while recording. On mobile, speech recognition runs on-device so the audio never leaves the phone, and the recognized text is relayed end-to-end encrypted to the focused desktop agent. Dictating a long, precise prompt takes seconds instead of minutes: more context to the agent, fewer clarification round-trips and fewer wasted tokens. Provider-agnostic, works with Claude Code, Codex, Antigravity CLI, OpenCode, Aider, Grok Build and Mistral Vibe. A built-in Whisper / speech-to-text dictation that targets the agent prompt directly, instead of a separate dictation app and copy-paste.

### Voice Mode (two-way voice conversation with your AI agents)
https://agentsroom.dev/features/voice-mode
Voice Mode is a two-way, hands-free voice conversation with a running AI coding agent. Tap once and speak; the agent answers out loud in a natural voice, so you stay in the loop without typing prompts or reading walls of terminal output. Turn on hands-free and it keeps listening for your next turn between replies. Ask where the refactor stands and it tells you; say run the tests and report back and it does, then speaks the result. Pick the reply voice (alloy and others), keep an optional beep cue between turns, and let language auto-detect so you speak in your own words. Voice Mode runs on the AgentsRoom backend (speech-to-text in, text-to-speech out) and draws from the same voice credits as dictation. Distinct from Voice Dictation, which only transcribes your speech into the composer one way; Voice Mode is a live spoken back-and-forth. Provider-agnostic, works the same with Claude Code, Codex, Antigravity CLI, OpenCode, Aider, Grok Build and Mistral Vibe. The most natural way to keep up with a long-running agent without being chained to the keyboard.

### Mobile Companion (dictate, attach files and share screenshots from your phone to your AI agent)
https://agentsroom.dev/features/mobile-companion
The Mobile Companion turns your phone into a remote control for the AI coding agents running on your desktop. Three ways to feed the focused agent, all from the phone: voice dictation (tap the mic, the phone microphone records, the transcript lands in the desktop agent composer in the right project), file and photo attachments (pick a photo or any file and it drops into the composer as an attachment, like a desktop screenshot, images resized and compressed first), and a native iOS share extension and Android share intent that put AgentsRoom in the system share sheet so you can share a screenshot from any app straight into your focused desktop agent. Everything resolves the right destination on its own: the right project, the right agent, the focused input. It travels over the AgentsRoom end-to-end encrypted relay so it works on cellular, the server only relays ciphertext, and an offline queue holds shared files until a desktop agent is reachable. Ideal for reporting mobile bugs with a screenshot, sending context on the move, or dictating prompts when your dev machine has no microphone. Provider-agnostic, works with Claude Code, Codex CLI and more. A genuinely connected mobile companion and share extension for AI coding agents, something most desktop-only AI coding tools do not offer.

### SSH Connections (run AI agents on a remote server over SSH)
https://agentsroom.dev/features/ssh-connections
AgentsRoom is an SSH connection manager and a built-in SSH terminal in one. Save the SSH connections to your VPS and remote servers once, connect with an SSH key or a password, then run Claude Code, Codex or Antigravity CLI straight on the remote machine without a separate SSH client. Connection profiles can be scoped per project, so a project that lives on a remote box always opens its terminal over the right SSH connection. Run heavy builds, GPU jobs or long-running agents on a powerful server while you keep the same visual cockpit, status tracking and notifications on your laptop. Provider-agnostic and built for developers who code against remote servers, VPS instances and cloud machines.

### Remote Fleet (run AI agents on every machine, one window)
https://agentsroom.dev/features/remote-fleet
Remote Fleet links every computer you own into a single unified view. The office Mac, the home Mac, a build server in the corner: AgentsRoom shows every project and every Claude, Codex or Antigravity agent in one window, whichever machine it actually runs on. Each machine keeps running its own agents locally, and the fleet view aggregates their status, terminals and projects so you can pilot the whole fleet from wherever you are. Cross-device orchestration travels over an exclusive end-to-end encrypted relay, so your code and your agent output never leave your machines in the clear. Beyond your own machines, you can invite teammates into a project by email or pseudonym and collaborate on the same agents in real time: they attach to the agent sessions running on your machine, watch the live output and send input, with per-agent access control and a private end-to-end encrypted room per member, so a small team can treat one workstation like a shared local server without any SSH or VPN. The way to stop SSH-hopping between boxes and instead drive your entire multi-machine AI coding setup, solo or as a team, from a single screen.

## Comparisons

https://agentsroom.dev/alternatives
Side-by-side comparisons of AgentsRoom with other AI agent managers and terminals: Conductor, Superconductor, CMUX, AMUX, Muxy, Warp, Orca, Jean, JC, Liney, Paseo, iTerm2, tmux and Devin AI.

https://agentsroom.dev/alternatives/cmux
AgentsRoom vs CMUX. CMUX is a terminal-first CLI for parallel Claude sessions via git worktrees. AgentsRoom adds what CMUX lacks: a full visual GUI, real-time agent status, desktop notifications, multi-project view, drag & drop organization, 13 specialized roles, per-agent model, live token meter with overuse alert and a mobile companion app. AgentsRoom also supports optional git worktree isolation per task or per agent.

https://agentsroom.dev/alternatives/conductor
AgentsRoom vs Conductor (conductor.build, Melty Labs). Conductor orchestrates parallel Claude Code and Codex agents with automatic git worktrees, checkpoints and built-in code review, within one repository. AgentsRoom is project-oriented: a multi-project visual IDE with 13 specialized roles, desktop notifications, drag & drop zones, five supported providers (Claude, Codex, Antigravity, OpenCode, Aider), optional worktree isolation per task or agent, and an iOS/Android companion app over an end-to-end encrypted relay.