Databricks Big Book of AgentOps Drops

Databricks published the Databricks Big Book of AgentOps on September 2 as a playbook for running agents that reason, call tools and touch enterprise data.

This isn't a model drop. It's an operations manual for the moment the demo has to survive permissions, audits and the bill.

AgentOps is Databricks' term for building, evaluating, governing and improving agents in production. It pulls architecture, observability, security and cost into one repeatable process.

That distinction matters. An agent isn't a prompt and response. It picks tools at runtime, pulls data, calls APIs and chains steps on its own.

Every choice is a failure point. A bad tool call, an overbroad permission, a retry loop that quietly multiplies spend.

How agent failures pile up

Picture an agent as a junior analyst with a corporate card and API keys. One request fans out into several model calls once sub-agents, retries and guardrail checks kick in.

The book maps four agent architectures and four deployment patterns to that reality. Everything from a single workspace to a multi-account, multi-agent enterprise topology.

The throughline is platform control, not app-level patches. MLflow for evaluation and tracing, Unity Gateway for model and tool traffic, and Unity Catalog for discovery, lineage and access.

It also lists anti-patterns Databricks sees stall pilots. Starting too broad, jumping to multi-agent orchestration too early, adding a reasoning loop you don't need, leaving evaluation until the end.

The lifecycle section makes the cost point explicit. Attribute usage per request, set limits, assign ownership. Skip that and finance learns about scale from the invoice.

DevOps principles carry over as flow, feedback and continuous learning. Build a golden evaluation set from real traces, calibrate automated judges against subject matter experts, then let evaluation drive what ships next.

A worked customer email agent shows judges, human review and rules checks working together. A telecom support example goes deeper, down to schemas and billing sub-agent tooling where one customer must never see another's data.

What the book still doesn't solve

The case studies do the persuading.

FactSet turned a text-to-code assistant into a full agent system for a 44% accuracy gain. DXC Technology now runs three agents in production with eight more in pilot after cutting platform TCO by 30% on Databricks. Intercontinental Exchange hit 77% syntactic accuracy and 96% execution matches on a governed text-to-SQL agent. Block reports $10 million in productivity gains from seller operations agents governed via Unity Catalog.

Useful numbers, but self-reported and Databricks selected. No disclosed baselines, query distributions or time windows to stress test them.

The book's strongest push is governance early. Controls buried inside each app get harder to audit as agent count grows. The proposed fix is a platform layer for policy, tracing and permissions.

That's also where the gap sits. The guidance is Databricks native by design. Teams not on Unity Catalog and Unity Gateway will need to map the patterns to their own stack. And that recent Unity Gateway case that cut $1.2 million in agent waste shows the cost lever is real, but only if tracing is actually wired up before scale.

Stakeholder alignment gets its own chapter for a reason. A RACI matrix and communication cadence for sponsors, product, SMEs, security, compliance and finance. Good engineering alone doesn't ship agents.

Databricks, now at a $190B valuation after its $5B strategic financing in 2026, is betting the next enterprise lock-in isn't the model but the control plane around it. The book is the pitch for that plane.