Omnigent Introduces Harness Engineering at the Meta Level So Your AI Agents Finally Work as a Team

Every engineering team that has moved seriously into AI-assisted development eventually hits the same structural problem. It does not arrive as a single dramatic failure. It accumulates gradually: separate sessions for Claude Code and Codex with no shared context between them, guardrails configured in one tool that do not follow when a developer switches to another, cost surprises that only become visible when the monthly invoice arrives, and no way for a teammate to watch an agent session live without being physically at the same machine. Each of these problems is manageable in isolation. Together, they describe a gap between what individual AI agent harnesses provide and what teams working with multiple agents across complex workflows actually need.

Omnigent is a meta-harness: a software layer that wraps above existing AI coding agents including Claude Code, OpenAI’s Codex, and Pi, and gives teams a single place to compose, govern, and collaborate on those agents without changing what is underneath them. Released under the Apache 2.0 license by Databricks on June 16, 2026, the project sits one level above existing harnesses and makes them interoperable. It is currently in alpha, actively developed, and accompanied by the kind of candor about rough edges that distinguishes a genuinely useful early release from a polished demo.

The vocabulary that makes this legible

Understanding what Omnigent does requires being clear about the term harness. A harness is the scaffolding that wraps a foundation model and turns it into an agent capable of reading files, running terminal commands, and calling external tools. Claude Code, Codex, and Pi are all harnesses in this sense, the tools engineers already have open.

However each agent harness calls into its LLM internally, the interface it presents to the outside world is the same: messages and files go in, text streams and tool calls come out. Omnigent standardizes that interface so harnesses become swappable. A meta-harness is therefore not a replacement for any of these tools. It is the layer that treats each of them as an interchangeable component behind a common interface, and adds the capabilities that become necessary once more than one harness is in use simultaneously.

The best results no longer come from a single model in a single harness: Harvey beat a frontier model on quality and cost by giving an open-source worker model a frontier advisor it can call, Anthropic built its research product as a lead agent orchestrating parallel subagents, and Databricks’ own Genie uses different LLMs for planning, search, and code generation. Engineers are changing how they work too: instead of prompting one agent at a time, they design loops that drive whole teams of agents. These patterns span multiple harnesses, models, and people, but each harness only understands its own sessions. Omnigent is built to be the layer that understands all of them simultaneously.

A real cost and control problem driving the design

The motivation behind Omnigent is grounded in operational reality rather than architectural preference. Databricks adopted coding agents early across its 5,000 plus member engineering team and built thousands of agents for customers. That experience convinced them that the frontier of agent engineering is moving up a level.

Cost spirals have become endemic: Uber burned through its entire 2026 AI budget in four months as roughly 5,000 engineers ran Claude Code sessions with no spending caps, with individual heavy users reaching $500 to $2,000 per month. This is not an unusual story. It is the natural result of giving a large engineering team access to powerful agent tools without any infrastructure level enforcement of spending limits. A guardrail configured inside Claude Code does not follow when that same engineer opens Codex. A policy set through prompting in one session does not persist across the session boundary. When the spend limit is enforced at the invoice rather than at the meta-harness, the damage is already done.

The same survey found that 82% of executives feel confident their existing policies protect against unauthorized agent actions, while field data shows more than half of deployed agents operate without consistent security oversight or logging. That gap between executive confidence and operational reality is precisely where infrastructure-layer enforcement becomes the defensible answer.

The two pieces of the architecture

The Omnigent architecture has two parts. A runner wraps any agent in a sandboxed session with a uniform API. A server provides policies and sharing. The server exposes every session over the terminal, the app, and web APIs.

The runner is what makes harnesses interchangeable. Because every harness, whether a terminal-based coding agent like Claude Code or an SDK-based one like the OpenAI Agents framework, presents the same fundamental interface when viewed from above, the runner can wrap any of them in a uniform session container without modifying anything inside the harness itself. Switching from Claude Code to Codex, or running both simultaneously on different subtasks, requires a one-line change to a YAML configuration rather than a rewrite of the integration logic.

The server provides policies, session management, and sharing functions. Sessions can be used in parallel via the terminal, local web UI defaulting to http://localhost:6767, a macOS desktop app, mobile browsers, and APIs. This means the same session that starts in a developer’s terminal continues in a browser tab, is accessible on a phone, and can be shared with a teammate by URL, all without state duplication or manual synchronization.

Installing and getting started

The fastest installation path uses a single shell command that handles the full setup including dependencies:

curl -fsSL https://raw.githubusercontent.com/omnigent-ai/omnigent/main/scripts/install_oss.sh | sh

After installation, the CLI is available under two names, omnigent and the shorter omni, which are interchangeable. Starting a session picks up model credentials already present in the environment and offers one as the default:

omnigent

Specific harnesses can be launched directly:

omnigent claude       # Claude Code in a session the team can join
omnigent codex        # Codex
omnigent run path/to/agent.yaml   # a custom agent defined in YAML

