---
title: "Databricks Omnigent vs. Neutral Context Layer for AI Agents"
url: "https://atlan.com/know/ai-agent/databricks/databricks-omnigent-vs-neutral-context-layer/"
description: "Omnigent controls how AI agents run, while a neutral context layer controls what they know. See how Databricks Omnigent vs. a neutral context layer compare."
author: "Kovid Rathee"
author_role: "Head of Solution Architecture, Data & AI, Nexifi"
published: "2026-10-06"
updated: "2026-10-06"
---

> Atlan is hosting Context Conference, bringing together the leaders and builders at the frontier of giving AI the context it needs to understand their business. It runs online on October 28, 2026, from 11:00 AM to 2:00 PM ET. Atlan co-founder Prukalpa Sankar opens and closes the day. Leaders from AstraZeneca, BNY and Verizon share why they invest in context and what they get from it. Registrants get early access to The AI Context Gap, a new study from MIT Technology Review Insights. Register: https://atlan.com/context-conference/

---

Databricks Omnigent decides how your agents run. It does not decide what they know. Atlan, the [context layer for AI agents](https://atlan.com/know/context-layer-for-ai-agents/), supplies that second half: certified definitions, lineage, ownership, and policy context served through the [Atlan MCP server](https://atlan.com/know/what-is-atlan-mcp/) to Claude Code, Codex, Cursor, Pi, and custom agents alike. The two layers sit at different points in the stack, so the real design question is where each agent gets its business meaning once you stop standardizing on a single harness.

### Find the Context Gap Behind Your Meta-Harness

Takes your harnesses, what each one reads, and where definitions live, and returns the context gaps a meta-harness cannot fill, ranked, plus what to certify first. [Read the skill](/skills/meta-harness-context-gap-check.md).

*Paste into a new chat*

```
Use the skill at https://atlan.com/skills/meta-harness-context-gap-check.md to find the context gaps in our multi-harness agent setup. Ask me for whatever it needs.
```

*Run once in a terminal*

```
curl -fsSL --create-dirs \
  -o ~/.agents/skills/meta-harness-context-gap-check/SKILL.md \
  https://atlan.com/skills/meta-harness-context-gap-check.md
```

*For an agent*

```
curl -fsSL https://atlan.com/skills/meta-harness-context-gap-check.md
```


    Human
    Agent


  ClaudeChatGPTGeminiCursorOther
  Copy

.skp{margin:1.75rem 0;padding:1rem 1.125rem 1.125rem}
.skp h3{margin:0 0 .375rem!important;font-size:20px!important;line-height:24px!important;
 font-family:var(--font-funnel-display)!important;font-weight:600!important;color:#2B2B39!important}
.skp > p{margin:0 0 .875rem!important;font-size:14px!important;line-height:22px!important;color:#555572!important}
.skp > p a{color:#2026D2;text-decoration:underline}
.skp-box{margin-bottom:.75rem}
.skp-p em{display:block;font-size:10px;font-weight:700;letter-spacing:.06em;text-transform:uppercase;
 color:#F34D77;font-style:normal;margin-bottom:.25rem}
.skp-p > p{margin:0!important}
#seo-layout article .skp .skp-p pre{margin:0!important;overflow-x:auto}
#seo-layout article .skp .skp-p pre code{color:#2B2B39!important;font-size:12px!important;line-height:19px;
 white-space:pre-wrap;overflow-wrap:anywhere;background:none;padding:0;
 font-family:ui-monospace,SFMono-Regular,Menlo,monospace}
.skp-p + .skp-p{margin-top:.625rem}
.skp-cs{display:flex;flex-wrap:wrap;align-items:center;gap:.375rem}
.skp-seg{display:inline-flex;flex:0 0 auto;border:1px solid #DDDDE3;border-radius:999px;overflow:hidden;background:#fff}
.skp-m{min-height:32px;padding:.25rem .75rem;border:0;background:transparent;font-family:inherit;color:#77778E;cursor:pointer}
.skp-m:hover{color:#2026D2}
.skp-m.on{background:#2026D2;color:#fff}
.skp-sep{flex:0 0 auto;width:1px;height:20px;background:#DDDDE3;margin:0 .25rem}
.skp-tools{display:inline-flex;flex-wrap:wrap;gap:.375rem;min-width:0}
.skp-cp{margin-left:auto;min-height:32px;padding:.25rem .75rem;border-radius:999px;background:#fff;
 font-family:inherit;color:#555572;cursor:pointer}
.skp-cp:hover{border-color:#2026D2!important;color:#2026D2}
.skp-cs .skp-c{display:inline-flex!important;width:auto;flex:0 0 auto;align-items:center;gap:.375rem;
 min-height:32px;padding:.25rem .625rem;border-radius:999px;background:#fff;font-family:inherit;
 color:#555572;cursor:pointer}
.skp-cs .skp-c img{display:block!important;width:14px!important;height:14px!important;
 max-width:14px!important;flex:0 0 auto;opacity:.55;margin:0}
.skp-c:hover img,.skp-c.on img{opacity:1}
.skp-cs .skp-c:hover{border-color:#797DE4!important;color:#2026D2}
.skp-cs .skp-c.on{border-color:#2026D2!important;background:#F4F4FD;color:#2026D2}
.skp-agent .skp-tools,.skp-agent .skp-sep{display:none}

(function(){
  var p=document.querySelector('.skp[data-skill="meta-harness-context-gap-check"]');if(!p)return;
  var panes=p.querySelectorAll('.skp-p');
  function show(id){panes.forEach(function(x){x.hidden=x.dataset.skp!==id;});}
  function cur(){var a=p.querySelector('.skp-p:not([hidden]) pre code');return a?a.textContent:'';}
  show('prompt');
  p.querySelectorAll('.skp-p em').forEach(function(e){
    var par=e.parentElement;
    ((par.tagName==='P'&&par.textContent.trim()===e.textContent.trim())?par:e).hidden=true;
  });
  p.querySelectorAll('.skp-c').forEach(function(b){
    b.addEventListener('click',function(){
      p.querySelectorAll('.skp-c').forEach(function(x){var on=x===b;x.classList.toggle('on',on);x.setAttribute('aria-pressed',on);});
      show(b.dataset.skp);
    });
  });
  p.querySelectorAll('.skp-m').forEach(function(m){
    m.addEventListener('click',function(){
      var agent=m.dataset.skpMode==='agent';
      p.classList.toggle('skp-agent',agent);
      p.querySelectorAll('.skp-m').forEach(function(x){var on=x===m;x.classList.toggle('on',on);x.setAttribute('aria-pressed',on);});
      if(agent){show('agent');}else{var s=p.querySelector('.skp-c.on');show(s?s.dataset.skp:'prompt');}
    });
  });
  var c=p.querySelector('[data-skp-copy]');
  c.addEventListener('click',function(){
    navigator.clipboard.writeText(cur()).then(function(){
      c.textContent='Copied';setTimeout(function(){c.textContent='Copy';},1600);
    });
  });
})();

| Dimension | Databricks Omnigent | Neutral context layer |
| :---- | :---- | :---- |
| Primary role | Runs agents | Informs agents |
| What it controls | Tool calls, LLM requests, and file operations | Business meaning |
| Core capabilities | Composition, policies, and sandboxing | Definitions, lineage, and ownership |
| Portability | Swaps harnesses | Keeps context usable across every harness |
| Interfaces | A uniform agent API | Open protocols such as MCP and A2A |
| Risk it reduces | Runaway costs and unsafe actions | Conflicting agent answers |

---

## Why does Databricks Omnigent matter?

According to the [Databricks announcement](https://www.databricks.com/blog/introducing-omnigent-meta-harness-combine-control-and-share-your-agents) (June 13, 2026), Omnigent is an open-source meta-harness released under the Apache 2.0 license. It sits above the agents a team already uses, including Claude Code, Codex, Pi, and custom agents, and makes them interoperable. The [Databricks release notes](https://docs.databricks.com/aws/en/release-notes/product/2026/june) list Omnigent as a Beta feature from June 17, 2026.

The pitch is easy to follow. Teams now run several coding assistants and agent SDKs side by side, and each one carries its own configuration, sessions, and permission model. A [meta-harness is a different layer from a framework](https://atlan.com/know/ai-agent/agent-harness-vs-agent-framework/): it wraps harnesses instead of replacing them, and the [harness engineering](https://atlan.com/know/what-is-harness-engineering/) work moves up one level.

Omnigent bets on three things: composing agents, controlling them with policies, and collaborating live with teammates. The [Omnigent on Databricks documentation](https://docs.databricks.com/aws/en/omnigent/) describes the result as a common layer that lets you swap or combine harnesses without rewriting, with policies and sandboxing on top.

### Why was Omnigent built, and what does it fix for engineers?

Omnigent targets the friction that shows up once a team uses more than one harness. Engineers copy text and code between tools by hand. They keep separate harness, SDK, and model configurations current. They stitch sessions together across tools with little structure, and they rewrite code when they swap one harness for another. Omnigent attacks continuity and consistency across those agents, SDKs, and harnesses.

It stops there. Omnigent does not decide which definition of "active customer" an agent should apply, who owns a metric, or whether a column holds restricted data. That job belongs to a [context layer](https://atlan.com/know/what-is-context-layer/) that no single harness owns, which is the argument behind [single-stack lock-in versus a neutral context layer](https://atlan.com/know/ai-agent/context-layer/single-stack-lock-in-vs-neutral-context-layer/).

---

## How does the Databricks Omnigent meta-harness work?

Most harnesses share a shape: a chat interface that accepts files and makes tool calls, often reachable from a web app and a terminal UI. Codex has the [Codex SDK](https://learn.chatgpt.com/docs/codex-sdk), which controls local Codex agents programmatically. Claude Code has the [Claude Agent SDK](https://code.claude.com/docs/en/agent-sdk/overview), which runs the same agent loop as a library in Python and TypeScript. Omnigent wraps layers like these to give you cross-harness support through three features.

* **Composition** lets you define a harness-agnostic agent, pick its runtime, prompts, and LLM, and run subagents of one agent on different harnesses. The [agent YAML specification](https://github.com/omnigent-ai/omnigent/blob/main/docs/AGENT_YAML_SPEC.md) lists the harness values you can pick, from `claude-sdk` and `codex` to `cursor`, `pi`, and custom ACP agents. The [custom agents documentation](https://omnigent.ai/docs/use/custom-agents) shows an agent defined in a short YAML file with harness, model, prompt, MCP, and policy sections.
* **Control** applies [policies](https://omnigent.ai/docs/policies/overview) to every tool call, LLM request, and file operation. A policy can allow an action, ask for approval, or deny it, and it can track session state such as cumulative spend. [Omnibox](https://omnigent.ai/docs/omnibox) adds an OS-level sandbox with filesystem isolation, a default-deny network proxy, and placeholder credentials instead of real secrets.
* **Collaboration** lets teammates share live sessions that run on one or more harnesses.

### How to set up the Databricks Omnigent meta-harness

You install the `omni` command first. The [install guide](https://omnigent.ai/quickstart/install) offers curl, uv, and Homebrew routes and expects Python 3.12 or later, Node.js 22, and tmux. After `omni setup` configures credentials, you choose one of three ways to work.

1. Coding agents
2. Built-in multi-agent orchestrators
3. Custom agents

### Omnigent setup with coding agents

The [coding agents page](https://omnigent.ai/docs/use/coding-agents) covers spinning up agents with commands such as `omni claude` and `omni codex`. You can also import existing sessions with `omnigent import --harness claude --session `.

### Omnigent setup with built-in multi-agent orchestrators

Pick this route when one workflow should span several harnesses. The [built-in agents page](https://omnigent.ai/docs/use/builtin-agents) lists two orchestrators.

* **Polly** breaks a coding task into subtasks and hands them to agents on different harnesses, each in its own git worktree. Run `omni polly`.
* **Debby** is a multi-model brainstorming partner that queries more than one model and supports extended debate. Run `omni debby`.

### Omnigent setup with custom agents

Choose the [custom agents route](https://omnigent.ai/docs/use/custom-agents) when you want your own agents and orchestrators. The built-in orchestrators are plain YAML, so they double as templates. Behind every route, the [Omnigent server and runner](https://omnigent.ai/docs/deploy/overview) do the same work.

1. The server persists every conversation, message, and tool call in Postgres or SQLite, holds the catalog of registered specs, proxies MCP tool calls with server-side policy enforcement, and handles built-in accounts or OIDC/SSO.
2. A runner, one per session, executes the agent loop, manages the harness, runs tools, and streams events back to the server.
3. Web, terminal, and mobile interfaces talk to the server, never to the runner directly.

On Databricks, the [Omnigent documentation](https://docs.databricks.com/aws/en/omnigent/) describes a fully managed server and integration with Foundation Model APIs and Unity Gateway. [Databricks Sandbox](https://docs.databricks.com/aws/en/compute/serverless/sandbox) (Beta) can host an agent harness, and the Databricks announcement names [Databricks Apps](https://docs.databricks.com/aws/en/dev-tools/databricks-apps/), Lakebase, and Unity Catalog among its integration points. [Unity Gateway](https://docs.databricks.com/aws/en/ai-gateway/) governs LLM, MCP server, and coding-agent traffic, and our [Unity AI Gateway explainer](https://atlan.com/know/ai-agent/databricks/unity-ai-gateway/) covers how that control plane fits next to a context layer.

None of this, wherever you run it, tells an agent what your tables mean. Policies govern what an agent may do. Sandboxes contain what it can reach. Neither carries organizational grounding, awareness of systems outside the harness, or the tribal knowledge that decides whether an answer is right. That gap is [business context for AI](https://atlan.com/know/business-context-for-ai/), and it follows the agent whichever harness runs it.

---

## What is a neutral context layer and how does it work?

A context layer is an architectural component between an organization's enterprise systems and its AI agents. It accumulates and curates knowledge about systems, processes, and ways of working so agents can retrieve semantic context, entity resolution, permission resolution, freshness, lineage, and provenance. Our guide to [what an enterprise context layer actually is](https://atlan.com/know/what-is-the-enterprise-context-layer/) goes deeper on each of those.

A context layer earns the word neutral when it meets four tests.

* **No vendor lock-in.** It stores business logic, rules, policies, and definitions in open formats, so the knowledge stays available to every agent whichever harness it runs on. Open table formats help here: [Apache Iceberg](https://iceberg.apache.org/) lets multiple engines, including Spark, Flink, and Trino, read the same tables safely.
* **Standard protocols.** It serves context over [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro), an open standard for connecting AI applications to external systems, and speaks [A2A](https://a2a-protocol.org/latest/), the open standard for agent-to-agent communication. The [Open Semantic Interchange](https://snowflake.com/en/news/press-releases/snowflake-salesforce-dbt-labs-and-more-revolutionize-data-readiness-for-ai-with-open-semantic-interchange-initiative) initiative, announced September 23, 2025 with Atlan among its partners, defines a vendor-neutral semantic model specification. Our pieces on [why MCP matters for agents](https://atlan.com/know/mcp/why-mcp-matters-for-ai-agents/), [MCP versus A2A](https://atlan.com/know/mcp/mcp-vs-a2a-protocol/), and the [Google A2A protocol](https://atlan.com/know/google-a2a-protocol/) cover how the three fit together.
* **Tool-agnostic.** The [semantic layer for AI agents](https://atlan.com/know/ai-agent/semantic-layer-for-ai-agents/) does not hang off one harness, one agent SDK, or one foundation model provider, which keeps switching costs low.
* **Humans on the loop.** People certify and label context, so the layer stays high-signal. The [difference between a context layer and a semantic layer](https://atlan.com/know/ai-agent/semantic-layer/context-layer-vs-data-catalog-vs-semantic-layer/) matters here, because certification covers more than metric definitions.

---

## Databricks Omnigent vs. neutral context layer: key differences

The two layers answer different questions about the same agent.

| Question | Databricks Omnigent | Neutral context layer |
| :---- | :---- | :---- |
| What role does it play? | Makes harnesses and agents interchangeable with little effort | Grounds agents in organizational knowledge |
| Where does it sit? | Across and above harnesses, agent frameworks, and coding assistants | Between the harness or meta-harness and enterprise systems such as databases, documentation, and infrastructure |
| What do agents get from it? | Sandboxed environments with their own sessions | Curated context about the business: definitions, quality, lineage, and policy rules |
| What problem does it solve? | Too many harnesses force constant translation, so an API layer absorbs it | Organizational knowledge sits in many shapes and places, so a governed layer serves it |
| Is it vendor-locked? | Omnigent is Apache 2.0 licensed and the [repository](https://github.com/omnigent-ai/omnigent) is public, so you can run it on your own infrastructure or on Databricks | A truly neutral layer is not locked to one vendor |

On Databricks, agents can also draw on metadata already registered in Unity Catalog, such as [Unity Catalog metrics](https://atlan.com/know/ai-agent/databricks/unity-catalog-metrics/) and [Genie ontology](https://atlan.com/know/ai-agent/databricks/genie-ontology/). That covers the data assets Unity Catalog manages. Large organizations also keep context in systems outside it: other warehouses, BI tools, ticketing and documentation systems, and the people who know why a definition changed. Our look at [Genie context requirements](https://atlan.com/know/ai-agent/databricks/databricks-genie-context-requirements/) shows the same boundary from inside one Databricks product, and the [Agent Bricks overview](https://atlan.com/know/ai-agent/databricks/agent-bricks/) shows it again for agents built on the platform.

When several agents from several harnesses answer the same question, [enterprise context silos](https://atlan.com/know/enterprise-context-silos-ai-teams/) turn into conflicting answers. [Context management across multi-agent systems](https://atlan.com/know/context-management-multi-agent-systems/) breaks without one shared layer, and a meta-harness that lets you mix harnesses freely raises the stakes on that layer. A neutral context layer for enterprise AI such as Atlan gives every agent the same governed answer, whichever harness it runs on.

---

## How does Atlan provide a neutral context layer for the Omnigent meta-harness?

[Atlan](https://atlan.com/) is the [Context Layer for AI](https://atlan.com/context-layer/). Its [Context Lakehouse](https://atlan.com/context-lakehouse/) stores metadata in Apache Iceberg tables, so context stays readable by SQL engines without going through Atlan. That is the open-formats test from the previous section, applied to Atlan's own storage.

The delivery route for agents is MCP. According to the [Atlan MCP documentation](https://docs.atlan.com/product/capabilities/atlan-ai/how-tos/atlan-mcp-overview) (2026), Atlan MCP is a hosted server on every tenant, implements the open Model Context Protocol, and respects the permissions already set in Atlan. The [MCP tools reference](https://docs.atlan.com/product/capabilities/atlan-ai/references/mcp-tools) lists tools for semantic search, asset search, lineage traversal, and business glossary work, each marked Read, Write, or Admin. Our explainer on [how the Atlan MCP server builds context](https://atlan.com/know/what-is-atlan-mcp/) walks through them, and [MCP for data lineage](https://atlan.com/know/mcp/mcp-for-data-lineage/) shows what queryable lineage gives an agent.

Behind that interface, Atlan builds three things for agentic retrieval.

* An [Enterprise Data Graph](https://atlan.com/know/enterprise-data-graph/) captures assets, ownership, and granular lineage across enterprise systems, ready for graph traversal. It is the same [knowledge graph for AI agents](https://atlan.com/know/what-is-a-knowledge-graph/) idea applied to your estate.
* An [Active Ontology](https://atlan.com/know/what-is-active-ontology/) holds a business-specific glossary plus domain and metric definitions, aligned with the Open Semantic Interchange standard.
* [Context Engineering Studio](https://atlan.com/context-engineering-studio/) builds [Context Repos](https://atlan.com/know/ai-agent/context-repository-for-ai-agents/) for specific use cases and runs evaluations on them, and [Context Agents](https://atlan.com/context-agents/) work from the same context.

Freshness and certification decide whether an agent can trust what it reads. [Context freshness](https://atlan.com/know/ai-agent/context-freshness/) and [context poisoning](https://atlan.com/know/context-poisoning/) both get worse as you add harnesses, because each new agent is another reader of whatever is stale or wrong.

### How can an Omnigent agent use the Atlan MCP server?

Two documented routes exist, and both use standard MCP configuration.

On your own infrastructure, the [Omnigent tools documentation](https://omnigent.ai/docs/build/tools) shows a remote MCP server declared under `tools` in the agent YAML with `type: mcp` and a `url`, plus optional `headers` for credentials and a `tools` allow-list. An allow-list matters in practice: expose the read-only search, lineage, and glossary tools first and keep Write and Admin tools off until you have reviewed them.

```yaml
tools:
  atlan:
    type: mcp
    url: https:///mcp
    tools: [semantic_search, traverse_lineage]
```

On Databricks, the [MCP Services documentation](https://docs.databricks.com/aws/en/agents/mcp-tools/mcp-services) describes registering an external MCP server as a Unity Catalog securable, with EXECUTE grants, tool selection, service policies, and audit logging. Registration happens through the UI or REST API. The URL above is a placeholder: use the endpoint and authentication method from the Atlan MCP documentation for your tenant.

---

## What should you check before wiring context into a multi-harness setup?

A meta-harness makes it cheap to add a fourth harness and expensive to notice that all four answer from different definitions. Five checks catch most of the damage before it ships.

1. **List the harnesses and the context each one reads.** Each harness loads its own instruction files, memory, and tools. The [agent harness failures and anti-patterns](https://atlan.com/know/agent-harness-failures-anti-patterns/) are mostly context that one harness has and another lacks.
2. **Name the five or six business terms agents get wrong most often.** Revenue, active customer, churn, and a handful of others carry most of the disagreement. Put one certified definition for each in one governed place.
3. **Route lookups through one interface.** MCP gives every harness the same entry point, so a definition changes once.
4. **Test with the same question on every harness.** A question that returns different numbers on two harnesses points to a context gap, not a harness bug. This is where [data quality for agent harnesses](https://atlan.com/know/data-quality-ai-agent-harnesses/) pays off.
5. **Decide who certifies.** Context without an owner drifts, and [what makes data AI-ready](https://atlan.com/know/ai-agent/data-for-ai/what-makes-data-ai-ready/) starts with named owners.

[Best AI agent harness tools](https://atlan.com/know/best-ai-agent-harness-tools-2026/) compares the runtimes themselves, and [how to build an AI agent harness](https://atlan.com/know/how-to-build-ai-agent-harness/) covers the engineering underneath. This page covers the part neither one reaches.

---

## Databricks Omnigent vs. neutral context layer for AI: moving forward

Coding assistants and harnesses such as Claude Code, Codex, Cursor, Antigravity, and Pi each ship with their own structure. Demand to cut the friction between them keeps rising, both for multi-agent work and for moving from one harness to another. Omnigent answers that with a harness for harnesses: a uniform API for composition, control, and collaboration, deployable on your own infrastructure or on Databricks.

It leaves the context problem open. A neutral context layer pulls context from enterprise systems and serves it through open protocols, which is how Atlan built its enterprise context layer. An Omnigent agent can reach it through MCP today. What stays unsettled is how much of the certification work teams will automate and how much they will keep human, and that choice shapes every agent you add.

---

## FAQs about Databricks Omnigent vs. neutral context layer for AI agents

### 1. What is Databricks Omnigent? Is it another agent framework?

Omnigent is an open-source meta-harness that sits on top of coding assistants, agent SDKs, and harnesses. It lets you work with several harnesses at once, including separate ones for subagents. It is not an agent framework. It is a harness for harnesses.

### 2. Which AI agents or harnesses does Databricks Omnigent support?

Databricks names Claude Code, Codex, Pi, and custom agents, and the Omnigent documentation also covers Cursor, Copilot, Hermes, and Devin. The agent YAML specification lists harness values for Claude, OpenAI Agents SDK, Codex, Cursor, Pi, Antigravity, Qwen Code, Kimi, Kiro, Copilot, Hermes, and custom ACP agents. Support levels vary by harness, so check the current documentation before you commit.

### 3. Is Omnigent only available in Databricks?

No. Omnigent is an open-source project under the Apache 2.0 license. You can run it on your own machine or server with credentials for the harnesses you use. Databricks also offers a managed deployment.

### 4. Where and how do you run Omnigent agents?

You can run Omnigent agents locally or on Databricks. After you install `omni` with curl, uv, or Homebrew, you start agents with commands such as `omni claude` or `omni polly`. A local run opens a web interface, which the documentation lists at `http://localhost:6767`.

### 5. Can an Omnigent agent use the Atlan MCP server?

Yes, through standard MCP configuration. On your own infrastructure, declare the Atlan MCP server under `tools` in the agent YAML and limit it with a tool allow-list. On Databricks, you can register it as an MCP Service in Unity Catalog. The agent then reaches asset search, business glossary, lineage, and more, under the permissions set in Atlan.

---

## Sources

1. Introducing Omnigent: A Meta-Harness to Combine, Control and Share Your Agents, Databricks, 2026. https://www.databricks.com/blog/introducing-omnigent-meta-harness-combine-control-and-share-your-agents
2. June 2026 release notes, Databricks Documentation. https://docs.databricks.com/aws/en/release-notes/product/2026/june
3. Omnigent on Databricks, Databricks Documentation. https://docs.databricks.com/aws/en/omnigent/
4. Omnigent server and runner, Omnigent Docs. https://omnigent.ai/docs/deploy/overview
5. Contextual policies, Omnigent Docs. https://omnigent.ai/docs/policies/overview
6. Omnibox, Omnigent Docs. https://omnigent.ai/docs/omnibox
7. Install, Omnigent Docs. https://omnigent.ai/quickstart/install
8. Coding agents, Omnigent Docs. https://omnigent.ai/docs/use/coding-agents
9. Built-in multi-agent orchestrators, Omnigent Docs. https://omnigent.ai/docs/use/builtin-agents
10. Custom agents, Omnigent Docs. https://omnigent.ai/docs/use/custom-agents
11. MCP and tools, Omnigent Docs. https://omnigent.ai/docs/build/tools
12. Agent YAML specification, omnigent-ai/omnigent, GitHub. https://github.com/omnigent-ai/omnigent/blob/main/docs/AGENT_YAML_SPEC.md
13. omnigent-ai/omnigent repository (Apache 2.0), GitHub. https://github.com/omnigent-ai/omnigent
14. Databricks Sandbox, Databricks Documentation. https://docs.databricks.com/aws/en/compute/serverless/sandbox
15. Databricks Apps, Databricks Documentation. https://docs.databricks.com/aws/en/dev-tools/databricks-apps/
16. Unity Gateway overview, Databricks Documentation. https://docs.databricks.com/aws/en/ai-gateway/
17. Connect agents to tools with MCP Services, Databricks Documentation. https://docs.databricks.com/aws/en/agents/mcp-tools/mcp-services
18. Codex SDK, OpenAI Codex Documentation. https://learn.chatgpt.com/docs/codex-sdk
19. Agent SDK overview, Claude Code Docs, Anthropic. https://code.claude.com/docs/en/agent-sdk/overview
20. What is the Model Context Protocol (MCP)?, modelcontextprotocol.io. https://modelcontextprotocol.io/docs/getting-started/intro
21. Agent2Agent (A2A) Protocol, Linux Foundation. https://a2a-protocol.org/latest/
22. Apache Iceberg, Apache Software Foundation. https://iceberg.apache.org/
23. Snowflake, Salesforce, dbt Labs, and More Revolutionize Data Readiness for AI with Open Semantic Interchange Initiative, Snowflake, 2025. https://snowflake.com/en/news/press-releases/snowflake-salesforce-dbt-labs-and-more-revolutionize-data-readiness-for-ai-with-open-semantic-interchange-initiative
24. Atlan MCP overview, Atlan Documentation, 2026. https://docs.atlan.com/product/capabilities/atlan-ai/how-tos/atlan-mcp-overview
25. Atlan MCP tools reference, Atlan Documentation, 2026. https://docs.atlan.com/product/capabilities/atlan-ai/references/mcp-tools
26. Context Lakehouse, Atlan, 2026. https://atlan.com/context-lakehouse/