Databricks Omnigent: Multi-Agent Orchestration, Cost Control, and Governance Explained

Omnigent is an open-source meta-harness that sits above your existing agents (Claude Code, Codex, Pi, custom agents) and orchestrates them as a unified system, letting teams compose multiple agents, enforce stateful governance policies, and collaborate across devices without rewriting infrastructure for each harness.

Introduced at Databricks’ Data + AI Summit 2026, Omnigent addresses a problem that has emerged rapidly: organizations are now managing multiple LLMs, agents, and AI tools at the same time, creating a coordination challenge that barely existed two years ago.

The Multi-Agent Problem

Teams are increasingly reaching for more than one agent. Databricks itself reports keeping four or five open at once — Claude Code for analysis, Codex for engineering, plus custom agents for narrower tasks.

Because each tool operates in its own environment, teams end up switching contexts, copying work between systems, and managing separate sessions across laptops, phones, and browsers.

Governance adds another layer of complexity. When several agents run in parallel:

• spending limits are difficult to enforce,
• approval gates depend on individual judgment,
• security policies remain guidelines rather than hard controls,
• costs and accountability become harder to track.

This is where many teams hit a wall.

At the Summit, Databricks framed the agent loop itself – the LLM reasoning – as only about 1% of the work. The remaining 99% is the surrounding infrastructure: deployment, security, evaluation, monitoring, context management, sharing, and orchestration. Most teams rebuild that infrastructure for every new agent. Omnigent is designed to provide it once, at the orchestration layer, for the entire agent team.

What Does Omnigent Actually Do?

Omnigent is an open-source coordination framework or layer that lets you:

• Compose: Run Claude Code, Codex, Pi, or custom agents in the same place. Switch between them with one-line YAML changes.
• Control: Enforce stateful policies (cost caps, approval gates, sandbox constraints) at the orchestration layer, not via prompts.
• Collaborate: Share live agent sessions by URL across web, mobile, macOS, and APIs.

Think of it as a “meta-harness”, not a replacement for Claude Code or Codex, but a governance layer above them that lets teams orchestrate multiple agents as a unified system.

Omnigent comes in two forms: the open-source tool you run yourself, and a managed version inside Databricks’ Agent Bricks that adds Unity AI Gateway governance. Most of this article describes the open-source tool; where the managed version differs, we say so.

What Happens When You Run Multiple Agents Without An Orchestration Layer?

Running multiple agents sounds manageable in theory. In practice, orchestration failures happen quietly.

Scenario 1: Agent Cost Tracking Failure

A fraud-detection team at a financial services firm ran three agents in parallel – Codex for feature engineering, Claude Code for model interpretation, and a custom agent for threshold optimization. Without unified cost tracking, one agent spent $3K/day undetected for weeks.

Result: A six-figure surprise on the bill.

Scenario 2: Agent Governance Failures

A data platform team had five engineers, each with a different agent and no shared governance. One engineer’s agent wrote sensitive customer data to a public log (caught only by audit). Another agent, without approval gates, modified a production schema after an npm install, a supply-chain attack pattern nobody saw coming, a third pushed code without review.

Result: Three separate security incidents, all preventable.

When You Have 5+ Agents Running in Parallel Without Orchestration

• Cost spirals silently → No unified budgets, no spending caps. Agents optimize for quality, not cost. Result: you discover the problem in next month’s bill (usually five or six figures).
• Governance becomes theater → Access control exists (which tables agents can touch), but approval gates don’t. Policies live in Slack messages, and Google Drive. Result: agents make production changes without review.
• Debugging is a nightmare → An incident happens. Which agent caused it? Without centralized tracing, you’re looking at five separate logs. Result: hours wasted, liability unclear.
• Scaling is painful → Add a sixth agent? You rebuild orchestration logic from scratch. Result: each new agent doubles your infrastructure debt.

This is the core insight: every failure above stems from the same root cause: agents operating in silos have no shared context. No shared context about spending. No shared context about policies. No shared context about what happened. Orchestration solves this by breaking silos. It creates one unified context layer that all agents access and operate within.

That’s what Omnigent does, and that’s what Ghodsi meant by “the bottleneck is context.”

How Does Omnigent Work? Three Core Capabilities

