What you will be able to do
- Pick Knowledge Assistant, Information Extraction or Supervisor Agent from the shape of a business requirement
- Name the inputs each brick needs and the ways it can be tuned and used once built
- Compose an existing Knowledge Assistant and a Genie Agent under one Supervisor Agent, granting end users the access each subagent needs
- Decide when a brick, a simpler LLM pattern, or a custom agent is the right build
Key concept
Agent Bricks — Agent Bricks are agent builders you configure in the workspace UI instead of writing code. You point a brick at your data or at existing agents, it builds the system and an endpoint, and subject matter experts improve it with natural-language feedback instead of code changes.
1.What an Agent Brick gives you
An Agent Brick is a pre-designed agent for one common job. You configure it in the workspace, not in a notebook. Each one starts the same way: open Agents in the left navigation, click Create Agent, and pick the brick. Three of them map to the problem shapes that come up most often in enterprise generative AI. Knowledge Assistant answers questions over a pile of documents. Information Extraction turns those documents into fields in a table. Supervisor Agent, which the exam calls the Multi-Agent Supervisor, puts one entry point over several agents and tools.
Every brick ends in something you can call. Knowledge Assistant and Supervisor Agent each produce an agent endpoint that you can chat with in AI Playground or build into an application. Information Extraction produces an extraction agent that you can run from SQL, from a scheduled pipeline, or over REST. Applications call that endpoint or function, whatever happens inside it.
Tuning works through feedback, not code. Knowledge Assistant and Supervisor Agent take natural-language guidelines and examples from subject matter experts. Information Extraction turns reviewer feedback into updated field descriptions. This is the main reason to choose a brick: the people who know the right answer can improve the agent themselves, without an engineer turning their comments into prompt edits. Each brick also needs the same platform underneath: serverless compute, Unity Catalog, and a serverless usage policy with a nonzero budget.
Checkpoint 1 of 8· Match them up
Match each Agent Brick to the problem it is built to solve
Tap a term, then the definition that fits it.
Knowledge Assistant answers questions over documents. Information Extraction turns documents into structured fields in a table. Supervisor Agent (the exam's Multi-Agent Supervisor) puts a single entry point over several agents and tools.
“Information Extraction transforms unstructured documents and text into key, structured insights using a defined schema.”Source: docs.databricks.com
2.Knowledge Assistant: cited answers over your documents
Knowledge Assistant builds a question-and-answer chatbot whose answers cite the documents they came from. Its typical uses are answering questions from product documentation, HR policies and support knowledge bases. In all three, the answer already exists in prose and someone needs to find it and trust it. Internally it uses an Instructed Retriever approach, which Databricks positions as an improvement on traditional RAG. It also handles documents in multiple languages.
Each knowledge source is one of three kinds, and each has rules that catch people out.
- Files in a Unity Catalog volume (or a directory in one): txt, pdf, md, ppt/pptx and doc/docx. Files over 100 MB are skipped silently, as are PDF, Word and PowerPoint files over 500 pages. Each slide counts as one page.
- Files in a Unity Catalog table: the table must be a streaming table or have Change Data Feed enabled. It needs a
contentcolumn of BINARY or STRING type and ametadataor_metadataSTRUCT column withfile_path,file_name,file_sizeandfile_modification_time. Tables ingested from SharePoint or Google Drive through Databricks connectors already have this shape. - An AI Search index: supported only if it was built with
databricks-gte-large-en,databricks-bge-large-enordatabricks-qwen3-embedding-0-6b. You also choose the Doc URI column, which the agent uses for its citations, and the Text column it retrieves from.
A table-type source does not make Knowledge Assistant a database query tool. The table is just a container for files: one row per document, with its content and file metadata. An orders table with columns such as order ID, date and amount does not fit that schema. Even a table that did fit would give the assistant documents to retrieve, not rows to aggregate. Questions that need structured queries belong to a different agent, combined with the assistant as described in the Supervisor Agent section.
You can attach up to 10 knowledge sources, each with a name and a Describe the content text that tells the agent when to use it. An optional Instructions field sets how the agent should respond. The first build and sync can take up to a few hours. After that, the content is not kept in step automatically: when files are added or changed, someone with CAN MANAGE must click Sync. Syncing is incremental, so only new files are processed. To test the agent, chat with it in the Build tab and use View thoughts, View trace and View sources to see how it reached its answer and which files it cited. To improve it, experts add questions and guidelines in the same interface, and you share the agent so they can work on it with you.
Checkpoint 2 of 8· Check yourself
A team wants to attach a Unity Catalog table to a Knowledge Assistant as a "Files in a Table" knowledge source. Which table can the assistant accept?
A table-type source holds files. It must be a streaming table or have Change Data Feed enabled, and it needs a content column plus a metadata STRUCT with the file fields. A business table such as orders doesn't fit that schema and wouldn't let the assistant run aggregate queries. A table without CDF that isn't a streaming table fails the first requirement.
“The table is either a streaming table or a table with Change data feed enabled.”Source: docs.databricks.com
Checkpoint 3 of 8· Exam question
A retail company's HR team receives repetitive questions about vacation policy, benefits enrollment, and reimbursement procedures. The answers exist across dozens of PDF and Word policy documents stored in a Unity Catalog volume, and HR wants a chatbot that cites the specific document and section it used to answer, with minimal custom engineering. Which Agent Bricks component should the team use to build this solution?
Correct answer: A — Knowledge Assistant, which ingests the PDF and Word files from Unity Catalog volumes and produces citation-backed answers via a guided Instructed Retriever approach
- A. Knowledge Assistant is designed exactly for this scenario: it ingests unstructured documents from Unity Catalog volumes and generates chatbot answers with citations back to the source documents, using a guided, low-code workflow rather than hand-built retrieval code.
- B. Multi-Agent Supervisor coordinates multiple already-built subagents to handle different task domains, but this scenario has a single knowledge domain (HR policy documents), so there is nothing to route between and no need for a supervisor layer.
- C. Information Extraction is built to pull specific structured fields out of documents into a schema, not to power a conversational, citation-backed question-answering chatbot, so it does not match the stated requirement.
- D. A hand-built LangChain retrieval chain could technically answer the questions, but it requires engineers to author, tune, and maintain the retrieval and prompt logic themselves, which conflicts with the team's goal of minimal custom engineering.
Sources1
3.Information Extraction: documents into schema fields
Information Extraction turns unstructured text into structured values. You give it unstructured text, PDFs, images or tables and a schema, and it returns a value for each field. Typical examples are parties and terms from contracts, line items and payment terms from invoices, and key details from medical records. Use it when the output is a row per document. Use Knowledge Assistant when the output is an answer to a person's question. Thousands of invoices that should become invoice_number, vendor_name and total_amount columns are an extraction job. A chatbot over those same invoices would still leave someone to type the numbers into a table.
To build one, select the data: upload files, or choose a Unity Catalog volume, or a table plus a STRING or VARIANT column. You need at least one file or row. Then define the schema in one of three ways: describe the fields in natural language and click Generate Schema, add fields by hand with a name, type and description, or edit the JSON directly. The schema follows the same rules as designing a JSON schema the model can follow: clear field names, explicit types and precise descriptions. The difference is that here you refine it in the Agent Bricks UI, and each Save and run extraction reruns the agent on your inputs so you can see the effect straight away.
Tuning has two levers and one measurement. You can leave natural-language feedback on individual outputs, which automatically rewrites the field descriptions. You can also edit the descriptions yourself. Optional settings add Precision mode (better accuracy for nuanced fields and long documents), Citations and Confidence scores. Versions let you compare or restore earlier schemas. To measure quality, run an evaluation against a Unity Catalog table with an input column and a ground-truth JSON column. It reports overall field accuracy, documents fully correct, and precision, recall and F1 for each field.
Once the agent is good enough, Use Agent gives you three ways to run it. Run in SQL opens a query that calls ai_extract with your schema across the whole volume or table. Create a Lakeflow pipeline keeps a streaming table up to date with extracted data as new files arrive, which is how invoices end up as a Delta table without per-vendor parsing code. The REST API serves applications and automation, with a default limit of 120 requests per minute per workspace.
SELECT ai_extract(
'Invoice #12345 from Acme Corp for $1,250.00 dated 2024-01-15',
'{
"invoice_id": {"type": "string", "description": "Unique invoice identifier"},
"vendor_name": {"type": "string", "description": "Legal business name"},
"total_amount": {"type": "number", "description": "Total invoice amount"},
"invoice_date": {"type": "string", "description": "Date in YYYY-MM-DD format"}
}',
options => map('version', '2.1')
);Checkpoint 4 of 8· Check yourself
Vendor invoices land in a Unity Catalog volume every day. An extraction agent's schema now gives accurate invoice_number, vendor_name and total_amount values. The team wants those fields in a Delta table that stays current as new invoices arrive, without writing parsing code. What should they do next?
A finished extraction agent doesn't need custom code to run at scale. Use Agent → Create a Lakeflow pipeline runs it on new data and updates a streaming table. A Knowledge Assistant only answers questions in chat. An evaluation scores the agent's output against ground truth you already have. It doesn't fill a table.
“This creates a Lakeflow pipeline that updates a streaming table with your extracted data.”Source: docs.databricks.com
Checkpoint 5 of 8· Exam question
A finance team receives thousands of scanned vendor invoices as PDFs. They need to populate a Delta table with structured columns such as invoice_number, vendor_name, invoice_date, and total_amount for downstream reporting, and want to avoid writing custom parsing code for each vendor's invoice layout. Which Agent Bricks component best fits this requirement?
Correct answer: A — Information Extraction, which applies a user-defined schema over parsed invoice content and returns the requested structured fields for each document
- A. Information Extraction is purpose-built to pull structured fields from documents using a schema you define, so pointing it at the invoice content directly produces the invoice_number, vendor_name, invoice_date, and total_amount columns the finance team needs.
- B. Knowledge Assistant is designed for conversational question answering with citations, not for emitting structured rows of fields into a table, so it does not address the finance team's reporting need.
- C. Multi-Agent Supervisor coordinates multiple specialized subagents across different task domains, which is unnecessary overhead for a single, well-defined field-extraction task on one document type.
- D. Hand-written regular expressions tuned per vendor template is exactly the custom, per-layout parsing work the finance team wants to avoid, and it does not generalize well as new vendor formats appear.
Sources3
4.Supervisor Agent: one endpoint over many specialists
Supervisor Agent coordinates specialists that already exist. It routes each request to the right one and combines their results into a single answer. Subagents can be Genie Agents, Knowledge Assistant endpoints, model serving endpoints, Unity Catalog functions, tables and volumes, AI Search indexes, MCP servers, custom agents, and even other supervisors. You can add up to 50 agents and tools. Its intended uses span several domains: market analysis across research reports and usage data, or customer service that covers policy, FAQ and account questions.
This is how you extend a working Knowledge Assistant without rebuilding it. If users of a wiki assistant now also ask questions about an orders database that an existing Genie Agent can query, create a supervisor and add both as subagents. The assistant keeps answering wiki questions, Genie handles the order questions, and the supervisor decides which to call. Write a detailed description for each subagent, because the supervisor uses those descriptions to decide where to send work. The optional Instructions field controls how the supervisor responds.
Sharing a supervisor means granting access at two levels. Users need CAN QUERY on the supervisor itself, and each subagent needs its own grant, as in the table below. Without that explicit access, the supervisor cannot return useful answers from the subagent. Hovering over a subagent tile opens it so you can set those permissions.
| Subagent type | Required end user permission |
|---|---|
| Genie Agent | Access to the Genie Agent and its underlying Unity Catalog objects |
| Knowledge Assistant agent endpoint | CAN QUERY on the agent endpoint |
| Model serving endpoint | CAN QUERY on the serving endpoint |
| Unity Catalog function | EXECUTE on the Unity Catalog function |
| Custom agent | CAN_USE on the Databricks app |
| Supervisor Agent | CAN QUERY on the Supervisor Agent |
Every supervisor also has a code execution tool, and you neither add nor configure it. When a request needs a calculation or a data transformation, the supervisor writes Python, SQL or shell commands and runs them in a sandboxed serverless session. That sandbox has no outbound network access, whatever the workspace network policy says. Its data access is read-only and limited to the Unity Catalog tables and volumes you added as tools, within the end user's own permissions.
Checkpoint 6 of 8· Match them up
Users already hold CAN QUERY on a Supervisor Agent but get no useful answers from its subagents. For each subagent, which grant does every end user still need?
Tap a term, then the definition that fits it.
CAN QUERY on the supervisor is not enough on its own. The supervisor enforces each end user's own permissions, so every subagent needs its own grant, and the grant depends on the subagent's type.
“End users of the supervisor agent need explicit access to interact with each subagent.”Source: docs.databricks.com
Checkpoint 7 of 8· Exam question
A team built a Knowledge Assistant that answers questions from internal wiki pages. Users now also want to ask questions that require querying a separate structured orders database through an existing Genie Agent, and the team wants to reuse the existing Knowledge Assistant rather than rebuild it from scratch. What is the appropriate next step?
Correct answer: A — Wrap the existing Knowledge Assistant and the Genie Agent as subagents under a new Multi-Agent Supervisor, which will route each question to the appropriate subagent
- A. A Multi-Agent Supervisor is designed to combine already-built components like a Knowledge Assistant and a Genie Agent as subagents, routing each incoming question to whichever one can answer it, which reuses both existing systems without modifying either one.
- B. Knowledge Assistant ingests unstructured document sources and is not built to answer natural-language queries against a live structured orders database the way a Genie Agent is, so folding the database in as a table source would not replicate that query capability.
- C. Information Extraction pulls structured fields out of content according to a schema; it is not a conversational question-answering system and cannot substitute for either the wiki chatbot or the database query agent.
- D. Discarding the working Knowledge Assistant to hand-build a new LangChain agent throws away the reuse the team explicitly wants and requires re-implementing retrieval and database querying logic that the existing components already handle.
Sources2
5.Choosing a brick, a simpler pattern or a custom agent
Start simple. Use a brick when one fits. Write a custom agent only when you need control that no brick offers. Agent systems range from a single prompt to a multi-agent system, and each step up adds flexibility at the cost of complexity and latency. Many requirements do not need an agent at all. A fixed summarisation step, or basic retrieval followed by generation, is a deterministic chain in which the developer, not the LLM, decides which tools run and in what order.
| Design pattern | When to use | Cost |
|---|---|---|
| LLM + prompt | Generic question and answer; quick prototype for short-term use | Minimal customization |
| Deterministic chain | Well-defined tasks; static pipelines such as basic RAG; no on-the-fly decisions | Inflexible; requires code changes to adapt |
| Single-agent system | Moderate to complex queries in the same domain | Less predictable; must guard against repeated or incorrect tool calls |
| Multi-agent system | Large or cross-functional domains with multiple expert agents | Complex to orchestrate; harder to trace and debug |
Match the requirement to a brick by the shape of its output. A cited answer over documents means Knowledge Assistant. Schema fields per document mean Information Extraction. Questions that cross specialist domains, such as documents plus structured data plus actions, mean Supervisor Agent over the specialists you already have. Each of these is cheaper than building the same thing by hand, and keeping it tuned is cheaper too, because experts improve it through feedback instead of code.
A custom agent pays off when the bricks run out: you need your own orchestration logic, a framework of your choice, or behaviour that no brick's configuration exposes. Custom agents are not tied to any of the patterns above, so you can start simple and add autonomy as requirements grow. Replacing a working brick with custom code just to add a capability is usually wrong when a supervisor can combine the brick with another agent.
One caveat limits where the brick advice above applies: Knowledge Assistant and Supervisor Agent now carry a legacy label. In practice, "legacy" means Databricks no longer recommends them as the starting point for a new agent. The problem shapes above still describe what each brick does, but a team starting a new build should reach for Genie Agents when it wants a low-code agent over its documents and data, and for the Agent Bricks CLI when it wants to write the agent in code, including when it needs to coordinate several agents. Information Extraction is not part of that label: its current version is the recommended one, and only the earlier version is called legacy. When an exam scenario describes an existing Knowledge Assistant or Supervisor Agent, compose and tune it as described above. When it describes a new build, weigh the Genie Agents and CLI paths first.
Checkpoint 8 of 8· Match them up
Following the start-simple rule, which design pattern is the simplest one that meets each requirement?
Tap a term, then the definition that fits it.
Each step up adds flexibility but also complexity and latency, so pick the simplest pattern that fits. Basic RAG with no on-the-fly decisions is a deterministic chain. A multi-agent system is only worth it when the work spans several expert domains.
“Deterministic chain | Well-defined tasks Static pipelines such as basic RAG No need for on-the-fly decisions”Source: docs.databricks.com
Sources
(5)
Every claim above is drawn from one of these pages, quoted as it was written on the date shown.
- 1.
“Knowledge Assistant creates an agent endpoint that you can use downstream for your applications.”
↩︎ What an Agent Brick gives you“Use Knowledge Assistant to create a chatbot that can answer questions about your documents and provide high-quality responses with citations.”
↩︎ Knowledge Assistant: cited answers over your documents“follows an Instructed Retriever approach to address limitations of the traditional retrieval-augmented generation (RAG) approach”
↩︎ Knowledge Assistant: cited answers over your documents“Supported file types are txt, pdf, md, ppt/pptx, and doc/docx.”
↩︎ Knowledge Assistant: cited answers over your documents“Files larger than 100 MB are automatically skipped during ingestion and are not included in the knowledge base.”
↩︎ Knowledge Assistant: cited answers over your documents“AI Search indexes are only supported if the index uses one of the following embedding models”
↩︎ Knowledge Assistant: cited answers over your documents“The agent uses this in its citations.”
↩︎ Knowledge Assistant: cited answers over your documents“You can provide up to 10 knowledge sources.”
↩︎ Knowledge Assistant: cited answers over your documents“It can take up to a few hours to create your agent and sync the knowledge sources you provided.”
↩︎ Knowledge Assistant: cited answers over your documents“Provide questions and guidelines directly in the experience, and share your agent to let others collaborate and improve the agent's performance.”
↩︎ Knowledge Assistant: cited answers over your documents“For new low-code agents over your documents and data, use Genie Agents. For new agents written in code, use the Agent Bricks CLI.”
↩︎ Choosing a brick, a simpler pattern or a custom agent“The table contains a metadata or _metadata column of STRUCT type with the following fields”
↩︎ Exam trap 1“If you update or add files to your knowledge sources, you must click Sync for the agent to pick up the changes.”
↩︎ Exam trap 2“The table is either a streaming table or a table with Change data feed enabled.”
↩︎ Checkpoint - 2.
“Supervisor Agent builds the system for you and lets you improve it over time with human feedback.”
↩︎ What an Agent Brick gives you“coordinates Genie Agents, agent endpoints, Unity Catalog functions, MCP servers, and custom agents to work together to complete complex tasks”
↩︎ Supervisor Agent: one endpoint over many specialists“You can select up to 50 different agents and tools.”
↩︎ Supervisor Agent: one endpoint over many specialists“The supervisor uses the information in the description to help it coordinate agents.”
↩︎ Supervisor Agent: one endpoint over many specialists“The supervisor has built-in access controls, so that its end users only access the subagents and data they have access to.”
↩︎ Supervisor Agent: one endpoint over many specialists“If the end user does not have access to any subagents, the supervisor will end the conversation.”
↩︎ Supervisor Agent: one endpoint over many specialists“Every supervisor includes a code execution tool by default.”
↩︎ Supervisor Agent: one endpoint over many specialists“It blocks all outbound network egress regardless of your workspace's network policy”
↩︎ Supervisor Agent: one endpoint over many specialists“Supervisor Agent is a legacy offering and is not recommended for new systems.”
↩︎ Choosing a brick, a simpler pattern or a custom agent“Supervisor Agent builds the system for you and lets you improve it over time with human feedback.”
↩︎ Key concept“End users of the supervisor agent need explicit access to interact with each subagent.”
↩︎ Exam trap 3“the supervisor will redirect the conversation away from subagents the user cannot access.”
↩︎ Prediction“End users of the supervisor agent need explicit access to interact with each subagent.”
↩︎ Checkpoint - 3.
“Access to a serverless usage policy with a nonzero budget.”
↩︎ What an Agent Brick gives you“Information Extraction transforms unstructured documents and text into key, structured insights using a defined schema.”
↩︎ Information Extraction: documents into schema fields“Information Extraction automatically generates a JSON schema with field names and definitions for you.”
↩︎ Information Extraction: documents into schema fields“provide natural language feedback on one or more inputs, which auto-tunes your descriptions when you press Save and run extraction”
↩︎ Information Extraction: documents into schema fields“Precision mode: Improves accuracy for nuanced fields and long documents.”
↩︎ Information Extraction: documents into schema fields“An evaluation scores each extraction against a known correct answer (ground truth)”
↩︎ Information Extraction: documents into schema fields“This creates a Lakeflow pipeline that updates a streaming table with your extracted data.”
↩︎ Information Extraction: documents into schema fields“The default rate limit for ai_extract REST API requests is 120 requests per minute per workspace.”
↩︎ Information Extraction: documents into schema fields“This page covers the new version of Information Extraction.”
↩︎ Choosing a brick, a simpler pattern or a custom agent“Information extraction is available through the Agent Bricks UI, in SQL, and with the REST API.”
↩︎ Exam trap 4“Information Extraction transforms unstructured documents and text into key, structured insights using a defined schema.”
↩︎ Checkpoint - 4.
“Introduce more complex agentic behaviors when you truly need them for better flexibility or model-driven decisions.”
↩︎ Choosing a brick, a simpler pattern or a custom agent“The LLM does not make decisions about which tools to call or in what order.”
↩︎ Choosing a brick, a simpler pattern or a custom agent“Custom Agents are agnostic to these design patterns, so you can start simple and evolve toward higher levels of automation and autonomy”
↩︎ Choosing a brick, a simpler pattern or a custom agent“Deterministic chain | Well-defined tasks Static pipelines such as basic RAG No need for on-the-fly decisions”
↩︎ Checkpoint - 5.https://docs.databricks.com/aws/en/agents/conceptsOfficial docs
“Earlier products, such as Knowledge Assistant and Supervisor Agent, are no longer recommended for new agents.”
↩︎ Choosing a brick, a simpler pattern or a custom agent