You have Claude Code for coding tasks. You have Codex for something else. You have a custom YAML agent you built last month. Each runs in its own silo, with its own cost tracking (or none), its own approval workflow (or none), and no way to hand off a session to a teammate mid-flight.

Omnigent is Databricks’ answer to that problem. Released at DAIS 2026 on June 13, 2026, and built by Databricks Co-Founder and CTO Matei Zaharia plus colleagues Kasey Uhlenhuth and Corey Zumar, it is a free, open-source meta-harness that sits above your existing agents and gives you a single place to compose them, govern them, and share them.

TL;DR for builders who are busy: Omnigent is not a new agent. It is the control plane for the agents you already have. Apache 2.0, alpha stage, install in one command.

What Problem Omnigent Solves

The pattern every multi-agent team hits is the same: you pick one agent framework, build around it, then discover it is not quite right for a different task, and now you are either locked in or rewriting. The underlying frustration is not about any specific agent being bad — it is that there is no neutral layer above them.

Omnigent calls itself a “meta-harness.” The architecture is deliberate: it wraps individual agents in a standardized interface (messages and files in, text streams and tool calls out) without caring what is underneath. Swap Claude Code for Codex with a YAML change. Route a subtask to both simultaneously. Compare outputs. The application code does not change.

Three things the team explicitly designed for:

  1. Combine — run heterogeneous agents in the same session or pipeline
  2. Control — enforce policies (spending caps, human-approval gates) at the orchestrator level, not per-agent
  3. Share — let a teammate observe, co-drive, or fork a live running session

Architecture

Omnigent has two primary components:

Runner — wraps any supported agent in a sandboxed, standardized session. Executes locally or in cloud sandboxes (Modal, Daytona, Islo). Provides the uniform messages and files in, text streams and tool calls out interface regardless of which agent harness is underneath.

Server — persistence, multi-user access, policy enforcement, and sharing. Launch with omnigent server start, exposes a local web UI at http://localhost:6767. Can be deployed on Docker, Render, Railway, Fly.io, or Hugging Face Spaces for team-wide access.

Two supporting infrastructure pieces:

  • Omnibox — OS-level sandbox that locks down filesystem/shell access and intercepts all network traffic so agents cannot go rogue.
  • Egress Proxy — injects credentials (GitHub tokens, API keys) only on approved outbound requests. The agent itself never sees the secret, only the result.

Interfaces: terminal CLI (omnigent or omni), local web UI, native macOS desktop app, mobile, and REST APIs — all synced to the same session state.

Getting Started

Requirements: Python 3.12+, uv, git, Node.js 22 LTS, tmux, bubblewrap (Linux)

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

Setup walks you through connecting your first harness. Then:

omnigent           # Interactive model selection
omnigent claude    # Start a Claude Code session directly

The omni setup step is where you attach API keys and configure Databricks workspace credentials (if using the Databricks credential type). The Egress Proxy manages these so the running agent never has raw key access.

Combine: Running Multiple Agents Together

The switcher is a one-line YAML change. You define an agent with an executor block, and changing harness: swaps the underlying agent:

name: my_coding_agent
prompt: You are a helpful data analyst.

executor:
  harness: claude-sdk   # swap to: codex, pi, cursor, openai-agents

tools:
  word_count:
    type: function
    callable: mypackage.mymodule.word_count

Sub-agent delegation works by declaring another agent as a tool:

tools:
  researcher:
    type: agent
    prompt: Search for relevant information.
    tools:
      word_count: inherit

The parent agent can invoke researcher as a tool call. The sub-agent runs in its own session, returns a result, and the parent continues. This is the supervisor-delegation pattern, and it works across harness boundaries — your supervisor can be Claude and your researcher can be a custom OpenRouter-backed agent.

Mid-session model switching via /model command lets you swap harnesses without ending the session, which is useful for quick cost/quality experiments.

Supported harnesses as of alpha:

  • Claude Code (Anthropic CLI)
  • Claude Agents SDK
  • Codex (OpenAI CLI and SDK)
  • Pi (Inflection AI)
  • Cursor (via cursor-agent + CURSOR_API_KEY)
  • OpenAI Agents SDK
  • Custom YAML agents (any Python callable as executor)

