Databricks Summit 2026 🏛️ Hail The Emperor 🤴

“Saluta l’Imperator Databricks, Lakehouse in stream.
Veni, vidi, vici frà, agenti in collab: dream team.”
(adapted from “Saluta i king” by Club Dogo)

---

🏛️ The Five Pillars Of Modern Analytics

Before the Emperor starts handing swords to agents, Databricks wants to make one thing very clear: Modern analytics is not “dashboards plus a chatbot.” It’s a stack.

A governed stack where data, pipelines, semantics, dashboards, and conversational agents all stand on the same foundation instead of living in five rival provinces with five definitions of revenue.

Databricks frames this around five pillars.

1. Lakehouse Architecture: The Stone Floor

First, the empire needs a foundation. The lakehouse combines open storage formats, cloud object storage, and Unity Catalog governance so analytics does not depend on fragile extracts, proprietary silos, or secret dashboard kingdoms.

🏛️ In Roman terms: one capital, many provinces, fewer illegal spreadsheet republics.

2. Data Engineering And Preparation: The Roads

Data doesn’t arrive clean, fresh, and business-ready because Jupiter smiled upon the pipeline. It has to be ingested, transformed, orchestrated, monitored, and prepared.

That’s where Lakeflow enters: connectors, declarative pipelines, jobs, and low-code preparation trying to turn the messy middle of data engineering into something less like plumbing archaeology.

The Queen built the roads. The Emperor intends to send agents across them.

3. Unified Semantics: The Law

This is where things get serious. If Finance, Sales, Marketing, BI, SQL, and AI agents all define customer, revenue, or churn differently, you don’t have self-service analytics. You have civil war with charts.

Metric Views and Unity Catalog Business Semantics move key definitions into the governed platform so dashboards, notebooks, SQL users, and agents can reuse the same business logic.

The empire needs roads. But it also needs laws.

4. AI-Powered Dashboards: The Oracle With Charts

Dashboards are not dead. They are becoming smarter, easier to build, and more connected to governed data and shared semantics.

The old dashboard answered: What happened?
The new AI-powered dashboard should help answer: Why did it happen, what changed, and where should I look next?

The oracle still shows the chart. Now the oracle also speaks. Naturally, the Senate should still check its sources.

5. Conversational Agents: The Citizen’s Advisor

Finally, analytics leaves the priesthood. AI/BI Genie gives business users a way to ask questions in natural language over governed data, Metric Views, and curated context.

That is the dream: fewer tickets, fewer dashboard clones, fewer “can you pull this for me?” messages at 5:47 p.m.

But this is also where the story becomes imperial. Because once users stop only viewing dashboards and start asking agents to explain, compute, summarize, schedule, recommend, or act, analytics becomes something bigger.

The five pillars give the empire its analytical foundation. The agentic layer asks the harder question: Who governs the work? 🤔

---

🗺️ Genie Ontology: The Imperial Census Of Enterprise Context

Every empire needs a census. Not because counting citizens, roads, grain shipments, suspicious goats, and governors with creative accounting habits is fun. Because power without context becomes chaos.

That’s the role Databricks wants Genie Ontology to play in the agentic enterprise.

Modern companies are not marble temples of knowledge. They are messy civilizations of tables, dashboards, notebooks, Jira tickets, Google Docs, SharePoint folders, Slack wisdom, ancient PDFs, abandoned experiments, and business logic nobody remembers approving.

Now unleash an agent into that.

A generic agent searches live, opens too much, misses the authoritative source, burns tokens, apologizes politely, and returns with a beautifully formatted lie.

Very elegant. Very expensive. Very wrong.

Genie Ontology is Databricks’ attempt to solve that problem by building the context map before the question arrives. Not at runtime, while the agent panics. Before.

👑 Instead of forcing every agent to rediscover the business from scratch, Genie Ontology extracts knowledge from enterprise assets, connects it into a living context graph, ranks authority, and enforces permissions.

No map, no empire. Just sandals, panic, and bad SQL.

The Problem: Runtime Wandering

The classic agent loop looks heroic until the invoice arrives.

A user asks a question. The agent searches documents, samples tables, opens dashboards, follows stale links, retries with more context, calls a larger model, and somewhere in the distance Finance hears boss music.

This creates three problems.

First, enterprise context is not a pile of files. It’s a graph. Pipelines create tables. Tables feed dashboards. Dashboards influence decisions. Queries reveal what people actually trust. Jira tickets explain why the metric changed. Notebooks contain both genius and crimes against joins.

A blind agent often stops at the first plausible artifact. That’s how you get a confident answer from a deprecated dashboard, a sandbox table, or Kevin’s notebook from 2021. Kevin is gone. His join condition remains.

Second, stale context does not delete itself. Obsolete KPI decks, abandoned forecasting notebooks, and temporary dashboards sit in the estate like cursed scrolls. A model can summarize them perfectly. That is the terrifying part.

The grammar is alive. The business answer is dead.

Third, live retrieval is expensive. Every search, schema inspection, table sample, document load, tool call, retry, and “let me verify that” loop burns latency and tokens.

At enterprise scale, that is how your AI program becomes a golden aqueduct pouring money into the sea.

The point of Genie Ontology is simple: If the platform already knows which sources matter, the agent does not need to rummage through the whole empire every time someone asks, “Why did Q3 revenue move?”

Less wandering. Less guessing. Less “Ave, Caesar, your token budget is dead.”

The Census: Context Before The Question

This is the interesting architectural move. Databricks is not saying: Just give the model a bigger context window. That’s the enterprise equivalent of solving city planning by building a larger cart.

Genie Ontology tries to precompute useful business context from the assets the company already uses: tables, queries, dashboards, pipelines, notebooks, documents, tickets, connected apps, and usage patterns.

👑 The goal is not only to know that a table exists. The goal is to know what it means, who uses it, which assets depend on it, which definitions repeat, which dashboards are trusted, which authors seem authoritative, what is fresh, what is stale, and what this specific user is allowed to see.

That matters because enterprise truth rarely lives in one perfect file called truth.md. It’s distributed across systems, people, usage, lineage, and institutional habit.

🏛️ In Roman terms: the census doesn’t create the empire, it makes the empire legible.

OntoRank: PageRank For Corporate Reality

Databricks described OntoRank as similar in spirit to PageRank. But instead of ranking web pages, it ranks business context.

A naive keyword search sees “Q3 sales” and returns 45,000 dashboards, notebooks, docs, tables, and query fragments. Chronological chaos.

An authority-aware system asks better questions: Which source is certified? Who authored it? How often is it used? Is it fresh? Does it connect to trusted assets? Do other assets agree with it? Can this user actually access it?

That distinction matters.

The Finance dashboard may outrank the random notebook. The current Metric View may outrank the old quarterly deck. The trusted owner may matter more than the loudest keyword match.

Same parchment. Different authority.

OntoRank is basically asking: Did this scroll come from the imperial archive, or from a guy outside the Forum selling premium prophecy?

Permission-Aware Context: The Border Guards

A unified context graph is powerful. It’s also dangerous if badly governed.

If the ontology learns from a restricted payroll spreadsheet, confidential board deck, or sensitive customer table, it must not casually paraphrase that knowledge to someone without access.

Otherwise, congratulations. You built a very elegant data exfiltration machine wearing a toga.

This is why permission-aware context is not a side detail. It’s the product. The graph cannot become a shadow access layer. If a user cannot access the source, its snippets should not slip into the answer dressed as imperial gossip.

This matters because agents don’t merely retrieve data. They remix it. They summarize it. They infer from it. They turn small leaks into polished paragraphs.

In the agentic era, access control cannot stop at the table gate. The border guards now inspect context.

The Census Is Not The Law

This is the part worth being careful about.

👑 An ontology is not automatically truth.

A graph can connect bad definitions. It can rank stale assets if stale assets are still popular. It can reflect organizational confusion with impressive confidence.

That’s why Genie Ontology should not replace curated semantics.

Some definitions are too important to infer from vibes: ARR, gross margin, net revenue retention, active customer, payroll cost, legal entity, risk tier.