Omnigent (open-source, Apache 2.0) addresses this through three interlocking capabilities.

Can You Run Multiple Agent Harnesses Without Rewriting Everything?

Omnigent’s answer is straightforward: define your agents in YAML. Each agent specifies a harness (Claude Code, Codex, Pi, custom), a model (Claude, GPT-5, Qwen), and a set of tools. Then run them all in the same session.

name: my_agent
prompt: You are a helpful data analyst.
executor:
  harness: claude-sdk
  # Swap one line to switch harnesses
  # harness: codex
  # harness: pi
tools:
  researcher:
    type: agent
    prompt: Search for relevant information and summarize it.

One line changes the harness. Your tools, skills, and governance rules stay the same.

Why does this matter? Because of cost optimization.

You can run cheap models (Qwen, Claude 3.5 Haiku) for simple tasks and stronger models (Claude Opus, GPT-5) only when needed. There is no need to lock into a single vendor or harness. It also means flexibility, if Codex works better for one task but Claude Code for another, you switch without rebuilding infrastructure.

How Do You Enforce Policies Without Relying on Prompts?

Here’s where Omnigent gets serious about enterprise viability.

Traditional agent governance relies on prompts: “Don’t spend more than $100” or “Ask for approval before pushing to git.” But prompts are suggestions, and they’re not enough at scale.

Omnigent enforces policies as code at the orchestration layer, not through prompts.

Examples (from Databricks’ 2026 Summit):

• Cost caps: Pause an agent after every $100 spent, requiring human approval to continue.
• Approval gates: Require human sign-off before any git push that follows an npm install (catching supply-chain attacks).
• Sandbox constraints: Never expose your GitHub token to an agent; inject it only on approved egress requests.
• PII guardrails: Block agents from writing customer data to public logs.

In the open-source tool these policies are Python functions. You update them in one place, and all agents see the change immediately. (The managed version of Databricks expresses governance through Unity AI Gateway instead).

policies:
  budget:
    type: function
    handler: omnigent.policies.builtins.cost.cost_budget
    factory_params:
      max_cost_usd: 100.00
      ask_thresholds_usd: [50.00]

This approach scales. A 50-person team can run 100+ agents, and governance is enforced by the platform.

How Do Teams Collaborate on Live Agent Sessions?

A final, often-overlooked feature: agent sessions are shareable by URL.

One person starts an agent session on their laptop. They share the URL with a teammate. Both can see the agent’s reasoning in real time, on their phone, browser, or macOS app. Messages, sub-agents, terminals, and files stay in sync.

Why does this matter?

• Review workflows: Teammates can watch an agent work, ask it to pause, and steer it interactively.
• Debugging: Multiple people can inspect the same reasoning trace without copying outputs.
• Distributed teams: An agent running on a server can be watched and controlled from any device.

This is less about fancy features and more about making agents a collaborative tool, not a solo system.

Why Does Omnigent Matter Right Now?

Omnigent didn’t emerge from nowhere. It’s part of a larger shift in how Databricks, and the industry, thinks about AI agents.

At the 2026 Data + AI Summit, Databricks reframed its entire platform around four pillars: Context, Control, Cost, and Choice.

• Context: Agents need access to accurate, governed business data and meaning. This comes from Unity Catalog, Genie Ontology (continuously learned business context from 50+ connected apps), and Unity Catalog Semantics.
• Control: Agents must operate within enforced boundaries. Cost budgets, approval gates, and sandbox constraints are platform responsibilities, not agent promises.
• Cost: Multi-agent deployments must be economically viable. Unity AI Gateway provides transparent cost tracking; Agent Bricks + Omnigent enforce caps.
• Choice: Teams should pick the right LLM and harness for each task, not be locked into one vendor.

The Databricks Agentic Stack

Omnigent is the meta-harness layer above your coding agents; on Databricks it runs managed inside Agent Bricks, governed by Unity AI Gateway.

For a team adopting this stack, Omnigent is the orchestration layer that makes it practical. It sits between the governed context (what agents can access) and governance enforcement (what they’re allowed to do), enabling multi-agent coordination at enterprise scale.

How Do You Get Started With Omnigent? (Open Source vs. Managed)

