Introduction

Back in June 2025, Databricks announced the launch of Agent Bricks: A New Approach to Building AI Agents. With it came promises about how it would make our lives easier by simplifying the management of most AI workflows with an intuitive, easy-to-use, and user-friendly UI.

But how useful is it really? And do they actually manage to enable non-machine-learning-savvy users to solve ML tasks?

Well, I don't like cliffhangers either, so the answers are a lot and yes. But this is not a perfect product (or at least it isn't while it's in Beta), and it comes at the price of flexibility in many relevant areas. If you'd like to know more in detail, you should continue reading.

What is Agent Bricks?

Here, we won't go into full detail of Agent Brick's capabilities, as it's not relevant for the use case about to be presented. The need-to-know basics are that Agent Bricks is mostly a wrapper for resources you already had available in Databricks, with the difference that now they are more accessible than ever through a unified and simplified UI. Examples of these unified resources are:

Multi-agent: multiple AI agents working together, each with specialized capabilities
Foundational Models: large, pre-trained neural networks that are designed to learn general patterns in language, images, or other data types, and can be fine-tuned for specific tasks with additional training
Mosaic AI Model Serving: a solution for deploying AI and ML models for real-time serving and batch inference

The only exception to this definition would be the newly introduced feature of text extraction from PDFs, which I’ll explain in the next section.

If you're interested in understanding this tool's limitations and capabilities in detail, its documentation reference is your best ally.

Use cases:

Databricks presented Agent Bricks with four use cases that compose the main pillars of its toolkit:

Text parsing

What the first three have in common is that they share the capability not only to process structured data but to process unstructured data. Think of a dataset composed of formats like JPG/JPEG, PNG, and PDFs; now it's possible to integrate them into workflows without any special processing.

This is possible thanks to a new SQL function ai_parse_document(). This function invokes a state-of-the-art generative AI model from Databricks Foundation Model APIs to extract text content from unstructured documents and stores it in a table in Unity Catalog, both as an object and as plain text. This enables the previous workflows to use a wide variety of data sources.

From Theory To Practice: Real-World Implementation

Building a personal financial assistant

When I set out to test this tool, I wanted to develop something that was both useful for me personally as well as technically challenging enough so that I’d have an excuse to explore Agent Brick's capabilities. Learning about finance and how the stock market works had been on my bucket list for too long, so I decided to give it a shot.

Goal: Developing a financial assistant capable of analyzing market information and providing insight about potential opportunities to an unknowing user.

Although I lacked much of the financial world context needed to tackle this task when I started, I was aware that publicly traded companies are legally required to submit quarterly reports about their performance to their shareholders. These reports tend to be of considerable length and granularity, as they need to cover several aspects of their business operations, third-party reviews, and the description of the direction the company is taking.

All of this makes for a very interesting read — if you have the time and knowledge to understand them, that is. I didn't, and that was the beginning of this POC.

*Image displaying initial architectural vision

Attribute extraction

Like most AI workflows, the first step for building the solution is finding a suitable corpus to train our assistant on. Luckily for this particular POC, a huge database of the annual reports of the publicly traded companies in the US is available free of charge in PDF format at AnnualReports.com

Leveraging the capabilities for unstructured formats, I decided to extract a set of revenue metrics out of these reports. This would take only two steps:

1. Extract all text from the PDF dataset. This is possible simply by dragging and dropping our PDFs into a Unity Catalog Volume, selecting the path through a UI, and selecting which SQL Warehouse to use to extract the text. I was able to launch a parsing job to extract these attributes, which we stored in a Unity Catalog table.

2. Building an Information Extraction Job that extracts the specific attributes I want. For this the only required step is clicking on the Build** button and defining the JSON schema of the expected output.

*Image displaying the 10-K form for Nvidia*

The output of these two steps was an Agent Endpoint with the capability of extracting the specified fields out of the corpus. This can easily be stored in a Unity Catalog table with the following SQL script.

