Databricks
Advances in foundation models cannot scale enterprise automation without an open meta-layer to resolve the operational silos, security hazards, and fractured session states created by competing agent harnesses.
AI-assisted summary of Introducing Omnigent: an open meta-harness – Matei Zaharia, Co-founder and CTO, Databricks — original source. Check the original for full context.
Source published:
Key ideas
- Databricks introduced Omnigent, an open-source "meta-harness" designed to provide a unified interface, sandboxing, and collaboration layer across disparate AI agent harnesses like Claude Code, Cursor, and OpenAI Codex. (0:00)
- Omnigent tackles the multi-agent fragmentation problem across three core pillars: composition (multi-agent orchestration and session forking), collaboration (real-time shared sessions and handoffs), and control (contextual security policies and budget caps). (3:40)
- Rather than relying on static per-tool permissions, Omnigent enforces stateful policies that track context over time—such as revoking external network access if sensitive data is touched or pausing execution when spend thresholds are reached. (9:40)
- The open-source stack is architected around a local Runner and an optional central Server built on standard infrastructure like PostgreSQL, Docker, and OpenTelemetry, operating independently of the Databricks platform. (7:52)
Detailed notes
## Background Published on YouTube by Databricks on June 24, 2026, this keynote features Databricks Co-founder and CTO Matei Zaharia introducing Omnigent, an open-source meta-harness for AI agents. According to the page description, Omnigent makes agents interoperable so that user sessions, governance policies, and skills persist regardless of where an agent or foundation model is running.
## TL;DR Matei Zaharia introduces Omnigent, an open-source meta-harness designed to overcome the fragmentation, security risks, and collaboration barriers created by siloed AI agent software wrappers. Omnigent establishes a unified layer over diverse tools like Claude Code and OpenAI Codex, enabling seamless session forking, supervisor-driven multi-agent orchestration, and bi-directional terminal, web, and mobile interfaces. It also provides real-time multi-user collaboration and contextual, state-aware governance policies—such as dynamic spend caps and permission tracking. Zaharia emphasizes that open-sourcing Omnigent provides the broader AI ecosystem with a turnkey application scaffolding to safely manage, compose, and deploy agents across organizations.
## Atmosphere & style The talk carries the grounded, fast-paced energy of a developer-focused keynote, blending architectural diagrams with live, authentic terminal demonstrations. Zaharia speaks with an approachable, self-deprecating wit, bantering about pet-store dog harnesses, mocking overwhelming permission prompts, and spontaneously looping in a colleague supposedly on vacation to debate joke diffs in a README. It feels practical, unpretentious, and deeply informed by real-world engineering frustrations, shifting fluidly from multi-agent orchestration to live budget guardrail tripwires.
## Bulletin - [00:00](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=0s) Databricks introduced Omnigent, an open-source "meta-harness" designed to provide a unified interface, sandboxing, and collaboration layer across disparate AI agent harnesses like Claude Code, Cursor, and OpenAI Codex. - [03:40](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=220s) Omnigent tackles the multi-agent fragmentation problem across three core pillars: composition (multi-agent orchestration and session forking), collaboration (real-time shared sessions and handoffs), and control (contextual security policies and budget caps). - [09:40](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=580s) Rather than relying on static per-tool permissions, Omnigent enforces stateful policies that track context over time—such as revoking external network access if sensitive data is touched or pausing execution when spend thresholds are reached. - [07:52](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=472s) The open-source stack is architected around a local Runner and an optional central Server built on standard infrastructure like PostgreSQL, Docker, and OpenTelemetry, operating independently of the Databricks platform.
## Key takeaways - [00:00](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=0s) The bottleneck in agent usability and enterprise adoption is not model capability, but rather the fragmented software scaffolding surrounding models, known as harnesses. - [01:55](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=115s) Rapid, uncoordinated development of proprietary agent wrappers creates isolated silos that cannot be fixed by faster coding alone. - [03:40](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=220s) Multi-agent workflows struggle with composition, as cross-harness architectures like continuous loops and tiered advisor-executor models lack standardized orchestration protocols. - [03:40](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=220s) Collaboration between human engineers and agents is broken by fragmented desktop contexts and a lack of standardized session state for team handoffs. - [03:40](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=220s) Standard agent permission models overwhelm users with static approval dialogs that fail to prevent severe operational accidents or security breaches like prompt injection. - [07:52](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=472s) Omnigent introduces a meta-harness abstraction sitting directly above individual agent harnesses, standardizing inbound messages, outbound events, and tool execution. - [07:52](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=472s) Architecturally, Omnigent separates responsibilities into a local execution Runner for sandboxing and monitoring, and an optional central Server for team policies, history, and MCP registry management. - [09:40](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=580s) Users gain uniform access across the original terminal UI, web browsers, native desktop apps, mobile clients, and standard REST APIs without altering underlying agent code. - [16:08](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=968s) Omnigent enables session forking, allowing developers to switch underlying harnesses (such as moving from Claude Code to Codex) while keeping the full conversation and file diff history intact. - [16:08](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=968s) The included supervisor agent, Polly, demonstrates cross-harness task distribution by delegating sub-tasks to multiple local agent installations in parallel and synthesizing their outputs. - [18:40](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=1120s) Real-time session sharing allows remote team members to join live agent workspaces, review code diffs, submit inline feedback, and execute prompts collaboratively. - [20:24](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=1224s) Dynamic, stateful policy enforcement monitors model expenditure in real time, automatically pausing execution for approval or enforcing hard budget caps across primary and sub-agents. - [22:01](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=1321s) Databricks open-sourced Omnigent to establish an open industry standard for agent interoperability, comparable to open data formats and sharing protocols.
## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=0s) The Emergence of Agents and the Hidden Harness Problem
Matei Zaharia opens the second day of keynotes by announcing a brand-new open-source project that the Databricks engineering team released just days prior, over the weekend on Saturday. The project introduces an entirely new layer designed for developing and operating AI agents. Zaharia explains that this development stems directly from the patterns and obstacles Databricks observed across various agent deployments, which revealed that the existing agentic stack lacks a crucial abstraction to make agents truly effective. He calls this concept a "meta-harness"—essentially a harness of harnesses.
Acknowledging that agents have legitimately started to work, Zaharia points out that coding agents were the first major success story, to the point where almost every software engineer uses them regularly. Other specialized agents, such as Databricks Genie, have demonstrated that high-performing domain-specific agents are viable. Given how straightforward it has become to produce working code with these tools, one might logically question why dedicated agent infrastructure is even necessary. If an engineer dislikes an off-the-shelf agent, they could theoretically write their own. But Zaharia warns that reality is far messier: using agents in day-to-day work can be deeply frustrating, and from an engineering management standpoint, the security hazards and operational risks are genuinely alarming. Displaying an illustration of an agent, he observes with some amusement that the root of the problem is visible in the harness encasing the figure itself.
- Databricks launched this open-source meta-harness project on Saturday, just before the keynote. - Coding agents represent the first widely adopted agentic paradigm, followed by specialized tools like Genie. - The fundamental issue is not model capability, but rather the software layer wrapping around the model—the harness itself.
---
[01:55](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=115s) What Is an AI Agent Harness?
Zaharia unpacks the definition of an agent harness: it is the software scaffolding surrounding a large language model that acts as the agent's interface to the external world. While a foundational model like Claude merely consumes text and outputs tokens, an application like Claude Code functions as the harness. The harness grants the model access to files, handles the user interface, manages execution permissions, and mediates interaction with the operating system. The same relationship exists between foundational models and harnesses like Codex or custom-built agents.
Because building a harness is accessible and co-designing the harness software alongside the underlying model yields superior results, the industry has experienced an explosion of distinct harnesses. Pointing to a slide overflowing with agent software and SDKs, Zaharia compares the ecosystem to an experience he had visiting a pet store over the weekend, where every possible shape, size, and color of dog harness is on display. However, this hyper-fragmentation creates a core problem: agents inevitably need to interoperate, yet each remains isolated inside its custom-built wrapper. Zaharia emphasizes that unstructured rapid development will not bridge this divide: “If everyone is just vibe coding their own thing, uh they will still be incoherent. So so you know, there's no no amount of like faster coding will solve this problem.”
```mermaid flowchart TD accTitle: Agent Harness Architecture accDescr: Diagram illustrating how foundational language models sit inside software harnesses that interact with the external environment.
subgraph Harness["Agent Harness Layer (Software Scaffolding)"] UI["User Interface"] FS["File System & Execution Tools"] Sec["Security & Permission Engine"] LLM["Foundation Model (Predicts Tokens)"]
UI <--> LLM FS <--> LLM Sec <--> LLM end
Env["External World (Codebase, APIs, Cloud Infra)"] Harness <--> Env ```
---
[03:40](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=220s) The Interoperability Hurdle: Composition, Collaboration, and Control
Zaharia outlines the three core interoperability hurdles facing the multi-agent ecosystem: composition, collaboration, and control. Databricks confronts these challenges continually from two perspectives: internally across thousands of engineers who rely on coding agents, and externally as they develop and maintain customer-facing agent products like Genie.
The first challenge is composition. Modern workflows frequently require combining disparate agents to produce better outcomes. When engineers encounter bugs and an agent gets stuck, they often supply different inputs or invoke alternative agents in parallel. While orchestration works smoothly within a single walled garden like Claude Code or Codex, orchestrating across completely different harnesses remains broken. Zaharia details several emerging multi-agent paradigms: - **Loops:** Agent architectures where models supervise each other or iterate continuously until a task is solved. - **Advisors:** Tiered architectures where a small, fast, inexpensive model performs the bulk of repetitive execution while an expensive frontier model serves as an advisor—either directing the cheaper model or being summoned only when the smaller model gets blocked. Zaharia references research papers and technical blog posts exploring this pattern from Harvey AI, Anthropic, Databricks (specifically within Genie), and his own research lab at UC Berkeley.
The second challenge is collaboration across humans and agents. Zaharia shows an image of a cluttered desktop packed with multiple coding agent terminals, Slack, and Google Docs, remarking that his daily workflow consists of endlessly copy-pasting text from one window to another. The lack of standard session state prevents basic handoffs: if an engineer must step away from their desk, there is no straightforward way to export and hand over an active agent session with its full historical context to a teammate.
The third challenge is control and governance. Agents are vulnerable to prompt injection attacks and are prone to severe operational blunders, such as accidentally dropping a production database (an issue Zaharia notes could be reverted with Databricks Lakebase, but remains catastrophic elsewhere). Relying on user approvals is fundamentally flawed because interactive prompts are overwhelming. Zaharia mocks the standard Claude Code confirmation dialog: “Here's the average permission prompt when Claude asked me something. It's like, 'Do you want to run this hundred line Python script? Yes or no?' So, you know, it's it's a huge pain as a user. Just waiting, you know, just hoping that users will review every action is not enough either.”
---
[07:52](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=472s) Introducing Omnigent: The Meta-Harness
To resolve the fragmentation across composition, collaboration, and control, Zaharia argues that the industry needs an open layer positioned directly above the harness layer: a meta-harness. Databricks resolved to build this meta-harness and release it as an open-source project named Omnigent, allowing developers and enterprises to integrate any harness, custom workflow, or specialized tool.
Omnigent operates over a universal interface that abstracts away harness-specific quirks. It normalizes inputs into standardized inbound message streams, outbound event streams, and tool-calling interfaces. Zaharia notes that Omnigent already supports mainstream coding agents, and the team added integrations for Cursor and Antigravity immediately following Saturday's launch based on community demand. It similarly accommodates custom enterprise agents constructed with frameworks like the OpenAI Agents SDK.
Architecturally, Omnigent consists of two primary components: 1. **The Runner:** A local software component that wraps directly around an individual agent harness. It provides sandboxed execution, enforces security parameters, monitors health, and maintains operational stability. 2. **The Server:** An optional centralized service that provides team-level collaboration and policy governance. Connecting agents to the Omnigent server unlocks shared session histories, team-wide session sharing, and centralized management of Model Context Protocol (MCP) servers and reusable agent skills.
```mermaid flowchart TD accTitle: Omnigent Meta-Harness Architecture accDescr: Diagram depicting how Omnigent wraps around multiple agent harnesses and connects to an optional centralized server.
subgraph ServerLayer["Optional Centralized Omnigent Server"] History["Central History & Auditing"] Policy["Global Security Policies & Limits"] Skills["Central MCP & Skill Registry"] Collab["Session Sharing & Handoffs"] end
subgraph MetaLayer["Omnigent Meta-Harness Layer"] StandardAPI["Common Interface: Messages, Events, Tools"] Runner1["Omnigent Runner (Sandboxing & Monitoring)"] Runner2["Omnigent Runner (Sandboxing & Monitoring)"] end
subgraph Agents["Diverse Agent Harnesses"] A1["Claude Code"] A2["Cursor / Antigravity"] A3["Custom Agent (OpenAI Agents SDK)"] end
ServerLayer <--> MetaLayer Runner1 <--> A1 Runner1 <--> A2 Runner2 <--> A3 StandardAPI --- Runner1 StandardAPI --- Runner2 ```
[09:40](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=580s) Unified Access, Open-Source Architecture, and Core Tenets
Matei Zaharia explains that introducing Omnigent creates a uniform interface for every agent across multiple environments. Regardless of the underlying engine, users retain the agent's original terminal UI while simultaneously gaining web access, a native application, mobile interfaces, and standard REST APIs. Databricks built Omnigent strictly as open-source software that operates completely independently of Databricks itself. It is designed to scale flexibly from single-machine local development setups to enterprise clusters, utilizing standard infrastructure software:
```mermaid flowchart TD accTitle: Omnigent Architecture Overview accDescr: Diagram illustrating how Omnigent provides uniform interfaces, standard infrastructure, and three core pillars.
subgraph ClientInterfaces["Uniform Client Interfaces"] Terminal["Terminal CLI"] WebUI["Web Interface"] Native["Native App / Mobile"] API["REST API"] end
subgraph CoreEngine["Omnigent Meta-Harness Layer"] Server["Open-Source Server"] Infra["PostgreSQL / Docker / OpenTelemetry"] end
subgraph Capabilities["Core Value Pillars"] Comp["Composition\n(Multi-Harness / YAML / Forking)"] Collab["Collaboration\n(Shared Live Sessions)"] Control["Control\n(Contextual Policies & Cost Limits)"] end
Terminal & WebUI & Native & API <--> Server Server --- Infra Server --> Comp Server --> Collab Server --> Control ```
This meta-harness architecture delivers three core advantages:
1. **Composition:** Users can combine agents across disparate harnesses and LLMs using lightweight YAML definitions, or switch dynamically between active harnesses on the fly. 2. **Collaboration:** Teams gain real-time shared sessions, enabling colleagues to join an active agent stream, read progress, issue commands, and comment directly on workspace files. Zaharia admits that since building it, “once this is available, like all my work I I try to do through this.” 3. **Control:** Current industry tooling relies on static per-tool rules (allow, deny, or prompt). Omnigent introduces *contextual security policies* where permissions evolve dynamically according to previous state. Zaharia highlights this distinction: “Today, in most agent tools, the controller is always just for for each type of tool call, do I allow it or deny it or ask the user? They're very static.” Omnigent policies track context: if an agent reads a confidential document, subsequent external network access (such as sending emails outside the company domain) is revoked, whereas operations remain unrestricted if it only touches public marketing material. It also introduces budget-enforcing cost caps (e.g., hard-limiting an agent run to $5.00) and an isolated OS sandbox to safeguard the host machine.
- Server stack runs using standard PostgreSQL, Docker, and OpenTelemetry instrumentation. - Supports stateful, context-aware security authorization rather than static per-action lists. - Enforces runtime cost thresholds that prevent uncontrolled LLM expenditure.
[12:06](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=726s) Demo: Terminal, Web UI, and Interactive Code Review
Zaharia begins his live demonstration on his Databricks dev box mirrored to his laptop, launching an agent session wrapped by Omnigent:
```bash omni claude ```
Running Claude behind Omnigent boots Claude Code with Databricks-specific extensions, custom prompt settings, and MCP (Model Context Protocol) configurations already attached. Zaharia tests it by querying `what is this project?` from inside the Omnigent repository, which Claude responds to using Databricks' internal engineering jargon (referencing concepts like "Archiving").
The terminal session synchronizes bi-directionally with Omnigent's web UI. Zaharia opens the browser dashboard to reveal real-time logs, live file explorers, and markdown renders. After checking out `README.md`, he types a web prompt: `add a joke to the top of the readme`. The terminal reflects the incoming command instantly. The web interface visually surfaces the modified file in a dedicated diff viewer. Zaharia uses the inline code review interface to highlight the injected lines, add comments requesting changes (`delete the jokes`), and submit batch feedback directly to the agent. He also demonstrates a dedicated native desktop client, highlighting how it cuts through messy browser tab sprawl and routes native OS notifications when agent tasks finish.
[16:08](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=968s) Session Forking and Multi-Agent Orchestration with Polly
Demonstrating composition, Zaharia demonstrates how Omnigent can switch harnesses without losing contextual state. With Claude having already altered the `README.md`, he forks the existing session over to OpenAI Codex:
```bash # Forking context to a different harness omni --fork --agent codex ```
Codex boots in the terminal with the entire conversation and file diff history intact. Zaharia prompts it to `Add a second joke too`, which Codex carries out on top of Claude's earlier work.
Building on this, Zaharia showcases multi-agent orchestration through an included supervisor agent called **Polly**. Operating within the same directory, Polly can coordinate disparate agents to execute divided tasks:
```mermaid flowchart TD accTitle: Polly Multi-Agent Execution Flow accDescr: Flowchart showing how supervisor agent Polly orchestrates Claude and Codex workers to evaluate jokes.
A["User Task:\nEvaluate jokes in README.md"] --> P["Polly (Supervisor Agent)"] P -->|"Spawn sub-task worker"| W1["Worker 1: Claude Code"] P -->|"Spawn sub-task worker"| W2["Worker 2: OpenAI Codex"] W1 -->|"Run evaluation"| R1["Rating & Feedback 1"] W2 -->|"Run evaluation"| R2["Rating & Feedback 2"] R1 --> P R2 --> P P -->|"Synthesized Conclusion"| O["Output:\nJoke 1: pretty good\nJoke 2: not quite as good"] ```
When Zaharia asks Polly to have both models rate the jokes inside the `README.md`, Polly checks the environment for local Claude and Codex installations, spins up background worker processes for each, monitors their execution via child terminals, and aggregates their results. Polly summarizes their assessments, declaring that joke number one is "pretty good" while joke number two is "not quite as good." Zaharia shares how he uses this workflow in production: “Thing I was doing last night is I asked that like find all the open GitHub issues about something and then, uh, investigate them in parallel and see if they've been fixed in the code.”
[18:40](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=1120s) Real-Time Live Collaboration Demo
To illustrate collaboration, Zaharia invites Ankit, an engineer on Databricks' AI team, into the live workspace to review the modified documentation:
> **Ankit:** “Oh man, Matei's calling me on vacation? Hey Matei.” > **Matei Zaharia:** “Hey man, you busy?” > **Ankit:** “Not really.” > **Matei Zaharia:** “Okay, I got this important change to the readme. Can you take a look and tell me which version you prefer? Thanks, yeah, I shared my session with you.” > **Ankit:** “All right, let me take a look. I know the—I know the agent said that joke one is better, but I kind of like joke two.”
Ankit joins the running session in real time, inspects the active diff, leaves feedback, and issues prompts straight to Zaharia's agent. All collaboration steps, conversation threads, and artifact mutations are archived centrally on the Omnigent server for future auditing and analysis, after which Zaharia transitions to demonstrating execution policies.
[20:24](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=1224s) Stateful Policies and Budget Controls in Omnigent
Matei Zaharia turns his live demo to stateful policies, highlighting how Omnigent continuously tracks the exact dollar cost incurred by each agent in real time right at the top of the interface. Rather than relying on static permissions, Omnigent enables contextual, state-dependent policies. To demonstrate this capability live, Zaharia walks through setting a dynamic budget limit on an active session. Because the session has already accrued approximately $0.25 in model consumption, he jokes that he will configure a deliberately silly constraint: instructing the system to trigger a user confirmation prompt whenever the agent tries to spend more than 20 cents. He then assigns the agent a heavy task requiring extensive file reading, showing that as the model starts processing and exceeds the defined threshold, execution immediately pauses and requests explicit user permission before proceeding.
Beyond single-session safeguards, these stateful policies allow users to govern complex hierarchical workflows, such as dictating that a primary agent can spin up a sub-agent but cap that sub-agent's maximum expenditure at a single dollar. For organizations and enterprise environments, administrators can define and manage these governance rules centrally across an entire team. In the demo, approving the prompt allows the agent to resume its task, while a separate hard ceiling—such as stopping execution altogether once it hits $5—remains enforced in the background. Emphasizing the versatility of this meta-layer, Zaharia points out that this control mechanism functions uniformly across any underlying agent model, whether running Claude, Codex, or another system entirely, noting that these examples only scratch the surface of what contextual policy enforcement can do.
```mermaid flowchart TD accTitle: Stateful Policy and Budget Guardrail Flow accDescr: An illustration of Omnigent evaluating agent cost against dynamic budget rules and triggering user approvals.
subgraph AgentExecution["Agent Execution"] Task["Agent Task Assigned<br>(File Reading / Sub-Agent)"] SpendTracker["Spend & State Tracker<br>(Tracks Real-Time $)"] end
subgraph PolicyEngine["Stateful Policy Evaluation"] CheckLimit{"Spend > Configured Limit?<br>(e.g., $0.20 Prompt / $5.00 Hard Stop)"} end
subgraph Resolution["Action & Governance"] AskUser["Pause & Request User Permission"] Continue["Approved: Continue Task Execution"] HardStop["Hard Ceiling: Terminate Execution"] end
Task --> SpendTracker SpendTracker --> CheckLimit CheckLimit -->|"Under Limit"| Continue CheckLimit -->|"Threshold Exceeded"| AskUser CheckLimit -->|"Max Ceiling Reached"| HardStop AskUser -->|"User Approves"| Continue ```
- Real-time spend tracking is displayed directly within the Omnigent interface for every active agent. - Policies can be contextual and state-aware, such as requiring manual sign-off when a spend threshold is crossed or enforcing hard spend caps. - Budget restrictions can be delegated down to spawned sub-agents (e.g., granting a sub-agent a maximum allocation of $1.00). - Policies can be configured centrally by administrators to standardize cost and security guardrails across teams.
---
[22:01](https://www.youtube.com/watch?v=3Xv0VjYhpCk&t=1321s) Why Open Source Omnigent and What Comes Next
Stepping back into his presentation slides to conclude the talk, Zaharia addresses why Databricks decided to release such a feature-rich platform as open source rather than keeping it proprietary. In his view, agent development has reached a juncture where tooling must transcend individual, siloed harnesses and SDKs, requiring a shared meta-harness layer. “We think this meta harness layer is going to be needed and it'll benefit from being open the same way that data formats and uh, sharing uh, protocols and stuff like that benefit from being open because it's an ecosystem things where people sort of have to agree on a way to do it to make it work well,” Zaharia explains. Databricks already relies heavily on Omnigent internally, and the open-source repository received significant community contributions within days of its initial public appearance.
Another major motivation for open-sourcing Omnigent is solving the universal UI and management overhead faced by every team building custom AI agents. Regardless of whether an agent is designed for writing code or handling domain-specific business logic, developers invariably need an application layer equipped with real-time collaboration, sharing, access controls, and security. Omnigent supplies that complete, turnkey application layer out of the box, even supporting a mobile client interface for interacting with agents on the go. Looking ahead, Zaharia previews upcoming developments, including broader ecosystem integration and automated agent optimization techniques. He summarizes the project's core philosophy by emphasizing that working above the individual harness transforms organizational productivity, allowing not just core software engineers but also product managers and designers to collaborate with AI agents daily.
- Omnigent is open-sourced to establish a vendor-neutral, shared standard analogous to open data formats and data-sharing protocols. - The project provides an out-of-the-box open-source application framework featuring collaboration tools, security policies, and mobile interface access for any agent workflow. - Future roadmap milestones include expanded ecosystem support and automated optimization for agent execution. - Internal adoption at Databricks spans cross-functional teams, enabling product managers and designers as well as engineers to build and interact with agents directly.
## Mentioned Matei Zaharia, Databricks, Omnigent, Genie, Claude, Claude Code, Codex, Cursor, Antigravity, OpenAI Agents SDK, Polly, Ankit, Model Context Protocol, Harvey AI, Anthropic, UC Berkeley, PostgreSQL, Docker, OpenTelemetry, GitHub, Slack, Google Docs
## Video description Introducing Omnigent: A Meta-Harness for AI Agents
Omnigent makes AI agents interoperable, so sessions, policies, and skills stay with users regardless of where the agent or model is running.
Learn more about Omnigent: https://www.databricks.com/blog/introducing-omnigent-meta-harness-combine-control-and-share-your-agents
00:00 — Why the agentic stack needs a new layer 01:55 — What's an AI agent harness? 02:40 — The problem with too many harnesses 03:40 — The interoperablity hurdle 07:52 — Introducing Omnigent 10:19 — Composition, collaboration, and control 12:06 — Matei demos Omnigent 22:03 — Why open source Omnigent?
Presenters: Matei Zaharia, Co-founder and CTO, Databricks
[Source](https://www.youtube.com/watch?v=3Xv0VjYhpCk)