Those are not suggestions. Those are imperial law. They need owners, review, certification, lineage, and governance.

👑 The best architecture uses both. Curated semantics for sacred business truth. Inferred ontology for the messy operational long tail.

Use only curated semantics, and you get twelve perfect metrics while the rest of the empire remains foggy.

Use only inferred ontology, and you get broad coverage with the occasional hallucinated decree from a provincial goat.

Neither is ideal.

The Senate writes the law. The census maps the provinces. The agent needs both.

👑 The Emperor’s Verdict

Genie Ontology turns enterprise context into infrastructure. That’s the big idea.

Agents should not rediscover the business from scratch every time someone asks a question. They need a governed map of trusted definitions, useful assets, relationships, owners, freshness, authority, and permissions before they act.

The upside is obvious: faster answers, fewer retrieval loops, lower token waste, and less chance of citing a zombie dashboard with excellent confidence.

But the ontology is only as good as the signals behind it. Bad metadata, stale dashboards, weak ownership, and contradictory definitions do not magically become truth because a graph connects them.

So the practical lesson is simple:

• Use curated semantics for high-stakes metrics.
• Let ontology map the operational long tail.
• Monitor conflicts.
• Retire obsolete assets.
• Treat metadata quality as production quality.

Because in the agentic era, bad metadata is not just messy. It becomes executable confusion.

---

🧠 Unity Catalog Semantics: The Senate Writes The Laws Of Meaning

An empire doesn’t collapse only when barbarians reach the gates. Sometimes it collapses because every province defines revenue differently.

Finance counts recognized revenue. Sales counts bookings. Marketing counts influenced pipeline. Customer Success counts expansion. The dashboard says one thing, the notebook says another, and somewhere an executive asks: Why are there four truths?

Welcome to semantic drift.

In the chatbot era, semantic drift was annoying. In the agentic era, it becomes dangerous.

Because an agent won’t merely report the wrong number. It may update a forecast, recommend a discount, trigger a workflow, notify Sales, generate an executive summary, and then explain to the CFO that the numbers are “directionally aligned.”

Which is corporate Latin for: prepare the lions.

If Genie Ontology is the imperial census, Unity Catalog Semantics is the Senate’s law code.

The ontology observes the empire. The Senate writes the laws. And if the Senate doesn’t write them, the agents will infer them.

Nobody wants that.

Metric Views: The Fiscal Statutes

For decades, metrics lived inside tools. Tableau had one formula. Power BI had another. Looker had LookML. dbt had a model. SQL had five versions. Excel had an unsupervised senator using SUMIFS() with the confidence of Caesar crossing the Rubicon.

That was already painful with humans. AI makes the mess scale.

Now thousands of users, and soon thousands of agents, can ask: What is ARR? What changed in churn? Which customers are at risk? Why did margin drop in EMEA?

If the semantic layer is fragmented, the agent sees a battlefield of plausible definitions and chooses one with imperial confidence.

👑 That’s why metrics can no longer be trapped inside dashboards. A certified metric needs to become a governed data product: reusable, documented, permissioned, lineage-aware, and available across analytics surfaces.

Not a chart calculation. Not a wiki paragraph. Not tribal ceremony. A constitutional object.

Grain: Where Empires Accidentally Get Rich

Every metric has a grain. This sounds boring until it ruins your quarter.

Customer revenue is not subscription revenue. Subscription revenue is not invoice-line revenue. Invoice-line revenue is not “I joined three fact tables and accidentally multiplied Rome by twelve.”

Metric Views help by forcing teams to define the important parts explicitly: sources, fields, measures, filters, joins, and aggregation logic.

That matters because a human analyst might inspect the join. An agent might simply say: The query succeeded.

Congratulations. The robot has discovered a fan-out trap and called it growth.

👑 A successful SQL query is not always a correct business answer.

The Senate exists to remind the oracle of that.

Agent Metadata: Teaching The Oracle Human Words

Machines don’t only need formulas. They need language.

A field called cust_ltv_adj_90d may be meaningful to its creator and absolutely nobody else on Earth.

Agent metadata adds the human layer: display names, descriptions, synonyms, formatting rules, and instructions that help AI systems map messy human questions to governed business concepts.

When someone asks, “Show customer lifetime value by region,” the agent shouldn’t treat the catalog like a cursed crossword puzzle.

It should understand that “CLV,” “LTV,” “customer value,” and “customer lifetime value” may all point to the same governed concept.

👑 This is where semantics becomes AI infrastructure.

Not because the model is stupid. Because companies are full of acronyms, renamed teams, inherited systems, regional terminology, and business words that behave like shapeshifters.

A semantic layer gives the oracle a dictionary. Without it, every acronym becomes prophecy.

Domains And Glossary: Provinces And Law Dictionaries

No agent should reason over the entire empire at once. That’s not intelligence. That’s context indigestion.

Domains organize the estate into business provinces: Finance, Sales, Marketing, Security, Product, Billing, Tax, Support, Incident Response.

Same word, different province.

In Marketing, incident may mean a campaign issue. In Security, it may mean an active breach. In Finance, it may mean someone approved a spend request containing the phrase “strategic synergy.”

Domains give agents scoped meaning. Glossary terms give them definitions.

Metric Views answer: How do we calculate this?
Glossary terms answer: What does this mean?
Ontology answers: Where does this meaning appear across the empire?

Together, they form the semantic constitution. Without them, every agent becomes a tiny lawyer inventing precedent in real time.

Terrible idea. Extremely billable.

The Senate And The Census Must Work Together

This is the important architectural distinction.

👑 Unity Catalog Semantics is curated. Genie Ontology is inferred.

One is law. The other is census.

The Senate says: This is the official ARR definition.
The census says: Here is where ARR appears, who uses it, which dashboards depend on it, which queries reference it, and where contradictions may exist.

Use only curated semantics, and you get perfect definitions for twelve sacred metrics while the operational long tail stays foggy.

Use only inferred ontology, and you get broad coverage with occasional probabilistic nonsense wearing a laurel crown.

Use both, and agents get something closer to enterprise common sense.

Still not human. But less likely to classify a deprecated dashboard as divine revelation.

Semantics Must Be Operated, Not Announced

The dangerous part of a semantic layer is that everyone loves it in a slide. Then nobody wants to maintain it.

👑 But semantics is not a one-time architecture project. It’s operating discipline.

Metrics need owners. Definitions need review. Deprecated measures need retirement. Breaking changes need communication. Contradictory KPIs need escalation. Versioning matters. Testing matters. Lineage matters. Adoption matters.

If nobody owns the law, the law becomes folklore. And folklore is exactly what agents are dangerously good at summarizing.

👑 The Emperor’s Verdict

Unity Catalog Semantics makes business meaning governable. That’s the real point.

Metrics can no longer live as private formulas scattered across dashboards, BI tools, notebooks, SQL scripts, and spreadsheets. In the agentic era, contradictions do not just create arguments. They create wrong actions.

• Metric Views give critical KPIs one governed home.
• Agent metadata gives AI systems the words and context they need to understand those KPIs.
• Domains and glossary terms keep meaning scoped, discoverable, and human-readable.

But none of this works by decree alone.

• Start with the metrics that already cause pain: ARR, churn, gross margin, active customer, pipeline, renewal risk.
• Define owners.
• Define grain.
• Define measures, fields, joins, filters, and formatting.
• Add synonyms and descriptions for humans and agents.
• Treat semantic definitions like code: reviewed, tested, versioned, promoted, deprecated.

Because agents don’t need more dashboard theology. They need law.

---

🔮 AI/BI: The Imperial Oracle Receives Strict Statutes

The oracle is not dead. It has learned to generate charts.

For decades, BI was the sacred dashboard altar of the enterprise. Executives asked, “How stands the wealth of our provinces?” and the oracle answered with a line chart.

Then the data priesthood descended into the SQL catacombs to explain why revenue meant four different things across regions, tools, and fiscal curses.

So no, generative AI will not kill BI. BI survived OLAP cubes, manual extracts, cursed PowerPoints, dashboard sprawl, and three generations of “self-service analytics.” BI will survive chat.

