Meta harness

A harness whose agents are other harnesses. Where a harness (channels/state/auth/tools/scheduling around one model loop — Agent knowledge systems) runs agents, a meta-harness orchestrates multiple harnesses behind one session surface: swap or combine Claude Code, Codex, Cursor, Pi, Hermes, custom agents — without rewriting — while adding the layers no individual harness owns: cross-device sessions, policy/sandboxing enforcement, and multi-agent supervision.

The exemplar: Omnigent (2026-10)

omnigent (OSS) (10.5k★, Apache-2.0, Python — already in the vault from the eleven-harness study, where it was named the meta-harness; now captured in full): “the open-source meta-harness for all your AI agents” —

• Harness-agnostic sessions: mix Claude Code, Codex, Cursor, OpenCode, Hermes, Pi + YAML-defined custom agents in one session; ask one agent to review another; split tasks across complementary agents
• Sessions follow you: terminal → browser → phone → desktop app; messages, sub-agents, terminals, files in sync (the Octop/multi-user lane’s device mobility, harness-agnostic)
• Cloud sandboxes as first-class hosts: Modal, Daytona, E2B, Kubernetes, NVIDIA OpenShell, microsandbox, Databricks, CoreWeave… disposable, CLI- or server-provisioned (managed hosts)
• Governance as the product: policies pause-for-approval on risky actions, cap spend, limit tool reach — scoped server/agent/chat (the Decision models placement argument, productized)
• Model-agnostic keys/subscriptions/gateways; ACP underneath for harness interop; Hindsight available as storage/memory extra

Why the category exists (vault grounding)

The eleven-harness study (Pi agent harness) found the stratification: harnesses converged on tool→platform by H1 2026, ACP in six systems, “harness hosting” as a role. Once harnesses are interoperable units, the next layer up is choosing between them per task — orchestration, not construction. Related lanes already in the vault:

• Orca (Git worktrees) — fleet-of-agents with worktree isolation; the worktree primitive, not the meta-harness role
• Octop / team harnesses (Pi agent harness) — multi-user containers around agents; social layer rather than harness-agnostic session layer
• Codemode (Code Mode) — the in-harness composition mechanism a meta-harness rides on
• openhuman — the opposite bet: one in-process kernel, ~2 MiB/agent, no meta layer needed

The design questions (open)

1. Where does policy live? Meta-harness governance (Omnigent) vs in-harness decision models (Jev) vs kernel enforcement (Aegis-BPF) — placement is the decision, not existence (Decision models).
2. Does the meta layer tax the loop? Every hop through orchestration adds latency/context; the openhuman bet says dense in-process beats supervised harness-of-harnesses.
3. Session portability vs. state fidelity — “continue on your phone” requires the session substrate (transcript + files + terminals) to be extractable from each harness; ACP makes this possible, not free.

Vault kin

• Pi agent harness — the harness landscape + eleven-harness study + team-harness lane
• Agent Client Protocol — the interop substrate a meta-harness presupposes
• Git worktrees — Orca: the fleet lane
• Decision models — governance placement
• Agent-accessible product — Omnigent’s product surface (every device, MCP-adjacent)

The second exemplar: Paperclip (2026-10-07, reclassified)

paperclip (OSS) (84k★, MIT — captured 2026-09-25, previously filed under Human Agents Workspace as the agent control plane): on reflection it qualifies as a meta-harness — the README says it outright: “If OpenClaw is an employee, Paperclip is the company” — orchestrate OpenClaw, Claude Code, Codex, Cursor, Bash, HTTP agents (“if it can receive a heartbeat, it’s hired”) toward business goals, managing goals not pull requests. The four pillars map exactly onto this note’s open questions: Agentic Task Manager (tasks/approvals/review gates — the governance placement), Org Chart for Agents (roles/permissions/boundaries for humans and agents mixed — policy as org design), Agent Employee Training (Skill Studio, evals, performance reviews — the LLM evals lane as HR), Agentic OS (cross-provider runtime, sandboxing, SSO/RBAC/cost controls — the infrastructure pillar). Plus: monthly budgets per agent with hard stops, immutable audit tickets, multi-org isolation, mobile monitoring.

