Overview
Design Applications is the planning layer of the Generative AI Engineer Associate exam. Its six official objectives ask you to write a prompt that returns a specific format such as JSON, choose the model task (summarization, classification, extraction, generation) that meets a business requirement, pick chain components for a given input and output, and turn a loosely worded use case into a concrete description of pipeline inputs and outputs. Two objectives are agent-focused: defining and ordering tools so an agent can gather knowledge or act across several reasoning steps, and deciding when Agent Bricks (Knowledge Assistant, Multi-Agent Supervisor, Information Extraction) fits better than a custom build.
The exam itself is current: the guide covers the version live since 18 March 2026, with 45 scored questions in 90 minutes and no published passing score. At 14% this section yields roughly six questions, but its vocabulary runs through every later section.
How it's tested
Expect brief business scenarios: a team describes what users send in and what they need back, and you choose the prompt, task, chain or agent design. Distractors are usually technically valid but mismatched to the requirement, so anchor on the stated input, output format and constraint before comparing options.
-
Requirement to task
A business need is described and you choose the model task, such as classification, extraction, summarization or open generation, that satisfies it.
-
Prompt for format
A downstream system needs a fixed structure and you select the prompt wording, examples or schema that reliably produce it.
-
Build or use Agent Bricks
A use case is described and you judge whether Knowledge Assistant, Information Extraction or Multi-Agent Supervisor covers it, or whether a custom agent is needed.
An insurer wants each incoming claim letter turned into fields like policy number, incident date and claimed amount for a database. A chat assistant over the letters is tempting because it uses the same documents. But the output is structured records, not answers to questions. That is an extraction task, and Agent Bricks Information Extraction is built to convert unstructured documents into structured fields, so it is the better design.
Objectives 6
Official objectives from the Databricks outline, in outline order.
1.1 Design a prompt that elicits a specifically formatted responseInstructions, examples and schemas that make output machine-readable.
- What it means
- This objective is about getting output a program can parse, such as JSON with named keys, a Markdown table or a single label. You combine clear instructions, a stated schema, delimiters around input text and, where needed, one or two examples of the exact format.
- What to understand
- Be explicit about field names, allowed values and what to do when information is missing. Few-shot examples anchor the format better than description alone. Delimiters separate instructions from user content. Lower temperature reduces variation. Where the serving layer supports structured outputs, a JSON schema is stronger than wording alone.
- How it shows up
- A downstream parser keeps failing and you choose the prompt change that fixes the format, usually an explicit schema plus an example.
- Common confusion
- Assuming a longer persona description fixes formatting; format comes from schema, examples and constraints.
1.2 Select model tasks to accomplish a given business requirementMapping needs to classification, extraction, summarization, translation or generation.
- What it means
- This objective asks you to read a business requirement and name the model task behind it. Routing tickets is classification, pulling invoice totals is extraction, condensing call notes is summarization, and drafting replies is generation. Some needs combine several tasks in sequence.
- What to understand
- The output type drives the task: a fixed label set means classification, specific fields mean extraction, shorter faithful text means summarization, new open text means generation. Picking the narrowest task usually gives better accuracy, lower cost and easier evaluation. Multi-step needs may chain tasks, such as classify then summarize.
- How it shows up
- A requirement is stated in business language and you pick the task or task sequence that meets it.
- Common confusion
- Choosing open generation for a need that has a fixed set of answers, which is classification.
1.3 Select chain components for a desired model input and outputPrompt templates, retrievers, models, parsers and memory in a chain.
- What it means
- A chain links components so that a given input becomes the desired output. Typical parts are a prompt template, a retriever over a vector index, the LLM, an output parser, and sometimes memory or a tool call. This objective asks which parts are needed for a stated input and output.
- What to understand
- If the answer needs private documents, a retriever is required. If output must be structured, add an output parser or structured output setting. If the conversation must remember earlier turns, add chat history or memory. If nothing external is needed, a template plus model may be enough. Extra components add latency and failure points.
- How it shows up
- You are given an input and target output and choose the minimal set of chain components that connects them.
- Common confusion
- Adding a retriever when the answer needs no external knowledge, or omitting it when it does.
1.4 Translate business use case goals into a description of the desired inputs and outputs for the AI pipelineTurning a goal into concrete pipeline inputs, outputs and success criteria.
- What it means
- Stakeholders describe goals like 'help support agents answer faster'. This objective asks you to restate that as pipeline terms: what goes in (a customer question plus account context), what comes out (a cited draft answer), from which sources, and how success is judged.
- What to understand
- A good specification names the input fields, the knowledge sources, the output format and length, who consumes the output, and the quality bar. It also flags constraints such as latency, data sensitivity and whether a human reviews the result. Clear inputs and outputs make later choices about retrieval, models and evaluation straightforward.
- How it shows up
- A vague business goal is given and you choose the most accurate input and output description for the pipeline.
- Common confusion
- Describing the model or framework instead of the inputs and outputs the business actually needs.
1.5 Define and order tools that gather knowledge or take actions for multi-stage reasoningTool definitions, descriptions and the sequence an agent follows.
- What it means
- Agents call tools: retrievers, SQL queries, Unity Catalog functions, APIs or other agents. This objective covers writing tool definitions an LLM can choose correctly and ordering them so that each step has the information it needs, for example looking up an order before issuing a refund.
- What to understand
- Each tool needs a clear name, a description of when to use it and typed parameters. Knowledge-gathering tools generally come before action tools, because actions depend on facts. Read-only tools are safer to expose broadly than tools that change data. Unity Catalog functions give governed, reusable tools. Too many overlapping tools confuse tool selection.
- How it shows up
- A multi-step task is described and you choose the correct tool order or the missing tool.
- Common confusion
- Letting an agent take an action before it has retrieved the facts that the action depends on.
1.6 Determine how and when to use Agent Bricks (Knowledge Assistant, Multiagent Supervisor, Information Extraction) to solve problemsChoosing a managed Agent Bricks template over a custom agent.
- What it means
- Agent Bricks lets you describe a task and data, and Databricks builds and tunes an agent for it. Knowledge Assistant answers questions over documents with citations. Information Extraction turns unstructured documents into structured fields. Multi-Agent Supervisor coordinates several agents, Genie spaces and tools behind one interface.
- What to understand
- Match the template to the output: grounded answers over documents suggests Knowledge Assistant, structured records from documents suggests Information Extraction, and routing across several specialist agents or data sources suggests Multi-Agent Supervisor. Agent Bricks suits common patterns that need fast delivery with built-in evaluation and tuning. Custom code with Agent Framework fits when the logic, tools or control flow are unusual.
- How it shows up
- A use case is described and you choose the Agent Bricks template, or recognize that custom development is required.
- Common confusion
- Using Knowledge Assistant for document-to-table extraction, which is the Information Extraction pattern.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
Structured output prompting
Schema, examples and delimiters that make responses parseable.
- Remember
- An explicit schema plus one example beats long prose instructions.
- Tested as
- Format-focused design questions.
- Trap
- Relying on persona text to control format.
-
Few-shot examples
Sample input and output pairs placed in the prompt.
- Remember
- They anchor both format and style.
- Tested as
- Prompt design and adjustment questions.
- Trap
- Using examples that conflict with the stated schema.
-
Task mapping
Linking a business need to classification, extraction, summarization or generation.
- Remember
- The output type reveals the task.
- Tested as
- Requirement-to-task questions.
- Trap
- Defaulting to generation for everything.
-
Chain
A sequence of components that turns input into output.
- Remember
- Include only the components the requirement needs.
- Tested as
- Component selection questions.
- Trap
- Adding retrieval when no external knowledge is needed.
-
Pipeline specification
A statement of inputs, sources, outputs, consumers and quality bar.
- Remember
- It precedes model and tool choices.
- Tested as
- Use case translation questions.
- Trap
- Naming a framework instead of inputs and outputs.
-
Tool description
The name, purpose and parameters an LLM reads to pick a tool.
- Remember
- Clear descriptions drive correct tool calls.
- Tested as
- Agent design questions.
- Trap
- Vague, overlapping descriptions across tools.
-
Gather before act
Knowledge tools run before tools that change state.
- Remember
- Actions depend on retrieved facts.
- Tested as
- Tool ordering questions.
- Trap
- Acting on assumptions before lookup.
-
Unity Catalog functions as tools
Governed SQL or Python functions that agents can call.
- Remember
- They inherit Unity Catalog permissions and discovery.
- Tested as
- Tool definition questions.
- Trap
- Hard-coding logic that should be a governed function.
-
Agent Bricks Knowledge Assistant
A managed agent that answers questions over documents with citations.
- Remember
- It is the managed RAG pattern.
- Tested as
- Agent Bricks selection questions.
- Trap
- Using it to produce structured records.
-
Agent Bricks Information Extraction
A managed agent that turns unstructured documents into structured fields.
- Remember
- Output is records, not chat answers.
- Tested as
- Agent Bricks selection questions.
- Trap
- Confusing it with Knowledge Assistant.
-
Agent Bricks Multi-Agent Supervisor
A managed coordinator that routes requests across agents, Genie spaces and tools.
- Remember
- It fits several specialist sources behind one interface.
- Tested as
- Multi-agent design questions.
- Trap
- Building custom routing when the supervisor fits.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
Model tasks by output type
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Classification | Assign one label from a fixed set | Closed answer space | Treating it as open generation |
| Extraction | Pull named fields from text | Output is structured values | Confusing it with summarization |
| Summarization | Condense text faithfully | Shorter version of the source | Allowing new facts to appear |
| Generation | Produce new open-ended text | Widest output space | Using it where a label suffices |
Agent Bricks templates
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Knowledge Assistant | Cited answers over documents | Question-answering output | Using it for field extraction |
| Information Extraction | Documents to structured fields | Tabular or JSON output | Expecting conversational answers |
| Multi-Agent Supervisor | Coordinates agents, Genie spaces and tools | Routing across sources | Using it for a single source |
| Custom Agent Framework build | Code-defined agent logic | Full control of flow and tools | Choosing it when a template fits |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
Persona fixes format
- What candidates pick
- Add a detailed expert persona to stop malformed JSON.
- Why it looks right
- Personas improve tone and are widely recommended.
- Why it's wrong
- Format reliability comes from an explicit schema, delimiters and examples, not from the role the model is asked to play.
Clue to watch for The problem described is unparseable output, not tone.
-
Generation for labels
- What candidates pick
- Have the model write a free-text description of the category.
- Why it looks right
- Generation feels flexible.
- Why it's wrong
- A fixed set of categories is a classification task, which is easier to constrain and evaluate.
Clue to watch for The requirement lists a closed set of allowed values.
-
Retriever by default
- What candidates pick
- Add vector retrieval to every chain.
- Why it looks right
- RAG is the headline pattern of the exam.
- Why it's wrong
- Retrieval only helps when the answer depends on external or private knowledge; otherwise it adds latency and noise.
Clue to watch for The task uses only the text the user supplies.
-
Act then verify
- What candidates pick
- Let the agent issue the refund and then check the order.
- Why it looks right
- The action is the business goal.
- Why it's wrong
- Actions should depend on gathered facts, so lookup tools must run first to avoid unsafe or wrong changes.
Clue to watch for One tool changes data and another reads it.
-
Knowledge Assistant for extraction
- What candidates pick
- Use Knowledge Assistant to fill a table from contracts.
- Why it looks right
- Both work over documents.
- Why it's wrong
- Knowledge Assistant returns cited answers; Information Extraction is the template that converts documents into structured fields.
Clue to watch for The target is rows and columns, not chat responses.
-
Framework as specification
- What candidates pick
- Describe the pipeline by naming LangChain and a model.
- Why it looks right
- Tools sound concrete.
- Why it's wrong
- A use case specification states inputs, sources, outputs and quality criteria; tool choices come afterwards.
Clue to watch for The question asks how to describe what the pipeline needs.
Answer framework
For a Design Applications scenario, work from the requirement toward the simplest design that satisfies it.
- Restate the use case as inputs, knowledge sources, required output format, consumer of the output and the quality bar it must meet.
- Identify the model task from the output type: fixed labels, extracted fields, faithful condensation or open generation, and note any task sequence.
- Pick only the chain components the requirement needs, adding retrieval, parsing, memory or tools when the input and output demand them.
- For agents, write clear tool descriptions and order knowledge-gathering tools before any tool that changes data or calls an external system.
- Check whether an Agent Bricks template already fits the pattern before choosing a custom Agent Framework build with more maintenance.
Practice question
Want more like this? The Databricks GenAI Assoc practice test has questions for every domain.
Checklist
0 of 10
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Approach this section as a requirements exercise. Take five realistic business requests, such as routing support tickets, summarizing call transcripts or answering HR policy questions, and for each one write down the inputs, knowledge sources, output format and the model task. This builds the habit the exam rewards: reading the output type first.
Next, practice structured prompting in a Databricks notebook or the AI Playground. Ask a Foundation Model API endpoint for JSON with a fixed schema, then break it by removing the example, and watch how reliability changes. That small experiment makes formatting questions easy.
Then study agents. Sketch a two-tool agent that looks up an order and then issues a refund, and write tool descriptions for each. Read the Databricks documentation pages for Agent Bricks and note what each of the three templates outputs and when a custom Agent Framework build is warranted. Finish with timed practice questions on this section, then continue to Data Preparation, which feeds the retrieval designs you sketched here.
FAQ
How much of the Databricks GenAI Associate exam is Design Applications?
Design Applications carries 14% of the exam, about six of the 45 scored questions, and sets up the design vocabulary used in later sections.
Is this exam still current in 2026?
Yes. The exam guide covers the version published on 18 March 2026, with 45 scored questions in 90 minutes. Databricks advises checking the guide again shortly before your test date.
Do I need to know Agent Bricks?
Yes. The March 2026 outline names Knowledge Assistant, Multi-Agent Supervisor and Information Extraction, so know what each produces and when to choose it.
How do I make an LLM return valid JSON?
State the schema with field names and types, delimit the input text, include an example of the exact output, keep temperature low and use structured output support where the endpoint offers it.
Why does tool order matter for agents?
Later steps rely on facts gathered earlier. Looking up data before taking an action prevents the agent from acting on guesses.
Does this section require coding?
Mostly no. It tests design choices, though recognizing prompt templates and tool definitions in code snippets helps.
What is the passing score?
Databricks does not publish a passing score for this exam, so aim for consistent strength across all six sections.
Other Artificial Intelligence & Machine Learning certifications
Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.
Test your Domain 1 knowledge
You have covered structured prompts, task selection, chain components, tool ordering and Agent Bricks. Test whether you can pick the simplest correct design under time pressure.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the Databricks GenAI Assoc AI tutor Get any concept explained your way