Because an empire cannot be governed by random questions shouted into a text box. That’s not an operating model. That’s chaos with autocomplete.

The real shift is not that dashboards disappear. The shift is that dashboards become conversational, semantic, governed, and connected to the same laws of meaning used by agents.

🏛️ In Roman terms: The oracle may speak freely, but now the Senate checks its sources.

Dashboards Are Ritualized Answers

Dashboards are boring until they fail. Then everyone suddenly rediscovers religion.

Core KPIs are not one-off curiosities: revenue, margin, pipeline, churn, infrastructure health, supply chain delays, customer activation, security posture. These are recurring questions.

Every Monday morning, the governors should not rediscover how tax revenue is calculated. They should read the certified edict, understand the state of the empire, and move on before someone asks for “just a quick export.”

Dashboards are ritualized answers. They are stable places where the organization agrees: This is the number. This is the trend. This is the definition. This is where we look first.

AI/BI does not remove that ritual. It makes it more useful.

A user sees a chart move. They ask why. Genie investigates within the governed context of the dashboard, its datasets, and the semantic layer behind it.

That’s the right division of labor:

• Dashboards answer recurring questions.
• Genie handles the follow-up questions.

Without that split, every variation becomes a new dashboard.

One chart for Finance. One chart for Sales. One chart for “temporary analysis.” One chart nobody owns. One chart that somehow runs the company.

Rome didn’t fall in a day. It fell one duplicated dashboard at a time.

Genie Spaces: Computing Answers, Not Reciting Scrolls

Generic AI assistants are charming storytellers. They summarize old memos, paraphrase stale reports, and read ancient planning documents with beautiful grammar and no operational truth.

Useful? Yes. Enough for BI? No.

If a leader asks, “Why did activation drop yesterday in France?”, the answer should not come from a Q1 strategy PDF. It should come from governed, current business data.

That’s where Genie Spaces matter. A Genie Space is not just RAG over dusty scrolls. It’s a domain-specific conversational interface where users ask natural-language questions and get SQL queries, result tables, charts, and explanations over governed data.

The oracle is conversational. But the answer is computed. And computation is where governance can bite.

👑 Tables are permissioned. Metric Views are curated. Dashboard datasets are scoped. Unity Catalog knows who can access what.

The oracle doesn’t get to wander into the treasury just because it speaks in a soothing tone.

The Dashboard And The Chat Must Share The Same Law

The worst AI/BI architecture is simple: The dashboard uses one definition. The chatbot uses another. The notebook uses a third. The agent uses an abandoned query because it looked “highly relevant.”

That’s not self-service analytics. That’s semantic gladiator combat.

The point of connecting AI/BI to Unity Catalog Semantics and Metric Views is to keep dashboards and conversations under the same constitution.

A certified metric should be defined once and reused across dashboards, SQL, notebooks, Genie, alerts, external BI tools, and agents.

The magic is not that Genie can talk. Everyone can make something talk now. The magic is whether the thing talking is grounded in the same governed metric layer as the rest of the business.

Otherwise, conversational analytics becomes conversational contradiction.

With confidence. With charts. Very dangerous.

Ask Genie: The Oracle Inside The Temple

The dashboard-chat relationship becomes especially interesting with companion Genie Spaces.

A published dashboard can expose an Ask Genie experience so viewers can start from a chart and ask natural follow-up questions.

That’s where conversational BI belongs. Not as a floating chatbot with access to the entire empire. As an oracle attached to a governed temple.

A user sees revenue drop and asks: Which products contributed most? Was this driven by one region? Is this margin or volume? How does it compare to last year? Which customer segment changed?

This avoids the classic dashboard explosion where every follow-up question becomes another permanent visual monument.

The dashboard remains the official edict. Genie becomes the investigative augur beside it.

Very useful. Still needs supervision. Because when Genie is attached to a dashboard, the key question is not only what the chart shows. It’s what the underlying dataset exposes.

Don’t put forbidden scrolls backstage and assume nobody will ask the oracle about them.

The oracle reads the backstage notes. Design your datasets like a paranoid Roman border official.

BI Becomes A Front Door, Not A Dead End

This is the deeper point. Traditional dashboards often ended the conversation.

Here is the chart. Good luck.

Modern AI/BI should start the next conversation: Why did it move? What changed? Which segment matters? What is the anomaly? What should we inspect next?

That changes BI from a static reporting surface into a governed analytical front door.

But the front door must still open into the right building. If the dashboard is built on weak semantics, stale data, unclear ownership, or overly broad datasets, adding chat does not fix the problem. It accelerates the confusion.

AI-powered dashboards are only as trustworthy as the data, metrics, and permissions underneath them.

The oracle is powerful. The temple still needs foundations.

👑 The Emperor’s Verdict

AI/BI is not the death of dashboards. It’s dashboards plus governed conversation.

• Dashboards give the recurring answers.
• Genie handles the follow-up questions.
• Metric Views keep the meaning consistent.
• Unity Catalog keeps access under control.

That is the useful version.

The dangerous version is a chatbot bolted onto dashboard chaos, confidently explaining metrics nobody defined, over datasets nobody scoped, with permissions nobody reviewed.

So the practical lesson is simple:

• Treat dashboards as governed products.
• Build them on certified metrics.
• Expose only the datasets needed for exploration.
• Attach Genie where follow-up questions are valuable.
• Review what the companion space can see.
• Monitor usage and feedback.
• Retire dashboards that have become imperial ruins.

Because conversational BI only works if the conversation obeys the same laws as the dashboard.

Otherwise, you do not get an oracle. You get a rumor machine with charts.

---

🧞 Genie One: The Imperial Advisor For Every Citizen

The old enterprise had a hierarchy. Executives had dashboards. Analysts had SQL. Data engineers had notebooks. Everyone else had tickets, waiting periods, and the spiritual burden of writing: Could you please pull this data for me?

That was not democratized intelligence. That was a priesthood with a backlog.

Genie One is Databricks’ attempt to break that bottleneck without handing every citizen raw database access and a ceremonial sword.

The strategy is not: Let every business user query production tables and discover governance through litigation.
The strategy is: Give every user a governed AI coworker that can ask questions, find context, open dashboards, create documents, schedule tasks, use approved tools, and route work through the same control plane as the rest of the platform.

🏛️ In Roman terms: The citizen gets an advisor. The advisor still needs papers at the gate.

Genie Spaces Were Provinces. Genie One Is The Capital.

Genie already existed before this Summit, mostly as Genie Spaces: curated, domain-specific rooms for asking questions about a focused slice of data.

Each space is like a provincial office. Finance has one. Marketing has one. Procurement has one. Customer Support has one.

Each knows its territory, its tables, its trusted queries, its glossary, and its favorite ways of confusing newcomers.

Genie One changes the posture. It becomes the broader front door for business users: one place to ask questions, discover dashboards, use Genie Spaces, create documents, schedule work, and connect to the systems where work actually happens.

A Genie Space is a governed province. Genie One is the imperial reception hall.

The user shouldn’t need to know whether the answer lives in a dashboard, a Metric View, a query, a SharePoint file, a Google Drive document, or a suspicious spreadsheet created during the reign of Hadrian.

They should ask. The system should route. The governance should hold.

Simplicity Is A Security Feature

Enterprise tools usually fail adoption the same way. Too many tabs. Too many permissions. Too many acronyms. Too many dashboards that look official until someone quietly admits the real number lives somewhere else.

When official systems are too hard, users do not become more compliant. They become creative. They export data. They paste snippets into public AI tools. They build local spreadsheets. They ask the one person who “knows the numbers.” That person goes on vacation. The empire panics.

This is why Genie One matters as an interface strategy.

👑 The easiest path should also be the governed path.

That sounds like a product slogan, but it is actually a security principle.

If citizens can ask questions, inspect dashboards, and get useful answers inside the governed environment, they are less tempted to smuggle imperial data across the border in a CSV mule cart.

👑 The best compliance interface is not a 90-page policy PDF. It is a useful tool people actually use.

From Answering Questions To Doing Work

