AI Agent Orchestration: Comparative Research
Last researched: November 15, 2026. Status: research and evaluation. This compares documented architecture and operator reports, plus dated field notes from one operator’s own machine. It does not report an IrregularChat installation or a controlled head-to-head benchmark of these platforms.
For a mixed Codex, Claude Code, and OpenCode workflow, start with a bounded CAO pilot. Evaluate Gas City when durable engineering workflows and integration become the main problem; consider Paperclip when recurring responsibilities, budgets, and organizational oversight matter. Claude Code Agent Teams offers a smaller native starting point for Claude-only collaboration. These are selection hypotheses to test, not measured quality rankings.
Where this fits in the wiki
Section titled “Where this fits in the wiki”This page compares the systems that coordinate agents. The CLI agent comparison compares the workers themselves, while Agentic AI Patterns explains the underlying design patterns. Read the Agent Reliability Study before interpreting exit codes, retries, or historical success rates as evidence of correctness. Persistent personal assistants and the memory services behind them are a separate layer; see Persistent assistants.
Separate the layers
Section titled “Separate the layers”| Layer | Responsibility | Examples |
|---|---|---|
| Model | Generate reasoning and tool requests | Claude, GPT, DeepSeek |
| Harness | Run the model/tool loop and enforce its permissions | Claude Code, Codex, OpenCode, DeepSeek Harness |
| Orchestrator | Choose work, dependencies, owners, and escalation | Paperclip, Gas Town, Gas City, CAO, Agent Teams |
| Execution substrate | Dispatch and observe delegated sessions | Orca, a configured runner or session backend |
| Validation and integration | Accept artifacts and integrate a reviewed revision | Acceptance tests, independent review, merge queue, human approval |
| Persistent assistant | Keep a standing relationship with one person: memory, schedules, proactive messages, delegation | Hermes Agent, Claude Duet, ChatGPT dots |
| Memory service | Store what persists across sessions and tools, and answer questions about it | Built-in memory files, Honcho, Mem0 |
These responsibilities can share one product. A controller restarting a worker is different from restoring its conversation, and both are different from safely retrying an external write.
Reference design, not a required stack: products combine several boxes, and an extra substrate is optional. Failed validation returns work for revision. Durable records support recovery throughout the workflow. Open the full-size diagram.
Functional comparison
Section titled “Functional comparison”The entries describe native emphasis and documented mechanisms. “Configurable” means the operator must implement or verify the behavior.
| System | Coordination and durable work | Integration approach | Main cost of adoption |
|---|---|---|---|
| Paperclip | Organizational roles, issues, heartbeats, database-backed runs | Reviews, approvals, and workspace/adapter configuration | Operating a broader control plane |
| Gas Town | Mayor, Beads, hooks, worker lifecycle roles | Worktrees and Refinery merge queue | Many roles, processes, and conventions |
| Gas City | Configured agents, packs, formulas, reconciliation | Workflow-defined gates and processing | Designing and maintaining configuration |
| CAO | Supervisor, CLI sessions, messaging, journaled workflows | Repository and workflow policy | Testing CLI adapters and delivery behavior |
| Claude Code Agent Teams | Lead, teammates, shared local tasks | Operator-defined ownership and hooks | Experimental lifecycle and coordination limits |
Sources: Paperclip architecture, Gas Town architecture, Gas City migration map, CAO overview, and Agent Teams.
| Operational question | Paperclip | Gas Town / Gas City | CAO | Agent Teams |
|---|---|---|---|---|
| Several coding harnesses? | Adapters | Runtime configuration | Provider adapters | Claude Code sessions |
| Work survives a process? | Stored tasks and run state | External work ledger and workflow state | Workflow journal and session records | Task files; teammate restoration has limits |
| Dedicated merge path? | Configure | Refinery / configured workflow | Configure | Configure |
| Spending controls? | Reported-spend policies and pauses | Configure provider/infrastructure limits | Configure provider/workflow limits | Provider allowance; no comparable organization budget described |
| Correctness automatic? | No | No | No | No |
Avoid comparing “persistent: yes” without testing exactly what survives: assignment, Git changes, conversation, pending questions, credentials, or an external action receipt.
Paperclip: persistent organizational management
Section titled “Paperclip: persistent organizational management”Paperclip combines a Node.js server, React interface, and stored organizational state. Managers assign issues to agents connected through runtime adapters. Its scope extends beyond engineering into recurring operational responsibilities. Architecture and adapters.
Its strongest fit is an organization needing reporting relationships, goals, ownership, scheduled work, review decisions, and an audit trail. It adds administration and an adapter boundary where instructions, identity, workspace state, and usage must be carried correctly.
Budgets need a precise interpretation. Paperclip documents warnings and hard-stop policies, but enforcement uses recorded consumption. Delayed reporting and work already in flight can overshoot the configured limit. Test both the pause and the actual provider invoice; a dashboard total is not proof of a strict financial ceiling. Costs and budgets.
The November 6 release makes the native Runner the default for new agents on qualified hosts, while existing agents retain their runner. It also removes the Pipelines experiment; Cases and Routines remain. Pin the application and adapter versions together for a pilot, then rerun instruction-delivery, recovery, and permission tests after an upgrade. Release frequency alone does not establish reliability.
Paperclip is a service you run, not only a CLI: a web server plus an embedded PostgreSQL database. The server binds to 127.0.0.1:3100 by default and requires Node.js 24.11 or newer (installation guide). Keep it on loopback unless you deliberately add authentication and a reverse proxy.
Assessment: choose Paperclip when managing responsibilities and oversight is itself the requirement. A small engineering task does not automatically justify an organization platform.
Gas Town: a structured engineering factory
Section titled “Gas Town: a structured engineering factory”Gas Town makes durable work and controlled integration central to its design. Its vocabulary maps to concrete engineering responsibilities:
| Component | Responsibility |
|---|---|
| Mayor | Coordinate work across projects |
| Rig | Managed project workspace |
| Polecat / Crew | Task worker / persistent human-facing workspace |
| Witness | Observe per-project worker lifecycle |
| Deacon | Patrol and supervise background operations |
| Refinery | Process the project merge queue and verification gates |
| Beads / hooks | Track work and retain assignments outside a conversation |
| Convoy | Group related work |
The README describes runtime support including Claude Code, Codex, Gemini, and Copilot. The architecture distinguishes town-wide coordination from project-level implementation records. Worktrees separate branches and files; they do not isolate credentials or host processes.
Gas Town’s advantage is an established operating model for dispatch, recovery, and merging. The tradeoff is learning and operating that model. A preserved assignment can help a replacement worker continue, but cannot prove that the earlier changes are correct or that replaying an action is safe.
Assessment: useful for evaluating a prescribed factory workflow. The existence of Gas City is a reason to compare migration and maintenance costs, not evidence that Gas Town is abandoned.
Gas City: configurable factory infrastructure
Section titled “Gas City: configurable factory infrastructure”Gas City generalizes role behavior into configurable agents and workflows. Its migration guide maps Gas Town roles to agent definitions, formulas, events, waits, and orchestrator reconciliation. A Refinery-like role becomes a configured processing step rather than a mandatory standing identity.
The current quickstart also supplies a default factory setup and formulas; “configurable” does not mean every installation starts from nothing. Configuration separates reusable packs from a city’s deployment. Inspect both when reviewing what actually runs.
State backend matters. The default Beads setup uses Dolt; the README also documents a file backend. Name the configured backend in any durability claim. The default and fallback session backend is tmux; alternative backends should be qualified against their current documentation rather than assumed equivalent.
Assessment: evaluate it for custom, durable development workflows. Migration is an architectural translation, not a guaranteed in-place upgrade. Verify task import, ownership, worktree mappings, and pending merge state before moving real work.
AWS CLI Agent Orchestrator: heterogeneous CLI coordination
Section titled “AWS CLI Agent Orchestrator: heterogeneous CLI coordination”CAO runs a local server and native coding CLIs in tmux sessions. Supervisor profiles delegate through coordination tools; workers retain their native CLI capabilities and authentication. Its overview lists Claude Code, Codex, OpenCode, Kiro, Cursor, and additional providers. Being under AWS Labs does not mean every worker must use an AWS model.
CAO is a focused candidate for a developer already using several CLIs. A provider’s presence in the catalog is a starting point for testing, not proof of equal maturity.
Two limitations change evaluation plans:
- The OpenCode adapter guide labels multi-agent messaging experimental and describes an inbox-polling fallback. Test supervisor-to-worker and worker-to-supervisor messages after idle periods, not just initial launch.
- Workflows distinguish the recommended Python script tier from YAML. The documented YAML
parallel,pipeline, andloopmodes are reserved and not executable in the inspected revision. Validation that accepts a reserved mode does not establish that it runs.
Workflow resume replays journaled steps. Follow the determinism and retry constraints in the authoring guide. Do not treat persistence as an exactly-once guarantee for external actions.
Assessment: begin with one supervisor, two workers, and a disposable repository. Require a working delegation, result delivery, interruption, and independent acceptance cycle before connecting production credentials or enabling unattended work.
Claude Code Agent Teams: native session collaboration
Section titled “Claude Code Agent Teams: native session collaboration”Agent Teams uses a lead and independent Claude Code teammates sharing tasks and messages. It remains experimental and disabled by default. Documented limitations include un-restored in-process teammates on resume, lagging task status, one team per session, and no nested teams. Official team documentation.
Ordinary subagents offer another option with their own contexts and tool restrictions; teams add peer coordination. Choose based on whether workers need to communicate, not simply how many tasks exist.
Assessment: a small Claude-only research or review task is a reasonable pilot. Assign file ownership before parallel editing. Test shutdown and orphan cleanup, and keep a single-agent baseline so coordination overhead remains visible.
Orca: execution contract, not task planning
Section titled “Orca: execution contract, not task planning”Orca’s README describes it as “a substrate for orchestrators”: it “does not plan, decompose, route, or judge delegated work.” It belongs in the execution layer of the table above, not beside Paperclip or Gas Town. The supplied Orca diagram correctly separates the caller’s decisions from worker execution. Orca documents Codex, Claude, and Cursor adapters and a versioned orca/v1 envelope. The caller owns decomposition, routing, and acceptance. Pinned README.
Redrawn from the supplied diagram with an explicit acceptance boundary. Open the full-size diagram.
The lane contract separates delivery acknowledgment, native execution status, and semantic outcome. Treat semanticOutcome: unknown literally. Durable lane records and events allow inspection; they are not acceptance evidence by themselves. Failed, killed, or lost lanes require a new dispatch rather than an assumption that every terminal state is resumable.
Orca is small and quiet: two contributors, release v0.2.25 on July 13, and no commits since July 14 as of November 12. Qualify the exact version you run rather than assuming ongoing fixes.
CAO and Orca overlap in launching and observing workers. Adding both introduces another identity, error, and recovery boundary. Use Orca when its contract solves a concrete custom-supervisor requirement; it is not a prerequisite for CAO, Paperclip, or Gas City.
Related harnesses and native alternatives
Section titled “Related harnesses and native alternatives”| Harness | Relevance to this comparison |
|---|---|
| Claude Code | Native subagents and teams; also an external worker |
| Codex | Native delegation is a baseline worth testing before adding a control plane |
| OpenCode | Model-flexible harness; qualify the exact version and adapter |
| Mistral Vibe | Existing wiki workflow for self-hosted worker delegation |
| DeepSeek Harness | Plugin-oriented harness in developer preview; not a direct organization-platform equivalent |
Codex already documents subagents and an App Server for programmatic integration. An external orchestrator should justify what it adds over the harness’s own execution and delegation tools. DeepSeek’s README warns of compatibility-breaking preview changes; this review did not qualify it as a worker in the compared platforms.
Persistent assistants: memory and learning
Section titled “Persistent assistants: memory and learning”Hermes Agent, Claude Duet, and ChatGPT dots answer a different question from the orchestrators above. An orchestrator owns a body of work: assignments, dependencies, and integration. A persistent assistant owns a relationship with one person. It remembers that person between conversations, runs on a schedule, messages first, and acts across their accounts. It can hand coding work to a harness or an orchestrator (the Paperclip field report below connects Hermes to Paperclip), but it is not one.
“Learning” in these products means writing state that the next session reads: memory notes, a profile of the user, or a new skill. No model weights change. Evaluate it like any other write: what gets written, who approves it, and whether you can view, correct, and revert it.
| Hermes Agent | Claude Duet | ChatGPT dot | Codex memories | |
|---|---|---|---|---|
| What it is | Self-hosted agent runtime from Nous Research (MIT) | Anthropic app; research preview since October 21, 2026 | OpenAI’s persistent assistant, documented in the Codex docs | Opt-in memory for local Codex clients |
| Where it runs | Your host or container, with any configured model | Anthropic’s cloud, in a VM with its own browser, so your devices can be off | OpenAI’s service; tasks can run on a computer connected to the dot | Your machine |
| What persists | MEMORY.md and USER.md, every session in SQLite with full-text search, and skills | Conversation history and memory; carries over memory, skills, and connected apps from your Claude account | Its own notes, separate from ChatGPT saved memory, plus starting context from ChatGPT memory | Generated files under ~/.codex |
| How it learns | Records workflows as skills and revises them during use; optional external memory providers such as Honcho | Not documented beyond memory and history | Keeps notes between conversations | Carries context from earlier chats into later ones, including chats that used MCP tools or web search; OpenAI says rules that must always apply belong in AGENTS.md |
| Your control | Plain files you can read, edit, diff, and back up; memory.write_approval and skills.write_approval (both off by default) | Reset memory or delete history in settings; no documented way to view or edit individual memories | Delete the dot (irreversible; read what the confirmation says it removes); changing ChatGPT memory does not remove notes it already made | Off by default; Delete Codex memories per machine; /memories per chat |
| Actions | The tools and gateways you configure | Asks approval before it sends, pays, signs, or deletes; trading and moving money stay off-limits | Background and scheduled tasks | Codex’s own coding permissions |
| Access | Free software; you pay for the model and the host | Waitlist for US Pro, Max, and Ultra subscribers | ChatGPT; texting a dot is a US Pro beta | Codex clients |
Sources: Hermes memory and skills docs; Introducing Claude Duet and its safety, privacy, and security post; dot tasks and memory and controls; Codex memories. Hosted products change quickly; their docs did not describe self-hosting or choosing another model.
Memory services: Honcho and others
Section titled “Memory services: Honcho and others”Honcho (Plastic Labs, AGPL-3.0, v3.6.0 on November 10) is memory infrastructure, not an assistant. It models “peers” (people, agents, or anything else that changes over time) across sessions and answers questions about them. Run it managed at api.honcho.dev or self-host it. It plugs into several tools on this page:
- Hermes Agent: built in upstream (
hermes memory setup). External providers run alongside the built-in memory files and never replace them. - Claude Code: the claude-honcho plugin (MIT).
- Codex:
@honcho-ai/codex-honcho, which needs Codex 0.136.0 or later.
Mem0, Hindsight, and Supermemory offer similar hooks or MCP servers. One Honcho workspace shared by Hermes, Claude Code, and Codex gives each tool the same picture of you. It also makes that store a single target holding everything each tool saw. Self-host it, or read the managed service’s retention terms, before connecting an assistant that reads email or calendars.
Operating rules for memory
Section titled “Operating rules for memory”- Keep must-be-correct facts in files, not derived memory. The Hermes guide’s itinerary failure shows a wiped memory followed by a confidently wrong recall from a stale copy.
- Memory is a persistent prompt-injection path. An email or web page summarised into memory or a skill steers every later session. Turn on write approval where it exists, review memory and skill diffs, and back them up (
~/.hermes). - Separate identities. An assistant holding email and calendar credentials should not also hold push rights to code. Delegate coding through a harness or orchestrator with its own scoped credentials and the boundaries below.
- Test what “forget” means. For each product, record what a reset, a history deletion, and an account deletion actually remove, including copies in connected tools and shared memory services.
- Learning can turn a failure into a workaround. An agent that saves “lessons” on its own can record how it got past a control, and every later session inherits that. Read memory and skills like code, and keep service secrets out of the agent’s reach.
Several sessions, no orchestrator
Section titled “Several sessions, no orchestrator”Most of the work behind these field notes ran on none of the platforms above. One person ran several Claude Code sessions at once against the same repository and the same production host. Each had its own task and worktree, and nothing coordinated them. It is the cheapest arrangement to start, and the comparison above says least about it. Its failures come from shared state that no session owns.
Evidence: what operator reports can establish
Section titled “Evidence: what operator reports can establish”| Source | Observation | Evidence boundary |
|---|---|---|
| Felipe Fontoura, Paperclip field report | Reports 13 agents, roughly six weeks, and two custom adapters before an autonomous loop closed | One operator’s Paperclip/Hermes integration; not a benchmark of every adapter |
| DoltHub, Two Weeks in Gas Town | Reports about $6,000 in Claude API calls and difficulty establishing confidence in generated code | Firsthand engineering report from a vendor whose database participates in the ecosystem; not vendor-neutral comparative testing |
| Everpod, team run | Documents four teammates reviewing documents, coordination work, and substantial token usage | Hosting vendor’s single task experiment; not evidence of coding quality |
| Positive Reddit account / critical account | Reports range from fast refactoring to missed specifications and ineffective review | Uncontrolled, self-reported anecdotes |
No standardized head-to-head benchmark across these exact systems was identified in the sources inspected. That is a limit of this review, not proof that none exists. Platform documentation describes intended behavior; operator reports suggest failure cases to reproduce. Neither establishes a universal productivity winner. Secondary feature summaries are not used as substitutes for primary technical sources.
Development snapshot and version discipline
Section titled “Development snapshot and version discipline”The following default-branch revisions were retrieved from the GitHub API on November 10. They identify the source inspected, not tested installations. Links remain pinned so later README edits do not silently change the basis of this comparison.
| Project | Inspected commit | Commit date (UTC) | License |
|---|---|---|---|
| Paperclip | 30d99f4e324b | 2026-11-10 | MIT |
| Gas Town | 466aa41c83ee | 2026-10-28 | MIT |
| Gas City | f1f75f53cddf | 2026-11-10 | MIT |
| CAO | 92b292f2dd61 | 2026-11-10 | Apache-2.0 |
| Orca | 2b0add4e58d2 | 2026-07-14 | MIT |
Names, packages, and released versions
Section titled “Names, packages, and released versions”Several of these names collide with unrelated software. Install from the package named here and check the version actually installed.
| Project | Install as | Not to be confused with | Release status (November 10) |
|---|---|---|---|
| Paperclip | npm paperclipai, CLI paperclipai; Node.js 24.11+ | npm paperclip is an unrelated package | v2026.1106.0 (November 6); npm versions match the release tags |
| Gas Town | Homebrew gastown (still 1.1.0) or GitHub release binaries; CLI gt, with Beads bd and Dolt | Homebrew’s genometools and libslax also install a gt command; npm @gastown/gt is stale (0.12.0, March) and not the recommended path | v1.2.1 (June 6); main is 313 commits ahead. Gas Town 1.2.x refuses a bd newer than 1.0.4 (v1.2.0 notes) |
| Gas City | See its docs | Not a newer Gas Town version; a separate design with a migration path | v1.5.1 (October 24) |
| CAO | See its docs | — | v2.5.3 (October 8) |
| Hermes Agent | NousResearch/hermes-agent; CLI hermes, state in ~/.hermes; desktop app via Homebrew cask hermes-desktop | Nous Research’s Hermes language models are a model family, not this agent | v0.23.1 (November 9); on November 12 Homebrew still shipped hermes-agent 0.22.4 and hermes-desktop 0.21.2, which update on separate clocks |
| Honcho | Managed api.honcho.dev, or self-host from plastic-labs/honcho | — | v3.6.0 (November 10) |
| Orca | npm orcastrator, CLI orca | npm orca is Plotly’s image exporter; Linux desktops ship the GNOME orca screen reader under the same command; OrcaSlicer is a 3D-printing slicer | v0.2.25 (July 13) |
Default branches and packaged releases can differ substantially. For example, CAO’s inspected main revision is newer than its October 8 v2.5.3 release. Recheck whether each documented feature exists in the version installed for a pilot. Paperclip’s November 6 release is v2026.1106.0; other release channels must be inspected rather than inferred from a “latest” label. Stars and issue counts are omitted because they do not measure correctness or maintenance quality.
A practical evaluation plan
Section titled “A practical evaluation plan”Start with the existing reliability audit and evaluation frameworks. Do not reuse historical harness scores as current orchestrator rankings.
Make the assignment reviewable
Section titled “Make the assignment reviewable”Use a disposable repository at a fixed commit. Ask for an authenticated API endpoint, a small frontend, and a reviewed change. Keep hidden acceptance tests outside workers’ write access; include a negative authorization case. Before execution, record:
# Proposed evaluation record; not a product configuration file.task_id: endpoint-pilot-01base_commit: <full Git SHA>allowed_paths: [api/, ui/, tests/]worker_limit: 2deadline_minutes: 30spend_limit_usd: 10acceptance: external-tests-and-reviewexternal_writes: prohibitedThe spend limit above is a proposed experimental constraint. Enforce and measure it using the actual provider and controller mechanisms; writing a number in a record does not enforce anything.
Each handoff should include task ID, attempt ID, owner, base SHA, allowed paths, dependencies, deadline, and expected artifacts. A returned result should include the produced SHA, test commands and exit status, unresolved issues, and any side effects. Accept the artifact at that SHA; rerun integration tests on the combined tree.
Compare fairly
Section titled “Compare fairly”- Run a single-agent baseline and a native-delegation baseline before testing an external platform.
- Hold repository, acceptance criteria, models, worker cap, tool access, and spend envelope constant where possible. Record unavoidable differences rather than hiding them in a score.
- Separate installation time from task time. Record supervisor, worker, reviewer, retry, and infrastructure costs.
- Run both an independent-task scenario and a dependency-heavy scenario. Randomize platform order and repeat trials; retain failed and abandoned runs.
- Have an evaluator inspect artifacts and score defects independently of the agents’ completion claims.
Inject failures deliberately
Section titled “Inject failures deliberately”| Experiment | Evidence required to pass |
|---|---|
| Kill a worker mid-edit | Changes preserved, ownership reconciled, continuation identified |
| Restart the controller | Assignment and workflow state reconstructed without duplicate active owners |
| Deliver a duplicate completion | One integration decision; duplicate recorded or rejected |
| Interrupt an external write | Reconcile a receipt or idempotency key before retry; unknown outcome stays explicit |
| Exhaust a budget | New work stops; in-flight consumption and overshoot recorded |
| Delay a message or leave a worker idle | Delivery and blocked states visible; no silent completion |
| Introduce a merge conflict | Controlled resolution followed by combined-tree validation |
| Return a false “done” claim | Acceptance fails despite successful process exit |
| A CI run that never starts | Integration records a CI failure; “no checks reported” is not “no CI configured” |
| A worker finishes while no client is watching | The job is still collected, validated and integrated; nothing waits for a status query |
| A job that edits CI configuration | Refused before any push; nothing runs with CI secrets |
| An adapter that substitutes its own runtime for the harness you configured | The run log shows the harness’s own start record (for Claude Code, claude_code_version) and its instructions and hooks loaded |
| Another session deploys between your check and your deploy | The deploy re-reads the live version and stops unless it is an ancestor of the commit being shipped |
| A newer push cancels a pipeline that had deploys pending | The next deploy compares with the last successful deployment and ships the skipped changes |
Retry only classified transient failures with bounded attempts and backoff. A persisted journal cannot infer whether a remote write committed before a connection dropped. Keep this scenario synthetic until its recovery semantics are proven.
Proposed scoring
Section titled “Proposed scoring”| Dimension | Weight | Measurement |
|---|---|---|
| Correctness and review | 30% | Acceptance tests and defects remaining after review |
| Execution and recovery | 20% | Validated completions, interruption recovery, duplicate side effects |
| Coordination | 15% | Dependencies respected, duplicate work, integration conflicts |
| Human intervention | 10% | Operator actions and time, including rescue work |
| Cost efficiency | 10% | Total cost per accepted task, including failed attempts |
| Observability | 10% | Reconstruct task ownership, actions, revisions, and decisions |
| Setup and maintenance | 5% | Initial setup and upgrade/requalification effort |
These weights are a proposal. Correctness, authorization, and side-effect requirements should be pass/fail gates: a fast or cheap system should not compensate for failing them. Record raw measurements alongside any aggregate score.
Security and operating boundaries
Section titled “Security and operating boundaries”| Boundary | Required check |
|---|---|
| Workspace | Branch and path ownership; cross-worker reads and writes tested |
| Process and host | Actual sandbox, container, or VM policy; shared mounts and sockets inventoried |
| Credentials | Per-worker identity, minimum scope, revocation, no secrets in prompts or artifacts |
| Network | Allowed destinations and synthetic blocked-egress checks |
| External content | Treat fetched text and peer messages as untrusted input |
| Integration | Protected branches and CI gates; accept a specific reviewed revision |
| CI configuration | Agent-written changes to .github/workflows/, .gitlab-ci.yml and similar never pushed: a pushed branch runs its own CI config with the repository’s secrets before review |
| Lifecycle | Timeouts, cancellation, orphan detection, and explicit unknown outcomes |
| Model and provider policy | Per-project rules on model vendors and serving providers, checked where every request starts (agent prompt hook, lane dispatch, harness plugin) and failing closed; repository scans for code that calls a banned model. A prompt rule alone fails when a session predates it |
Field note (November 11, 2026). One self-hosted stack, a Hermes Agent front end in a SimpleX group submitting to a custom broker and an isolated Mistral Vibe worker, with a ship service that merges verified jobs, turned up three integration failures that a configuration review had missed. On GitHub, a workflow that Actions refused to start left no check runs or statuses, so the ship service read it as “no CI” (it would have merged untested on projects where CI was optional). A live site turned out to build from a fork owned by another account, not from the repository jobs were shipping to. And the only working forge credential could push workflow files, which is what made the CI-configuration refusal above necessary. Its layer mapping, shipping seam and lessons are public in the swappable agent stack pattern and the Hermes guide’s troubleshooting. One deployment’s report, not a benchmark.
Git worktrees and tmux sessions are coordination tools, not security boundaries. Distinguish tool permissions from OS enforcement. The CAO secret-response runbook and our reliability study’s isolation discussion are useful starting points. Protect logs and retained prompts as carefully as source code.
Selection by requirement
Section titled “Selection by requirement”| Requirement | Starting candidate | Qualification question |
|---|---|---|
| Coordinate existing mixed coding CLIs | CAO | Does each exact adapter reliably exchange messages and results? |
| Durable, customizable engineering factory | Gas City | Can the configured workflow recover and integrate correctly? |
| Established factory roles and merge queue | Gas Town | Is the operating model worth its maintenance cost? |
| Recurring multi-project responsibilities and budgets | Paperclip | Do adapter delivery, approvals, and spend controls work end to end? |
| Small Claude-only collaboration | Agent Teams | Does peer coordination outperform simpler delegation? |
| Custom supervisor with structured execution state | Orca | Does its contract and continuity behavior meet the caller’s needs? |
| Always-on personal assistant on your own host and models | Hermes Agent | Can you read, approve, and revert what it writes to memory and skills? |
| Managed proactive assistant across work apps | Claude Duet or a ChatGPT dot | Which actions need approval, and what do reset and deletion actually remove? |
| Shared memory across several agents | Honcho | Who can read the shared store, and where is it hosted? |
Adopt one orchestration layer first. Expand only after measured improvements in accepted output, recovery, or operator effort justify the added components. This recommendation does not authorize or imply installing any of these systems on community infrastructure.
Related wiki guides
Section titled “Related wiki guides”- Agentic AI Patterns — planning, tools, memory, and observability.
- Hermes personal assistant — a self-hosted persistent assistant: memory files, scheduled briefs, gateways, and hardening.
- CLI Agent Comparison — harness capabilities and dated measurements.
- Agent Reliability Study — scorer defects, process success, retries, and isolation.
- Evaluation Frameworks — designing repeatable evaluations.
- Claude Code orchestration — native delegation and existing community workflows.
- Codex Project Rules and Coding Agent Customization — persistent instructions and permission configuration.
- OpenCode and community workflows — mixed-model execution and version-specific setup.
- Mistral Vibe and headless gotchas — self-hosted worker behavior and recovery lessons.
- Server and Offline Coding Models — inference capacity and worker routing.
- Agent Pricing — distinguish subscriptions, API costs, and private serving costs; check each row’s date.
- Full-Stack Development with AI — development workflow context.
Primary resource directory
Section titled “Primary resource directory”| Project | Documentation | Development |
|---|---|---|
| Paperclip | Docs | Releases |
| Gas Town | Architecture | Releases |
| Gas City | Docs · Migration | Releases |
| CAO | Docs | Changelog |
| Claude Code | Agent Teams | Public repository is not the full proprietary implementation |
| Hermes Agent | Docs · Memory | Releases |
| Claude Duet | Introducing Claude Duet · Safety and privacy | Research preview; closed source |
| ChatGPT dots | Tasks and memory · Controls | Closed source |
| Honcho | Docs | Releases |
| Orca | Lane contract | Releases |