For two years the answer to "which coding agent should we standardize on?" has been a moving target. You picked Claude Code, then Codex shipped something you wanted, then Cursor's harness got better at a workflow you cared about, and each switch meant rebuilding the plumbing — the sandboxing, the credential wiring, the policy checks — around a new tool that spoke its own dialect. On July 6, 2026, Databricks open-sourced its answer to that treadmill: Omnigent, a "meta-harness" that sits one level above the coding agents and gives them all a single interface. It's Apache 2.0, mostly Python, and crossed 6.4k GitHub stars within days.

The word doing the work is meta-harness. A harness is the loop around a model that makes it an agent — it manages context, runs tools, applies the system prompt, and drives the edit-run-observe cycle. Claude Code, Codex, Cursor, OpenCode, Hermes, and Pi are all harnesses. Omnigent doesn't compete with them; it treats each as a swappable executor. This is the same move the industry already made from framework to harness — pushing the abstraction up a level as the layer below stabilized. Omnigent pushes it up once more.

The mechanical pitch: one line of YAML#

In Omnigent an agent is a declarative object, not a codebase. You write a YAML file with a prompt, an executor (the harness that runs it), and a set of tools:

name: my_agent
prompt: You are a helpful data analyst.
executor:
  harness: claude-sdk
tools:
  word_count:
    type: function
    callable: mypackage.mymodule.word_count
  researcher:
    type: agent
    prompt: Search for relevant information.

Changing which harness — or which model — runs that agent is a one-line edit to the executor block. The orchestration around it doesn't move. Policies apply at the meta-level, "consistently across all connected harnesses and models, regardless of whether a team is currently using Claude Code, Codex, or its own runtime agent," as Databricks puts it. Sandboxing spans nine backends (Modal, Daytona, Islo, E2B, CoreWeave, Kubernetes, OpenShell, Boxlite, Databricks), so the same definition runs on a laptop or in a cloud sandbox. Models can come from first-party keys, Claude Pro/Max or ChatGPT subscriptions, OpenAI-compatible gateways like OpenRouter and LiteLLM, or a Databricks workspace. Sessions are multiplayer: you can invite someone to watch an agent's workspace, comment on its files, or send it commands.

All of that is competent plumbing. None of it is the interesting part.

The interesting bet: who reviews the code#

Omnigent ships an orchestrator agent named Polly who writes no code herself. She plans, delegates the work to coding sub-agents in parallel git worktrees, then does one thing that quietly reframes the whole exercise: she routes each diff to a reviewer from a different vendor than the one that wrote it. Claude Code writes; a Codex- or Pi-backed reviewer reads. Then they swap on the next task.

Model heterogeneity stops being a procurement hedge and becomes a correctness control.

Think about what that assumes. If every model shared the same failure modes, cross-vendor review would be theater — you'd just get two agents making the same mistake and nodding at each other. Polly's design is a wager that they don't fully share failure modes: that the systematic blind spots baked into one lab's training and harness are least likely to be reproduced by a competitor's. Self-review by the same agent, by contrast, has a structural ceiling — a model is worst at catching exactly the errors its own priors make invisible. Routing the diff across the vendor line is the cheapest available way to break that correlation. It is the multi-agent-review argument, but with the diversity axis moved from prompt to provider.

That's the one genuinely non-obvious idea in Omnigent, and it's the one most likely to outlive the product. You can adopt cross-vendor review without adopting the meta-harness at all.

Where the skepticism belongs#

The thesis underneath Databricks' move is that both the model and the harness commoditize, so the durable, lock-in-resistant layer is one step up — governance, portability, and heterogeneous review. That's a coherent bet, and a self-interested one: a meta-harness that runs anywhere sells more Databricks compute than a harness that competes with Claude Code head-on.

But every abstraction over incompatible tools pays the same tax, and it's worth naming. A meta-harness is only as good as the fidelity of its lowest common denominator. Claude Code's real value isn't "it runs a loop" — it's the specific, hard-won behaviors of its loop: how it compacts context, when it fans out subagents, the texture of its tool-use. An interface broad enough to also drive Codex and Cursor risks exposing the intersection of what they share and hiding what makes any one of them worth choosing. Omnigent's answer — YAML that can pass through harness-specific config — mitigates this, but the tension is permanent. The more faithfully it exposes each harness, the leakier and less uniform the abstraction; the more uniform, the more it flattens.

Which is the honest way to read the launch. Omnigent isn't a claim that the harness wars are over. It's a bet on where the value pools after they cool — in the orchestration, the policy, and the review, rather than in any single agent's loop. Databricks has decided that layer is worth owning in the open. Given how many teams are still rewriting their plumbing for the third time this year, it's a bet with an obvious constituency. Whether the abstraction holds its fidelity under real workloads is the thing to watch — and the harness-engineering discipline that made the individual agents good is exactly what a meta-harness has to preserve to be worth the indirection.