Genie One is not just a chat box wearing a purple robe. Databricks is pushing it toward coworker behavior: documents, schedules, alerts, skills, MCP tools, and repeatable workflows.

A user might ask it to prepare a customer brief. Monitor a metric. Draft a business review. Summarize documents. Update a report. Create a reusable skill. Turn a conversation into a dedicated agent.

That’s the shift from analytics assistant to operational coworker.

A chatbot answers. A coworker acts. And once an agent can schedule, monitor, write, generate, call tools, or update systems, the governance stakes change completely.

That is powerful. It’s also how a helpful robot becomes a compliance incident with excellent formatting.

So the story is not only: Genie One can do more.
The story is: Genie One can do more while Databricks tries to keep the action inside governed rails.

The advisor can leave the library. But the guards follow.

Live Data Beats Polished Scrolls

Generic AI assistants are very good at reciting old scrolls. They can summarize a Q3 memo, paraphrase a PDF, and produce a majestic answer from numbers that expired three reorganizations ago.

Useful? Yes. Enough for enterprise intelligence? No.

If a regional manager asks, “Why did activation drop yesterday in France?”, the answer should not come from a stale planning deck. It should come from governed, current business data.

That’s the advantage Databricks is trying to claim with Genie One. Not just conversation. Routing.

The system can move across Genie Spaces, dashboards, queries, Metric Views, documents, and connected sources, then compute or retrieve the answer from the right place.

Generic assistant: Prompt ➜ old documents ➜ plausible summary ➜ polished illusion.

Genie One: Prompt ➜ governed context ➜ trusted assets ➜ computed or retrieved answer ➜ citations.

That last part matters. Not decorative citations. Operational citations.

Users and auditors need to know whether an answer came from a governed table, a dashboard, a Metric View, a document, or an external system.

Because in the agentic empire, “trust me, bro” is not lineage. It’s treason with bullet points.

The Advisor Leaves The Palace

One important detail is easy to underestimate: Genie One is not meant to live only inside the Databricks workspace.

It’s moving toward the places where business users already work: chat, mobile, dashboards, documents, meetings, and the eternal thread where someone says “quick question” and accidentally summons an analytics war.

That matters for adoption.

Business users don’t live in warehouses. They live in Slack, Teams, phones, meetings, and recurring status rituals that should have been emails but became governance ceremonies.

Putting the advisor there makes sense. It also raises risk. A user asking from mobile is less likely to inspect SQL, citations, lineage, and permissions like a data engineer at a desktop.

So defaults matter. A lot.

👑 The easier the interface, the stronger the governance underneath must be.

When the oracle fits in your pocket, the border guards cannot take lunch.

Citizen-Scale AI Means Citizen-Scale Blast Radius

This is the part where the demo excitement needs adult supervision.

Genie One lowers the barrier to enterprise AI. Great.

That also means more users asking more questions, creating more documents, scheduling more tasks, generating more agents, and consuming more model capacity.

A single analyst experimenting with AI is manageable. A whole company creating recurring coworkers is a different animal.

One useful conversation becomes a shared agent. A shared agent becomes a scheduled task. A scheduled task becomes recurring cost, tool access, or operational action. Then Finance asks why the token budget looks like a Roman victory parade.

Citizen-scale AI needs citizen-scale governance. Not later. Not after the pilot. At the beginning.

👑 The Emperor’s Verdict

Genie One turns Genie into the citizen-facing interface for the agentic lakehouse.

Every citizen gets an advisor. Now the empire must govern the advisors.

The upside is clear: business users get one front door into governed data, dashboards, documents, tools, tasks, and agents.

But the blast radius expands. A conversation can become an agent. An agent can become a task. A task can become recurring cost, tool access, or operational action.

So rollout must be deliberate.

• Start with high-value domains.
• Use certified Metric Views and governed dashboards.
• Separate read-only advisors from write-capable operators.
• Set budgets and rate limits early.
• Require owners for shared agents, skills, and scheduled tasks.
• Audit citations, tools, permissions, and usage.

Because the future is not every citizen writing SQL. The future is every citizen having an AI advisor.

The Roman question remains: Who governs the advisors?

---

🛡️ Unity AI Gateway: The Praetorian Guard For Models, Agents, MCPs, And Spend

Every empire needs gates. Not decorative gates. Real gates. The kind with guards, ledgers, inspections, and one exhausted official asking why Marketing requested 40,000 denarii for “experimental prophecy.”

That’s the job of Unity AI Gateway.

In the chatbot era, AI governance could ask a relatively simple question: Can this user call this model?

In the agentic era, the question becomes much uglier: Can this user, through this agent, using this model, with this context, call this MCP tool, access this data, trigger this API, spend this much money, and leave an audit trail before the village catches fire?

Welcome to the Praetorian Guard.

Unity AI Gateway is Databricks’ answer to AI sprawl: one governed control point for models, agents, MCP servers, coding tools, skills, spend, traces, permissions, rate limits, routing, and guardrails.

Because the empire doesn’t let every legion buy its own elephants.

The New Shadow IT Wears A Toga

Shadow IT used to be easy to recognize. A rogue spreadsheet. A corporate-card SaaS subscription. An Access database quietly running payroll logic since 2008.

Still horrifying. But recognizable.

The new Shadow IT is stranger: unapproved model keys, local MCP servers, ad-hoc prompt libraries, custom agent skills, coding assistants with broad repository access, ownerless bots, and Slack workflows calling external APIs with the confidence of a drunk centurion.

Individually, each thing looks useful. Together, they become a distributed barbarian confederation with API access.

This creates three big problems.

First, sensitive context leaks. An unmanaged model call can expose source code, customer data, financial logic, strategy, prompts, contracts, or regulated PII because someone pasted “just enough context” into a “quick prototype.”

No gate, no inspection. No inspection, no empire.

Second, accountability disappears. When an agent breaks something, “Who clicked the button?” is no longer enough.

Which user initiated the task? Which agent acted? Which model responded? Which context was injected? Which MCP tool was called? Which policy allowed it? Which response caused the next action?

Without traces, the investigation becomes archaeology.

The robot may improvise. The empire keeps receipts.

Third, the invoice catches fire. Agents don’t spend like humans. They loop. They retry. They call larger models. They invoke tools. They evaluate themselves. They ask for more context. They try again because confidence was only 0.84 and apparently the Treasury exists to fund emotional closure.

That is how “small pilot” becomes “why did the invoice arrive on a horse?”

Cost controls, budgets, usage dashboards, rate limits, and routing policies are not glamorous. They are survival infrastructure.

The Emperor loves innovation. The treasurer loves caps.

Governed Choice, Not Mercenary Model Sprawl

Model leadership changes constantly. Today’s champion is tomorrow’s legacy dependency with a new pricing page.

If every app hardcodes one provider, one model, one key, and one routing rule, the enterprise becomes brittle very quickly.

Unity AI Gateway pushes a better pattern: Applications, agents, and coding tools go through a governed endpoint. That endpoint routes to approved model backends. Policies, rate limits, guardrails, logs, and budgets travel with the request.

👑 The app should not care whether a task goes to a frontier model, a cheaper model, a local model, or a fallback route. That decision should be governed centrally.

Simple classification? Use a smaller model.
Sensitive workload? Keep it inside approved boundaries.
Expensive reasoning? Use the imperial oracle only when the task deserves imperial money.
Model outage? Fail over without rewriting the app.

This is not “use every model chaotically.” That is a barbarian market with API keys. This is governed choice.

Different legions. One command structure.

Runtime Policy: Law At The Gate, Not In A PDF

A policy trapped in a compliance document is theater.

Beautiful theater. With footnotes. But still theater. Agentic AI needs policy that executes at runtime.

When a request arrives, the system should inspect it, route it, limit it, log it, sanitize it, block it, or allow it.

Low-risk actions may only need logging, cost controls, and privacy guardrails.

High-risk actions need more. Writing to a CRM. Opening Jira tickets. Changing production code. Sending external messages. Touching payroll. Triggering customer workflows.

Those are not “just prompts.” Those are actions. And actions require law.

