Agent Bricks: from pilot to production
Building an agent is easy. Putting one into production is hard, which is why most agents stall in pilot and never ship.
Databricks frames the reason as the 99% problem. The agent reasoning loop, the part everyone demonstrates, is about 1% of what it takes to run an agent in production. The other 99% is everything around it: giving the agent the right model access, grounding it in governed enterprise data, controlling what it is allowed to do, evaluating whether it works, monitoring it once live, and deploying it reliably.
Agent Bricks is built for that 99%. It is a platform to build, deploy and govern enterprise agents on the Lakehouse, with the production harness agents need, and it is running at real scale, with more than 100,000 agents deployed.
- Govern data access first with Unity Catalog, which is what actually lets the work reach production.
- Evaluate before deploying, rather than shipping on a good demonstration.
- Monitor and bound autonomy, because agents drift and consequential actions need a person.
The pilot to production gap
Agent demonstrations are everywhere; agents running in production are rare. The gap between the two is the single biggest disappointment in enterprise super intelligence today.
The reasoning loop, the model thinking through a task and calling a tool, is roughly 1% of what production requires. It is also the part that demonstrates beautifully, which is exactly why teams overestimate how close they are. The other 99% covers connecting the agent to the right models and keeping that access managed, grounding it in accurate and governed data so it reasons from reality, controlling what data and tools it can reach, evaluating whether it works before anyone relies on it, monitoring it in production as its behavior drifts, and deploying and operating it reliably.
Teams build the 1% in a sprint and then stall, not because the agent is bad but because none of the production machinery around it exists yet.
What Agent Bricks is
Agent Bricks is a platform to build, deploy and govern enterprise agents on the Lakehouse.
| Capability | What it provides |
|---|---|
| Model access | Agents connect to the right models through a managed layer instead of ad hoc integrations |
| Data context | Agents are grounded in governed enterprise data on the Lakehouse, so they reason from the organization’s real data |
| Identity-first governance | Unity Catalog governs what data and tools an agent can reach, treating the agent as an identity under the same permissions and audit as everything else |
| Evaluation | Agents are tested before they are trusted, using synthetic task data and model judges tracked through MLflow |
| Monitoring and memory | Agents are observed in production to catch drift and misuse, and given durable state rather than running as stateless one-shots |
| Deployment | Agents ship and operate reliably at scale, with more than 100,000 running on the platform |
The design point is that Agent Bricks is the production harness. It assumes the easy 1% and provides the hard 99%, which is the inversion an organization needs to move from an impressive pilot to a dependable, governed agent doing real work.
Getting agents to production
Crossing the gap is a matter of treating an agent like production software rather than a notebook experiment.
- Govern data access first. Use Unity Catalog so the agent reaches only what it is permitted to, with full audit. This is a security requirement and also what lets the work reach production at all.
- Evaluate before deploying. Define what success looks like and test the agent against it. An agent that was never evaluated is an agent nobody should trust.
- Monitor continuously. Watch for drift and misuse, because behavior changes as the data and environment change. An agent that worked at launch can quietly degrade.
- Bound the autonomy. Grant least privilege and separate reasoning from action, so the agent cannot do more than its mandate even when it reasons its way to wanting to.
- Keep people in the loop. Require approval for consequential actions, the ones that move money, change records or affect a person.
None of this is exotic. It is standard production engineering applied to a new kind of software.
The Varmoda approach
Varmoda, a Databricks partner, builds production agents on Agent Bricks by focusing on the 99% that gets them live.
Varmoda’s teams govern data access with Unity Catalog so agents reach only what they are permitted to, under audit; evaluate agents against defined success criteria before deploying them; and monitor them in production for drift and misuse. Autonomy is bounded with least privilege access, and people stay in the loop for consequential actions. Delivery is United States based and secure.
The reframe is simple: build the whole agent, not just the loop. The reasoning loop is the easy part. The data grounding, the governance, the evaluation and the monitoring decide whether an agent ever leaves the pilot.