Omnigent is available two ways:

Open Source (GitHub)

The Omnigent repo is on GitHub (omnigent-ai/omnigent). You can clone it, run it locally, or deploy to a server (VPS, Railway, Render, Fly.io, Cloudflare serverless, or Databricks Apps).

Requirements:

• Python 3.12+
• Node.js 22 LTS
• tmux (for terminal sessions)

Setup (30 minutes for local proof-of-concept):

uv tool install omnigent        # or: pip install omnigent
omnigent                        # starts a session
omnigent setup                  # add model credentials

You’ll get a CLI and a local web UI (localhost:6767). Add credentials for your harnesses (Claude, Codex, custom agents), define agents in YAML, and start orchestrating.

Managed (Inside Agent Bricks)

Databricks also offers a managed version within Agent Bricks. You don’t manage deployment; Databricks does. Costs are baked into your Databricks bill.

Is Omnigent Right for Your Team?

Good Fit: Data Engineering, ML, Platform, Security Teams

• Data Engineering Teams: If you’re orchestrating multiple agents for data pipeline automation, lineage tracking, and quality checks, Omnigent’s cost control and policy enforcement are game-changers.
• ML Teams: ML engineers often use multiple harnesses for different tasks: Codex for algorithm code, Claude Code for data preparation, custom agents for hyperparameter tuning. Omnigent orchestrates them without rewriting infrastructure.
• Platform and DevOps Teams: If you’re building internal tools for your organization, Omnigent lets you compose agents for CI/CD, incident response, and compliance without rebuilding orchestration for each use case. Example: A compliance agent that requires approval gates (Omnigent policy), a CI/CD agent that auto-remediates failures, and a support agent that surfaces incident context to on-call engineers.
• Enterprise Security and Compliance Teams: Omnigent’s sandbox constraints, token isolation, and policy-as-code approach appeal to regulated industries. Agents operate in a governed sandbox, with every action logged to the Lakehouse (for audit) and monitored by Lakewatch (for anomalies).

Wait and Watch: Early POCs and Single-Agent Teams

Omnigent may be unnecessary for teams that only use one AI agent. In those cases, Agent Bricks offers a simpler way to build and manage the workflow.

Teams working on an early proof of concept should also begin with a lighter tool, such as Agent Bricks or Claude Code. Omnigent becomes more useful once the project expands to several agents that need to share tasks, follow common policies, and work together.

It may also be too technical for teams without engineering support. Configuring workflows in YAML and defining governance policies require technical knowledge. These teams may find it easier to start with Genie or the visual interface available in Agent Bricks.

Why Choose Omnigent Over Building Your Own Orchestration?

• Cost of building vs. using: Building takes several months of engineering time, governance enforcement, policy management, cost tracking, and sandbox constraints, with recurring maintenance as harnesses evolve. Using Omnigent means setup in hours or days, policy updates in minutes, and governance enforced by Databricks’ platform investment.
• Governance at scale: Most teams don’t enforce policies until something breaks. Omnigent enforces them proactively.
• Future-proofing: New harnesses emerge constantly. With homegrown orchestration, you rewrite glue code for each. Omnigent abstracts the harness layer, so you swap vendors without touching orchestration.
• Databricks backing: Omnigent is open-source and Apache 2.0-licensed (not vendor lock-in), but it’s backed by a company investing billions in the agentic era. Policy enforcement, performance improvements, and harness support will evolve.

Summary

AI agents are becoming your data layer’s primary users, but managing multiple agents without unified orchestration creates silent cost spirals, governance failures, and security incidents.

As Vadym Mariiechko notes in Addepto’s Data + AI Summit analysis, “Model intelligence is commoditizing – the winner is who owns the governed, contextualized data layer that agents rely on.” Omnigent, Databricks’ open-source meta-harness, is designed exactly for this: it sits above your existing agents (Claude Code, Codex, Pi, custom) and orchestrates them as a unified system.

The problem may seem abstract with one or two agents, but it compounds rapidly. Without centralized governance, one agent can spend $3K/day undetected for weeks. Without approval gates, agents write sensitive customer data to public logs or modify production schemas after supply-chain attacks. Without orchestration, each new agent doubles infrastructure debt.