The Connected Agent

Meta-harnesses fill the gaps your harness leaves.

Scroll down

Meta-harnesses are the missing layer.

Agentic engineering changes how developers work. The focus shifts from low-level implementation details to system architecture and data flow, from working in a single repository to orchestrating many at once, managing sessions and context across implementation tasks. Everyone hand-stitches their own workflows to make existing harnesses adapt to this new way of working. Just like everyone built around React until the meta-frameworks arrived. The meta-harness is like the meta-frameworks, that layer that comes with batteries included.

A harness mostly operates inside one repo

You start a harness in a folder and it gets to work. That folder is usually a repository, and inside it the agent reads the code, runs the tests, makes the change, opens the PR.

But a harness has no notion of a repository. That is not an accident or a flaw. The harness is the agentic primitive, and it focuses on doing that one job well. Just like in the JavaScript framework world, where React core limits itself to the UI layer and rendering components.

AI changes the nature of your work

AI agents take over more and more of the lower-level implementation, and you level up a floor. Your focus shifts to the system architecture, the integration points, the way data flows end to end: not just what the frontend renders, but how the backend retrieves and exposes it.

Your work now potentially stretches across repositories: the frontend, the backend, the design system. By default, the harness still operates inside a single box, with no notion of the repos around it.

You become the plumbing

The harness, though, is local to each of those repos. To make agents work across the frontend and the backend at once, you do the stitching yourself. Concretely, today:

  1. 01

    Fetch and branch

    Pull the second repo and get it onto the right branch.

  2. 02

    Set up worktrees

    So agents work in each repo independently, without stepping on each other.

  3. 03

    Route context by hand

    CLAUDE.md files, custom scripts, copied-in markdown, so each agent knows what the other is doing.

  4. 04

    Land the PRs together

    Push the coordinated PRs so they land together instead of breaking each other.

Git has the what, agent sessions have the why

There is a second shift hiding inside the first. Work used to be one person per problem; now it is you plus a handful of agents. You operate like an architect: you care that the data flows through the system the right way, you do not sit at the keyboard of every change. The agent holds the details, and the reasoning behind them, the way a coworker used to.

Every company knows how that story ends: the coworker who knows why the payment retry logic looks the way it does changes jobs, and the knowledge goes with them. Git keeps what changed; the session keeps why, so your agent session is more valuable than the git history. With agents, it is gone every time a session ends.

Agents are developers who quit after every single session, and the why goes with them.

Real work is multiplayer

Real work within an organization is much more complex than one person's. Your teammates run their own sessions against the same systems, all day, every day. Each session solves problems, rules out approaches, encodes decisions.

Real work builds on the work that came before it. Someone on your team has almost certainly worked through the exact area you are about to touch, but your agent has no way of knowing what your coworker's agent did. While the organization runs hundreds of sessions, all of them stay local to the developer's machine, invisible to everyone else.

The answer: meta-harnesses

You have seen this move before. React gave you the core, and you chose the router, the data-fetching library, the component library, and stitched them together yourself. It worked, and it did not transfer: every team rebuilt the same setup differently. Then Next.js and TanStack packaged the proven choices into a meta-framework which made React apps faster and more stable to build.

A meta-harness makes the same move around your harness. It fills the gaps with proven solutions to support your workflow. Your agent gets more capable, more autonomous and you get more productive.

Meta-harness capabilities

The meta-harness is still a broad, fast-moving idea. There is no single fixed definition yet, and the exact properties depend on the type of meta-harness and the scope it takes on.

Right now meta-harnesses operate in two ways. Harness optimization is the Stanford Meta-Harness usage: an outer-loop system searches over the harness around an LLM, tuning prompts, memory, retrieval, context formatting, tools, completion checks, and runtime code.

Harness orchestration is the industry usage: a control layer sits above many agent harnesses and handles routing, composition, sandboxing, policy, observability, and collaboration.

Here are some of the potential capabilities.