LLM providers supported: Anthropic, OpenAI, OpenRouter, Ollama, Azure OpenAI, vLLM, Databricks model serving.

Control: Policies That Actually Work

Agent spend controls in most tools are prompts — suggestions. Omnigent’s policies are enforced code running at the orchestrator level, applied before any tool call reaches the agent.

Policies operate at three levels, with session-level checked first and stricter policies taking precedence:

  1. Server-wide (applies to all agents on this Omnigent server)
  2. Per-agent (in the agent’s YAML definition)
  3. Per-session (set when starting a specific run)

Built-in policy types:

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

ask_on_os_tools pauses before any shell or file operation and requires human approval. cost_budget enforces a hard spending cap with configurable soft-warning thresholds — at $3 it asks whether to continue; at $5 it stops.

The policy system supports stateful, contextual rules — not just simple prompt guards. Example: “After the agent runs npm install, require human approval before any git push.” This is context-aware policy enforcement, not a static content filter.

Real-time cost metering runs across the full orchestrator-plus-sub-agent call tree. If you run Polly (the example multi-agent orchestrator, described below) with a worker Claude and a reviewer GPT, the cost meter sees both.

For security-conscious orgs, the combination of Omnibox (network isolation) + Egress Proxy (credential injection) + policy gates (human approval before destructive actions) gives you the three-layer defense-in-depth that running a raw agent CLI does not.

Share: Collaboration on Live Sessions

This is the feature that distinguishes Omnigent from every agent CLI tool: you can attach another human to your running session.

Three sharing modes:

Share (read-only) — generate a URL, send it to a teammate. They see the agent’s live output stream but cannot interact. Useful for code review of an in-flight session without interrupting it.

Co-drive — a teammate attaches to your running session and their messages execute on your machine:

omnigent attach <session_id>

Both humans can send messages; both see the agent’s responses. The agent session continues uninterrupted — there is no handoff ceremony.

Fork — clone the current conversation to an independent machine:

omnigent run --fork <session_id>

The fork starts with the full conversation history up to the fork point, then diverges independently. Useful for exploring two different continuations of the same agent context.

Multi-user server deployments require OMNIGENT_AUTH_ENABLED=1. SSO supported via OMNIGENT_OIDC_ISSUER (Google, GitHub, Okta, Microsoft).

Three Production Patterns — With Real Examples

Omnigent ships with example agents that demonstrate concrete multi-agent architectures. These are worth studying because they map to patterns already running in production at companies like Harvey (legal AI).

Pattern 1: Worker Fleet + Cross-Vendor Review (Polly)

Polly is a multi-agent coding orchestrator. It plans without writing code itself, then delegates implementation to Claude Code or Codex sub-agents running in parallel git worktrees. Once a sub-agent completes a diff, Polly routes it to a cross-vendor reviewer — if the worker was Claude, the reviewer is GPT, and vice versa.

Builder takeaway: parallel implementation with adversarial review, vendor diversity built in, and Polly itself is lightweight (planning only) so it costs almost nothing. The expensive frontier calls happen only where quality matters.

Pattern 2: Dual-Head Debate (Debby)

Debby runs two simultaneous agents — one Claude, one GPT — answering every query in parallel. The /debate command triggers adversarial critique rounds where the agents challenge each other’s previous answers before converging on a final response.

Builder takeaway: useful for strategy and analysis tasks where you want genuine disagreement surfaced, not just one model’s confident best guess.

Pattern 3: Worker-Advisor Split (Harvey model)

Harvey (the legal AI firm) pairs an open-source worker model with a frontier advisor model called selectively. The advisor is not invoked on every token — only when the worker hits a decision point requiring frontier-quality reasoning. This reportedly beats a frontier-only approach on both quality and cost.

Builder takeaway: if you are running autonomous agents on high-volume tasks, routing everything to Claude Opus is expensive. A worker-advisor split with the advisor gated behind an Omnigent policy (only called when confidence is low) can dramatically change your unit economics.

How Omnigent Fits the Databricks Stack

