Free desktop app for AI agent teams powered by the stock Claude Code and OpenAI Codex CLIs you already use.
This fork removes the upstream closed-source multimodel runtime entirely: teams run on the genuine CLIs you already have installed — stock Claude Code and stock OpenAI Codex — using your existing logins and subscriptions, with live consoles into every agent. No proprietary binary is ever downloaded or bundled.
Pick the Codex provider and the team runs entirely on the stock codex CLI — no forked runtime involved:
- Every member is a real interactive Codex session — the lead and each teammate run as their own
codexTUI in a window of one app-managed tmux session ("codex lanes") - The app is the team fabric — lanes get the built-in agent-teams MCP tools via
-cconfig overrides, so the kanban board, task tools, and messaging work exactly like Claude teams; inbound messages are pasted straight into the member's pane (Codex queues input even mid-turn) - Open a console on any member — watch an agent live and type to it directly, or attach from any terminal with
tmux - Real model picker and auth — team dialogs list actual Codex models from the Codex app-server catalog and show your ChatGPT/API-key connection state
- Uses your Codex login — ChatGPT account or API key from
~/.codex, nothing extra to configure
- Claude teams launch on your installed
claudeCLI with the login and subscription you already have - Interactive tmux runtime — the lead is a real interactive Claude session, teammates get their own panes broken out into named windows, and member cards gain an "Open console" action (headless remains the automatic fallback without tmux)
- Direct teammate messaging — DMs are delivered into the runtime's own session mailboxes instead of being relayed through the lead
Each launch picks its runtime from the team's provider: Claude leads → stock Claude, Codex leads → stock Codex lanes, and the fork only on explicit opt-in — a Codex team can never silently run on the Anthropic binary.
A third board view renders tasks as complete workflows on a vertical timeline — stage rail, each task's full journey (created → status moves → review → approved) rebuilt from its history, plus board insights (completed, in review, average cycle time), ordered by creation time.
Concurrent tmux paste-buffer collisions, fork-only control-plane probes leaking into stock launches, codex members stuck as "stale runtime"/forever-joining after launch, scheduler runs failing on stock auth, stale session-team directories being re-adopted, and a GET /api/teams/:teamName/agent-runtime diagnostics endpoint for member liveness.
Known limitation: interactive tmux teams stop when the app quits (restart adoption is not built yet); relaunch the team from the team view after restarting the app.
The original README follows.
|
|
|
|
|
|
|
|
|
|
|
|
Click any preview to open the full-size image.
Watch demo on the site or here:
demo_new_15s.webm
Older demos
demo_new-English_with_captions.mp4 |
landing_demo_3x.mov |
Install Claude Code or OpenAI Codex, sign in with the CLI, and the app will detect it. No proprietary agent runtime is downloaded or bundled.
|
May trigger SmartScreen - click "More info" -> "Run anyway" Run normally. Administrator mode is not required. |
|
The macOS build is code-signed but not notarized, so the first launch is blocked with "Apple could not verify 'Agent Teams AI' is free of malware…". Open it either way:
-
System Settings — try to open the app, then go to System Settings → Privacy & Security, scroll to the bottom, and click Open Anyway.
-
Terminal — clear the download quarantine flag:
xattr -dr com.apple.quarantine "/Applications/Agent Teams AI.app"
Either step is needed once per download. Right-click → Open no longer works: Apple removed that bypass in macOS 15.
- What's new in this fork
- Installation
- Table of contents
- What is this
- Comparison
- Quick start
- FAQ
- Roadmap (new)
- Vision
- Development
- Tech stack
- Ideas
- Contributing
- Partnerships
- Security
- License
An orchestration layer for AI agent teams running on stock Claude Code and OpenAI Codex.
- Assemble your team — create agent teams with different roles that work autonomously in parallel
- Sit back and watch — tasks change status on the kanban board while agents handle everything on their own
- Agents talk to each other — they communicate, create and manage their own tasks, review, leave comments
- Review changes like in Cursor — see what code each task changed, then approve, reject, or comment
- Built-in review workflow — easily see how agents review each other's tasks to make sure everything went exactly as planned
- Token analytics and budgets — see input, output, cache, and reasoning usage across teams, agents, tasks, projects, models, runtimes, sessions, commands, and runs. Spot expensive work, track trends and forecasts, set monthly token or estimated-cost budgets, and get alerts at 80% and 100%
- Organizations and global overview — group teams into departments, squads, or any nested structure. Track every organization on one live map with team and agent status, task progress, dependencies, delegation, and cross-team communication
- Cross-team communication — agents can fully communicate across different teams; you can configure or prompt them to collaborate and message each other between teams
- Stay in control — send a direct message to any agent, drop a comment on a task, or pick a quick action right on the kanban card whenever you want to clarify something or add new work
- Flexible autonomy — let agents run fully autonomous, or review and approve supported tool actions one by one (you'll get a notification) — configure the level of control that fits your security needs
- Task-specific logs and messages — clearly see agent/runtime logs (tools), actions and messages in isolation for each individual task, making it easy to trace what happened for any assignment
- Integrated terminal workspace — run commands in a visual PTY, switch between the team runtime and local shell, and use persistent history, autocomplete, and terminal settings without leaving the app
- Interactive agent consoles (tmux) — Claude Code teams run the lead as a real interactive session inside an app-managed tmux session, with every teammate in its own pane. Click "Open console" on a member card to watch an agent live and type to it directly — or attach from any terminal with
tmux. Headless mode remains the automatic fallback when tmux isn't available - Workflow view on the kanban — a third board view that renders tasks as complete workflows on a vertical timeline: stage rail, each task's full journey (created → status moves → review → approved) built from its history, and board insights (completed, in review, average cycle time)
- Solo mode — one-member team: a single agent that creates its own tasks and shows live progress. Saves tokens; can expand to a full team anytime
- Stock CLI orchestration — auto-detect installed Claude Code and OpenAI Codex CLIs and use their existing subscriptions or API-key configuration
More features
-
Live process section — see registered background services, stop them, and open their URLs directly in the browser
-
Per-agent CPU/RAM history — see how many local resources each live teammate uses over time
-
Task creation with attachments — send a message to the team lead with any attached images. The lead will automatically create a fully described task and attach your files directly to the task for complete context.
-
Auto-resume after rate limits — when the lead hits a Claude rate limit and the reset time is known, the app can automatically nudge the lead to continue once the cooldown has passed
-
Deep session analysis — detailed breakdown of each agent session: agent output, tool calls, bash commands, and subprocesses
-
Smart task-to-log/changes matching — automatically links session logs/changes to specific tasks
-
Advanced context monitoring system — see what consumes context: user messages, project instructions, tool outputs, available thinking summaries, and team coordination. View token usage, context-window share, and estimated cost by category.
-
Recent tasks across projects — browse the latest completed tasks from all your projects in one place
-
Zero-setup onboarding — start with the free model with no auth, then connect paid/account providers only when you need them
-
29 interface languages - choose the app language and preferred agent communication language. Includes English, Chinese, Spanish, Hindi, Portuguese, French, Arabic, German, Japanese, Korean, Russian, Ukrainian, and 17 more.
-
Built-in code editor — edit project files with Git support without leaving the app
-
Branch strategy - choose per teammate at launch: use the main checkout or run selected agents in their own git worktree. You can still spell out branch rules in the provisioning prompt.
-
Team member stats — global performance statistics per member
-
Attach code context — reference files or snippets in messages, like in Cursor. You can also mention tasks using
#task-id, or refer to another team with@team-namein your messages. -
Notification system — configurable alerts when tasks complete, agents need your response, new comments arrive, or errors occur
-
Genuine Claude Code runtime — Claude teams run on your installed
claudeCLI with the login and subscription you already have. The interactive tmux mode can be disabled withAGENT_TEAMS_DISABLE_INTERACTIVE_RUNTIME=1(Windows and tmux-less systems fall back to headless automatically) -
MCP integration — supports the built-in
mcp-server(see mcp-server folder) for integrating external tools and extensible agent plugins out of the box -
Post-compact context recovery — when the active runtime compacts its context, the app restores the key team-management instructions so kanban/task-board coordination stays consistent and important operational context is not lost
-
Task context is preserved — thanks to task descriptions, comments, and attachments, all essential information about each task remains available for ongoing work and future reference
-
Workflow history — see the full timeline of each task: when and how its status changed, which agents were involved, and every action that led to the current state
| Feature | Agent Teams | Gas Town | Paperclip | Cursor | Claude Code CLI |
|---|---|---|---|---|---|
| Live team collaboration | ✅ █████████░ 9/10 · Agents plan, delegate, work, and review together | ✅ ████████░░ 8/10 · Persistent teams with coordination and recovery | |||
| Human control and approvals | ✅ Per-action approvals, roles, and notifications | ✅ Gates, roles, escalation, recovery | ✅ Board approvals, roles, pause, stop | ✅ Permissions + hooks | |
| Visual team progress | ✅ Teammates, tasks, blockers, handoffs, activity, logs | ||||
| Team workspace | ✅ Tasks, code, terminal, review, and teammates in one app | ❌ No desktop UI | |||
| Easy setup | ✅ Start free, no signup or API key | ❌ Manual CLI stack | npx terminal command, less convenient than an app |
||
| Agent readiness and recovery | ✅ Clear ready/stuck status with launch diagnostics | ✅ Working/stalled/failed health with recovery controls | |||
| Kanban board | ✅ 5 columns, real-time | ❌ Dashboard, not Kanban | ✅ 7 columns, drag-and-drop | ❌ | ❌ |
| Code review | ✅ Agent review plus accept, reject, and comment in the app | ✅ Accept / reject individual changes | |||
| Cross-team communication | ✅ Direct agent messages and shared task links across teams | N/A | ❌ | ||
| Linked tasks | ✅ Tasks can link to and block each other | ✅ Task deps + grouped work | ✅ Goals, parent tasks, blockers | ❌ | ✅ Shared task list |
| Agent activity and history | ✅ Messages, tool calls, timeline, token use, and cost | ||||
| Organizations & global overview | ✅ Nested groups, live team/task status, relations, cross-team activity | ✅ Org chart + board governance | ❌ | ||
| AI runtimes | ✅ Stock Claude Code or stock OpenAI Codex teams | ✅ Many providers, terminal-first | ✅ Bring your own agents/runtimes | ||
| Budget controls | ✅ Budget alerts + hard caps for scheduled runs | ✅ Per-agent budgets + hard stops | /usage + workspace limits |
||
| Separate agent workspaces | ✅ Optional workspace per teammate | ✅ Core primitive | ✅ Worktrees / branches | ✅ Agents Window worktrees | ✅ Built-in for sessions and subagents |
| Terminal | ✅ Built-in visual terminal for team and local commands | ✅ Built-in IDE terminal | |||
| Built-in code editor | ✅ With Git support | ❌ | ❌ Control plane, not editor | ✅ Full IDE | ❌ |
| Task attachments | ✅ Auto-attach, agents read & attach files | ❌ Not task-level | ✅ Docs, attachments, work products | ||
| Price | Free OSS UI + free model with no auth, paid providers optional | Free OSS, runtime plans needed | Free OSS, self-hosted + infra | Free + paid usage | Claude plan or API usage |
Live collaboration scores measure how well agents communicate, divide work, and complete complex tasks together.
Sources and methodology
Agent Teams product evidence checked in local source on July 11, 2026: organizations feature, terminal workspace, token usage budgets, scheduled run budget cap. Competitor fact sources checked on July 11, 2026: detailed research notes, Gas Town README, Gas Town provider guide, Gas Town scheduler, Gas Town dashboard source, Gas Town release, Paperclip README, Paperclip adapters, Paperclip heartbeat protocol, Paperclip org chart, Paperclip OrgChart source, Paperclip budgets, Paperclip runtime services, Paperclip Kanban source, Paperclip work products, Paperclip release, Cursor terminal, Cursor Cloud Agents, Cursor Agent Review, Cursor Bugbot, Cursor worktrees, Cursor multitask agents, Cursor cloud subagents, Cursor Models & Pricing, Cursor Team Pricing, Claude Code CLI, Claude Code agent teams, Claude Code worktrees, Claude Code subagents, Claude Code workflows, Claude Code costs, Claude pricing.
- Download the app for your platform (see Installation)
- Launch the desktop app - start with the free model with no auth, or let the setup wizard detect runtimes and guide provider authentication
- Create a team — Pick a project, define roles, write a provisioning prompt
- Watch — Agents spawn, create tasks, and work. You see it all on the kanban board
The desktop app is the main product. The web version is currently in active development.
Does it read or upload my code?
The app reads local runtime/session data to power the UI, but it does not upload, sync, or send your project or code to Agent Teams servers. There is no Agent Teams cloud backend for storing your code. If you launch an external AI runtime, that runtime communicates directly with its provider under the provider's own terms. Setup checks only verify provider access and capabilities; they do not upload your project to Agent Teams.
Can agents communicate with each other?
Yes. Agents send direct messages, create shared tasks, and leave comments - all coordinated by the app's own orchestration layer.
Is it free?
Yes. The app is free and open source. Model access follows the Claude Code or OpenAI Codex account/API configuration already present in the corresponding stock CLI.
Can I review code changes before they're applied?
Yes. Tasks with detected code changes include a full diff view where you can accept, reject, or comment on individual code hunks — similar to Cursor's review flow.
What happens if an agent gets stuck?
Send a direct message to course-correct, or open the teammate status to inspect diagnostics and restart the agent. Agent Teams also has a nudge system: the app can send a short control message when there is a clear reason to wake an agent up, such as after a known rate-limit cooldown, when a teammate has not synced with its current task or review, or when progress appears stalled. Nudges are guarded and rate limited, so they are meant to help the agent continue, not spam it. If an agent needs your input, you'll get a notification and the task will show a distinct badge on the board.
Does it support multiple projects and teams?
Yes. Run multiple teams in one project or across different projects, even simultaneously. To avoid Git conflicts, enable git worktree isolation for selected teammates when launching the team, and use the provisioning prompt for any extra branch or merge rules.
What if the Linux app freezes or shows a blank window over RDP?
Some RDP (Remote Desktop Protocol) sessions expose virtual GPU drivers that can break Electron rendering. Launch with `AGENT_TEAMS_DISABLE_GPU=1` to disable Electron hardware acceleration for that run, for example `AGENT_TEAMS_DISABLE_GPU=1 pnpm dev` from source or `AGENT_TEAMS_DISABLE_GPU=1 ./Agent.Teams.AI.AppImage` for AppImage builds.
- Launching 24/7 autonomous teams in the cloud with current UI (in progress)
- Automatic account switching (in progress)
- Navigating very complex long tasks without losing context (in progress)
- Multiple AI runtimes and provider-backed coding agents
- A secure universal plugin system regardless of the type of agents
- Efficiency and controllability under load with 20-100+ agents in parallel
Agent Teams AI is moving toward a simple interface for highly autonomous work. From a phone, users should be able to see only the high-level tasks that matter and give the lead agent instructions by voice. The lead should route each request to the right project and team, while agents break it down, work in parallel, communicate, review, resolve blockers, and prepare the final result with minimal supervision.
Technical subtasks and coordination should remain available as a secondary layer, while the main view surfaces only the decisions, blockers, and outcomes that genuinely need attention. Agents should first try to solve problems together and involve the user only when human input is truly required.
This vision is not tied to a specific SDLC or workflow. Users should be free to organize teams however they prefer and continue using their existing plugins, skills, MCP servers, rules, and agent settings.
For feature architecture and implementation guidance:
- Canonical standard - docs/FEATURE_ARCHITECTURE_STANDARD.md
- Repo working instructions - CLAUDE.md
- Feature root guidance - src/features/README.md
- Reference implementation -
src/features/recent-projects
Electron 40, React 19, TypeScript 5, Tailwind CSS 3, Zustand 4. The desktop app reads local project, app, and runtime/session data. Claude Code data under ~/.claude/ is one supported local source, while some runtime modes may also use provider or startup capability services when required.
Build from source
Prerequisites: Node.js 24.16.0 LTS, pnpm 10+
On macOS, official Node.js 24 prebuilt binaries require macOS 13.5+.
git clone https://github.com/777genius/agent-teams-ai.git
cd agent-teams-ai
pnpm install
pnpm devpnpm dev starts the desktop Electron app. Do not start a browser/web dev server for normal development; that path is limited and is not the supported way to run agent teams locally.
Claude teams launch on the genuine Claude Code CLI found on your PATH (interactive tmux mode
when tmux is available, headless otherwise). Set AGENT_TEAMS_DISABLE_INTERACTIVE_RUNTIME=1 to
force headless stock launches. Point CLAUDE_CLI_PATH at a specific claude binary if you need
to override PATH resolution.
runtime bundle on every app start. Do not use CLAUDE_DEV_RUNTIME_ROOT for the normal source
development loop: that override runs bun run build:dev before Electron starts and can make the app
appear stuck at bun run ./scripts/build.ts --dev. Use it only when intentionally validating the
generated development bundle.
Use pnpm dev:mcp for automated interactive or visual UI verification. It exposes the current
Electron renderer through the local Chrome DevTools Protocol endpoint on 127.0.0.1:9222, avoiding
window-selection ambiguity when packaged or other Electron apps are also open.
The desktop app auto-discovers Claude Code projects from ~/.claude/.
The Matter Dashboard uses the trimmed vendored Link runtime in vendor/link; a separate
Link clone or global lnk installation is not required. Python 3.10+ must be available
to execute the bundled source. Explicit Link command, script, and Python environment
overrides remain supported for development and testing.
Link is an MIT-licensed third-party project. See THIRD_PARTY_NOTICES.md and
vendor/link/UPSTREAM.md for the upstream repository, copyright notice, license, and
base revision used by the vendored snapshot.
Fresh clones install Terminal Platform SDK packages from vendor/terminal-platform, so
pnpm install --frozen-lockfile does not require a sibling ../terminal-platform checkout.
Those artifacts are pinned in vendor/terminal-platform/manifest.json and can be refreshed from a
local Terminal Platform checkout with:
CLAUDE_TERMINAL_PLATFORM_ROOT=/path/to/terminal-platform pnpm terminal-platform:packFor local Terminal Platform development, build Terminal Platform first, then run this app with the same environment variable:
CLAUDE_TERMINAL_PLATFORM_ROOT=/path/to/terminal-platform pnpm dev:mcpWhen the variable is set, the Electron build aliases Terminal Platform SDK imports to that local
checkout and the terminal runtime loads terminal-platform-node from the local native artifact.
Development launches use the app-managed process backend for teammates by default. To inspect
teammates in tmux panes while debugging, start the desktop app with:
CLAUDE_TEAM_TEAMMATE_MODE=tmux pnpm devThe same override is available per launch from custom CLI args with
--teammate-mode tmux. Use this as an operator/debug mode; the default process backend provides
stronger app-owned lifecycle, diagnostics, and cleanup for normal team launches.
pnpm dist:mac:arm64 # macOS Apple Silicon (.dmg)
pnpm dist:mac:x64 # macOS Intel (.dmg)
pnpm dist:win # Windows (.exe)
pnpm dist:linux # Linux (AppImage/.deb/.rpm/.pacman)
pnpm dist # Current platformDistribution scripts run the production build and stage the terminal-platform runtime before packaging. No proprietary agent runtime is downloaded or bundled — teams always run on the CLIs installed on the user's machine.
| Command | Description |
|---|---|
pnpm dev |
Desktop app development with hot reload |
pnpm dev:mcp |
Desktop app development with hot reload and local CDP debugging on port 9222 |
pnpm build |
Production build |
pnpm typecheck |
TypeScript type checking |
pnpm lint |
Lint (no auto-fix) |
pnpm lint:fix |
Lint and auto-fix |
pnpm format |
Format code with Prettier |
pnpm test |
Run all tests |
pnpm test:watch |
Watch mode |
pnpm test:coverage |
Coverage report |
pnpm test:coverage:critical |
Critical path coverage |
pnpm check |
Full quality gate (types + lint + test + build) |
pnpm fix |
Lint fix + format |
pnpm quality |
Full check + format check + knip |
- Planning mode to organize agent plans before execution
- Visual workflow editor (@xyflow/react) for building and orchestrating agent pipelines with drag & drop
- Remote agent execution via SSH: launch and manage agent teams on remote machines over SSH (stream-json protocol over SSH channel, SFTP-based file monitoring for tasks/inboxes/config)
- Generic ACP runtime: connect Agent Client Protocol-compatible agents through one reusable runtime integration
- Limited standalone dashboard for local or trusted-network use. It does not provide the full desktop runtime and should not be exposed directly to the internet without authentication and a reverse proxy.
- 2 modes: current (agent teams), and a new mode: regular subagents (no communication between them)
- Curate what context each agent sees (files, docs, MCP servers, skills)
- User-managed runtime profiles and built-in presets: choose a profile per team launch or schedule, isolate provider credentials and config roots (
CLAUDE_CONFIG_DIR,CODEX_HOME), optionally isolate the child-processHOME, and pin running teams to an immutable profile snapshot - Slash commands
- Outgoing message queue — queue user messages while the lead (or agent) is busy; clear agent-busy status in the UI; flush to stdin or relay from inbox when idle (durable queue on disk for the lead inbox path)
-
createTasksBatch— IPC/service API to create many team tasks in one call (playbooks, markdown checklist import, scripts); complements singlecreateTask - Command palette — extend Cmd/Ctrl+K beyond project/session search to runnable actions (quick commands, navigation shortcuts, team/task operations) in a keyboard-first flow
- Custom kanban columns
- Run terminal commands
- Monitor agents processes/stats
- Reusable agents with SOUL.md
- Messenger integrations
- SDK to programmatically launch agents ...
See CONTRIBUTING.md for development guidelines. Please read our Code of Conduct.
We are open to partnerships and collaboration opportunities. If you see a way to create value together, we are ready to discuss mutually beneficial terms.
Contact: quantjumppro@gmail.com
IPC and standalone HTTP handlers validate IDs, paths, and payload shape at the boundary. Project editing and write operations are constrained to the selected project root, while read-only discovery also accesses local Claude data under ~/.claude/ and app-owned state paths when required. Path traversal and sensitive config/credential targets are blocked. See SECURITY.md for details.
The standalone HTTP dashboard is intended for local or trusted-network use and does not include built-in authentication for public deployment. Do not expose it directly to the internet without an authenticated reverse proxy.
GitHub Dependabot helps surface dependencies with known vulnerabilities and available security updates.