Omnigent vs Paperclip — two poles of the same category: Omnigent is the developer’s meta-harness (sessions, sandboxes, harness interop via ACP — you still direct the work); Paperclip is the executive’s meta-harness (org charts, budgets, goal alignment — you manage outcomes and the agents self-direct through a hierarchy). One optimizes the loop, the other optimizes the org chart. The Human Agents Workspace open question (“does the control plane absorb the communication plane?”) gains a third term: both planes may end up features of the meta-harness.

Third exemplar: Paseo (2026-10-08, user-called fit)

LLMpsycho → paseo (OSS) (20.1k★ TypeScript; tweet + README captured): “orchestrate multiple coding agents from desktop and mobile” — Claude Code, Codex, Copilot, OpenCode, Pi, Antigravity, Muse Code through one interface; daemon architecture (local server manages the agents; desktop/mobile/web/CLI are all clients — “the mobile app is the full app, native on iOS and Android”); parallel agents each in its own worktree; built-in orchestration where “agents can create worktrees, launch other agents, and talk to them, across providers”; plugins on the daemon appear in every client; voice control; self-hosted, zero telemetry. This fills the third pole: Omnigent = the harness-agnostic session layer, Paperclip = the executive org-chart, Paseo = the personal ADE — the individual developer’s multi-agent cockpit (the “agent GUIs, desktop apps optimized for multi-session multi-agent workflows” lane from Coding with agents 2026-10-07). Notable: it’s the Orca worktree-fleet pattern (Git worktrees) with a phone client and a plugin bus — the fleet cockpit without Orca’s merge-picking workflow.

Fourth exemplar: Moyai, the background-work pole (2026-10-08)

LLMpsycho → moyai (OSS) (205★ Python, LiteLLM/BerriAI team; tweet + README captured): “a self-hosted coding agent for background work” — task arrives from browser or Slack, the agent edits code, runs tests, opens a PR; corrections mid-work; resume with saved files + conversation history; full-text session search (“ask Moyai in chat to recover archived sessions”). The meta-harness move is explicit in the README: harness-per-session selection — Codex SDK for openai/ models, Claude Agent SDK for anthropic/ (auto-assigned), or pick Hermes, Claude Agent SDK, Codex, OpenCode, Deep Agents, or Tool Loop per session, “every harness runs in the same isolated workspace with the same tools and permissions.” Model access via LiteLLM (100+ providers, keys stay on the server, “the sandbox never sees them”); sandboxes on Modal or Substrate. The economic receipt: they migrated their internal agent Devin → Moyai and published the bill — $101,872vs$21,700 over the same 31 days (79% cheaper). Pole four: where Omnigent follows sessions and Paperclip runs orgs, Moyai is the delegated-background-lane meta-harness — fire tasks out-of-band (Slack), let the harness choice be a per-task implementation detail, review the PR when it lands. Bonus for the vault: Hermes is a first-class harness option in a shipping product’s selector.

Fifth exemplar: Tern, the terminal-workspace pole (2026-10-09)

0xSero (193 hearts/12k views; “new awesome meta-harness just dropped”) -> stencil.so/tern (closed beta, waitlist; tweet + page captured): “a neoterminal for the Electron-weary” — a Rust-native workspace where the terminal is the agent surface. The load-bearing design: a daemon owns the sessions — close the window or bounce the daemon, “you never lose work”: every pane comes back in its directory over its old scrollback, “with omp mid-conversation” (the agent survives the window, exactly the Hermes-gateway/pi durable-agent pattern, at the terminal layer). tern remote serve does the same for a server over QUIC (iroh), reachable via Tailscale peer addressing; tern web serve serves the same session to a browser tab on wasm/WebGPU and an iPhone client — “one session, exactly the same; type on one, the others follow.” The graphics bet: programs describe their UI over the Tern Surface Protocol — “Mermaid, LaTeX, diffs, live pages… faster than a TUI draws text,” drawn natively (wgpu), no web stack. The demo pairs pi + omp agents in panes alongside shells. Pole five: where Paseo is the personal ADE and Orca the fleet cockpit, Tern is the terminal-as-harness — the daemon + multi-client + agent-pane pattern the Coding with agents 2026-10-07 note predicted for the “CLIs shift to servers” lane, built by Stencil (the pi-adjacent shop; omp is their agent). Kin: tmux-with-a-daemon done properly, Mosh’s roaming-session promise with a graphics protocol attached.