CREATE TABLE `catalog_name`.`schema_name`.`output_table` AS
WITH query_results AS (
  SELECT `input_column` AS input,
    ai_query(
      'endpoint_identifier',   -- model/endpoint being called
      input,
      failOnError => false
    ) AS response
  FROM (
    SELECT `input_column`
    FROM `catalog_name`.`schema_name`.`source_table`
  )
)
SELECT
  input,
  response.result AS response,
  response.errorMessage AS error
FROM query_results

SQL script demonstrating how to store Information Extraction Agent Endpoint's output into a table

Furthermore, it was able to leverage this information by connecting this table with a new Genie Space. This allowed me to run aggregation on the revenue information extracted from the reports:

*Image displaying chat interface with Genie agent*

Building a Reports Knowledge Assistant

After testing the text parsing capabilities of Agent Bricks, I was particularly interested in developing a Knowledge Assistant to help answer naive questions regarding the assessments that the company reported in the previously mentioned dataset. This kind of information is not so easily structured, so I opted for using an LLM with a context-specific augmented system.

Normally, this process would be time-consuming, but with Databricks Agent Bricks and a Retrieve Augmented Generation (RAG) system, it becomes much more streamlined.

Traditional RAG Pipeline Building Steps

However, with the Knowledge Assistant UI, we only need to select the source of our information ( in our case, the volume of PDFs) and add a description and instructions on how we expect our Agent to behave:

*Image displaying a custom knowledge assistant that specializes in reading Nvidia annual reports and providing feedback*

Adding Stock Market context to a Genie Agent:

The next thing I aimed for was providing stock market information to my assistant. Because market information is much more structured than reports and available through different huggingface's datasets and APIs, I decided that using a Genie Agent was a well-suited solution to leverage the SQL-query building expertise of Genie to calculate the aggregation of the evolution of the price of stocks for different dates. This again didn't provide any new workflows for the things we'd already seen before.

Joining the three agents in a Multi-agent architecture

Having a reports expert KA as well as a Market Genie agent capable of calculating metrics over market information was great as standalone solutions, but what would be significantly better is if we could join both specialist agents into one well-rounded agent.

This was possible through the Multi-Agent use case. All I had to do was select the Genie space and the KA agent endpoint, and we were able to have our multi-agent!

*Image displaying Agent selection from Multi-Agent's UI*

Analysis and Portfolio Building:

Despite the assistant’s technical capabilities so far, something was missing. It didn't feel like a true assistant yet because it couldn't analyze the factual data it was collecting. I realized it needed a source of information that would help it understand economics and financial theory to provide the insightful answers I was expecting.

To address this gap, I applied the same approach I used with the reports, but this time I curated a dataset of scientific articles and books. ResearchGate became my primary source for scientific reports, theses, and articles that I felt confident feeding into my second Knowledge Assistant. The creation process remained the same.

Updating the MultiAgent:

The final step was integrating my academic Knowledge Assistant into the multi-agent system I had already created. While this could be time-consuming in other frameworks and would typically require re-running the entire AI workflow, Databricks simplifies the process. It allows us to update our agent's configuration and have an operational updated agent within minutes.

Conclusion

Agent Brick's speed of development and ease of use are clearly among the tool's strongest advantages. With little to no previous experience, I was personally able to develop a financial assistant in a matter of days. This assistant was able to query and retrieve factual data from both unstructured and structured data sources, and used a research framework of my choosing to implement a layer of analysis that would enable users to access and understand data

Still, this convenience comes at the cost of flexibility. Users cannot choose their own models, run A/B experiments, or fine-tune core components like embeddings and chunking strategies (yet). Nor is there support for advanced orchestration features such as MCP agents or workspace-level action tools. These limitations won’t matter to casual users like me, exploring these workflows for the first time, but they can be frustrating for more advanced practitioners.

Overall, Agent Bricks represents a powerful step forward in enabling AI workflows for users. It lowers the barrier of entry and accelerates prototyping in a way that few platforms can match. As the product matures beyond its Beta stage, the hope is that Databricks will expand customization and control, enabling users to balance ease of use with the depth and flexibility required for production-grade solutions.

Keeping Up With Agent Bricks