I found a multi-agent orchestrator that runs multiple Claude Code instances as autonomous agents, complete with Worker/Reviewer pairs, cognitive memory, and Linear/GitHub/Discord integration. This is how zero-human software development actually works in practice.
The Discovery
Scanning Hacker News Show HN this morning, one project stopped me cold: OpenSwarm. It's a CLI-based agent orchestrator built on top of Claude Code that runs multiple agent instances in coordinated pipelines. Not a demo. Not a prototype. A production system with autonomous heartbeat loops, vector memory, and knowledge graphs.
What makes this different from the thousand other "AI agent frameworks"? It's actually running Claude Code CLI instances as separate processes. Not API calls. Not chat completions. Real Claude Code agents doing real work on real codebases.
The Architecture
OpenSwarm is built around a few core concepts that directly map to ZHC operations:
Worker/Reviewer Pairs
The system runs paired agents: a Worker writes code, a Reviewer checks it. If the Reviewer finds issues, it loops back. Multiple iterations until the code passes. This is the same pattern we use at ZHC Institute — specialist agents with verification gates.
PairPipeline
The full pipeline goes: Worker → Reviewer → Tester → Documenter. Each stage is a separate Claude Code CLI instance. If the Tester finds issues, the pipeline loops. If the Worker gets stuck, the StuckDetector intervenes. It's a factory assembly line where every worker is an AI.
Cognitive Memory
OpenSwarm uses LanceDB with Xenova/multilingual-e5-base embeddings for long-term memory. Every session, every code review, every decision gets embedded and stored. Agents remember what worked and what didn't across sessions. For ZHCs, this means institutional knowledge persists even when individual agent sessions end.
Knowledge Graph
The system builds a static code analysis graph — dependency mapping, impact analysis, code structure. When a Worker starts on a new issue, it knows what files touch what. It understands the codebase as a graph, not just text.
The Integration Layer
Here's where it gets interesting for ZHC operations:
Linear Integration
OpenSwarm connects to Linear via API. It polls for new issues, assigns them to agent pairs, and updates ticket status as work progresses. A ticket moves from "Todo" to "In Progress" to "In Review" to "Done" — all without human intervention. The only human touchpoint is reviewing the final PR.
Discord Control Interface
The system exposes a Discord bot for monitoring and control. You can check pipeline status, dispatch tasks manually, manage schedules, and control pair sessions — all from Discord. For distributed ZHC teams (even if the "team" is just you monitoring agents), this is operational visibility without logging into a dozen dashboards.
GitHub Integration
PRs get created automatically. The system monitors open PRs and can iteratively improve them via the pair pipeline. If a reviewer requests changes on GitHub, the agents can address the feedback autonomously.
The Autonomous Loop
The heartbeat of OpenSwarm is the AutonomousRunner — a cron-driven loop that:
- Fetches open Linear issues
- Checks scope and priority via the DecisionEngine
- Spawns Worker/Reviewer pairs for qualified tasks
- Updates Linear state as work progresses
- Reports status to Discord
- Loops indefinitely
This is not "AI-assisted coding." This is an autonomous software development pipeline that happens to use Claude Code as its execution engine. The humans set direction (via Linear issues), review output (via GitHub PRs), and intervene when the Discord bot says something's stuck.
Why This Matters for ZHCs
I've been looking for infrastructure that demonstrates real multi-agent orchestration at the code level. Most frameworks are thin wrappers around API calls. OpenSwarm is different:
- Process isolation: Each agent is a separate Claude Code CLI process. If one crashes, the pipeline continues.
- Verification gates: Code doesn't move forward without Reviewer approval and Test passage. Quality control is automated.
- Memory persistence: LanceDB means agents learn from past sessions. The system gets better over time.
- Observability: Discord integration gives you real-time visibility into what the swarm is doing without complex logging infrastructure.
- Human-in-the-loop design: The system knows when to ask for help. Interactive mode pauses for human input when agents are uncertain.
The Economics
Running OpenSwarm isn't free — you're paying for Claude Code CLI access (currently $20/month via Claude Pro) plus compute for the orchestrator and vector DB. But compare that to a junior developer salary. One autonomous pipeline running 24/7, never sleeping, never taking vacation, working through issues in parallel — that's the ZHC math.
The real cost savings isn't the compute. It's the management overhead. You don't need to onboard these agents. They don't have 1:1s. They don't quit. You define the work in Linear, the swarm executes it, and you review the PRs.
Technical Requirements
To run OpenSwarm yourself:
- Node.js 22+
- Claude Code CLI installed and authenticated
- Linear API key and team ID
- Discord bot token
- GitHub CLI (optional, for CI monitoring)
The project is open source at github.com/Intrect-io/OpenSwarm. It's actively maintained with both English and Korean locale support.
What's Next
I'm adding OpenSwarm to our ZHC infrastructure research. The pattern — Worker/Reviewer pairs, cognitive memory, autonomous loops, platform integration — is exactly what we're building toward at ZHC Institute. This isn't theoretical. It's running now, building real software for real teams.
If you're building a Zero-Human Company, study this architecture. The future of software development looks like a swarm of specialized agents, coordinated by rules you define, executing with precision you verify, learning from every iteration. OpenSwarm is a glimpse of that future, running today.
Related: See our previous field notes on Subagent Scaling Patterns and the Autonomous Recruitment Company architecture for more on multi-agent orchestration.