The agent can suggest. The gate decides.

Guardrails Are Useful. They Are Not Magic Walls.

Guardrails matter. They can inspect inputs and outputs, detect risky content, and help enforce privacy, safety, and compliance rules.

Good. Very good. But a guardrail is not a divine force field blessed by Jupiter.

Guardrails have scope. They depend on what content is inspected, what policies are defined, and what the tool layer exposes.

They may not understand every hidden side effect, external API behavior, prior turn, binary artifact, system instruction, or operational consequence.

So use them. But do not worship them.

A guardrail is one checkpoint in the gate system. Not the entire wall of Rome.

👑 The proper architecture combines guardrails with permissions, rate limits, endpoint controls, trace logging, MCP governance, model routing, human approvals, and boring old access design.

The empire survives through layers. Not vibes.

MCP Governance: Giving Models Hands Without Losing Fingers

Models think. MCP gives them hands. That’s why MCP governance matters.

A model that answers can be wrong. A model connected to tools can be wrong and do things. Search files. Query data. Call APIs. Update tickets. Read repositories. Touch operational systems. Start workflows.

In Databricks’ architecture, MCP servers become governed resources instead of random side doors. They can be registered, permissioned, monitored, and brought under Unity AI Gateway visibility.

That matters because agents discover and use tools dynamically. If the tool layer is unmanaged, your security model has a hole shaped exactly like: But it was just an MCP server.

And that is how barbarians enter the city disguised as productivity.

Coding Agents: The Praetorian Guard Enters The IDE

The gateway story is not only about business chatbots. It also reaches developers.

Coding agents can read codebases, generate changes, call tools, run commands, and spend tokens faster than a junior engineer with twelve terminals and no fear.

Wonderful. Terrifying. Both.

A coding agent with no central governance can leak secrets, call expensive models indefinitely, use unmanaged tools, and generate changes nobody can trace.

This is why the IDE is now a frontier province. Send guards.

Governance belongs at the point of execution. Not after code has been generated. Not after secrets have been pasted. Not after a local tool spent three days calling the most expensive model because someone typed “full auto” and went for coffee.

At the gate.

The Imperial Ledgers: Usage, Traces, And AI Telemetry

If you cannot inspect AI behavior, you cannot govern it.

The gateway turns AI activity into telemetry: who called what, which endpoint was used, which model responded, how much was consumed, what failed, what was blocked, and which tools were involved.

That telemetry is gold. It’s also dangerous.

Prompts and responses may contain secrets, PII, source code, customer data, pricing strategy, legal language, or confidential business logic.

So the ledger must be governed like production data. Not dumped into a random schema named ai_logs_fun.

The ledger is useful because it records the empire. The ledger is dangerous because it records the empire. Guard the ledger.

Budgets And Rate Limits: The Treasury Gets A Sword

Rate limits control throughput. Budgets control spend visibility and alerts. Together, they make AI usage administrable.

This is where AI adoption becomes AI operations.

A demo does not need a treasury model. A fleet of agents does.

Endpoint limits help prevent overload. Budget filters help attribute spend by team, project, product, or cost center. Per-user or per-group controls help prevent one enthusiastic citizen from discovering infinite reasoning at imperial expense.

Free frictionless access is not automatically democratization. Sometimes it’s just a very elegant invoice cannon.

The goal is not to make AI hard to use. The goal is to make the governed path easier than the bypass.

Because if the official road is slow, confusing, and bureaucratic, users will build side roads. And side roads rarely have guards.

👑 The Emperor’s Verdict

Unity AI Gateway turns AI governance into runtime control. That’s the point.

The upside is clear: model traffic becomes visible, costs become attributable, agents become traceable, MCP tools become governable, and AI activity becomes something the enterprise can actually inspect.

But the gate is not magic marble. Guardrails have limits. Logs can become sensitive. Hard caps can break workflows. Painful onboarding creates bypasses. Centralized control without good developer experience becomes a rebellion with API keys.

So the practical rule is simple:

• Make the governed road easier than the bypass.
• Route model, agent, MCP, and coding-tool traffic through the gateway.
• Tag endpoints.
• Set budgets early.
• Use rate limits before the invoice catches fire.
• Govern telemetry like production data.
• Separate read-only advisors from write-capable operators.
• Require owners for every agent, skill, MCP server, and endpoint.

Because the Emperor may command the empire. But the Praetorian Guard watches the gate.

---

When your AI agents stop wandering the empire and finally get a map, laws, guards… and a token budget.

---

🧞‍♂️ Genie Agents: The Legions Leave The Palace

Genie One is the imperial advisor at the palace gates. Genie Agents are the legions sent into the provinces.

The enterprise doesn’t need one giant omnipotent bot with infinite confidence, unclear permissions, and a sword.

That’s not architecture. That’s how a chatbot from Marketing ends up interpreting payroll policy, querying finance metrics, updating CRM, and announcing victory in Slack before Legal opens the first scroll.

The agentic enterprise needs specialized garrisons. Finance agents. Procurement agents. Security triage agents. Customer support agents. Product telemetry agents.

Each should know its province, laws, tools, owner, budget, and marching limits.

A legion without orders is not an army. It’s an armed expense report.

👑 That’s the promise of Genie Agents: focused AI coworkers that reason over governed context and perform repeatable work.

The legions are leaving the palace. Somebody had better issue marching orders.

From Genie Spaces To Operational Agents

Genie Spaces were already useful. They gave teams domain-specific conversational analytics over governed data: natural-language questions, generated SQL, result tables, charts, and explanations.

Very good for analytics. Very useful for self-service. But corporate work rarely ends at the chart.

A procurement workflow may need spend data, vendor contracts, policy documents, ticket history, and a supplier-risk tool.

A finance close workflow may need Metric Views, variance explanations, notebooks, task checklists, approvals, and comments for the people who mysteriously uploaded numbers at 11:58 p.m.

An HR policy workflow may need documents, eligibility rules, ticket history, and very strict access boundaries.

The old question was: What does the data say?
The agentic question is: What should happen next, and who is allowed to do it?

That’s the leap. A Genie Space answers inside a domain. A Genie Agent helps move the work forward.

👑 This doesn’t mean every Genie Space should become an agent.

Please do not agentify every dashboard. Rome already has enough bureaucracy.

It means the platform now has a path from conversational insight to repeatable operational coworker.

The chart explains the problem. The agent helps carry the work.

Specialized Garrisons Beat One Giant Bot

A universal enterprise bot sounds attractive until it meets reality. Reality contains ambiguity.

The word customer means different things in Sales, Finance, Support, Billing, and Legal.

The word active can mean logged in, paying, contracted, onboarded, or “still receiving emails because nobody cleaned the system.”

The word “incident” can mean a security breach, a support escalation, a campaign failure, or a meeting where someone said “strategic alignment” four times.

A giant general-purpose agent has to resolve all of that from context. A domain-specific agent can be scoped to one province.

That is the garrison pattern: Smaller agents. Clearer context. Narrower permissions. Better evaluation. More accountable ownership. Less chance that a support bot discovers the payroll table and starts making career recommendations.

The future is not one imperial robot. The future is a disciplined army of boringly well-scoped agents.

And in enterprise AI, “boringly well-scoped” is praise of the highest order.

Agents Need Tools. Tools Need Law.

A chatbot can answer. An agent can act. That verb changes everything.

Once connected to MCP servers, functions, or external APIs, an agent can retrieve documents, query systems, open tickets, update records, generate code, and trigger workflows.

A hallucinating model creates confusion. A hallucinating model with write access creates an incident report.

So every tool should be treated as an imperial weapon. Not “just an API wrapper.” A weapon.

👑 A simple risk model helps: Read-only agents can search documents, query tables, inspect dashboards, and summarize evidence.

Draft-only agents can prepare tickets, emails, reports, code, or Slack messages, but a human still executes.

Low-risk action agents can make bounded, logged, reversible changes inside approved systems.

High-risk action agents touch production writes, customer-impacting decisions, payroll, finance, code merges, or external communications.

Those need human approval. Always.

