Monte Carlo brings native Agent Bricks observability to Databricks — zero instrumentation required

Ahead of Databricks Data + AI Summit, Monte Carlo is thrilled to launch native observability support for agents built on Agent Bricks. Agent Bricks already writes MLflow trace data to Unity Catalog Delta tables as part of its standard operation. Monte Carlo now reads those traces directly through your existing Databricks connection — no SDK to install, no pipeline to configure, and nothing to deploy on your side. Just connect once, and every agent you run on Agent Bricks is observable.

This is what it means for agent observability to be truly native: it works the way your infrastructure already works, not the way an observability vendor needs it to.

The missing layer in enterprise AI

Enterprises are moving fast on AI agents. They’re building on platforms like Agent Bricks precisely because they want a governed, production-ready path from idea to deployment. But deployment is where most observability stories end, yet it’s where the real challenges begin.

An agent in production is a live system. It retrieves data, calls tools, reasons across steps, and produces outputs that drive business decisions. Any of those steps can degrade silently: a retrieval returns stale data, a tool call fails without surfacing an error, or a response drifts from policy without triggering an alert. Without observability, teams find out when something goes wrong by hearing about it from a user or a downstream system. This is almost always far too late, and typically provides no trail to follow to troubleshoot and prevent it from happening again.

Deploying AI at scale safely requires more than a strong build platform. It requires continuous visibility into what agents are doing in production, and the ability to connect agent behavior to the data and infrastructure underneath it. That connection is what Monte Carlo provides — and with native Agent Bricks support, it has never been easier for Databricks users to establish it.

Native integration: what it means and why it matters

Agent Bricks agents write their traces natively to Unity Catalog Delta tables as part of how the platform operates. Monte Carlo connects to those tables directly through your existing Databricks connection, the same connection you already use for data observability across your Lakehouse.

There is nothing new to set up on your side. No instrumentation in your agent code, no additional pipeline, and no new infrastructure to maintain. From the moment you select your Databricks warehouse and choose an agent from the dropdown, Monte Carlo begins reading traces and surfacing observability data.

Monte Carlo supports both Knowledge Assistant agents — Agent Bricks’ managed template for enterprise Q&A — and custom agents built via the Mosaic AI Agent Framework. Both are discoverable directly from the agent picker once your Databricks connection is configured.

This is crucial because adoption is often where teams stall in adopting agent observability. Tools that require instrumentation get adopted in development and abandoned in production ops due to the overhead required to deploy and maintain them across large fleets of agents. Native integration removes that friction entirely, ensuring that observability actually gets used when it matters the most: in your production environment, when the stakes are high and the consequences of agentic failures impact your real customers. 

End-to-end visibility: from your data to your agents

What makes Monte Carlo’s Agent Bricks integration uniquely powerful is not just what it covers in the agent layer, but that it connects the agent layer to everything beneath it.

Monte Carlo already monitors your Databricks environment end to end: Delta Lake tables for freshness, schema drift, and volume anomalies; Lakeflow pipelines for health and lineage; and the data quality of every asset your agents and analytics depend on. With native Agent Bricks observability, that coverage extends into the agents themselves.

The result is a single, unified view of your entire data and AI system. It’s not two separate tools with two separate contexts, but one coherent picture that answers the question that matters the most in production: why did this agent fail?

When an agent starts producing degraded outputs, the answer is rarely obvious. It could be a data quality issue in a Delta table the agent retrieves from or a Lakeflow pipeline that loaded stale data. It’s just as likely, however, that it’s a tool call returning an unexpected result or a model-level issue exclusively. 

Without end-to-end visibility, an on-call engineer has to manually stitch together signals from multiple systems to find the root cause. With Monte Carlo, those signals surface in one place — automatically correlated, with lineage that traces from the agent output back through every data dependency.

What you get out of the box

Once connected, Monte Carlo surfaces the full agent observability experience across four dimensions:

• Span-level traces: Every step your agent takes — tool calls, retrievals, model interactions, and reasoning steps — are captured as structured trace data you can inspect, query, and monitor.
• Conversation history: Full conversation context alongside trace data, so you can review exactly what an agent said, what it was working with, and where a response diverged from expected behavior.
• Eval monitors: Continuous evaluation against real production traffic — LLM-as-judge checks, rule-based output validation, trajectory monitors that alert when an agent deviates from expected tool sequences or step patterns.
• Incident management: Every alert routed to the right owner with a clear escalation path, tracked through to resolution — across Slack, PagerDuty, Microsoft Teams, ServiceNow, or wherever your team works.

And because all of this sits alongside your data observability, incidents that span both layers surface together. 

Establishing agent trust at enterprise scale

The promise of enterprise AI isn’t just that agents can be built, but that they can be trusted in the complex and unpredictable production environment. 

That trust requires continuous observability that connects every layer of the stack — data, pipelines, and agents — into a single, accountable view. Monte Carlo’s native Agent Bricks integration is built on that belief: that end-to-end visibility is not an optional layer on top of enterprise AI, it’s a prerequisite for deploying it safely.

Get started

Native Agent Bricks observability is available now. If you’re attending Databricks Data + AI Summit this week, come find us at Booth #206 — we’d love to show you the integration live. Alternatively, you can schedule a demo with us montecarlo.ai or connect with us through Databricks Partner Connect.

Our promise: we will show you the product.