Skip to content

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.

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.

LayerResponsibilityExamples
ModelGenerate reasoning and tool requestsClaude, GPT, DeepSeek
HarnessRun the model/tool loop and enforce its permissionsClaude Code, Codex, OpenCode, DeepSeek Harness
OrchestratorChoose work, dependencies, owners, and escalationPaperclip, Gas Town, Gas City, CAO, Agent Teams
Execution substrateDispatch and observe delegated sessionsOrca, a configured runner or session backend
Validation and integrationAccept artifacts and integrate a reviewed revisionAcceptance tests, independent review, merge queue, human approval
Persistent assistantKeep a standing relationship with one person: memory, schedules, proactive messages, delegationHermes Agent, Claude Duet, ChatGPT dots
Memory serviceStore what persists across sessions and tools, and answer questions about itBuilt-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 architecture: objective and acceptance criteria flow to an orchestrator, execution adapters, worker harnesses, durable evidence, and independent validation before integration.

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.

The entries describe native emphasis and documented mechanisms. “Configurable” means the operator must implement or verify the behavior.

SystemCoordination and durable workIntegration approachMain cost of adoption
PaperclipOrganizational roles, issues, heartbeats, database-backed runsReviews, approvals, and workspace/adapter configurationOperating a broader control plane
Gas TownMayor, Beads, hooks, worker lifecycle rolesWorktrees and Refinery merge queueMany roles, processes, and conventions
Gas CityConfigured agents, packs, formulas, reconciliationWorkflow-defined gates and processingDesigning and maintaining configuration
CAOSupervisor, CLI sessions, messaging, journaled workflowsRepository and workflow policyTesting CLI adapters and delivery behavior
Claude Code Agent TeamsLead, teammates, shared local tasksOperator-defined ownership and hooksExperimental lifecycle and coordination limits

Sources: Paperclip architecture, Gas Town architecture, Gas City migration map, CAO overview, and Agent Teams.

Operational questionPaperclipGas Town / Gas CityCAOAgent Teams
Several coding harnesses?AdaptersRuntime configurationProvider adaptersClaude Code sessions
Work survives a process?Stored tasks and run stateExternal work ledger and workflow stateWorkflow journal and session recordsTask files; teammate restoration has limits
Dedicated merge path?ConfigureRefinery / configured workflowConfigureConfigure
Spending controls?Reported-spend policies and pausesConfigure provider/infrastructure limitsConfigure provider/workflow limitsProvider allowance; no comparable organization budget described
Correctness automatic?NoNoNoNo

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:

ComponentResponsibility
MayorCoordinate work across projects
RigManaged project workspace
Polecat / CrewTask worker / persistent human-facing workspace
WitnessObserve per-project worker lifecycle
DeaconPatrol and supervise background operations
RefineryProcess the project merge queue and verification gates
Beads / hooksTrack work and retain assignments outside a conversation
ConvoyGroup 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, and loop modes 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.

Orca reference: a caller dispatches through Orca to Codex, Claude Code, or Cursor. Durable lane records return delivery and native status, while the caller separately verifies semantic correctness.

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.