A procurement agent can draft a vendor review. It should not sign the contract.

A support agent can summarize escalation history. It should not refund a customer without policy.

A code agent can propose a fix. It should not merge to production because the tests looked emotionally supportive.

Agents should earn authority gradually. Read first. Draft second. Act later. And only under law.

MCP: The Supply Roads Of The Agentic Empire

MCP gives agents a standard way to connect to tools, resources, prompts, and context.

That’s powerful because agents need hands. But hands without governance are how the robot steals the imperial seal.

In the Databricks story, MCP servers are not supposed to become random side doors. They are supposed to be registered, governed, monitored, and routed through the same control plane as the rest of the agentic stack.

🏛️ In Roman terms: MCP builds roads to the provinces. Unity AI Gateway checks passports at the gates. Unity Catalog decides who may enter the temple.

This matters because tool access is where agentic AI becomes operational.

A model endpoint is one thing. A model endpoint with access to Slack, Google Drive, GitHub, Jira, Salesforce, calendar systems, and internal APIs is another thing entirely.

That’s not a chatbot. That’s a junior employee with supernatural typing speed and questionable judgment.

Supervise accordingly.

Agent Identity: Who Is Marching, And Under Whose Banner?

The oldest automation mistake is letting the tool inherit too much authority from the human who launched it.

A person may have broad access. That doesn’t mean every bot they create deserves the same power.

👑 An agent needs its own identity, scope, owner, purpose, and limits.

The question is not only: Can this user access this table?
It is: Can this agent, created by this team, acting for this user, in this workflow, call this tool, read this document, use this metric, spend this budget, and perform this action?

That’s the agentic security model. Human identity matters. Agent identity matters. Tool identity matters. Context matters. Action type matters.

The old empire checked who entered the gate. The new empire checks who entered, what they carried, which legion they served, which province they were assigned to, and whether they were trying to bring an elephant into the Senate.

Again.

The Agent Passport

Every shared agent should have a passport. Not a decorative description. A real operational identity card.

Name: Quarterly Close Assistant
Owner: Finance Analytics
Domain: Finance / Close
Data scope: Certified Metric Views and approved close tables
Document scope: Accounting policy docs and close checklist
Tool scope: Jira drafts, Slack summaries, read-only Salesforce lookup
Action tier: Draft-only by default
Human approval: Required for external messages and system writes
Budget: Monthly cap and alerts
Trace logging: Enabled
Evaluation set: Close variance questions and known failure cases
Expiration: Review every 90 days

This prevents agent decay. Because agents decay.

Documents change. Metrics change. Schemas change. Policies change. Tool APIs change. A well-configured agent in July can become a liability by November if nobody owns it.

The passport answers the important questions: Who owns this legion? Where may it march? Which tools may it carry? How much may it spend? When must it report back?

Without that, the agent estate becomes a forest of orphan bots doing helpful things nobody remembers approving.

Rome didn’t fear one legion. Rome feared legions that stopped reporting to Rome.

Low-Code Agent Creation: Productivity Or Proliferation?

The magic of Genie Agents is that teams can create specialized agents more easily. That’s also the danger.

Business experts can encode workflows without waiting six months for a platform program. Excellent.

They can also create five agents by Friday. Less excellent.

Agent sprawl is the new dashboard sprawl. At first, it looks like empowerment. Then you wake up with three renewal-risk agents, seven procurement assistants, four HR policy bots, two finance close agents, and a temporary escalation bot still running every morning at 7:00. Nobody knows which one sent the VP a chart from a stale table.

👑 That’s why registries, ownership, expiration policies, budgets, and trace dashboards are not optional. The easier agents are to create, the more aggressively they must be inventoried.

The empire can tolerate many legions. It cannot tolerate unknown legions.

Human-In-The-Loop Is Not Weakness

There is a fantasy version of agents where humans disappear and machines run the empire.

Cute. Also a great opening scene for an audit disaster.

Human-in-the-loop is not failed automation. It’s how serious workflows work.

The right design is not always: Do the thing.
Often it is: Investigate. Draft. Explain the evidence. Prepare the action. Ask for approval. Execute only after confirmation.

This is especially true for high-risk actions: production writes, customer-impacting decisions, financial operations, legal workflows, code changes, and security actions.

👑 A good agent reduces toil. It doesn’t eliminate accountability.

The legion can prepare the road. The commander still signs the order.

👑 The Emperor’s Verdict

Genie Agents turn governed conversations into operational coworkers.

• Genie Spaces answer inside domains.
• Genie One opens the front door.
• Genie Agents move focused workflows from insight to action.

The upside is clear: narrower context, restricted tools, assigned owners, connected data and documents, and no giant company-wide bot with a sword.

But the risks scale fast. Low-code creation creates sprawl. MCP tools increase blast radius. Shared channels create permission challenges. Write-capable agents become production software.

• So start read-only.
• Promote gradually.
• Assign owners.
• Define scope, budget, action tier, evaluation set, and expiration date.
• Route tools through governed connections.
• Log traces.
• Delete dormant agents.
• Require human approval for high-risk actions.

The legions are leaving the palace. The question is whether Rome still knows who commands them.

---

🏗️ Databricks Apps + Genie App Builder: The Empire Gets Vibe-Coded Villas

Dashboards show what happened. Agents discuss what should happen next. Apps let citizens do something.

That’s why the application tier matters.

At some point, all the lakehouse plumbing, semantic law, ontology maps, AI gateways, traces, and Metric Views must reach normal humans who do not want to open a notebook, configure a CLI, or learn why the word cluster gives data engineers a thousand-yard stare.

Business users don’t want raw tables. They want tools.

A sales manager wants a renewal-risk cockpit. A finance analyst wants a close-review app. A support lead wants an escalation console. A procurement team wants a vendor-risk workflow.

Nobody wants to file an IT ticket and wait until the next fiscal reign. That’s the promise of Databricks Apps and Genie App Builder.

The lakehouse stops being only an analytical backend. It becomes an application platform.

🏛️ In Roman terms: The empire is no longer just building aqueducts. It’s building villas. Some will be magnificent. Some will be vibe-coded marble sheds with suspicious plumbing. This is why building codes matter.

Vibe Coding Is A Productivity Miracle And A Governance Fire

Vibe coding changes the economics of internal software.

A domain expert can describe an idea and get a prototype in hours instead of waiting months for eight meetings, three backlogs, and a Jira epic named after a dead emperor.

That’s genuinely exciting. It also creates a new problem:

👑 When apps become easy to create, apps become easy to abandon.

Dashboard sprawl was annoying. App sprawl is a different beast. A stale dashboard lies. A stale app lies and writes back. Different danger class.

The new Shadow IT is not just spreadsheets. It’s micro-apps, tiny portals, quick forms, internal tools, hackathon winners, executive demos that somehow became production, and temporary apps with permanent users.

Rome has seen this movie. The villa starts as a weekend project. Then someone stores the treasury inside.

App Spaces: City Walls For Citizen Builders

The key concept is App Spaces.

Without boundaries, a vibe-coded app is terrifying.

Who can access it? Which tables can it read? Which APIs can it call? Which credentials does it use? Which policies apply? Who owns it? Who pays for it? And why is it querying the entire customer table when it only needed three columns and a prayer?

App Spaces create a governed perimeter for groups of apps. Admins define allowed resources, data access, on-behalf-of-user scopes, and security policies at the App Space level. Apps built inside that boundary inherit the rules.

That’s the right model. Zone the city first. Then let citizens build.

The point is not to stop creativity. The point is to make the creative path safer than the illegal path.

Good governance does not say: No citizen shall build.
It says: Build inside these walls, use these roads, do not tunnel into payroll, and stop storing secrets in JavaScript.

Genie App Builder: The Architect With Catalog Awareness

Generic app builders are fast. But many are blind. They don’t know your catalogs, certified metrics, Unity Catalog policies, business terminology, or why net_rev_adj_v4 survived three finance wars and one executive reconciliation ritual.

Genie App Builder is Databricks’ answer to that gap.
Not just: Make me a React app.
But: Make me an app using the governed data, semantics, and workspace context already inside Databricks.

