Databricks Agent Bricks vs LangGraph for building agents

Summary

• Agent Bricks and LangGraph are both frameworks for building stateful, multi-tool agents, but they differ in scope and integration.
• Agent Bricks is Databricks' native framework, built into the Databricks platform and integrated with Unity Catalog, model serving, and workspace infrastructure.
• LangGraph is LangChain's open-source framework that runs on any infrastructure (cloud or on-premise) and is portable across platforms.
• Agent Bricks abstracts infrastructure and governance through Databricks (compute, access control, deployment). LangGraph requires you to orchestrate these separately.
• The choice depends on whether you prioritize platform integration and managed infrastructure (Agent Bricks) or portability and framework flexibility (LangGraph).

Databricks Agent Bricks vs LangGraph for building agents

Both Agent Bricks and LangGraph enable developers to build sophisticated, stateful agents that reason over tools and maintain context across interactions. The key difference is integration: Agent Bricks is a platform service tightly integrated with Databricks infrastructure, governance, and deployment. LangGraph is a portable, open-source framework you self-host or run on any cloud.

What is an agent?

An agent is an AI system that combines a language model with tools (functions, APIs, data queries) and reasoning logic. Instead of generating a static response, an agent observes its output, reasons about what to do next, calls appropriate tools, and repeats until it completes a task. Agents are stateful: they maintain context and conversation history, enabling multi-turn interactions and complex workflows.

Key capabilities to evaluate

Capability	Why it matters	Agent Bricks	LangGraph
Agent state management	Persisting agent memory and context	Built-in, unified with Databricks workspace state	Managed explicitly (your code)
Tool definition and binding	Declaring what an agent can do	Native Databricks function binding	Python functions or custom tools
Model flexibility	Which LLMs you can use	Databricks models, external via Model Serving	Any LLM API (OpenAI, Anthropic, local, etc.)
Observability and monitoring	Tracing agent reasoning and tool calls	Integrated with Databricks workspace, audit logs	Requires custom logging or external tools
Deployment model	How you run agents in production	Managed service (Databricks clusters/serverless)	Self-hosted or cloud deployment (your infrastructure)
Access control	Agents inherit permissions	Via Unity Catalog (source-native governance)	Requires separate permission layer
Framework learning curve	How long to get started	Moderate (Databricks platform knowledge helpful)	Steep (graph-based reasoning model, Python)
Portability	Move agents to other platforms	Platform-specific (Databricks)	Portable (any Python environment)
Cost model	How you pay for execution	Databricks compute (DBUs)	Your infrastructure (cloud instances, self-hosted)

How Databricks approaches agent building

Agent Bricks (GA) is Databricks' native framework for building agents. You define agent behavior using Python, specify tools (functions, API calls, data queries), and Agent Bricks manages reasoning loops, state persistence, and execution.
Agents run on Databricks infrastructure: clusters or serverless compute. This means they inherit Databricks' compute isolation, governance, and monitoring. Tool calls can query Unity Catalog tables directly, and access control is enforced at the data layer (a user's agent can only call tools that access data the user has permission to see). Deployment integrates natively: agents run within the Databricks workspace alongside notebooks, jobs, and applications.
Agent Bricks also integrates with Databricks Model Serving, so agents can call both first-party Databricks models and external model endpoints (OpenAI, Anthropic, custom models) through a unified interface.

LangGraph's approach

LangGraph is LangChain's open-source framework for building stateful agents as directed graphs. You define nodes (states and actions) and edges (transitions), then invoke the graph. LangGraph is language-agnostic in principle (though primarily Python), and runs anywhere Python runs.
LangGraph excels at representing complex agent workflows: conditional branching, multi-agent communication, and iterative reasoning. Because it's a framework, not a managed service, you control all infrastructure: which cloud, which compute, which models. This portability is valuable if you need to run agents across multiple environments or integrate with non-Databricks systems.
The trade-off: you manage deployment, scaling, logging, and security yourself. LangGraph provides the reasoning framework; you provide the infrastructure and governance.

Common deployment patterns

Pattern 1: Platform-integrated agents (Databricks)
Organizations using Databricks for analytics and AI use Agent Bricks to build agents that query their data lakehouse, run on Databricks compute, and enforce governance through Unity Catalog. No additional infrastructure to manage.
Pattern 2: Portable agent development (LangGraph)
Teams building agents for deployment across multiple cloud providers or on-premise systems choose LangGraph. They maintain a single agent codebase and deploy instances on different infrastructure (AWS Lambda, Google Cloud Run, Kubernetes, etc.).
Pattern 3: Hybrid approach
Some organizations use LangGraph to prototype agent logic locally or in a cloud framework (for flexibility), then migrate to Agent Bricks for production on Databricks (for governance and integration with the lakehouse).

FAQs

Should I use Agent Bricks or LangGraph?

Choose Agent Bricks if you're on Databricks and want governance, integrated compute, and managed infrastructure. Choose LangGraph if you need portability, are not on Databricks, or prefer a framework-only approach with full control over infrastructure.

Can I use LangGraph on Databricks?

Yes. You can run LangGraph agents in a Databricks notebook or job, calling Databricks tables via Python. However, you lose the platform integration benefits: governance is not automatic, and you manage state and logging yourself. Agent Bricks is simpler if you're already on Databricks.

What LLMs can Agent Bricks use?

Agent Bricks supports Databricks Foundation Models, and external models through Model Serving. This includes OpenAI, Anthropic, and other providers you configure in Model Serving.

Is LangGraph open-source?

Yes. LangGraph is maintained by LangChain as open-source (Apache 2.0 license). You can use it freely and contribute to it.

Can I migrate an agent from LangGraph to Agent Bricks?

Partially. The reasoning logic can transfer, but Agent Bricks and LangGraph have different APIs. You'd rewrite the agent definition in Agent Bricks' syntax. The core logic (state, transitions, tool calls) translates; the infrastructure layer differs significantly.