Two example agents ship with the repository and make strong starting points for understanding what multi-agent orchestration looks like in practice:

omnigent run examples/polly/
omnigent run examples/debby/

The same example agents can be run on different harnesses with a single flag, without modifying the agent definition itself:

omnigent run examples/polly/ --harness pi
omnigent run examples/debby/ --harness openai-agents
omnigent run examples/polly/ --harness cursor

Two example agents that demonstrate the architecture

The project ships two example agents that illustrate different aspects of multi-agent orchestration, and they are worth understanding in some detail because they represent real patterns rather than toy demonstrations.

Polly is a multi-agent coding orchestrator who writes no code herself. She is the tech lead: she plans, delegates the work to coding sub-agents, Claude Code, Codex, or Pi, in parallel git worktrees, then routes each diff to a reviewer from a different vendor than the one that wrote it. The developer merges. This is a meaningful workflow pattern: the agent that writes code is not the same agent that reviews it, which avoids the well documented problem of a model being systematically blind to its own characteristic failure modes. Cross-vendor review, where a Claude Code implementation is reviewed by a Codex instance, provides a form of independent checking that a single model reviewing its own output cannot offer.

Polly orchestrates parallel subagents. Claude Code, Codex, and Pi run in parallel, streaming their steps live. A session cost meter ticks up as they work, and policy toggles show the control layer in action: the cost budget pauses the run at $3.00 for approval, and a contextual policy halts a git push that follows an npm install until the developer allows it. Once the sub-agents finish, each diff is cross-reviewed by a different vendor than the one that wrote it, then marked ready to merge.

The second example agent is Debby, a brainstorming partner with two simultaneous voices. Every question asked goes to both a Claude head and a GPT head, and the two answers are laid out side by side. Invoking the /debate command within the session causes the two heads to critique each other’s responses for several rounds before converging toward a synthesized position. This pattern is useful precisely because it externalizes the comparison that a developer would otherwise have to do manually by running the same prompt in two separate browser tabs and reading both responses.

Stateful, contextual governance that cannot be bypassed by prompting

Unlike simple allow/deny mechanisms, Omnigent’s policies dynamically track session state and make context-dependent decisions. This is the design characteristic that distinguishes governance at the meta-harness layer from governance through system prompts, which is how most individual agent tools currently implement their safety controls.

A policy defined in a system prompt has two fundamental weaknesses. First, it can be overridden or forgotten by the model in the course of a long session. Second, it only applies within the harness where it was set. A cost limit configured as a Claude Code instruction does nothing when the same developer switches to Codex. A guardrail set in Omnigent applies to both because it lives above them.

The built-in policy system allows defining spend caps, action approvals, and tool access limits at three levels: server-wide for all users and all agents, per agent for a specific harness or custom agent, and per session for a specific conversation. Stricter rules at lower levels take precedence. A policy that requires approval before any shell command is executed can be applied across all sessions by default, while a specific session might relax it for an agent working in a disposable sandbox where shell access is lower risk.

A representative policy configuration in YAML shows how these controls are expressed:

policies:
  approve_shell:
    type: function
    handler: omnigent.policies.builtins.safety.ask_on_os_tools
  cap_calls:
    type: function
    handler: omnigent.policies.builtins.safety.max_tool_calls_per_session
    factory_params:
      limit: 50
  budget:
    type: function
    handler: omnigent.policies.builtins.cost.cost_budget
    factory_params:
      max_cost_usd: 5.00
      ask_thresholds_usd: [3.00]

The budget policy here enforces a hard spending cap at five dollars per session while issuing a soft warning at three dollars, giving the developer an opportunity to review what the agent is doing before the hard limit is reached. The shell approval policy pauses execution and requires explicit human confirmation before any operating system command runs. The call cap prevents a runaway agent loop from making more than fifty tool calls in a single session regardless of how it was instructed.

These policies track agent actions and enforce guardrails at the meta-harness layer, not through prompts. One example pauses an agent after every $100 it spends. Another requires human approval to git push once the agent installs a new npm package. This second example is a particularly useful illustration of stateful, contextual enforcement: the policy is not simply “require approval for git push.” It is “require approval for git push if the current session has recently installed a package from npm.” The condition is not a static permission rule but a dynamic check against session history, which is the kind of nuanced, situation-aware control that prompt-based guardrails cannot provide.

Real-time collaboration that replaces the screenshot-and-paste workflow

For engineering teams, one of the most practically impactful capabilities in Omnigent is the ability to share a live agent session with teammates in real time. The current alternative in most teams involves copying terminal output into Slack, sharing screenshots of what the agent is doing, or trying to describe its progress in words. None of these substitutes effectively for actually seeing the agent’s live session, including the full message history, any files it has created or modified, and the ability to send a message directly into the running conversation.

Collaboration means sharing live agent sessions by URL. Teammates watch the agent work and chat with it in real time. They can comment on files, co-drive the session, or fork the conversation.