That matters because enterprise apps usually fail in the wiring.

Which table? Which metric? Which filter? Which permission? Which user identity? Which system owns the truth?

A Databricks-aware builder can start from platform context instead of forcing citizen developers to wire the empire with string literals and hope.

The human still reviews. Always.

But the starting point is better than a generic vibe-coded app wandering through the catalog like a tourist with admin credentials.

The architect has a map. Still check the foundations.

Serverless Micro Apps: No More Always-On Marble Temples

Internal tools have weird traffic patterns.

A quarterly planning app burns hot for one week, then disappears like a New Year’s resolution. A compliance app wakes up during audit season. A troubleshooting console sleeps until something explodes. Running always-on infrastructure for all of that is absurd.

That’s like keeping a full legion outside a villa that gets visitors twice a month.

Serverless Micro Apps change the economics. They run in lightweight isolated runtimes, start when needed, and scale down to zero when idle.

Small tools become viable. Departmental workflows become affordable. Experimental apps become less financially terrifying.

The empire can have many villas without paying guards to stand in empty courtyards all night.

Apps On Marketplace: The Vendor Comes To The Data

The Marketplace story matters too.

Historically, buying a third-party data app often meant moving sensitive data out of your secure environment, setting up pipelines, negotiating security reviews, and praying the vendor’s architecture did not anger the compliance gods.

Apps on Databricks Marketplace flip that model.

The application comes to the customer’s Databricks environment. The data stays closer to where it already lives. The app runs under the customer’s Databricks governance.

That’s not just procurement convenience. It’s a distribution model for enterprise AI and analytics applications.

Vendors can ship apps. Customers can deploy them near governed data. Teams can move faster without copying datasets into another side kingdom.

Rome prefers vendors who come through the gate. Not vendors who ask the treasury to leave the city.

Read-Only Apps Are One Thing. Write-Back Apps Are Another

A read-only app is manageable. Still risky. But manageable.

The moment an app writes back, changes state, updates records, triggers workflows, sends messages, or modifies operational systems, it becomes a production system.

Not a cute internal tool. Not a prototype. Not “just a form.” A production system.

A read-only app can show accounts at renewal risk.

A write-back app can update account notes, override risk scores, create Jira tickets, notify Slack, and change CRM state.

That second app needs serious law: Input validation. Audit logging. Identity propagation. Permission checks. Owner assignment. Rollback strategy. Schema validation. Rate limits. Traceability.

Human approval for risky actions. Because a button is never just a button. A button is a tiny emperor. It issues commands. And tiny emperors need constitutions.

The Proxy Permission Trap

One classic app risk is the proxy permission trap.

A builder has high access. The app runs with broad credentials. A lower-access user opens it. Suddenly, the app reveals data they should never see.

Congratulations. You built a marble backdoor.

This is why identity must be explicit: builder, user, service principal, on-behalf-of-user access, and downstream system.

The app should not become a credential blender where everyone drinks from the builder’s access cup.

The real question is: Can this user, through this app, for this purpose, access this data and perform this action?

That’s the application version of agent governance.

Same empire. Different gate.

The Orphan App Problem

Apps decay. Owners leave. Schemas change. Metrics evolve. APIs deprecate. Security policies tighten. The app remains.

Still polished. Still clickable. Still wrong.

That’s worse than an abandoned notebook because apps face users directly. They look official even when the plumbing is antique and the SQL is nervous.

The same passport discipline used for agents applies here too. Every app needs an owner, scope, identity model, budget, review date, expiration policy, and criticality level.

This sounds bureaucratic. Good. Apps are bureaucracy with buttons. And a button without ownership is how you get an incident titled: Unknown workflow changed customer status for 4,000 accounts.

Engineers Are Not Replaced. They Become City Planners.

Natural-language app builders don’t make engineers obsolete. They move the engineering problem.

Less time hand-building every tiny departmental interface. More time designing safe foundations: App Spaces, reusable templates, approved APIs, write-back services, validation libraries, deployment patterns, observability, security policies, cost controls, and review workflows.

The citizen can build the villa. Engineers design the city plan.

Roads. Zoning laws. Aqueducts. Fire codes. Rules about not connecting the kitchen directly to the treasury.

That’s not a smaller engineering role. It’s a more important one.

👑 Because if everyone can build, the platform must make good building easy and dangerous building difficult.

The future belongs to paved roads. Not heroic manual approvals.

👑 The Emperor’s Verdict

Databricks Apps turn the lakehouse into an application platform.

• Dashboards help citizens see.
• Agents help citizens reason.
• Apps help citizens act.

The upside is clear: governed data, metrics, models, and workflows can become usable interfaces for business users: review queues, approval forms, risk cockpits, operational consoles, marketplace tools, and buttons that actually do something.

But apps change the risk class. A bad dashboard may mislead. A bad app may act.

So build inside governed city walls.

• Create App Spaces before broad app creation.
• Use certified Metric Views for business logic.
• Keep write-back behind reviewed APIs or governed functions.
• Attach every app to an owner, budget, criticality tier, review date, and retirement policy.
• Avoid broad service accounts.
• Watch for proxy-permission leaks.
• Retire orphan apps.

👑 Because low-code doesn’t mean low-risk.

The empire doesn’t need fewer villas. It needs better city planning.

---

🏟️ Agent Bricks + Omnigent: The Gladiator Arena For Developer Agents

At some point, every empire builds an arena. Eventually, some engineer looks at the chaos and says: What if we gathered all the strongest gladiators, handed them weapons, measured the damage, and called it a platform?

Enter Agent Bricks and Omnigent.

Databricks is looking at the exploding world of developer agents: Claude Code, Codex, Cursor-style workflows, LangGraph, CrewAI, custom wrappers, terminal bots, notebook assistants, and mysterious YAML creatures from the frontier.

And it is making a very imperial observation: If developers are going to unleash automated workers across codebases, notebooks, pipelines, tools, repositories, and data models, the empire needs an arena.

Not a lawless pit. A governed arena.

With sandboxes, budgets, memory, policies, evaluation, traces, and guards making sure the gladiator does not “optimize” the production database because a test looked lonely.

Agent Bricks is Databricks’ platform for building, deploying, governing, and improving agents.

Omnigent is the meta-harness for coordinating multiple agent harnesses without forcing developers to copy-paste between five digital interns like a sleep-deprived circus trainer.

🏛️ In Roman terms: Agent Bricks builds the Colosseum. Omnigent organizes the gladiators. Unity AI Gateway checks who paid for the elephants.

The Missing 99% Of Agent Engineering

Building a demo agent is easy now. Painfully easy. Dangerously easy.

• Connect a model.
• Give it tools.
• Add a prompt.
• Ask it to do something impressive.

Suddenly everyone says transformational while procurement quietly wonders whether this needs a new vendor review.

But production agents are not demos.

Production agents need the other 99%: Model choice. Tool access. Context retrieval. Memory. Sandboxing. Deployment. Tracing. Evaluation. Monitoring. Cost control. Security policies. Human approvals. Versioning. Collaboration. Retirement plans. And therapy for whoever owns the incident channel.

That’s the point of Agent Bricks.

👑 Stop treating agents as clever loops around LLMs. Treat them as production software. Software with memory, tools, cost, identity, state, logs, permissions, and failure modes.

A gladiator with a sword is entertainment. A gladiator with network access is infrastructure. Different governance tier.

The Empire Does Not Worship One Gladiator

No single model rules forever. This week, one model wins at code refactoring. Next week, another wins at SQL.

A smaller model wins at cheap classification. A frontier model wins at hard planning. An open model wins because Legal slept better.

A custom model wins because it understands your weird internal ontology and does not ask why the sacred table has seven columns named status.

Hardcoding developer workflows to one model vendor is not strategy. It’s dependency cosplay.

Agent Bricks pushes a better pattern: model choice under a governed platform boundary.

• Cheap models for cheap tasks.
• Specialized models for specialized tasks.
• Frontier models for hard reasoning.
• Custom models where enterprise context matters.
• Fallback routes when a provider breaks.
• Budgets when a developer accidentally starts a philosophical debate between three premium models over a unit test.

