Open Source Project #180: Omnigent — Databricks' Meta-Harness for Unified Control of Claude Code, Codex, and Cursor

AI coding agent meta-orchestration framework open-sourced by Databricks co-founder Matei Zaharia. Sits above Claude Code, Codex, Cursor and other tools to provide policy governance (token budgets, tool access limits), cloud sandboxing (Modal/E2B/Daytona/Kubernetes), real-time collaboration (session sharing/co-driving/forking), MLflow observability, and YAML-defined multi-agent orchestration. The Kubernetes analogy for AI agents. 8.1k Stars, Apache 2.0, Alpha stage.

·8 min read·AI Tools
open-sourceAI-agentmulti-agentorchestrationmeta-harnessClaude-CodeCodexCursorDatabrickspolicy-governancesandboxingcollaboration

Introduction

"You use Claude Code for planning and Codex for fast execution. But you're manually copying output between them."

This is article #180 in the "One Open Source Project a Day" series. Today's project is Omnigent — an AI agent meta-orchestration framework open-sourced by Databricks co-founder Matei Zaharia in June 2026. 8,100 Stars.

Omnigent's position is specific: it's not another AI coding agent. It's the layer that sits above existing agents — a meta-harness. The analogy Databricks makes: Kubernetes doesn't replace servers, it adds orchestration, policy, and observability on top of them. Omnigent doesn't replace Claude Code; it makes Claude Code, Codex, Cursor, and Pi manageable components of one unified system instead of a pile of independent tools.

If you've used multiple AI coding tools, you've probably hit this: each tool has its own interface, its own API key management, its own context and session, and configuring team-level permissions and budgets for each separately is its own overhead. Omnigent targets exactly that layer.

8,100 Stars. 1,200 Forks. Apache 2.0. Alpha stage.

What You'll Learn

  • What a "meta-harness" is and how Omnigent relates to agent frameworks
  • Policy Governance: three-tier policy stacking for token budgets and tool access
  • Cloud sandboxes: local OS isolation (bwrap/seatbelt) plus cloud execution (Modal/E2B/Daytona)
  • Multi-agent orchestration: YAML sub-agents, parallel worktrees, cross-vendor reviewers
  • Real-time collaboration: session sharing, co-driving, forking
  • MLflow Tracing integration: unified observability across harnesses

Prerequisites

  • Experience with at least one of Claude Code, Codex, or Cursor
  • Basic understanding of AI coding agents (context, tool calls, system prompts)
  • Familiarity with YAML configuration format

Background: The Fragmented Agent Landscape

The 2026 AI coding tool landscape: Claude Code with claude-sdk and claude-native modes, Codex with its own CLI, Cursor embedded in the IDE, OpenCode, Hermes, Pi — each with distinct capabilities, each a separate island.