The co-driving capability is particularly valuable for situations where a domain expert needs to intervene in the middle of an investigation without taking over the entire session. A teammate can attach to a running session and send messages that execute on the host machine, providing guidance or course correction at the exact point where their expertise is needed. After that intervention, the session continues under normal operation without needing to be restarted or reconstructed.

Forking allows a different kind of collaboration: a developer can clone a conversation at any point and continue it independently on their own machine, which is useful when a session has reached a branch point where two different approaches need to be explored without one overwriting the other.

Setting up multi-user access for a team requires enabling authentication on the server and distributing invite links, with no email server required:

OMNIGENT_AUTH_ENABLED=1 omnigent server start

Team members receive a single-use invite link, set a password, and immediately have access to the shared environment. For organizations with existing identity infrastructure, OIDC integration is available to allow login through Google, GitHub, Okta, or Microsoft accounts.

Writing custom agents in YAML

One of the clearest examples of Omnigent’s design philosophy is how simple it is to define a custom agent. An agent definition specifies a system prompt, a harness, and a set of tools, which can include local Python functions and other agents as sub-agents:

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 and summarize it.
    tools:
      word_count: inherit

Running this agent requires one command:

omnigent run path/to/my_agent.yaml

Changing the harness from claude-sdk to codex or pi is a single line change in the YAML file. The agent’s behavior, its prompt, its tools, and its sub-agents all remain the same. Only the underlying model and execution environment change. This is the practical payoff of the abstraction: the agent definition captures what the agent does, and the harness controls how it does it, and these two concerns are cleanly separated.

For teams that want to avoid writing YAML from scratch, agents can build agents: describing the agent you want in any Omnigent chat causes it to author the YAML file for you.

Cloud sandboxes and sessions that follow the developer

Sessions follow the developer: start in the terminal, continue in the browser, pick it up on the phone. Messages, sub-agents, terminals, and files stay in sync. This continuity is one of the less visible but more practically significant aspects of the architecture. The current experience with individual agent harnesses is tied to a specific machine and a specific terminal session. If that session ends or the machine needs to restart, the session is gone. Starting work in the terminal and reviewing results on a phone while away from the desk requires a fundamentally different session model.

Omnigent provides that model through its server architecture. Deploying the server on a VPS or home server requires a single Docker Compose command, and the session then becomes reachable from any device on any network. The server can also provision cloud sandboxes, using Modal, Daytona, or Islo, for sessions that need disposable compute without keeping a laptop online. A session that starts a long running agent job and then gets disconnected does not lose the work: the agent continues in the cloud sandbox, and the developer reconnects to see the results when convenient.

Vendor neutrality and what it means for lock-in

Omnigent does not come with its own LLMs but works with existing credentials, from direct API keys and cloud gateways to on-premises clusters. For companies currently heavily dependent on a single LLM provider, this reduces lock-in: sessions, policies, and skills are tied to the meta-harness layer, not to a specific model. Investments in governance and security policies are retained when switching providers.

This is a meaningful structural advantage over tools that couple governance logic to a specific model or harness. A policy that requires approval before shell commands, or a spending cap, or a tool access restriction, does not need to be reconfigured when the underlying model changes. The policy sits at the meta-harness layer, above the model, and applies regardless of which harness is running at any given time.

The project supports API keys, subscription-based access through the official Claude and Codex CLIs, and any OpenAI or Anthropic compatible gateway including OpenRouter, LiteLLM, Ollama, vLLM, and Azure OpenAI. For teams already running their own model infrastructure, this means Omnigent can sit above their existing setup without requiring any change to how models are served.

What comes next

Omnigent is in alpha, and the project documentation is candid about this status. The deterministic core of the session and policy system is the most stable surface. The newer systems including the full fleet orchestration, backend abstraction, and token economy ledger are recently built and not yet fully tested in production environments. The project asks users to pin a specific version if stability is critical and to report what breaks.

The trajectory suggested by the current architecture points toward a world where the meta-harness layer becomes the primary interface through which engineering teams interact with AI agents of all kinds, rather than each agent being a separate tool with its own session management, its own governance, and its own collaboration story. Databricks believes people will soon work with agents through this new layer, the meta-harness. That is why they are open sourcing Omnigent under Apache 2.0.

Conclusion

Omnigent addresses the organizational and technical reality that multi-agent workflows have already arrived for serious engineering teams, but the tools to manage them at scale have not kept pace. By building a common abstraction layer above existing harnesses rather than replacing them, enforcing stateful and contextual governance policies at the infrastructure level rather than through prompts, and providing real-time collaboration capabilities that treat the agent session as the primary shared workspace, Omnigent gives teams the control plane that the current generation of individual agent tools cannot provide on their own.

Its open source release under Apache 2.0 and its explicit commitment to vendor neutrality mean that investment in governance and collaboration at the meta-harness layer is not tied to any single model provider, which is precisely the kind of durable infrastructure foundation that teams managing multiple agents across complex workflows need to build on.

The repository is available at: https://github.com/omnigent-ai/omnigent