Field report · · AgentConn Team
One Queue, Three Agents: Cross-Vendor Wiring
How OpenRig, Open Engine, and Omnigent wire Claude, Codex, and ChatGPT into shared task loops with state handoffs.
The discourse around AI coding agents has spent most of 2026 obsessing over a question that’s already obsolete: which agent is best? Claude Code dominates complex reasoning. Codex CLI excels at rapid, parallelized task execution — OpenAI’s own internal data shows median Codex output tokens are 56x higher than typical ChatGPT coding sessions. ChatGPT handles conversational planning and specification better than either. And yet most teams still copy-paste between them manually, losing state at every handoff.
The Latent Space newsletter declared it meta-harness summer — the season when the engineering community stopped debating which harness to pick and started building the layer above all of them. Three open-source projects have converged on the same architectural answer: a shared task queue that routes work between Claude, Codex, and ChatGPT with state preservation, cost-aware routing, and recovery semantics. Here’s how they work, when to use each, and how to wire your own cross-vendor loop.
The Integration Layer Is the Bottleneck
Every team running multiple agents hits the same wall. It’s not model quality. It’s not even cost. It’s the handoff — the moment work crosses from one agent to another and context evaporates.
Nate B Jones described the problem precisely in his Open Engine walkthrough: “one job crossing seven systems where a person carries state between handoffs — what was decided, what source mattered, what changed.” The human becomes a glorified clipboard, shuttling decisions between tools that can’t see each other’s work.
This is fundamentally different from the fleet orchestration problem — fleets manage parallel agents running the same harness. Cross-vendor wiring manages serial handoffs across different harnesses, where each agent brings different strengths and the challenge is preserving enough state that Agent B doesn’t redo what Agent A already figured out.
Three Projects, One Pattern
What’s remarkable about the current wave is how independently three teams arrived at nearly identical architectures. All three implement a shared task record, a routing layer, and recovery semantics — the same three primitives, expressed in different dialects.
OpenRig: YAML Topologies for Agent Teams
OpenRig takes the infrastructure approach. You define your agent team in a YAML file called a RigSpec — pods, members, edges, continuity policies — and boot it with one command. Claude Code and Codex run in the same rig, managed as a single system on your local machine.
The key abstraction is the topology. Rather than coding agent interactions, you declare them: which agents exist, how they communicate, what happens when one fails. A rig is “a topology of coding agents working together — defined in YAML, booted with one command, managed as a single unit.”
# Example RigSpec (simplified)
pods:
- name: planner
member: chatgpt
role: decompose tasks, generate specs
- name: implementer
member: claude-code
role: write code, run tests
- name: reviewer
member: codex
role: parallel review, security scan
edges:
- from: planner → implementer
- from: implementer → reviewer
- from: reviewer → planner # feedback loop
continuity:
on_failure: pause_and_notify
state_persist: sqliteThe Hacker News discussion captured the positioning cleanly: “Anthropic shipped Claude Managed Agents — a cloud-hosted, Claude-only runtime at $0.08/session-hour. OpenRig is the local side: open source, cross-harness, runs on your machine, costs nothing.”
Architecturally, OpenRig runs on tmux with a Hono HTTP daemon, SQLite for state, and an MCP server for tool integration. RigSpec is declarative — you describe the topology, not the execution. This means you can version-control your agent team composition the same way you version-control infrastructure with Terraform or Kubernetes manifests.
💡 OpenRig’s local-first design means your agent topology runs on your machine with zero cloud dependency. Compare this with Anthropic’s Managed Agents, which require cloud connectivity and charge per session-hour.
Open Engine: The Shared Task Record
Where OpenRig focuses on topology, Open Engine focuses on the handoff primitive itself. Nate B Jones built it around a seven-part task record — a structured document that travels with the work across tools, preserving source attribution and operational constraints so context doesn’t die in a private chat.
The design philosophy is radical simplicity. Open Engine doesn’t try to manage agents or define topologies. Instead, it defines what a task looks like when it moves between systems, and provides a nine-question framework that turns “one annoying handoff into a task an agent can claim, pause, resume, and finish with evidence.”
The receipt system is the clever part. When an agent completes a subtask, it doesn’t just report success — it produces a structured receipt that includes what changed, what evidence supports the change, and what constraints were respected. This makes completion auditable, not just self-reported.
Nate B Jones demonstrates the Open Engine shared task queue connecting Claude, ChatGPT, and Codex with structured handoffs.
Omnigent: The Meta-Harness With Identity
Omnigent from the Databricks ecosystem attacks the problem from the enterprise angle. It’s a meta-harness — a layer that sits above Claude Code, Codex, Cursor, and custom agents, letting you “swap harnesses without rewriting, enforce policies and sandboxing, and collaborate in real time from any device.”
The distinguishing feature is identity and permissions. As the Databricks blog post argues, agents need to authenticate as themselves, not as the user who launched them. When Agent A hands off to Agent B, the permissions context needs to travel with the task — Agent B shouldn’t inherit Agent A’s access scope by default. This is the enterprise governance layer that OpenRig and Open Engine deliberately omit.
⚠️ Omnigent’s identity model matters most in regulated environments. If your agents access production databases, customer data, or financial systems, the question of “which agent did this, and was it authorized?” isn’t academic — it’s compliance.
The Routing Table: When to Send Work Where
Cross-vendor orchestration only makes sense if you route intelligently. Sending every task to Claude Code because it’s “the best” is like hiring a senior architect to write CSS — expensive and slow for work that doesn’t need that depth.
Here’s the routing heuristic emerging from teams running cross-vendor queues in production:
| Task Type | Route To | Why |
|---|---|---|
| Complex reasoning, multi-file refactors | Claude Code | Deepest context window, best at maintaining coherence across files |
| Parallel batch operations, test generation | Codex CLI | 56x higher median output, built for throughput over depth |
| Spec writing, API design, documentation | ChatGPT | Strongest at conversational iteration and structured output |
| Security scans, dependency audits | Codex CLI | Fast parallel execution, good at rule-based checking |
| Architecture decisions, tradeoff analysis | Claude Code | Best reasoning about constraints and second-order effects |
| User-facing copy, error messages | ChatGPT | Optimized for natural language quality at scale |
The Scopir orchestration guide formalizes this as a three-agent stack: orchestrator, specialist worker, reviewer. The orchestrator (typically ChatGPT or Claude) decomposes the task, workers (typically Codex for throughput or Claude for depth) execute subtasks, and the reviewer validates the output. MCP serves as the protocol layer for cross-vendor communication.
Building Your Own Cross-Vendor Loop
You don’t need to adopt a full meta-harness to get cross-vendor benefits. Here’s a minimal shared-queue architecture you can wire today with tools you already have.
Step 1: Define the Task Record
Every task in the queue needs five fields at minimum:
{
"id": "task-042",
"description": "Refactor auth middleware to use JWT rotation",
"constraints": ["Don't break existing sessions", "Keep backwards compat for 30 days"],
"context": { "prior_decisions": [], "relevant_files": [] },
"routing_hint": "deep_reasoning"
}The constraints and context fields are what distinguish this from a simple todo list. They carry the state that would otherwise evaporate during a manual copy-paste handoff.
Step 2: Implement Cost-Aware Routing
Route based on task complexity and the cost profile of each agent:
def route_task(task):
if task.routing_hint == "deep_reasoning":
return "claude-code" # $15/M output tokens, best reasoning
elif task.routing_hint == "batch_parallel":
return "codex-cli" # Fast, high-throughput
elif task.routing_hint == "conversational":
return "chatgpt" # Best for spec iteration
else:
return "codex-cli" # Default: cheapest capable agentThe multi-harness plugin marketplace on GitHub demonstrates how to make this routing transparent — install a plugin once, use it across any agent in your fleet.
Step 3: Handle Failures and Recovery
The hardest part of cross-vendor wiring isn’t the happy path — it’s recovery. What happens when Codex times out mid-task? When Claude’s context window fills up? When ChatGPT’s rate limit kicks in?
OpenRig handles this with continuity policies — declarative rules that specify what happens on failure (pause and notify, retry with a different agent, or escalate to a human). Open Engine handles it with the receipt system — if the last receipt shows partial completion, the next agent can pick up from where it stopped rather than starting over.
The minimum viable recovery pattern:
- Checkpoint before handoff. Save the task state (what’s done, what’s pending) to a durable store before passing to the next agent.
- Idempotent operations. Design subtasks so they can be safely retried — the next agent applying the same change shouldn’t break anything.
- Fallback routing. If the primary agent fails, route to the secondary. Claude times out → fall back to Codex. Codex rate-limited → queue for retry in 60 seconds.
💡 The opencode-ai/opencode project (179K GitHub stars) demonstrates orchestrator plugin architecture that supports this pattern — agent-agnostic plugins that handle routing, checkpointing, and fallback natively.
What Cross-Vendor Wiring Means for Lock-In
The emergence of cross-vendor orchestration has profound implications for harness lock-in. If your orchestration layer treats individual harnesses as swappable components, then no single vendor can lock you in at the agent level. Today’s Claude Code dependency becomes tomorrow’s routing table entry — one line in a YAML file.
This is exactly why Anthropic launched Managed Agents at $0.08/session-hour and why OpenAI is pushing Codex as a platform play. The value shifts from the agent to the orchestration layer, and whoever controls orchestration controls the workflow. OpenRig, Open Engine, and Omnigent are the open-source answer to that consolidation pressure.
The harness engineering discussion on HN captured the tension: the meta-harness pattern — one layer above individual harnesses that manages routing, state, and recovery across all of them — is either the foundation of agent interoperability or the next layer of lock-in, depending on who builds it.
Getting Started
If you’re running multiple agents today and manually handling handoffs, here’s the minimal path forward:
- Start with OpenRig if you want declarative topology management and local-first execution. Define your agent team in YAML, boot it, iterate.
- Start with Open Engine if your primary pain is handoff quality. The seven-part task record and receipt system can be adopted incrementally without changing your existing setup.
- Start with Omnigent if you need enterprise governance — identity, permissions, audit trails across agents.
All three projects are open source and actively maintained. The pattern is converging. The question isn’t whether cross-vendor orchestration will become standard tooling — it’s whether you’ll build on it before your competitors do.
For a broader look at the orchestration landscape, see our best agent orchestration tools roundup and the handoff patterns guide.