The point is not to unleash every model chaotically. That’s not freedom. That’s a barbarian festival with API keys. The point is governed choice.

The Emperor enjoys excellence. The treasury enjoys not paying frontier prices for goat math.

Omnigent: The Meta-Harness Above The Harnesses

Agent harnesses are everywhere now. A harness is the runtime wrapper around an agent: the interface, session state, tools, memory, logs, policies, and execution loop that let a model actually do work.

In plain English: The model is the brain. The harness is the chair, desk, toolbox, notebook, badge, and supervisor. And every harness has its own version of those things.

Its own interface. Its own session. Its own memory. Its own tools. Its own logs. Its own way of failing heroically.

A developer may use Claude Code for one task, Codex for another, a custom Databricks agent for internal workflows, and a separate SDK agent for production automation.

Individually, useful. Together, chaos.

Omnigent is Databricks’ open-source answer to that chaos.

Not another gladiator. The arena manager.

It sits above agents and harnesses, wrapping them behind a common interface so teams can compose them, swap them, share sessions, apply policies, and collaborate without rebuilding everything every time the model fashion cycle changes.

The unit of work stops being: One person prompts one agent in one terminal.

It becomes: A team coordinates multiple agents, tools, policies, and review loops around a shared task.

Individual harnesses are local taverns. Omnigent is the imperial road system between them.

The Gladiator Team Pattern

The strongest agentic workflows will not always be one big model doing everything.

Often, they will look more like teams: A planning agent. A coding agent. A testing agent. A documentation agent. A security-review agent. A cheap worker model. A frontier advisor model. And a human reviewer who still remembers why the old pipeline used that cursed join.

This is where Omnigent becomes useful. It can coordinate multiple agents and harnesses without forcing every tool into one monolithic framework.

Claude Code can sit beside Codex. A custom internal agent can contribute. A human can review the workspace. Policies can follow the session. Costs can be tracked.

The work becomes collaborative instead of trapped inside one terminal on one laptop like a private gladiator match in someone’s basement.

Rome prefers its battles observable.

Sandboxes: The Arena Has Walls

Never let an autonomous coding agent warm up inside the active treasury. That’s the first law of civilized agent engineering.

Databricks Sandbox is the protected arena where agents can compute, test ideas, run code, use tools, launch subagents, and fail safely before anything reaches production.

The architectural point is bigger than the feature itself: Coding agents need isolated execution environments with controlled access to files, networks, secrets, credentials, and governed data.

Because coding agents are powerful for exactly the same reasons they are dangerous. They can read files. Edit code. Install packages. Run commands. Execute tests. Inspect errors. Try again. A poisoned README.A malicious code comment. A compromised package. A prompt-injected issue description.A leaked environment variable. An overeager agent deciding that cleanup means deleting the wrong kingdom.

👑 Sandboxes make mistakes survivable.

The gladiator should be able to fight. The gladiator should not wander into the Senate with a live deployment token.

Agent Memory: The Gladiator Remembers The Last Battle

A coding agent with no memory is exhausting. Every session begins like the founding of Rome.

It doesn’t remember which approaches failed.
It doesn’t remember repository conventions.
It doesn’t remember flaky tests.
It doesn’t remember the team’s catalog pattern.
It doesn’t remember the human already said: Never touch that folder unless Saturn himself approves.

So it asks again. Or worse, it guesses.

Agent Bricks introduces managed memory so agents can persist context and session history across longer work.

That matters because serious work is long-horizon: Refactoring a repository. Debugging a pipeline. Building a data app. Improving an agent. Migrating a workflow. Optimizing a harness.

These tasks do not fit neatly into one prompt and one answer. They require state.

Memory is useful. Memory is also dangerous.

Bad memory becomes institutionalized wrongness. Sensitive memory becomes a security problem. Stale memory becomes a fossil with write access.

So memory needs governance, expiry, visibility, and review.

The gladiator should remember the last battle. Not hallucinate imperial law from an old wound.

Policies That Understand State

Most coding-agent controls are too blunt: Allow. Deny. Ask. Continue.

Better than nothing. Not enough for production agent work.

Good policy should depend on what already happened.

Did the agent download a package? Require approval before pushing code.
Did it touch sensitive data? Block publishing.
Did it access a secret? Restrict network egress.
Did it exceed cost? Pause.
Did it write outside its allowed workspace? Stop the parade.

This is where the meta-harness layer matters.

A single model call is stateless. A real agent session is not. It has history. It has actions. It has files. It has tools. It has cost. It has risk.

👑 Policies should understand the session, not just the latest prompt.

Otherwise, the guard at the gate is checking sandals while the elephant walks through.

Evaluation: The Arena Needs Scorekeepers

The worst agent demo metric is applause. The second worst is vibes.

Production agents need evaluation.

Did the agent solve the task? Did it use the right tool? Did it respect permissions? Did it avoid sensitive data? Did it choose a reasonable model Did it spend too much? Did it produce a correct answer? Did the human accept the result? Did the same workflow work again tomorrow?

This is why traces, benchmarks, human feedback, LLM-as-judge evaluations, regression tests, and cost telemetry matter. Without them, every agent improvement is just a new gladiator costume.

Looks impressive. Might still stab the wrong person.

The arena needs scorekeepers.

👑 The Emperor’s Verdict

Agent Bricks is Databricks’ attempt to make agents production-grade.

Omnigent is the layer for coordinating the messy, multi-harness reality developers already live in.

Together, they say something important: The future of agent engineering is not one model, one prompt, one terminal, one hero. It’s systems.

Teams of agents. Shared sessions. Governed model choice. Sandboxed execution. Persistent memory. Runtime policies. Traces. Evaluation. Budgets. Human review.

That’s the grown-up version of the agentic dream. The danger is also obvious.

Developer agents are powerful actors with access to code, tools, secrets, data, and infrastructure. They can improve productivity dramatically. They can also create very expensive, very fast, very confident accidents.

• So use the arena.
• Require sandboxes.
• Route model calls through governed endpoints.
• Treat memory as sensitive state.
• Evaluate agent behavior continuously.
• Track cost per session, task, model, and team.
• Use human approval where the blast radius is real.

And never forget: A gladiator who can write code is not a toy. He’s a junior engineer with no fear, no lunch break, and root-level ambition.

---

🤴 Final Verdict: Hail The Emperor, But Keep The Senate Awake

Databricks Summit 2026 was not really about giving the artificial brain more IQ. It was about giving it an empire.

Because intelligence without roads is wandering. Intelligence without law is danger. Intelligence without ledgers is bankruptcy with better grammar.

That’s the real shift. The lakehouse is becoming less like a warehouse and more like Rome itself: the place where roads, laws, citizens, advisors, legions, gates, archives, villas, arenas, and treasury controls meet.

Not one more tool. A governed civilization for agents.

And civilization matters because an agent is not a dashboard. A dashboard shows the state of the province.

An agent may enter the province, call the tool, draft the decree, spend the gold, update the record, and return wearing a laurel crown.

Very impressive. Also exactly why the Senate must stay awake.

The winners will not be the enterprises that unleash the loudest oracle. They will be the ones that civilize the oracle.

Define meaning before action. Guard the tools before the legions march. Trace the work before trust expands. Measure value before scaling the spectacle. Retire the ghosts before they haunt production.

That’s the imperial lesson.

The Queen built the foundations. The Emperor brought the command structure.

Now Rome must choose: Spectacle or civilization.

Let the advisors speak. Let the agents march. Let the villas rise. Let the arenas open. But keep the laws visible, the gates guarded, the treasury sober, and the humans accountable.

Because the agentic future will not be won by prophecy. It will be won by the empire that knows which prophecy deserves to become action.

Ave, Databricks. But keep the Senate awake.

Quis custodiet ipsos agentes?

---

“In questo mondo di numeri
Devi essere il numero uno”
(from “Numero uno” by Ensi)

The agents have left the palace: smaller swords, stricter passports, fewer accidental invasions of Finance.