Swappable harnesses

The harness is never locked in. Resume the same session on Claude Code, Codex, or OpenCode, switching agents whenever another one fits the task better.

Meta-harness
Thin instrumentation layer
Harness
swappable runtime
Claude Code
Codex
OpenCode

Repository knowledge

The agent works with added context about the landscape around it: which repositories exist, how they relate, and where a change belongs.

Provisioning and setup

It provisions the repos an agent needs, clones them into isolated worktrees, and runs the setup scripts before work starts.

Claude Code v2.1
Opus 4.8 with high effort · Claude Max
~/code/acme
❯█
poly-ms-frontend · Opus 4.8 (1M context) · 95%● high · /effort
● myorg/poly-ms-products
queued · setup
● myorg/poly-ms-orders
queued · setup
● myorg/poly-ms-gateway
queued · setup

Work across repositories at once

Agents edit several repos in parallel and open coordinated PRs, so the changes land together instead of breaking each other.

Claude Code v2.1
Opus 4.8 · working across 3 repos
❯█
✓Committed & pushed to 3 repos
impl-cancel-order-568d33ca → main
Pull requests0 across 0 repos
myorg/poly-ms-frontend · feat: add order cancellation action
impl-cancel-order-568d33ca → main · just now
CI · In progress
myorg/poly-ms-backend · feat: add order cancellation API
impl-cancel-order-568d33ca → main · just now
CI · In progress
myorg/poly-ms-design-system · feat: add cancel-order dialog
impl-cancel-order-568d33ca → main · just now
CI · In progress

Session durability

Sessions are captured, stored, and indexed for search, so agents can resume them or pull them in as context instead of starting cold.

Claude Code v2.1
Opus 4.8 · resuming a stored session
❯█

Multiplayer and collaboration

Shared, resumable sessions let you build on a coworker's, turning individual runs into org-wide memory.

Distilled memory

The meta-harness can steer processes like "dreaming": offline passes that consolidate finished session runs into a shared pool of general knowledge. Future sessions connect to it and start with what earlier ones learned instead of from a cold context.

Organizational rules and policies

Policy lives at the meta-harness layer, checking prompts, tools, and actions against your organization's rules in code.

Claude Code · wrapped by acme meta-harness
every action checked against org policy
›█
❯█
⬡policy hook
acme-org↻
awaiting action…
enforced in code · not prompts

Feedback loops

Wrap act, verify, and correct loops around your harness, from a single goal-driven run to scheduled and event-driven loops.

tries to stoptries to stopcondition not met, sent back to workcondition not met, sent back to work
Harness works
on the task
Meta-harness
Checks the condition
each time it tries to stop
Loop ends
goal met, or the turn limit is reached

The landscape

A handful of meta-harnesses are taking shape across the industry, each approaching the problem from a different starting point.

By Nx

Polygraph

Polygraph focuses on cross-repo coordination and memory. It gives your agents a unified dependency graph across your organization without moving any code, durable sessions anyone can resume, and institutional memory that carries from one session to the next. It runs behind whatever harness you use, so that shared context follows your agents no matter which one drives them.

Explore Polygraph

By Databricks

ImageOmnigent

Omnigent focuses on swapping harnesses and governing them. It puts Claude Code, Codex, Cursor, OpenCode, and Pi behind one interface you change in a single line, then enforces guardrails in code, not prompts: spend caps, approval gates, and OS-level sandboxing. Sessions run in the cloud and are shareable and co-drivable in real time.

Explore Omnigent

By SuperagenticAI

metaharness

metaharness focuses on optimizing a single harness rather than orchestrating many. An outer loop asks a coding agent to improve the scaffolding around a model, instruction files, setup flows, validation and test scripts, routing logic, then scores each proposal and keeps the best. Every candidate is snapshotted to disk, so the search stays reviewable. It's an open take on the Stanford Meta-Harness paper.

Explore metaharness

Resources