HarnessRelevance to this comparison
Claude CodeNative subagents and teams; also an external worker
CodexNative delegation is a baseline worth testing before adding a control plane
OpenCodeModel-flexible harness; qualify the exact version and adapter
Mistral VibeExisting wiki workflow for self-hosted worker delegation
DeepSeek HarnessPlugin-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 AgentClaude DuetChatGPT dotCodex memories
What it isSelf-hosted agent runtime from Nous Research (MIT)Anthropic app; research preview since October 21, 2026OpenAI’s persistent assistant, documented in the Codex docsOpt-in memory for local Codex clients
Where it runsYour host or container, with any configured modelAnthropic’s cloud, in a VM with its own browser, so your devices can be offOpenAI’s service; tasks can run on a computer connected to the dotYour machine
What persistsMEMORY.md and USER.md, every session in SQLite with full-text search, and skillsConversation history and memory; carries over memory, skills, and connected apps from your Claude accountIts own notes, separate from ChatGPT saved memory, plus starting context from ChatGPT memoryGenerated files under ~/.codex
How it learnsRecords workflows as skills and revises them during use; optional external memory providers such as HonchoNot documented beyond memory and historyKeeps notes between conversationsCarries 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 controlPlain 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 memoriesDelete the dot (irreversible; read what the confirmation says it removes); changing ChatGPT memory does not remove notes it already madeOff by default; Delete Codex memories per machine; /memories per chat
ActionsThe tools and gateways you configureAsks approval before it sends, pays, signs, or deletes; trading and moving money stay off-limitsBackground and scheduled tasksCodex’s own coding permissions
AccessFree software; you pay for the model and the hostWaitlist for US Pro, Max, and Ultra subscribersChatGPT; texting a dot is a US Pro betaCodex 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.

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.

  • 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.

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”
SourceObservationEvidence boundary
Felipe Fontoura, Paperclip field reportReports 13 agents, roughly six weeks, and two custom adapters before an autonomous loop closedOne operator’s Paperclip/Hermes integration; not a benchmark of every adapter
DoltHub, Two Weeks in Gas TownReports about $6,000 in Claude API calls and difficulty establishing confidence in generated codeFirsthand engineering report from a vendor whose database participates in the ecosystem; not vendor-neutral comparative testing
Everpod, team runDocuments four teammates reviewing documents, coordination work, and substantial token usageHosting vendor’s single task experiment; not evidence of coding quality
Positive Reddit account / critical accountReports range from fast refactoring to missed specifications and ineffective reviewUncontrolled, 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.

ProjectInspected commitCommit date (UTC)License
Paperclip30d99f4e324b2026-11-10MIT
Gas Town466aa41c83ee2026-10-28MIT
Gas Cityf1f75f53cddf2026-11-10MIT
CAO92b292f2dd612026-11-10Apache-2.0
Orca2b0add4e58d22026-07-14MIT

Several of these names collide with unrelated software. Install from the package named here and check the version actually installed.

ProjectInstall asNot to be confused withRelease status (November 10)
Paperclipnpm paperclipai, CLI paperclipai; Node.js 24.11+npm paperclip is an unrelated packagev2026.1106.0 (November 6); npm versions match the release tags
Gas TownHomebrew gastown (still 1.1.0) or GitHub release binaries; CLI gt, with Beads bd and DoltHomebrew’s genometools and libslax also install a gt command; npm @gastown/gt is stale (0.12.0, March) and not the recommended pathv1.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 CitySee its docsNot a newer Gas Town version; a separate design with a migration pathv1.5.1 (October 24)
CAOSee its docs—v2.5.3 (October 8)
Hermes AgentNousResearch/hermes-agent; CLI hermes, state in ~/.hermes; desktop app via Homebrew cask hermes-desktopNous Research’s Hermes language models are a model family, not this agentv0.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
HonchoManaged api.honcho.dev, or self-host from plastic-labs/honcho—v3.6.0 (November 10)
Orcanpm orcastrator, CLI orcanpm orca is Plotly’s image exporter; Linux desktops ship the GNOME orca screen reader under the same command; OrcaSlicer is a 3D-printing slicerv0.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.

Start with the existing reliability audit and evaluation frameworks. Do not reuse historical harness scores as current orchestrator rankings.

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-01
base_commit: <full Git SHA>
allowed_paths: [api/, ui/, tests/]
worker_limit: 2
deadline_minutes: 30
spend_limit_usd: 10
acceptance: external-tests-and-review
external_writes: prohibited

The 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.

  1. Run a single-agent baseline and a native-delegation baseline before testing an external platform.
  2. 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.
  3. Separate installation time from task time. Record supervisor, worker, reviewer, retry, and infrastructure costs.
  4. Run both an independent-task scenario and a dependency-heavy scenario. Randomize platform order and repeat trials; retain failed and abandoned runs.
  5. Have an evaluator inspect artifacts and score defects independently of the agents’ completion claims.
