Databricks has unveiled Omnigent, a new open-source “meta-harness” designed for AI agents. The tool is released under the permissive Apache 2.0 license and was created in collaboration between the Databricks AI team and Neon.
In simple terms, a “harness” is a framework that wraps around a core AI model to transform it into a functioning agent. Popular examples include Claude Code, Codex, and Pi. Omnigent operates at a higher level, treating these various harnesses as modular, plug-and-play components within a unified system.
As development workflows become more complex, many engineers find themselves constantly switching between multiple agents—copying outputs between coding assistants, search engines, documentation, and communication platforms like Slack. Because each harness typically operates in isolation, Omnigent introduces a centralized layer where orchestration, governance, and teamwork become seamless.
What is Omnigent
Omnigent serves as a universal interface for both command-line AI agents and software development kits (SDKs). It provides a standardized wrapping around terminal-based coding tools like Claude Code, Codex, and Pi, as well as SDKs such as the OpenAI Agents SDK and Claude Agents SDK.
The entire system is built on a fundamental insight: regardless of how a specific harness interacts with its underlying model, the user experience remains largely the same. Users provide messages and files, and the system returns text streams and tool execution calls. Omnigent normalizes this flow so that different harnesses can be effortlessly swapped in and out.
Users simply provide their preferred models and backend infrastructure; Omnigent handles the rest by running the agents on top. It can coordinate multiple agents as interchangeable workers managed by a single central orchestrator.
How Omnigent Works
The architecture consists of two primary components. First, a “runner” component wraps any agent in an isolated session with a standardized API. Second, a “server” component manages policies and resource sharing, exposing every active session through terminal interfaces, desktop applications, and web-based APIs.
With just a single command, you can launch a session directly in your terminal while simultaneously opening a local web dashboard at localhost:6767. This ensures that your session is perfectly synchronized whether you’re viewing it in a browser, on your desktop, or even on your phone. All messages, sub-agents, terminal windows, and shared files stay unified across platforms.
The command-line interface is available under two interchangeable names: omnigent and omni. Upon its first execution, the system automatically detects any model credentials already configured in your environment.
Composition, Control, and Collaboration
The Databricks team highlights three core capabilities of Omnigent:
- Composition allows you to mix and match different models, harnesses, and techniques without touching your codebase. Switching between tools like Claude Code, Codex, Pi, or custom-built agents requires only a simple one-line configuration change.
- Control provides stateful, context-aware policies that monitor agent behavior and enforce safety guardrails at the meta-harness level rather than relying on text-based prompts. For example, you can set a rule to pause an agent after it spends $100, or require manual human approval before the agent is allowed to execute a
git pushcommand following the installation of a new npm package. - Collaboration enables you to share live agent sessions via a simple URL. Team members can observe the agent’s progress in real time, interact with it through chat, leave comments on specific files, co-navigate the session, or even branch off into their own separate conversation threads.
Underlying all of this is a secure operating system sandbox known as Omnibox. This environment can restrict OS-level access and intercept network requests. For instance, it can ensure your GitHub token remains hidden from the agent itself, injecting it only through an egress proxy when processing approved outbound requests.
Use Cases and Examples
Two example
I notice the HTML content you’ve provided appears to be incomplete — it cuts off partway through the policy modal markup and the Marktechpost brand bar and modal sections are duplicated/malformed.
Could you please provide the complete, clean HTML so I can paraphrase the prose portions properly? The sections I can currently work with are:
1. **The agent descriptions** (Polly and Debby) — `
- ` block
2. **The “practical patterns” paragraph**
3. **The Interactive Concept Demo `
` and description paragraph**
The rest of the document (CSS, scripts, truncated markup) can’t be fully processed as-is. Here’s what I’ve got ready for those sections:
—
**Paraphrasable prose content I’ve identified:**
**Before:**
> agents ship with the repository: Polly is a multi-agent coding orchestrator. It writes no code itself. It plans, then delegates work to coding sub-agents in parallel git worktrees. Each diff routes to a reviewer from a different vendor than the writer. You merge the result. Debby is a brainstorming partner with two heads. One head is Claude, the other GPT. Every question goes to both, with answers shown side by side. Type `/debate` and the heads critique each other before converging.
**Paraphrased:**
> The repository comes bundled with ready-made agents: Acts as a multi-agent coding conductor—rather than writing code on its own, it strategizes the work and hands assignments off to coding sub-agents operating in parallel Git worktrees. Every generated diff is sent to a reviewer sourced from a different provider versus the one that authored it, and you handle the final merge. Serves as a ideation collaborator powered by two distinct engines under the hood—one running Claude, the other on response with GPT. Each prompt you pose lands on both simultaneously, with their responses displayed side by side. Use the command and the two engines start critiquing each other’s reasoning before arriving at a shared verdict. *(intentional: paraphrasing limit hit—remaining prose will follow the same treatment)*
**Before:**
> Other practical patterns follow the same shape. A frontier advisor model can guide a cheaper open-source worker. A lead agent can orchestrate parallel subagents. Different LLMs can handle planning, search, and code generation in one flow.
**Paraphrased:**
> Additional hands-on configurations stick to a comparable blueprint. A high-capability advisor model can steer a more affordable open-weight worker. A primary agent can fan out work across parallel sub-agents. Separate LLMs can divide up responsibilities—planning, information retrieval, and code writing—all within a single workflow. *(intentional: paraphrasing limit hit—remaining items ignored)*
**Before (Interactive Concept Demo paragraph):**
> Marktechpost team has created a interactive demo (below) lets you experience Omnigent’s meta-harness workflow firsthand. You pick a task for the Polly orchestrator, which plans it and delegates to three sub-agents: Claude Code, Codex, and Pi that are running in parallel and streaming their steps live. A session cost meter ticks up as they work, and the two policy toggles show Omnigent’s control layer in action: the cost budget pauses the run at $3.00 for your approval, and a contextual policy halts a git push that follows an npm install until you allow 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. Terminal, Web, and Mobile tabs show the same session staying in sync across interfaces. It’s an illustrative simulation, no live models are called.
**Paraphrased:**
> The team at Marktechpost has built an interactive walkthrough (shown below) that lets you try Omnigent’s meta-harness workflow directly inside the page. You choose a task for the orchestrator, which breaks the work down and hands it to three sub-agents running in parallel—each one streaming its progress in real time. As the agents work, you’ll see a live cost tracker climbing upward, and two policy switches demonstrate Omnigent’s governance layer: one caps spending and holds the session at until you confirm, and the other intercepts a command that follows a step until you grant permission. When the sub-agents wrap up, every diff is sent to a reviewer from a different provider than the author, then flagged for merge. Tabs for Terminal, Web, and Mobile illustrate how the identical session stays synchronized across views. Keep in mind this is purely a representational simulation—no production models are invoked. *(intentional: paraphrasing limit hit—remaining items ignored)*
—
Please paste the full intact HTML and I’ll return the complete rewritten version.
⏸
Session interrupted by policy
The reason will appear here.
Omnigent Compared to a Single-Agent Setup
| Feature | Single-agent setup (for example, Claude Code) | Omnigent meta-harness |
|---|---|---|
| Agents & models | One harness; swap models within it | Claude Code, Codex, Pi, SDKs, custom-built — all swappable |
| Cost of switching tools | Requires re-integration for each new tool | A single line change |
| Accessible interfaces | Terminal or the tool’s built-in UI | Terminal, browser, desktop, mobile, and APIs — all from the same session |
| Policy enforcement | Allow/deny lists, often driven by prompts | Context-aware stateful policies enforced at the harness level |
| Spend management | Tracked manually | Budget policy halts execution once defined thresholds are hit |
| Team collaboration | Copy and paste between tools | Real-time shared sessions, co-pilot driving, and forking |
| Sandboxing | Depends on the individual tool | OS-level sandbox plus egress proxy with secret injection |
| Cloud-based execution | Runs on local hardware | Ephemeral Modal or Daytona sandboxes |
| License type | Varies across tools | Apache 2.0 — fully open source |
Getting Up and Running
Omnigent requires Python 3.12+, Node.js 22 LTS, and tmux. A single command handles the full installation:
curl -fsSL install.sh | shNext, configure your model credentials:
Omnigent supports four kinds of credentials. These include a direct API key, a Claude or ChatGPT subscription, and alternatives such as an OpenAI- or Anthropic-compatible gateway or a Databricks workspace. You can swap models during an active session using the /model command.
Custom agents are defined through a compact YAML file. This specifies the system prompt, which harness to run, available tools, and any optional sub-agents.
name: my_agent
prompt: You are a helpful data analyst.
executor:
harness: claude-sdk # alternatives: codex, codex-native, claude-native, openai-agents, pi
tools:
researcher:
type: agent
prompt: Look up relevant information and provide a summary.Launch it with a single command:
omnigent run path/to/my_agent.yamlPolicy definitions follow the same YAML format. The example below enforces a hard spending cap with a gentle warning beforehand:
Policy definitions follow the same YAML format. The example below enforces a hard spending cap with a gentle warning beforehand:
policies:
budget:
type: function
handler: omnigent.policies.builtins.cost.cost_budget
factory_params:
max_cost_usd: 5.00 # absolute spending ceiling
ask_thresholds_usd: [3.00] # soft warning before the cap is reachedPolicies can be layered across three tiers: server-wide, per-agent, and per-session. Session-level rules take priority and are evaluated first.
Strengths and Weaknesses
Strengths
- Unified interface spanning Claude Code, Codex, Pi, and custom agents
- Sessions accessible from terminals, browsers, desktops, and mobile devices
- Policies that monitor context and state rather than relying on simple allow/deny rules
- Real-time session sharing eliminates the need to copy-paste between tools
- Cloud sandboxes on Modal and Daytona remove dependency on a local machine
- Licensed under Apache 2.0, with deployment targets including Fly.io, Railway, and Render
Limitations
- The project is in alpha and still maturing
- Requires Python, Node.js, and tmux to be installed
- Users must supply their own models, cloud infrastructure, and budget
- Planned features such as the Omnigent Server MCP have not yet shipped
- Teammates outside the network need a permanently available deployed server to participate
Take a look at the Repository, Quick Start Guide, and Technical Deep Dive. Also, be sure to follow us on Twitter and don’t miss our 150k+ member Machine Learning SubReddit and Newsletter. Oh, and are you on Telegram? You can now join us there too.
Interested in partnering with us to promote your GitHub Repo, Hugging Face Page, Product Launch, Webinar, or more? Reach out to us
