# Running Claude Code Across Environments

*Research document on multi-agent orchestration for AI coding agents* *Last updated:
March 2026*

**Related:**

- [Claude Code Sub-Agents](research-claude-code-sub-agents.md) — Internal sub-agent
  architecture, model configuration, compaction/handoff patterns
- [Claude Code Orchestration Interfaces and UIs](research-claude-code-orchestration-and-uis.md)
  — Control protocols, IDE surfaces, and external orchestration interfaces
- [API References for Bridge Integrations](api-references-bridge-integrations.md) —
  Multi-agent protocols (MCP, ACP, A2A, ANP) and bridge APIs

* * *

## Introduction: The Multi-Agent Orchestration Problem

Claude Code is currently used in fairly siloed ways—via IDE plugins (like Cursor’s
integration), Anthropic’s Claude Code Cloud web UI, or the desktop app.
These provide powerful single-agent coding assistance, but orchestrating **multiple
Claude Code instances** concurrently in different environments remains challenging.

There is growing interest in frameworks that let many coding agents collaborate on tasks
(for example, coordinating agents from a Slack channel, or across multiple terminals)
with persistent state and minimal manual overhead.
This is essentially a **multi-agent orchestration** problem that breaks down into
several components:

1. **Shared Memory / Task Tracking** — How agents know what work exists and who’s doing
   what
2. **Inter-Agent Communication** — How agents coordinate and hand off work in real-time
3. **Event-Driven Triggers** — How to wake up or spawn agents based on external events
4. **Cross-Machine Coordination** — How agents on different machines or cloud instances
   collaborate
5. **Execution Environments** — Where agents run safely and scalably

This document surveys the current landscape of tools and approaches addressing each of
these challenges.

* * *

## Part 1: Shared Memory and Task Tracking

Before coordinating multiple agents, it’s critical to have a **shared persistent memory
or task tracker** so agents can see the overall work state.

### Beads: Git-Backed Memory for Coding Agents

**Beads**, created by Steve Yegge in late 2025, is a foundational tool in this space.
It is essentially a **lightweight issue-tracking database for coding agents**, with each
“bead” representing a unit of work (issue/task) containing a description, status,
assignee, etc.

Under the hood, Beads stores issues as a JSON Lines file and syncs them via Git,
augmented by a local SQLite cache and a background daemon for real-time updates.
This design gives agents a form of long-term memory: they can query what tasks exist,
which are in progress or done, and even preserve history of work in Git.

**Why is Beads important for multi-agent setups?** If you run 5 Claude Code instances in
parallel, you need them to not step on each other’s toes.
Beads addresses this by **tracking task status centrally** and even allowing atomic task
claims (with the daemon) so two agents don’t accidentally grab the same issue.
Users and agents file tasks into Beads, and each Claude instance can query “ready”
tasks, mark tasks as in-progress or closed, etc., all via CLI commands (`bd create`,
`bd claim`, `bd close`, etc.).

**Beads limitations:** Its architecture—using a local SQLite database and continuous
daemon—can be brittle or **incompatible with sandboxed and cloud environments**:

- Many cloud environments disallow background processes
- SQLite file locking breaks on network filesystems (NFS/SMB)
- The background sync can conflict with manual Git operations
- **Beads doesn’t run well inside Claude Code Cloud/desktop sandbox**

This motivated alternatives that retain Beads’ benefits with simpler, more
environment-agnostic designs.

**January 2026 Update:** Beads has seen rapid development alongside Gas Town:
- Steve Yegge merged **17 PRs in one day** on Beads alone
- The **GUPP Principle** ("Git Up and Push Protocol") addresses context window
  management: “If there is work on your hook, YOU MUST RUN IT”
- Beads expects to be in the **LLM training corpus** soon, improving how naturally
  agents use it

### TBD: A Git-Native Beads Successor

**TBD (To Be Done)** is a drop-in replacement for Beads that emphasizes *durability,
simplicity, and cross-environment compatibility*. Key design differences:

| Aspect | Beads | TBD |
| --- | --- | --- |
| Storage | SQLite + JSONL | Individual Markdown files |
| Background process | Required daemon | None |
| Sync mechanism | Continuous daemon | On-demand CLI |
| Network filesystem | Problematic | Works fine |
| Cloud sandbox | Doesn’t work | Works anywhere |
| Merge conflicts | Common in JSONL | Rare (one file per issue) |

**TBD’s design philosophy:**
- Each issue is a separate Markdown file with YAML front-matter
- All issue files live on a dedicated Git **sync branch**, keeping main clean
- No SQLite locks or daemon needed—just Git and filesystem
- Can “npm install -g tbd **anywhere**: local dev, CI, cloud IDEs, network filesystems”

**Trade-offs:** TBD uses **“advisory” claims** rather than atomic locks.
If two agents claim the same task simultaneously, a merge conflict may occur—TBD detects
this and preserves both versions in an “attic” (last-write-wins with conflict
resolution).
This makes TBD **ideal for async or loosely coupled multi-agent workflows**,
but for tight real-time hand-offs, something like Agent Mail is still needed on top.

### Other Git-Native Issue Trackers

The trend toward git-native issue tracking for agents includes:

- **git-bug** — Distributed bug tracker embedded in Git (Go, ~1.7k stars)
- **SCIIT** — Issues stored as block comments in source code, tracked via Git hooks
- **git-issue** — Decentralized issue management by Diomidis Spinellis
- **Ticket** — Simple Bash-based ticket tool

All embrace simplicity, no always-on services, and Git for distribution.

* * *

## Part 2: Multi-Agent Orchestration Frameworks

### Gas Town: Full Multi-Agent Orchestrator (Built on Beads)

While Beads is a passive issue tracker, **Gas Town** is Steve Yegge’s ambitious attempt
to build a full **multi-agent orchestrator** on top of Beads.
Released January 1, 2026, it’s described as a *“multi-agent orchestration system for
Claude Code with persistent work tracking”*.

**Architecture concepts (Mad Max themed):**
- **Mayor** — Coordinator agent with full context of all ongoing work
- **Polecats** — Ephemeral worker agents that spawn, complete a task, and disappear
- **Rigs** — Projects under development, each linked to a Git repo
- **Convoys** — Bundles of tasks assigned to an agent as a batch
- **Mailboxes** — Inter-agent message passing (inspired by Agent Mail)

Gas Town lets a developer launch and manage **20-30 Claude Code agents in parallel**,
dividing work among them and preserving context across agent restarts.

Gas Town adds several orchestration features: **“Convoys”** bundle multiple tasks to
assign to an agent as a batch, and built-in **mailboxes/handoffs** allow agents to send
messages or “email” each other tasks and results asynchronously.
Gas Town also defines **persistent agent identities** via special “Role beads” and
“Agent beads”—giving each agent a stable address and profile in the task database.