Matei Zaharia (inventor of Apache Spark, Databricks co-founder) ran into this while driving AI agent adoption across Databricks' 5,000+ engineer organization:

  • Different agents have different strengths; one task often needs multiple agents working together
  • Agent output requires manual transfer between tools
  • Team-level governance has no infrastructure (who accesses what tools? what's the token budget?)
  • No unified observability — no visibility into which agent spent what, or what decisions it made

Omnigent distills that deployment experience into a framework that tackles the whole problem.

Core Architecture: The Meta-Harness Layer

Omnigent's architecture has three layers:

┌─────────────────────────────────────────┐
│           Omnigent Server               │
│   Policy governance / collaboration /   │
│   observability / API                   │
├─────────────────────────────────────────┤
│           Omnigent Runner               │
│   Sandboxing / unified API /            │
│   session management                    │
├──────────┬──────────┬───────────────────┤
│ claude-sdk│  codex  │  cursor / pi / …  │
│ (harness) │(harness) │   (harnesses)    │
└──────────┴──────────┴───────────────────┘
  • Harness (execution layer): the existing agent tools — claude-sdk, claude-native, codex, codex-native, cursor, hermes, opencode, pi, openai-agents
  • Runner (runtime layer): wraps any harness in a sandboxed session with a uniform API
  • Server (service layer): policy enforcement, session sharing, cross-device sync

The Kubernetes analogy holds: Kubernetes doesn't replace servers — it adds orchestration, elasticity, and policy above them. Omnigent doesn't replace Claude Code — it adds unified control above it.

Policy Governance

Policies are one of Omnigent's core differentiators. Three tiers stack:

Server-wide (shared across all agents)
    ↓
Agent-level (defined per agent)
    ↓
Session-level (dynamic adjustments per task)

Cost Control

# Token budget in the agent definition
policies:
  cost:
    max_tokens_per_session: 50000
    max_tokens_per_turn: 5000
    alert_at: 40000   # alert when approaching limit
    pause_at: 50000   # pause and wait for human approval

Agents that exceed budget pause automatically, waiting for a human to decide whether to continue. This solves the common problem of agents quietly burning large token budgets on complex tasks with no warning.

Tool Access Control

Policies support stateful conditional restrictions — not just static allow/block lists:

policies:
  tools:
    # After downloading an npm package, require approval before git push
    - condition: "after:tool:npm_install"
      require_approval: ["git_push"]
    
    # Never allow the agent to read .env files directly
    - block: ["read_file:.env*"]
    
    # Agent can call APIs, but credentials injected via proxy — agent never sees them
    - network:
        egress_proxy: "https://my-credential-proxy"
        direct_credential_access: false

Stateful rules like "require git push approval after npm install" were effectively impossible with per-tool agent configurations.

Cloud Sandboxes

Omnigent supports two sandboxing approaches:

Local OS Sandboxing

  • Linux: bwrap (Bubblewrap) namespace isolation
  • macOS: seatbelt sandbox
  • Windows: Windows Job Objects (limited support; no PTY/tmux wrapper)

Cloud Execution Environments

Route agent execution to cloud sandboxes instead of local machines:

ProviderBest for
ModalStateless function-style tasks
E2BCode execution sandbox
DaytonaDevelopment environments
KubernetesEnterprise private cloud
CoreWeaveGPU-intensive tasks
DatabricksData analytics tasks

Multi-Agent Orchestration: YAML-Defined

Omnigent agents are defined in YAML. An agent can call other agents as tools:

# Basic agent definition
name: my_coder
prompt: |
  You are an expert Python developer.
  Focus on correctness and test coverage.
executor:
  harness: claude-sdk
tools:
  run_tests:
    type: function
    callable: mypackage.testing.run_pytest
  search_docs:
    type: mcp
    url: https://docs-mcp.example.com

Multi-Agent Pattern: Polly

Omnigent ships a built-in example called Polly — a supervisor orchestrator demonstrating the parallel worktree pattern:

name: polly
prompt: |
  You are a supervisor coordinating multiple coding agents.
  Delegate coding tasks to sub-agents, then route diffs to reviewers.
tools:
  coder_a:
    type: agent
    harness: claude-sdk
    prompt: "Implement the feature in a git worktree"
  coder_b:
    type: agent
    harness: codex
    prompt: "Implement the same feature independently"
  reviewer_anthropic:
    type: agent
    harness: claude-sdk
    prompt: "Review the diff for correctness"
  reviewer_openai:
    type: agent
    harness: codex
    prompt: "Review the diff for security issues"

The pattern:

  1. Two coders on different harnesses implement the same feature in parallel git worktrees
  2. Diffs get routed to two reviewers from different vendors
  3. The supervisor synthesizes review feedback and makes the final call

Dual-Headed Agent: Debby

The other bundled example is Debby — runs Claude and GPT side-by-side with a /debate mode:

User question
    → Claude produces answer A
    → GPT produces answer B
    → /debate triggers: each model critiques the other's answer
    → Debby synthesizes both arguments into a final response

Real-Time Collaboration

Omnigent turns agent sessions into multi-person workspaces:

Session Sharing

# Generate a shareable URL
omnigent share <session_id>
# → https://omnigent.ai/s/abc123

Teammates open the URL, see the agent's output in real time, inject commands, and take over the session.

Session Forking

# Fork from an existing session — same context, independent development
omnigent run --fork <session_id>

Useful in code review: the main agent finishes an implementation, fork into two sessions with different reviewer agents, merge the conclusions back into the main session.

Authentication

  • OIDC login: Google, GitHub, Okta, Microsoft
  • Invite-only accounts via single-use invite links

MLflow Tracing Integration

The Omnigent + MLflow integration provides unified observability across all harnesses. Configuration is minimal:

uv tool install omnigent mlflow
 
export MLFLOW_TRACKING_URI="http://your-mlflow-server:5000"
export OMNIGENT_TELEMETRY_ENABLED="true"
 
omnigent run

Every agent execution automatically logs to MLflow:

  • Each conversation turn (prompt + response)
  • Tool invocations with arguments, results, and timing
  • Per-turn token consumption
  • Session metadata (model name, agent name, harness type)

Practical uses:

  • Model comparison: run the same task with Claude vs. GPT, compare cost and quality
  • A/B testing: evaluate different MCP server providers on cost/performance
  • Team insights: which harness excels at planning vs. execution? Which request types run slow? How much time goes to features vs. bugs?

Installation and Quick Start

# Install (uv recommended)
uv tool install omnigent
 
# Or pip
pip install omnigent
 
# Start (picks a model, opens localhost:6767 automatically)
omnigent
 
# Short alias
omni
 
# Upgrade
omni upgrade

The browser opens http://localhost:6767 with a GUI for configuring agents and viewing sessions. Terminal interaction also works directly.

Deploy to a Server

# Docker
docker run -p 6767:6767 omnigentai/omnigent
 
# Supported platforms: Render, Railway, Fly.io, Cloudflare

Server deployment gives teams a shared Omnigent instance with OIDC login — all policies and collaboration features managed centrally.

Resources

Summary

Omnigent doesn't try to build a better AI coding agent. It addresses what happens when you already have multiple agents and need to turn them into a coherent system.

Databricks' experience deploying AI agents across 5,000+ engineers surfaced the problem clearly: tools fragment, policy has no infrastructure, team collaboration has no shared foundation, observability is nearly absent. Omnigent packages the answer — meta-harness layer + policy governance + sandboxing + collaboration + observability — into one operational framework for running agents at scale.

The "meta-harness" concept itself is worth holding onto. As AI coding tools multiply and specialize, the need for this layer only grows. Today it's Claude Code and Codex. Tomorrow it might be five more specialized tools. The problems Omnigent solves — policy, cost, collaboration, observability — appear in every combination.

Explore PrimeSkills — A marketplace for handpicked AI Agents and skills. Each is validated in real enterprise workflows, stripping away hype and keeping only what truly works.

Welcome to my Homepage for more useful insights and interesting products.

← Back to Blog