Databricks Context Engineering

You cannot repair what you cannot see. This module teaches reading an MLflow trace span by span to find which input entered the context, when and why, and how to test that a change really fixed the run rather than moving the failure.

• Instrumenting an agent with MLflow tracing
• Reading spans, inputs and outputs
• Finding the step where the context went wrong
• Comparing a failing trace with a passing one
• Checking a fix against a set of saved traces

You build A trace review of a failing agent that pinpoints the cause and verifies the fix.

Every line of a prompt costs tokens and attention. You write system prompts with a clear structure, revise them from observed failures, and choose few-shot examples that earn their place, justifying what each element adds against what it costs.

• Structuring a system prompt: role, rules and format
• Revising a prompt from a failing trace
• Picking few-shot examples that generalize
• Counting what each element costs in tokens
• Instructions that conflict, and how to resolve them
• Testing a prompt change before shipping it

You build A system prompt revised in three steps, each backed by a measured difference.

Retrieval decides what the model gets to know. You chunk documents sensibly, fix retrieval problems in AI Search, design RAG over a governed corpus with Unity Catalog metadata, and limit sources to the authoritative ones.

• Chunking by structure and by meaning
• Diagnosing misses: recall, ranking and embeddings
• Filtering retrieval with Unity Catalog metadata
• Up-front retrieval against just-in-time retrieval
• Restricting retrieval to authoritative sources
• Evaluating a retrieval change

You build A retrieval setup over a governed corpus, with a before-and-after relevance check.

For tables, the right context is a well-prepared Genie space, not a long prompt. You choose which tables and columns to expose, write the instructions and sample questions that steer it, and improve it from the questions users really ask.

• Choosing tables and columns for a space
• Writing instructions and sample questions
• Trusted assets and certified answers
• Reading failed questions to improve the space
• Genie or retrieval over documents: choosing

You build A Genie space with instructions, trusted queries and a benchmark of test questions.

Agents forget unless you give them memory, and badly designed memory floods the context. You match memory types to the information needed, persist state across sessions in Lakebase, and weigh static against dynamic retrieval of what was remembered.

• Working, session and long-term memory
• Persisting conversation state in Lakebase
• Writing memories: what to keep and what to drop
• Static loading against dynamic recall
• Over-retrieval and how it hurts answers
• Tracking memory behavior with MLflow 3

You build An agent with session and cross-session memory, and a test that shows what it recalls.

Tool definitions are context too, and a crowded tool list confuses a model. You expose tools progressively, tell similar MCP tools apart through clear descriptions, and package rarely used capabilities as Agent Skills loaded on demand.

• What a tool definition costs in context
• Writing tool descriptions a model can choose between
• MCP servers and the tools they expose
• Disclosing tools progressively
• Packaging rare capabilities as Agent Skills
• Debugging a wrong tool choice from a trace

You build A tool set with progressive disclosure and a test showing the model chooses correctly.

A long session fills the window with things that no longer matter. You trim and compact history, tune a compaction prompt first for recall and then for precision, and judge what is safe to drop from a running trace.

• Trimming, summarizing and compacting compared
• Writing a compaction prompt
• Tuning for recall first, then precision
• What is safe to drop and what is not
• Testing that compaction loses nothing important

You build A compaction step tested on long traces for facts lost and tokens saved.

Several agents can lose each other’s context, and long tasks outlive any single window. You diagnose shared-context failures between sub-agents, decide what to propagate to each, and pick strategies for work that spans many steps.

• Sub-agents and what each one needs to know
• Context propagation and its failure modes
• Isolating context to avoid cross-contamination
• Notes, plans and state files for long tasks
• Choosing a strategy for long-horizon work

You build A two-agent workflow with defined context hand-offs, tested on a long task.

You get an agent that fails in several ways at once. You trace it, classify each failure, apply the right fix in prompt, retrieval, memory, tools or compaction, and prove with evidence that the agent now behaves.

• Triage: reading the traces and sorting failures by cause
• Choosing a fix for each failure mode
• Applying and measuring each change in turn
• Governing what the agent may retrieve and remember
• Writing up the repair for the team

You build A repaired agent with a before-and-after trace comparison and a written change record.