ExperimentEvidence required to pass
Kill a worker mid-editChanges preserved, ownership reconciled, continuation identified
Restart the controllerAssignment and workflow state reconstructed without duplicate active owners
Deliver a duplicate completionOne integration decision; duplicate recorded or rejected
Interrupt an external writeReconcile a receipt or idempotency key before retry; unknown outcome stays explicit
Exhaust a budgetNew work stops; in-flight consumption and overshoot recorded
Delay a message or leave a worker idleDelivery and blocked states visible; no silent completion
Introduce a merge conflictControlled resolution followed by combined-tree validation
Return a false “done” claimAcceptance fails despite successful process exit
A CI run that never startsIntegration records a CI failure; “no checks reported” is not “no CI configured”
A worker finishes while no client is watchingThe job is still collected, validated and integrated; nothing waits for a status query
A job that edits CI configurationRefused before any push; nothing runs with CI secrets
An adapter that substitutes its own runtime for the harness you configuredThe 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 deployThe 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 pendingThe 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.

DimensionWeightMeasurement
Correctness and review30%Acceptance tests and defects remaining after review
Execution and recovery20%Validated completions, interruption recovery, duplicate side effects
Coordination15%Dependencies respected, duplicate work, integration conflicts
Human intervention10%Operator actions and time, including rescue work
Cost efficiency10%Total cost per accepted task, including failed attempts
Observability10%Reconstruct task ownership, actions, revisions, and decisions
Setup and maintenance5%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.

BoundaryRequired check
WorkspaceBranch and path ownership; cross-worker reads and writes tested
Process and hostActual sandbox, container, or VM policy; shared mounts and sockets inventoried
CredentialsPer-worker identity, minimum scope, revocation, no secrets in prompts or artifacts
NetworkAllowed destinations and synthetic blocked-egress checks
External contentTreat fetched text and peer messages as untrusted input
IntegrationProtected branches and CI gates; accept a specific reviewed revision
CI configurationAgent-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
LifecycleTimeouts, cancellation, orphan detection, and explicit unknown outcomes
Model and provider policyPer-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.

RequirementStarting candidateQualification question
Coordinate existing mixed coding CLIsCAODoes each exact adapter reliably exchange messages and results?
Durable, customizable engineering factoryGas CityCan the configured workflow recover and integrate correctly?
Established factory roles and merge queueGas TownIs the operating model worth its maintenance cost?
Recurring multi-project responsibilities and budgetsPaperclipDo adapter delivery, approvals, and spend controls work end to end?
Small Claude-only collaborationAgent TeamsDoes peer coordination outperform simpler delegation?
Custom supervisor with structured execution stateOrcaDoes its contract and continuity behavior meet the caller’s needs?
Always-on personal assistant on your own host and modelsHermes AgentCan you read, approve, and revert what it writes to memory and skills?
Managed proactive assistant across work appsClaude Duet or a ChatGPT dotWhich actions need approval, and what do reset and deletion actually remove?
Shared memory across several agentsHonchoWho 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.

ProjectDocumentationDevelopment
PaperclipDocsReleases
Gas TownArchitectureReleases
Gas CityDocs · MigrationReleases
CAODocsChangelog
Claude CodeAgent TeamsPublic repository is not the full proprietary implementation
Hermes AgentDocs · MemoryReleases
Claude DuetIntroducing Claude Duet · Safety and privacyResearch preview; closed source
ChatGPT dotsTasks and memory · ControlsClosed source
HonchoDocsReleases
OrcaLane contractReleases

Recent changes

  1. docs(wiki): Hermes board recovers on its own (field note follow-up) @sac
  2. Merge branch 'docs/parallel-sessions-field-note' into 'main' sac
  3. docs(wiki): field note on queueing repository work on Hermes's Kanban board gitayam
  4. docs(wiki): field note on parallel sessions without an orchestrator gitayam
  5. docs(wiki): field note on moving the coding front door off the laptop gitayam