Yegge built Gas Town after reaching the limits of manually juggling 10+ agents ("Stage
7" in his terms), envisioning it as *“like Kubernetes, but for agents.”*

**January 2026 growth:**
- **100+ PRs merged** from nearly 50 contributors
- **44k lines of code** added, growing to **189k lines of Go code** total
- **2,684 commits** since Dec 15th first commit
- Yegge merged **25 PRs in one day** on Gas Town and **17 PRs** on Beads
- Supports multiple backends: Claude Code CLI (default) and OpenAI Codex CLI (optional)

**Real-time coordination and safety:** Gas Town is an **aggressive YOLO setup**—Yegge
warns it’s for experienced “chimp wranglers” at the frontier.
All agents run with high autonomy, so mistakes can happen fast.
Gas Town mitigates risk by persisting everything and using Git as a safety net.
Multiple agents might fix the same bug in different ways, and a human (or mayor) later
“picks the winner.” The philosophy is high throughput over perfection—an **“AI coding
factory”** with you as the manager overseeing a swarm of coding agents.

**Caveats:**
- Inherits Beads’ SQLite dependency—best for local Unix-like environments
- Requires Go 1.23+, Git 2.25+, tmux, and Beads v0.44+
- A GAS token crypto scam emerged (released Jan 13, peaked at 4 cents, fully pumped and
  dumped by Jan 19)—unrelated to the open-source project

### Moltbot (formerly Clawdbot)

A major new entrant with **68,000+ GitHub stars**, created by PSPDFKit founder Peter
Steinberger. Rebranded from “Clawdbot” after an Anthropic trademark challenge.

**Key differentiators:**
- **Headless execution** — Bypasses GUI entirely, executing shell commands at machine
  speed
- **Multi-platform messaging bridge** — Connects WhatsApp, Telegram, Discord, iMessage
  to coding agents
- **Multi-agent routing** — Routes provider accounts to isolated agents with per-agent
  sessions
- **Hierarchical orchestration** — Supervisor agents delegating to specialists
- **Cross-platform orchestration** — Coordinates between Codex, Cursor, Manus, and other
  tools

Unlike most orchestrators assuming same-machine execution, Moltbot’s messaging bridge
enables coordination across different platforms and environments.

### Claude Squad

Terminal app by smtg-ai managing multiple agents (Claude Code, Aider, Codex, OpenCode,
Amp):
- Uses **tmux** for isolated terminal sessions
- Uses **git worktrees** to isolate codebases (each session on its own branch)
- Supports **auto-accept/YOLO mode** for background task completion
- Install: `brew install claude-squad`

### Conductor (Melty Labs)

macOS app for parallel agent orchestration:
- Runs multiple Claude Code/Codex agents simultaneously
- Each agent gets isolated **git worktree** workspace
- Tight integration with **Linear** and **GitHub**
- See who’s working, who’s stuck, and what changed in one UI
- **Free** (no subscription), but **Apple Silicon only**

### Code Conductor (Open Source)

GitHub-native orchestration (github.com/ryanmac/code-conductor):
- Agents claim tasks, implement, and ship autonomously
- **Zero merge conflicts** via isolated worktrees
- GitHub-native—no external dependencies

### Oh My Claude (OMC)

Transforms Claude Code into multi-agent system:
- **32 specialized agents** and **40 skills**
- Zero learning curve
- **Sisyphus variant** — 11 specialized agents (Oracle, Prometheus, etc.)
  working continuously
- 18 lifecycle hooks, LSP and AST tools integration

* * *

## Part 3: Inter-Agent Communication

### MCP Agent Mail

**MCP Agent Mail** by Jeffrey Emanuel focuses specifically on inter-agent communication
and coordination. As Steve Yegge put it: *“Beads gives the agents shared memory, and MCP
Agent Mail gives them messaging… and that’s all they need.”*

**What Agent Mail provides:**
- Local **HTTP server ("MCP server")** for sending messages like email threads
- Each agent gets an **inbox and outbox** stored in a git-tracked archive
- **Agent identities** and lightweight “threads” for conversation context
- **Advisory file locking (reservations)** — agents request leases on files before
  modifying

The file reservation system addresses a key challenge: two agents editing the same file
can interfere or cause merge conflicts.
Agents request reservations via the mail server, and others avoid those files until the
lease expires. This is analogous to the “file check-out” approach of old source control
systems—Jeffrey even jokes it resembles his 1990s Accenture workflow where only one dev
could edit a file at once.
But in practice, he found that AI agents **“just figure it out”** and coordinate without
trouble—the agents negotiate via messages who works on what, often deciding a leader
among themselves.

**Git worktree support:** Agent Mail also supports working with a **Git worktree model**
(multiple working copies of the repo for each agent) as an alternative to single-folder
mode. Jeffrey modified Agent Mail to support worktrees, which avoids needing file locks
entirely—each agent works on its own branch and merges via Git.

**January 2026 updates:**
- **Automated message checking hooks** — Addressed complaint that agents forget to check
  messages; now works for Claude Code, with Codex and Gemini support coming
- **Commercial companion app** — Emanuel built using 7 Codex instances simultaneously,
  400 agent messages for complete implementation
- **Mobile app** — Provision and steer fleets of agents from iOS, broadcast
  instructions, enforce confirmation for dangerous actions

**Emanuel’s recommended stack:**
- Agent Mail MCP + warp-grep MCP + playwright MCP (for frontend)
- CLI tools: Beads, bv (Beads viewer), ubs, cass
- Enables running **10+ agents simultaneously** on complex projects

**The “Agent Village” concept:** Beads + Agent Mail = an environment where many agents
work in parallel, share a memory of tasks, and communicate like a small team.
This concept boosts productivity substantially: Jeffrey claims using 10+ agents with
this setup gave him effectively dozens of hours of work done in parallel for each human
hour, thanks to machine-speed typing and coordination.

Agent Mail also has a **companion mobile app and automation layer** (a commercial
offering) that allows provisioning and steering fleets of agents from an iOS app, with
features like broadcasting instructions to all agents and enforcing confirmation for
dangerous actions. This shows one possible future: an **“Agent HQ”** where a human
overseer can manage many agents remotely.

### Google’s A2A (Agent-to-Agent) Protocol

The **only purpose-built protocol** for cross-machine agent coordination, launched by
Google in April 2025 and now donated to the Linux Foundation.

**Key features:**
- **150+ organizations** supporting (Atlassian, Salesforce, SAP, Box, Cohere, etc.)
- JSON-RPC over HTTP with Server-Sent Events for streaming
- Agents expose **“Agent Cards”** at `/.well-known/agent.json` for discovery
- Version 0.3 released with gRPC support and security card signing

**A2A vs MCP:** | Protocol | Purpose | Scope | |----------|---------|-------| | MCP |
Agent-to-tool communication | How agents access tools and resources | | A2A |
Agent-to-agent communication | How agents collaborate with each other |

A hybrid approach using both protocols is emerging as the recommended pattern.

**Key capability:** “A2A enables cross-network collaboration—supporting the
collaboration of agents operating in different distributed network environments, such as
other clouds or multi-tenant systems.”

### MCP Remote Servers

MCP was designed for local tool connections but **can work remotely**:
- `MCPServerStdio` class for local subprocess servers
- `MCPServerSse` class for HTTP-based remote servers
- Can combine local and remote servers in one agent
- Cross-System Agent Communication MCP Server exists for multi-system coordination

* * *

## Part 4: Event-Driven Triggers and GitHub Automation

A key question for distributed agent workflows: **How do you trigger Claude Code
instances based on external events?**

### GitHub-Triggered Claude Code

**Official: Claude Code GitHub Actions** (github.com/anthropics/claude-code-action)

The official GitHub Action brings AI-powered automation to GitHub workflows:
- **Trigger**: `@claude` mention in any PR or issue comment
- **Workflow events**: `pull_request`, `issue_comment`, `issues`, `push`
- **Setup**: Run `/install-github-app` in Claude Code terminal

```yaml
# Example: Wake up Claude on any @claude mention
name: claude-responder
on:
  issue_comment:
    types: [created]
jobs:
  claude:
    if: contains(github.event.comment.body, '@claude')
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
```

**Claude Hub** (claude-did-this.com) — More autonomous webhook service:
- Complete end-to-end development workflows
- Implements features, reviews code, merges PRs, waits for CI, runs for hours
- Microservice architecture with container isolation and webhook verification
- **60-80% reduction** in manual review time claimed

### The Bot-to-Bot Problem

**Critical insight:** Most GitHub bot frameworks **explicitly prevent** bot-to-bot
communication to avoid infinite loops:

```yaml
# Standard anti-loop pattern
if: ${{ github.event.sender.type != 'Bot' }}
```

This is why scenarios like “Bot A files PR → Bot B reviews → Bot A responds” aren’t
built-in patterns—they’re considered anti-patterns.

**Workarounds for intentional bot-to-bot coordination:**

1. **Human-in-the-loop** — Use specific commands like `@claude-reviewer` vs
   `@claude-implementer` requiring human trigger

2. **State machine via GitHub** — Use PR labels/status checks as coordination mechanism
   rather than comment chains

3. **External orchestrator** — Have a central service manage agent-to-agent
   communication, only triggering GitHub when needed

**Example: Multi-Bot Workflow via GitHub Actions**

```yaml
# Workflow 1: Implementer bot
name: claude-implementer
on:
  issues:
    types: [assigned]
jobs:
  implement:
    if: contains(github.event.issue.labels.*.name, 'needs-implementation')
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          prompt: "Implement this feature and file a PR"

# Workflow 2: Reviewer bot (triggered by PR from implementer)
name: claude-reviewer
on:
  pull_request:
    types: [opened]
jobs:
  review:
    if: github.event.pull_request.user.login == 'claude-implementer-bot'
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          prompt: "Review this PR and request changes if needed"

# Workflow 3: Implementer responds to review
name: claude-respond-to-review
on:
  pull_request_review:
    types: [submitted]
jobs:
  respond:
    if: github.event.review.user.login == 'claude-reviewer-bot'
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          prompt: "Address the review feedback"
```

### Claude Code Hooks System

Claude Code provides hooks for event-driven behavior within sessions:

| Event | When It Fires | Use Case |
| --- | --- | --- |
| `PreToolUse` | Before Claude performs an action | Validation |
| `PostToolUse` | After Claude completes an action | Cleanup, logging |
| `Stop` | When Claude finishes responding | Trigger next steps |
| `SubagentStop` | When a subagent finishes | Coordinate subagent work |
| `SessionStart` | Session begins or resumes | Load context, set up environment |
| `SessionEnd` | Session terminates | Cleanup, sync state |

Hooks can perform async operations like HTTP requests, enabling webhook integration
within Claude Code sessions.

* * *

## Part 5: Cross-Machine Coordination

Most multi-agent frameworks assume **same-machine execution**. True cross-machine
coordination remains a significant gap in the ecosystem.

### Current State Comparison

| Framework | Same Machine | Cross-Machine | Notes |
| --- | --- | --- | --- |
| Gas Town / Beads | Yes | No (Git sync only) | Requires local SQLite, daemon |
| Agent Mail (MCP) | Yes | Partial | HTTP server could be networked |
| Claude Squad | Yes | No | tmux/worktree based |
| Conductor | Yes | No | macOS only |
| Moltbot | Yes | Partial | Messaging bridge approach |
| **A2A Protocol** | Yes | **Yes** | Purpose-built for this |
| **MCP Remote Servers** | N/A | **Yes** | Emerging pattern |

### claude-code-by-agents

The **closest existing tool** for cross-machine Claude Code coordination
(github.com/baryhuang/claude-code-by-agents):

- Desktop app and API for multi-agent orchestration
- Coordinates **local AND remote agents** through @mentions
- Supports routing to: `localhost:8081`, `mac-mini.local:8081`, `cloud-instance:8081`
- @mentions route to specific agents; orchestrator handles coordination
- File-based communication with automatic dependency management

### What Doesn’t Exist (The Gap)

**For Claude Code Cloud specifically:**
- **No native instance-to-instance communication** — sessions are isolated
- **No official orchestration API** for cloud instances
- **Teleport (`/tp`)** only brings sessions to your terminal, doesn’t connect them

**Architecture needed for cross-instance coordination:**

```
┌─────────────────────────────────────────────────────────────┐
│                    Orchestration Layer                       │
│  (GitHub webhook handler / A2A server / custom service)      │
└─────────────────────────────────────────────────────────────┘
        ↓ spawn/trigger         ↓ spawn/trigger
┌───────────────┐         ┌───────────────┐
│ Claude Code   │ ←─────→ │ Claude Code   │
│ Cloud #1      │  (via   │ Cloud #2      │
│               │   Git)  │               │
└───────────────┘         └───────────────┘
```

The coordination would happen through:
1. **GitHub** as the message bus (commits, PRs, issues)
2. **TBD sync branch** as shared state
3. **External orchestrator** to trigger new instances

* * *

## Part 6: Execution Environments

### Sprites.dev (Fly.io)

**Sprites** are stateful sandbox environments with checkpoint & restore—lightweight,
Firecracker-based VMs designed for AI coding agents.
Launched January 2026.

**Philosophy:** “Ephemeral sandboxes are obsolete.
Stop killing your sandboxes every time you use them.”

**Key features:**
- Boot in **1-12 seconds** with **100GB persistent storage**
- Auto-idle when inactive (stops billing, preserves state)
- Last 5 checkpoints mounted at `/.sprite/checkpoints`
- Pre-installed: Claude Code, Codex CLI, Python, Node
- Checkpoints restore in **~300ms**
- **500 Sprites free** with trial credits
- **Open-source local version coming** per Fly.io developer Thomas Ptacek

**Use cases for multi-agent orchestration:**
- Spawn 5 Sprites, each with Claude Code isolated from your main system
- Run Agent Mail server in one Sprite, agents in others communicate over private network
- Checkpoint before risky operations, rollback on failure
- Per-VM network policy (allow/restrict internet access)

**Security context:** Simon Willison predicts “we’re due a Challenger disaster with
respect to coding agent security”—Sprites addresses this with VM isolation.
If an agent goes haywire, it only damages its VM (which you can snapshot or wipe).

### Other Execution Options

- **Docker containers** — Lighter than VMs but less isolated
- **Firecracker microVMs** — What Sprites uses under the hood
- **GitHub Codespaces** — Cloud dev environments (can run TBD, limited multi-agent)
- **Claude Code Cloud** — Anthropic’s managed sandbox (isolated sessions, no cross-talk)

* * *

## Part 7: Claude Code’s Native Multi-Agent Features

### Hidden TeammateTool (Discovered January 24, 2026)

The community discovered that **Claude Code v2.1.19 contains a fully-built multi-agent
orchestration system** hidden behind feature flags.

**TeammateTool** (extracted from the binary) supports 13 core operations:
- `spawnTeam` / `discoverTeams` / `requestJoin`
- `assignTask` / `broadcastMessage` / `voteOnDecision`
- And more coordination primitives

**Tools to access it:**

| Tool | Approach | URL |
| --- | --- | --- |
| CC Mirror | Unlocks hidden feature, zero dependencies | github.com/numman-ali/cc-mirror |
| claude-sneakpeek | Parallel build with flags enabled | github.com/mikekelly/claude-sneakpeek |
| Claude-Flow | Third-party using native TeammateTool | github.com/ruvnet/claude-flow |

**CC Mirror** turns Claude into “The Conductor” that decomposes work into dependency
graphs, spawning background agents to execute in parallel while the lead continues
working.

**Warning:** The feature is experimental with “documented reliability issues”—not
recommended for production yet.
“Swarms mode is feature-flagged for good reasons.”

### The Task Tool (Official)

Claude Code’s official agent orchestration via the Task tool:
- Spawn specialized sub-agents that work independently
- Run in background without blocking workflow
- Return results to main session
- Each subagent type has specific tools available

### Anthropic’s Official Multi-Agent Research

Anthropic published details of their internal architecture:
- **Orchestrator-worker pattern** with Claude Opus 4 as lead and Claude Sonnet 4
  subagents
- **90.2% improvement** over single-agent Opus 4 on internal research evaluations
- Agents use **4× more tokens** than chat; multi-agent uses **15× more**

**Claude Cowork** (launched January 12, 2026):
- Autonomous agent operating as a “digital colleague”
- Manages file systems, orchestrates workflows, executes multi-step tasks
- Anthropic signals “multi-agent orchestration” as the next major milestone

**Important distinction:** Cowork is not exactly multiple agents—it’s **one Claude
executing a chain of tool-using actions**. But it’s a step toward an orchestrator-like
experience for end users.
Anthropic positions Cowork as a glimpse of the future where powerful coding agents are
more autonomous and can handle complex workflows beyond just Q&A chat—described as a
“general agent… well positioned to bring the wildly powerful capabilities of Claude Code
to a wider audience.”
Instead of requiring a power-user to manually orchestrate many Claude instances via tmux
(a la Gas Town), Anthropic might eventually provide a more **user-friendly
orchestrator** where Claude itself manages subtasks.
It wouldn’t be surprising if future versions allow something like “Claude spawns Claude”
internally.

* * *

## Part 8: IDE and Platform Integrations

> **See also:**
> [Claude Code Orchestration Interfaces and UIs](research-claude-code-orchestration-and-uis.md)
> provides a comprehensive analysis of the control protocols (Agent SDK, `--sdk-url`
> WebSocket, IDE integration protocol, ACP), UI surfaces, and third-party projects that
> have emerged since this section was originally written.

### Current State

IDE-based AI coding assistants (Cursor, VS Code Copilot, etc.)
are typically **single-agent affairs**. They excel at inline code suggestions and
one-at-a-time commands but **do not inherently support multiple agents concurrently**.

As Yegge’s “Dev Evolution” stages illustrate:
- **Stage 2-3:** Coding agent in IDE, maybe YOLO mode (most developers in 2024-2025)
- **Stage 6:** CLI, multi-agent, YOLO
- **Stage 7+:** Orchestrators like Gas Town

The jump to Stage 6 and beyond requires stepping outside the typical IDE plugin UI and
using CLI-based tools.

**VS Code experiments:** Third-party VSCode extensions experiment with agent
orchestration—for instance, **Continue** is an extension that allows the AI to run
iterative loops on code changes (somewhat like an agent refining code continuously).
There are also community projects where people run multiple VSCode instances each with a
coding agent and coordinate them manually via a shared repo—these are ad-hoc though, and
the real structured solutions are emerging outside the IDE, in the CLI/cloud space.

### OpenAI Codex Integrations

**Codex CLI** is analogous to Claude Code—open source, built in Rust:
- Run as **MCP server mode** for other agents to connect
- **Agents SDK** for orchestrating multiple Codex instances with hand-offs
- Full traces capturing every prompt, tool call, hand-off

**Slack integration:**
- Mention `@Codex` in a Slack channel to kick off coding tasks
- Spins up cloud task in OpenAI’s managed sandbox
- Posts diffs/answers back to thread
- Multiple threads can run different tasks concurrently

**GitHub integration:**
- Opens PRs, comments on issues
- **Linear integration** for issue tracking

### Gemini CLI (January 27, 2026)

Google’s new open-source AI agent under Apache 2.0:
- **Free tier:** 60 requests/min, 1,000/day with personal Google account
- **1M token context window** with Gemini 3 models
- Built-in: Google Search, file operations, shell commands, web fetch
- **MCP-extensible** for custom integrations
- Uses ReAct (reason and act) loop for complex use cases

* * *

## Part 9: Industry Trends and Future Directions

### Market Trends (2026)

**Gartner reports:**
- **1,445% surge** in multi-agent system inquiries Q1 2024 → Q2 2025
- Predicts **40% of enterprise applications** will embed AI agents by end of 2026 (up
  from <5% in 2025)
- Market projection: **$7.8B → $52B by 2030**

**Architectural shift:** From monolithic agents to “puppeteer” orchestrators
coordinating specialist agents—the “microservices revolution” for AI agents.

### Emerging Best Practices

- **3-7 agents** work best for most workflows; above 7, use hierarchical structures with
  team leaders
- Implement **retry logic with exponential backoff** for temporary failures
- Use **circuit breakers** to prevent cascading failures across agents
- Hybrid approach: **MCP for tool connections + A2A for agent coordination**

### Future Directions

**Convergence of Memory and Messaging:**
- Gas Town already uses Beads for both data and messaging
- OpenAI’s MCP aims to handle context sharing and tool usage in one protocol
- Likely emergence of unified “Agent Orchestration Server” handling both persistent
  storage of work items and real-time message passing
- MCP (Model Context Protocol) is openly specified—one could implement their own server
  if desired, and we may see hosted versions (e.g., OpenAI could offer a managed
  coordination server as part of their platform)

**Deeper Dev Ecosystem Integration:**
- Orchestration frameworks hooking into GitHub, Jira, Slack out-of-the-box
- OpenAI Codex shows the way with Slack/GitHub/Linear integration
- Anthropic equivalent expected (Claude Slack bot, GitHub Action)
- Agents will take tasks from your issue tracker directly, update tickets, open pull
  requests, and so on—the multi-agent layer acts as a bridge between human project
  management and agent work execution
- One could imagine raising a GitHub Issue tagged in a certain way and an AI agent
  automatically picks it up to work on

**Improved UIs:**
- Gas Town expects better UIs to come
- Web dashboards showing all agent instances, tasks, progress
- Orchestration as simple as dragging tasks to an “AI” column on Kanban

**Role Specialization:**
- Beyond N identical agents: test-writer, refactorer, doc-researcher
- Different system prompts or even different models per role
- Gas Town already supports multiple model types (Claude and Codex), and Agent Mail’s
  mention of “heterogeneous fleets (Claude Code, Codex, Gemini CLI, etc.)” shows users
  are mixing models
- A flexible orchestration layer should assign tasks to the best-suited agent
- Marketplace of third-party agent “skills” (Yegge’s “Mol Mall” concept)

**Cloud vs Local Balance:**
- OpenAI’s managed Codex tasks vs self-hosted approaches
- GitHub as central store (TBD pushing to repo) + lightweight messaging service
- Frameworks like OpenAI Agents SDK making orchestration mostly configuration
- It might even be possible to use GitHub Issues or Discussions as a makeshift
  coordination backend (agents could post messages there)—though purpose-built solutions
  are likely more efficient and secure
- Some people have already had agents manage multiple branches concurrently for
  different features

* * *

## Part 10: March 2026 Ecosystem Update

### Major Rebrands and Milestones

**OpenClaw (formerly Moltbot/Clawdbot):** Reached 100k+ GitHub stars.
Renamed from Moltbot on Jan 30, 2026 after Anthropic trademark complaints.
Creator Peter Steinberger announced he’s joining OpenAI (Feb 14). **Major security
crisis:** “ClawJacked” vulnerability enables full agent takeover via any website.
Microsoft, CrowdStrike, 1Password, and Oasis Security all published warnings.
Microsoft explicitly recommends running OpenClaw only in fully isolated VMs.
ClawHub skill registry launched for automatic skill discovery.

**Ruflo (formerly Claude Flow):** Rebranded Feb 27, 2026 with v3.5 as “first major
stable release.” ~19.9k stars, 2.2k forks, 5,800+ commits, 215 MCP tools, 60+ agents.
WASM kernels in Rust for policy engine.
([ruvnet/ruflo](https://github.com/ruvnet/ruflo))

**Gas Town:** Now has a companion web GUI
([gastown-gui](https://github.com/web3dev1337/gastown-gui)). Real-world cost reports:
~$100/hour in Claude tokens.

### Paperclip: Company-Level Agent Orchestration (NEW)

The most architecturally novel entrant in this space.
**Paperclip** is not another multi-agent coding orchestrator — it’s a **company-level
control plane** for autonomous AI organizations.
Open-sourced March 5-6, 2026. 4.3k+ stars in days.
([paperclipai/paperclip](https://github.com/paperclipai/paperclip))

Tagline: *“If OpenClaw is an employee, Paperclip is the entire company.”*

Core innovation: Treats agents as employees in a persistent org chart with roles,
reporting lines, monthly token budgets, goal hierarchies (every task chains to company
mission), heartbeat scheduling, board governance with approval gates, and full audit
trail. Agent- agnostic — works with Claude Code, OpenClaw, Codex, or any runtime via
`process` and `http` adapters.

See
[Claude Code Orchestration Interfaces and UIs](research-claude-code-orchestration-and-uis.md)
for detailed architecture analysis.

### New Orchestration Tools

| Tool | Stars | What It Does |
| --- | --- | --- |
| [cmux (Manaflow)](https://github.com/manaflow-ai/cmux) | 4.2k | Native macOS terminal app for AI agents (YC-backed, libghostty) |
| [Symphony (OpenAI)](https://github.com/openai/symphony) | NEW | Issue-tracker daemon: polls Linear, per-issue workspaces, Codex app-server |
| [Composio Agent Orchestrator](https://github.com/ComposioHQ/agent-orchestrator) | 3.1k | Agent/runtime/tracker-agnostic fleet manager with CI awareness |
| [Claude Squad](https://github.com/smtg-ai/claude-squad) | 5.8k+ | tmux TUI for multi-agent sessions with git worktrees |
| [myclaude](https://github.com/stellarlinkco/myclaude) | 2.4k | Multi-runtime orchestration (Claude, Codex, Gemini, OpenCode) |
| [Agent of Empires](https://github.com/njbrake/agent-of-empires) | ~931 | Rust tmux TUI supporting 6+ agent CLIs, Docker sandboxing |
| [Overstory](https://github.com/jayminwest/overstory) | ~320–760 | SQLite mail system, FIFO merge queue, 4-tier conflict resolution |
| [Agent Farm](https://github.com/Dicklesworthstone/claude_code_agent_farm) | ~619 | 20-50 parallel agents with lock-based coordination, 34 tech stacks |
| [Multiclaude](https://github.com/dlorenc/multiclaude) | ~250–500 | “Brownian ratchet” auto-merge (CI as one-way gate) |
| [cmux (craigsc)](https://github.com/craigsc/cmux) | ~276 | Git worktree lifecycle manager for Claude Code |
| [dmux](https://github.com/standardagents/dmux) | — | Lightweight multiplexer supporting 11 agent CLIs |
| [amux](https://github.com/mixpeek/amux) | ~41 | Single-file Python multiplexer + web dashboard, self-healing |
| [coder/mux](https://github.com/coder/mux) | — | Enterprise desktop/web app with audit logging, model governance |
| [ittybitty](https://github.com/adamwulf/ittybitty) | — | Manager/Worker hierarchy with emergency kill and agent caps |
| [CodePilot](https://github.com/op7418/CodePilot) | — | Electron desktop GUI with mobile bridges |
| [Agentrooms](https://claudecode.run/) | — | @mention-based multi-agent coordination |
| [OpenSwarm](https://github.com/Intrect-io/OpenSwarm) | — | Linear → Worker/Reviewer pipelines, LanceDB vector memory, Discord |
| [agent-swarm](https://github.com/desplega-ai/agent-swarm) | — | Docker-isolated workers, compounding knowledge, Slack/GitHub integration |

### cmux (Manaflow) — Native macOS Agent Terminal (NEW)

The most significant new entrant in the **terminal UI** category.
cmux ([manaflow-ai/cmux](https://github.com/manaflow-ai/cmux),
[cmux.dev](https://www.cmux.dev/)) is a **native macOS terminal application**
purpose-built for running multiple AI coding agents simultaneously.
YC-backed (via Manaflow), ~4,200 stars, peaked at #2 on Hacker News.

Unlike tmux-based approaches (Claude Squad, amux), cmux is a standalone terminal
emulator using **libghostty** for GPU-accelerated rendering.
Key capabilities:

- **Vertical tab sidebar** with git branch, PR status, ports, notifications per
  workspace
- **Built-in scriptable browser** — agents can snapshot accessibility trees, interact
  with dev servers directly
- **Notification system** — blue rings on panes needing attention, macOS desktop
  notifications via OSC escape sequences or `cmux notify` CLI
- **Full scriptability** via CLI + socket API: create workspaces, split panes, send
  keystrokes, orchestrate sub-agents

Philosophy: “A primitive, not a solution” — composable building blocks rather than
opinionated workflows.
Currently macOS only.

See
[Claude Code Orchestration Interfaces and UIs](research-claude-code-orchestration-and-uis.md)
for detailed feature breakdown.

### OpenAI Symphony — Issue-Tracker-Driven Orchestration (NEW)

**[openai/symphony](https://github.com/openai/symphony)** is OpenAI’s open-source
specification for a long-running daemon that continuously polls an issue tracker
(Linear), creates per-issue workspaces, and runs Codex sessions.
It’s architecturally the most spec-driven orchestrator in this space.

**Core loop:** Poll Linear → find eligible issues → create workspace → run
`after_create` hook (e.g. git clone) → launch Codex via app-server protocol → stream
turns → re-check issue state → continue or stop → exponential backoff retries on
failure.

**Key architectural patterns relevant to Claude Code orchestration:**
1. **WORKFLOW.md as unified config:** YAML front matter (polling, concurrency, hooks,
   sandbox policy) + Markdown body (prompt template with `{{ issue.identifier }}` Liquid
   variables). The prompt IS the configuration — version-controlled in-repo.
2. **Per-issue workspace isolation:** Each issue gets its own directory under a
   workspace root. Workspaces persist across runs.
   Safety invariants enforce workspace-root containment.
3. **Multi-turn continuation:** After each successful turn, worker re-checks issue state
   on the tracker. If still active, starts another turn on the same thread (up to
   `max_turns`). Continuation turns get brief guidance, not the full prompt.
4. **Reconciliation:** Every poll tick reconciles running agents against tracker state —
   stops agents for terminal issues, detects stalls (no event within 5 min → kill +
   retry).
5. **No persistent database:** All state is in-memory + tracker-driven + filesystem.
   Restart recovery just re-polls the tracker.
6. **Dynamic reload:** Watches `WORKFLOW.md` for changes, re-applies config without
   restart.

**Elixir reference implementation:** GenServer orchestrator, Erlang Ports for subprocess
management, Phoenix LiveView dashboard, `linear_graphql` dynamic tool injection.
Fully hot-reloadable.

**Codex app-server protocol:** JSON-RPC 2.0 over stdio — `initialize` → `initialized` →
`thread/start` → `turn/start`, then stream
`turn/completed`/`turn/failed`/`turn/cancelled` plus approval requests and tool calls.
Agent-agnostic: the `codex.command` config accepts any shell command that speaks this
protocol, making it theoretically possible to plug in Claude Code with an adapter.

See
[Claude Code Orchestration Interfaces and UIs](research-claude-code-orchestration-and-uis.md)
for the full architecture analysis.
Source code cloned to `attic/symphony/`.

### Claude Code Platform Changes (March 2026)

- **Opus 4.6** now default; Opus 4/4.1 deprecated from model selector
- **Agent Teams** shipped with bug fixes (hanging `--print`, nested teammate spawning)
- **`/loop` command:** Recurring interval prompts — a built-in heartbeat mechanism
- **Claude Agent SDK** (rebranded from “Claude Code SDK”) v0.1.48 with new
  `agent_id`/`agent_type` hook fields
- **Compaction API** (beta): Server-side context summarization
- **Tool Search** (public beta): Dynamic tool discovery from large catalogs

### Industry Scale

- Claude Code now authors **4% of public GitHub commits** (projected 20% by end of 2026)
- Skills ecosystem: ~50 (mid-2025) → **334+** (March 2026)
- Anthropic’s C compiler project: 16 agents, ~2,000 sessions, $20k API costs, 100k-line
  Rust C compiler building Linux 6.9 on x86/ARM/RISC-V

* * *

## Practical Recommendations

For teams seeking to coordinate Claude Code instances today, a combination of approaches
can work:

1. **Task Tracking:** Use **TBD** (or Beads if local-only) to persist tasks on GitHub
   with minimal friction

2. **Real-time Coordination:** Use **Agent Mail (MCP)** for task handoff between agents,
   possibly with each agent in a Sprite VM for safety

3. **GitHub-Triggered Workflows:** Use **Claude Code Action** for @mention-triggered
   automation; chain workflows for multi-bot coordination

4. **Cross-Machine:** Currently requires external orchestrator—consider **A2A protocol**
   or **claude-code-by-agents** for remote agent coordination

5. **Execution Environment:** **Sprites** for isolated, persistent VMs; local Docker for
   lighter-weight isolation

6. **Slack Integration:** Consider leveraging Slack integration (OpenAI’s Codex Slack
   bot is a model—you could create a Claude Slack bot analog using the Claude API and
   your coordination layer)

7. **GitHub as Coordination:** If real-time isn’t critical, using GitHub issues or PRs
   as the place where Claude agents look for work can be effective—one agent could post
   a fix as a PR, another (or a human) could review/merge, all tracked in GitHub

The “best” mechanism depends on how much real-time concurrency vs.
simplicity you need.
The bias is towards flexible, CLI-first infrastructure that can run anywhere—local,
cloud, Codespaces, Sprites—since they’re just Git and simple services.

All these tools are quickly evolving.
Pioneers like Yegge’s Gas Town + Beads and Emanuel’s Agent Mail illustrate the
possibilities (and pitfalls) of DIY solutions—they’ve massively increased coding
throughput for early adopters.
Now, with efforts like TBD (making the core tracking more reliable across platforms) and
big players like Anthropic and OpenAI formalizing orchestration capabilities (Cowork,
MCP, etc.), we’re likely to see these capabilities become more accessible.

8. **Company-Level Orchestration:** For teams running multiple agents toward business
   goals (not just coding tasks), **Paperclip** provides the highest-level abstraction:
   org charts, budgets, goal hierarchies, and governance — wrapping Claude Code,
   OpenClaw, or Codex as “employees”

9. **Native Terminal for Agent Sessions (macOS):** **cmux** (Manaflow) provides the best
   purpose-built terminal experience for managing multiple concurrent AI agents —
   vertical tabs, notification system, scriptable browser, full CLI/socket API. Think of
   it as the “IDE for agent supervision” on macOS.

10. **Issue-Tracker-Driven Daemon:** **Symphony** (OpenAI) demonstrates the most mature
    pattern for automated dispatch: poll an issue tracker, create per-issue workspaces,
    run agent sessions, reconcile state, retry with backoff.
    The WORKFLOW.md pattern (prompt + config in one versioned file) is particularly
    elegant and could be adapted for Claude Code + Linear/GitHub.

The future likely holds even more **turnkey orchestration services** (perhaps even a
dedicated “Claude Orchestrator” product from Anthropic eventually, or third-party
platforms built around this idea).
Paperclip represents the first serious open-source attempt at this — and its 4.3k stars
in days suggests strong demand.
Symphony shows OpenAI’s approach to the same problem (daemon-first, spec-driven).
cmux shows that the terminal itself is becoming a first-class orchestration surface.
Mixing and matching open-source solutions remains the state of the art, but the tooling
is maturing rapidly.

* * *

## References

### Beads and Gas Town (Steve Yegge)

- [Welcome to Gas Town](https://steve-yegge.medium.com/welcome-to-gas-town-4f25ee16dd04)
  — January 2026 launch post
- [Gas Town Emergency User Manual](https://steve-yegge.medium.com/gas-town-emergency-user-manual-cf0e4556d74b)
  — Updated guide
- [The Future of Coding Agents](https://steve-yegge.medium.com/the-future-of-coding-agents-e9451a84207c)
  — Vision post
- [Beads Best Practices](https://steve-yegge.medium.com/beads-best-practices-2db636b9760c)
  — Agent Village concept
- [GitHub: steveyegge/gastown](https://github.com/steveyegge/gastown) — Gas Town
  repository
- [GAS Token Crypto Scam - Pivot to AI](https://pivot-to-ai.com/2026/01/22/steve-yegges-gas-town-vibe-coding-goes-crypto-scam/)
  — Coverage of the unrelated GAS token pump-and-dump

### Agent Mail (Jeffrey Emanuel)

- [GitHub: Dicklesworthstone/mcp_agent_mail](https://github.com/Dicklesworthstone/mcp_agent_mail)
  — Main repository
- [Jeffrey Emanuel on automated hooks](https://x.com/doodlestein/status/2005311608961040826)
  — December 2025 update
- [Jeffrey Emanuel on companion app](https://x.com/doodlestein/status/1985405083488755740)
  — Commercial development

### OpenClaw (formerly Moltbot/Clawdbot)

- [Moltbot Guide - DEV Community](https://dev.to/czmilo/moltbot-the-ultimate-personal-ai-assistant-guide-for-2026-d4e)
- [What is Moltbot? -
  DigitalOcean](https://www.digitalocean.com/resources/articles/what-is-moltbot)
- [Moltbot Documentation](https://docs.molt.bot/)
- [GitHub: openclaw/openclaw](https://github.com/openclaw/openclaw) — OpenClaw (renamed
  from Moltbot Jan 30, 2026)
- [ClawJacked Vulnerability - Oasis Security](https://www.oasis.security/blog/openclaw-vulnerability)
  — Full agent takeover CVE
- [Running OpenClaw Safely - Microsoft](https://www.microsoft.com/en-us/security/blog/2026/02/19/running-openclaw-safely-identity-isolation-runtime-risk/)
  — VM isolation recommendation
- [OpenClaw Attack Surface - 1Password](https://1password.com/blog/from-magic-to-malware-how-openclaws-agent-skills-become-an-attack-surface)
  — Skill injection risks

### Claude Code Multi-Agent Features

- [Claude Code’s Hidden Multi-Agent Orchestration - The Unwind AI](https://www.theunwindai.com/p/claude-code-s-hidden-multi-agent-orchestration-now-open-source)
- [Unlocking Claude Code’s Hidden Swarm Mode - DEV Community](https://dev.to/tinaba96/unlocking-claude-codes-hidden-swarm-mode-how-to-spawn-an-ai-engineering-team-with-one-command-4ng4)
- [Claude Code’s Hidden Multi-Agent System - paddo.dev](https://paddo.dev/blog/claude-code-hidden-swarm/)
- [GitHub: numman-ali/cc-mirror](https://github.com/numman-ali/cc-mirror) — CC Mirror
- [Numman Ali on CC Mirror - X](https://x.com/nummanali/status/2007768692659015877) — CC
  Mirror announcement
- [GitHub: mikekelly/claude-sneakpeek](https://github.com/mikekelly/claude-sneakpeek) —
  Feature flag bypass
- [GitHub: ruvnet/ruflo](https://github.com/ruvnet/ruflo) — Ruflo (formerly
  Claude-Flow), rebranded Feb 27, 2026

### Anthropic Official

- [How we built our multi-agent research system](https://www.anthropic.com/engineering/multi-agent-research-system)
- [Claude Cowork Announcement](https://markets.financialcontent.com/wss/article/tokenring-2026-1-19-anthropic-unveils-claude-cowork-the-first-truly-autonomous-digital-colleague)
- [First impressions of Claude Cowork - Simon Willison](https://simonw.substack.com/p/first-impressions-of-claude-cowork)
  — Detailed analysis of Cowork as a general agent
- [Claude Code GitHub Actions](https://code.claude.com/docs/en/github-actions)
- [Claude Code Hooks Reference](https://code.claude.com/docs/en/hooks)
- [GitHub: anthropics/claude-code-action](https://github.com/anthropics/claude-code-action)
- [Building a C Compiler with Claude](https://www.anthropic.com/engineering/building-c-compiler)
  — 16 agents, ~2,000 sessions, $20k, 100k-line output

### Orchestration Tools

- [GitHub: manaflow-ai/cmux](https://github.com/manaflow-ai/cmux) — cmux native macOS
  terminal for AI agents (YC-backed, libghostty)
- [cmux.dev](https://www.cmux.dev/) — cmux website
- [GitHub: openai/symphony](https://github.com/openai/symphony) — Symphony issue-tracker
  daemon orchestrator (Elixir/OTP reference, language-agnostic spec)
- [GitHub: craigsc/cmux](https://github.com/craigsc/cmux) — cmux worktree lifecycle
  manager (separate project from Manaflow cmux)
- [GitHub: mixpeek/amux](https://github.com/mixpeek/amux) — amux tmux-based multiplexer
  \+ web dashboard
- [GitHub: coder/mux](https://github.com/coder/mux) — mux desktop app with custom agent
  loop
- [GitHub: paperclipai/paperclip](https://github.com/paperclipai/paperclip) —
  Company-level control plane for autonomous AI organizations (March 2026)
- [GitHub: smtg-ai/claude-squad](https://github.com/smtg-ai/claude-squad) — Claude Squad
  tmux TUI
- [GitHub: stellarlinkco/myclaude](https://github.com/stellarlinkco/myclaude) — myclaude
  multi-runtime orchestration
- [GitHub: dlorenc/multiclaude](https://github.com/dlorenc/multiclaude) — Multiclaude
  “brownian ratchet” auto-merge
- [GitHub: ComposioHQ/agent-orchestrator](https://github.com/ComposioHQ/agent-orchestrator)
  — Agent/runtime/tracker-agnostic fleet manager (~3.1k stars)
- [GitHub: njbrake/agent-of-empires](https://github.com/njbrake/agent-of-empires) — Rust
  tmux TUI for 6+ agent CLIs (~931 stars)
- [GitHub: jayminwest/overstory](https://github.com/jayminwest/overstory) — SQLite mail,
  FIFO merge queue, 4-tier conflict resolution
- [GitHub: Dicklesworthstone/claude_code_agent_farm](https://github.com/Dicklesworthstone/claude_code_agent_farm)
  — 20-50 parallel agents, lock-based coordination
- [GitHub: standardagents/dmux](https://github.com/standardagents/dmux) — Lightweight
  multiplexer, 11 agent CLIs ([dmux.ai](https://dmux.ai/))
- [GitHub: adamwulf/ittybitty](https://github.com/adamwulf/ittybitty) — Manager/Worker
  hierarchy orchestrator
- [GitHub: Intrect-io/OpenSwarm](https://github.com/Intrect-io/OpenSwarm) — Linear →
  Worker/Reviewer pipelines, LanceDB vector memory
- [GitHub: desplega-ai/agent-swarm](https://github.com/desplega-ai/agent-swarm) — Docker
  workers with compounding knowledge
- [GitHub: andyrewlee/awesome-agent-orchestrators](https://github.com/andyrewlee/awesome-agent-orchestrators)
  — Curated orchestration tools list
- [GitHub: hesreallyhim/awesome-claude-code](https://github.com/hesreallyhim/awesome-claude-code)
  — Largest curated Claude Code list (21.6k stars)
- [Conductor](https://www.conductor.build/) — Melty Labs macOS app
- [GitHub: ryanmac/code-conductor](https://github.com/ryanmac/code-conductor) —
  GitHub-native
- [Oh My Claude - Medium Review](https://medium.com/@joe.njenga/i-tested-oh-my-claude-code-the-only-agents-swarm-orchestration-you-need-7338ad92c00f)
- [GitHub: baryhuang/claude-code-by-agents](https://github.com/baryhuang/claude-code-by-agents)
  — Agentrooms cross-machine coordination
- [GitHub: web3dev1337/gastown-gui](https://github.com/web3dev1337/gastown-gui) — Gas
  Town web GUI companion

### Protocols and Standards

- [A2A Protocol Documentation](https://a2a-protocol.org/latest/)
- [Google A2A Announcement](https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/)
- [Microsoft: A2A Communication on MCP](https://developer.microsoft.com/blog/can-you-build-agent2agent-communication-on-mcp-yes)
- [Integrating Multiple MCP Servers - CodeSignal](https://codesignal.com/learn/courses/advanced-mcp-server-and-agent-integration-in-python/lessons/integrating-and-coordinating-multiple-mcp-servers-with-a-python-agent)
  — Guide to combining local and remote MCP servers

### Execution Environments

- [Sprites.dev](https://sprites.dev/) — Fly.io stateful sandboxes
- [Simon Willison on Sprites](https://simonwillison.net/2026/Jan/9/sprites-dev/)
- [Fly.io Sprites Announcement](https://devclass.com/2026/01/13/fly-io-introduces-sprites-lightweight-persistent-vms-to-isolate-agentic-ai/)

### OpenAI Codex

- [Codex CLI](https://developers.openai.com/codex/cli/)
- [Use Codex with the Agents SDK](https://developers.openai.com/codex/guides/agents-sdk/)
- [Use Codex in Slack](https://developers.openai.com/codex/integrations/slack/)
- [How OpenAI’s Codex for Slack enhances team collaboration - LinkedIn](https://www.linkedin.com/posts/denisedresser_codex-is-now-generally-available-activity-7381464835588460544-p6k7)
  — Discussion of Codex Slack integration

### Google Gemini

- [GitHub: google-gemini/gemini-cli](https://github.com/google-gemini/gemini-cli)
- [Gemini CLI Documentation](https://developers.google.com/gemini-code-assist/docs/gemini-cli)

### TBD (To Be Done)

- TBD Design Specification — Internal design document for the git-native issue tracker

### Industry Analysis

- [7 Agentic AI Trends to Watch in 2026 - MachineLearningMastery](https://machinelearningmastery.com/7-agentic-ai-trends-to-watch-in-2026/)
- [8 Best Multi-Agent AI Frameworks for 2026](https://www.multimodal.dev/post/best-multi-agent-ai-frameworks)
- [Claude Hub - Claude Did This](https://claude-did-this.com/)
- [PR-Agent by Qodo](https://github.com/qodo-ai/pr-agent)

### GitHub Integrations

- [Integrating Claude Code with GitHub Actions - Steve Kinney](https://stevekinney.com/courses/ai-development/integrating-with-github-actions)
- [Multiple branches and agents - Reddit](https://www.reddit.com/r/codex/comments/1o09pgj/multiple_branches_and_agents_working_at_the_same/)