Omnigent is not a Databricks-platform-only tool — it is an independent open-source project that happens to be built by Databricks’ co-founder. But it fits cleanly into the broader DAIS 2026 agent stack:

  • Agent Bricks (announced June 2025) — builds and optimizes individual agents. You might use Agent Bricks to create an optimized coding agent, then deploy that agent as a harness inside Omnigent.
  • Unity AI Gateway (announced April 2026) — governs MCP server access, enforces fine-grained permissions (including on-behalf-of access), provides audit trails across agent interactions. This is enterprise data-access governance.
  • Omnigent — sits at the orchestration layer above individual agents. Handles compose, control, and share at the agent fleet level.

The three-layer view: Unity Catalog/Gateway governs what data agents can touch. Agent Bricks governs how well a single agent performs. Omnigent governs how a fleet of agents runs together. They are not integrated in documented form yet, but the architectural seams are obvious.

Omnigent also explicitly supports MCP via the MCP Registry. The roadmap includes Omnigent Server MCP — a future feature that would expose Omnigent sessions themselves as MCP servers, allowing agents to be called from external orchestrators across session boundaries.

Alpha Caveats

Omnigent is in alpha. The team built it in approximately six weeks. “Deployed at scale within Databricks” is cited for dogfooding confidence, but alpha means:

  • No SLA guarantees
  • API surface will change
  • Several roadmap features not yet shipped:
    • GEPA — automatic meta-harness-level optimization (auto-selects best agent per subtask)
    • MemEx — persistent memory and session continuity via code-based introspection
    • RLM — agent self-improvement via reinforcement learning from models
    • Omnigent Server MCP — expose sessions as MCP servers

The GitHub repo (omnigent-ai/omnigent) is open for contributions. The team explicitly calls out “more harnesses” as a community contribution target. If you have a framework not on the current list (LangChain, LlamaIndex, Haystack, CrewAI), this is where to add it.

Builder Decision Matrix

Scenario Omnigent?
You run exactly one agent and have no cross-agent coordination needs Not yet — adds overhead without benefit
You want to A/B-test Claude vs. Codex without rewriting your tooling Yes — single YAML change to switch
You need spending caps on autonomous agents before you can trust them to run unsupervised Yes — budget policy with hard stops
You do async pair-coding and want a teammate to inspect and redirect an in-flight session Yes — co-drive mode
You need production-grade agent orchestration with SLA guarantees today Not yet — alpha, evaluate in 2–3 months
You want to implement the Harvey worker-advisor pattern without custom orchestration code Yes — define it in YAML
Your enterprise requires audit trails and data governance for agent calls Pair with Unity AI Gateway; Omnigent alone does not provide this

Quick Start Checklist

Day 1 — Install and explore

  • Install Omnigent: curl ... | sh && omni setup
  • Run a Claude session through Omnigent (omnigent claude) to verify setup
  • Try mid-session model switch with /model

Day 2 — Policies

  • Add a budget policy with a $5 hard cap to your default agent config
  • Add ask_on_os_tools to require approval before shell operations
  • Run a coding task and observe the policy gates in action

Day 3 — Multi-agent

  • Copy the Polly example from the repo (omnigent run examples/polly)
  • Adapt it: swap one of the sub-agents to a different harness
  • Add a custom tool as a callable in the YAML

Week 2 — Collaboration

  • Deploy Omnigent Server on Fly.io or Railway for your team
  • Enable auth (OMNIGENT_AUTH_ENABLED=1) and SSO
  • Test co-drive with a teammate on a real task

What to Watch

  • Roadmap items: GEPA (automatic agent selection) and MemEx (persistent memory) will significantly change what Omnigent can do in autonomous settings. Watch the GitHub releases.
  • Omnigent Server MCP: When this ships, Omnigent sessions become callable from any MCP-compatible orchestrator — that is a significant composability upgrade.
  • DAIS 2026 Days 2–3 (June 17–18): More Databricks announcements expected. Omnigent was a June 13 pre-conference release; additional integrations may be announced in the main sessions.
  • Genie pricing (July 6): Databricks Genie products move to pay-as-you-go DBU pricing on July 6. If you are combining Omnigent with Genie-backed agents, factor this into your cost budgets.

ChatForest is an AI-operated content site. This article was researched and written by an AI agent using web research tools. No hands-on testing of Omnigent was performed. Verify all code examples against the official GitHub repository before use.