Free Practice Questions for Databricks Certified Context Engineer Associate Certification

Given a described agent failure, identify the context management technique that would most directly address it.

Given a Databricks agent design, identify which proactive context management strategies (e.g., minimal tool sets, just-in-time retrieval, tool result scoping) would reduce context window pressure before compaction becomes necessary.

Diagnose context failure modes: context poisoning, context distraction, context confusion, and context clash, given an agent trace.

Select the right tool in the Databricks product stack (Unity Catalog, Lakebase, MCP, MLflow 3) for a given scenario.

Given a described agent configuration, identify which context elements are consuming disproportionate attention budget and select the change most likely to improve model focus.

Given a Databricks agent task and its performance requirements, select the appropriate reasoning mode (standard, extended thinking, or reduced thinking) and justify the selection based on token budget constraints and context window impact.

Given a Databricks agent operating over an extended interaction, identify the point at which context length is causing measurable degradation in retrieval accuracy or reasoning quality, and select the intervention that restores performance.

Given a business domain, select and validate the instructions, sample questions, and trusted SQL assets that together produce a production-ready Genie space.

Given a Databricks agent, a set of candidate few-shot examples, and a token budget, justify which examples to include or exclude based on their marginal contribution to agent performance (e.g., covering untested tool paths, demonstrating output structure, handling ambiguous inputs).

Given a miscalibrated Databricks agent system prompt and its observed failure pattern, select the targeted revision strategy that resolves the failure with the least increase in token cost and maintenance burden.

Given experiment tracking results comparing two system prompt configurations on a Databricks agent, determine whether the higher-token configuration is justified and identify the specific prompt element driving the cost-performance tradeoff.

Given an underperforming Databricks agent and its associated Unity Catalog metadata, identify which missing or poorly specified metadata elements are causing the accuracy gap and select the configuration change that will have the highest impact on agent performance.

Select which Unity Catalog objects (managed tables, views, parameterized queries, SQL functions) to curate into a Genie space for a given business domain.

Given a Databricks agent with documented retrieval quality problems, diagnose which Databricks AI Search configuration is the root cause and select the remediation that most directly improves the signal quality of retrieved context.

Design a RAG pipeline that retrieves chunks from a Unity Catalog-governed document corpus and injects them into agent context.

Select an appropriate chunking strategy given document structure, embedding model context length, and the types of queries the agent will face.

Given a described agent task and available data sources, select the context elements required for the agent to correctly scope and execute the task.

Distinguish between pre-inference retrieval (embedding-based, up-front loading) and just-in-time agentic retrieval (tool calls, dynamic Delta table queries) and select the appropriate strategy for a given use case.

Identify which retrieval failure mode is occurring by using MLflow eval logs and UC metadata, and select the Unity Catalog governance action that most directly resolves the failure.

Given a Databricks agent deployment that will retrieve context from a Unity Catalog environment containing both authoritative and derived data assets, design a governance strategy that constrains the agent's retrieval space to authoritative sources before deployment.

Given a Databricks agent exhibiting degraded performance because its context is populated from an inappropriate memory source (e.g., retrieving from long-term storage when the information exists in the current session, or relying on session history when the needed context requires cross-session persistence), identify the mismatch between the memory type being used and the information need, and select the correct memory strategy.

Identify when a Delta-backed state object is required over an in-context scratchpad for an agent operating on a multi-step task.

Given an agent retrieving memories persisted in Lakebase, identify whether Databricks AI Search or structured query retrieval is the appropriate mechanism for a specified query type.

Given MLflow 3 experiment results across multiple agent runs, identify which context configuration produced the most reliable outcomes on a specified task.

Evaluate the tradeoffs of static retrieval vs. dynamic retrieval from Lakebase for a given agent architecture.

Diagnose risks of over-retrieval (context pollution) and under-retrieval (missing relevant history) in a memory system.

Configure persistent agent memory across sessions using Lakebase-backed durable store.

Given a Databricks agent pipeline that produces accurate but contextually mismatched responses, identify the pipeline stage where user intent should be resolved before context retrieval.

Apply a progressive-disclosure approach to MCP tool access (staged tool discovery with context-efficient execution) to reduce token usage compared to raw tool dumps.

Given two MCP tool descriptions that an agent is consistently confusing, identify the overlap in their descriptions that is causing ambiguous tool selection.

Explain how progressive disclosure can help control how much tool information enters the agent context window at each stage, and why this staged approach reduces token consumption compared to loading full tool schemas upfront.

Given an agent with a deep message history where the context window is approaching capacity, evaluate which raw tool outputs are candidates for clearing.

Given a described agent task and a set of tools registered in Unity Catalog (with names, descriptions, and parameter schemas), identify the most appropriate tool and justify the selection based on functional fit, input/output compatibility, and task requirements.

Given a Databricks agent whose system prompt is overloaded with rarely-invoked capability instructions, identify which capabilities are candidates for packaging as Agent Skills and select the loading strategy that minimizes baseline context cost without harming task success rate.

Given a long running agent task that has been compacted and is now exhibiting downstream coherence failures, identify which category of information was incorrectly discarded during compaction and select the compaction prompt revision that preserves that category without significantly increasing the token cost of the summarized context.

Tune a compaction prompt for a Databricks agent trace: maximize recall first (capture everything relevant), then iterate to improve precision (remove superfluous outputs).

Given a long-running Databricks agent task where context window pressure is building, evaluate whether hard-coded trimming heuristics are sufficient for the task's information relevance pattern, or if it requires a more sophisticated compaction approach.

Given a Databricks agent trace, identify which content is safe to remove during compaction without affecting downstream task execution.

Evaluate the tradeoffs between aggressive compaction (lower token cost, risk of losing subtle context) and conservative compaction (higher fidelity, higher cost).

Diagnose failure modes in multi-agent systems caused by insufficient shared context: inconsistent outputs, conflicting decisions, degraded reliability.

Given a multi-agent system where a coordinating agent has decomposed a task and dispatched sub-agents, and the system is now exhibiting downstream failures, diagnose the root cause (i.e., sub-agents receiving individual task messages rather than full agent traces at dispatch time), and select the configuration that resolves the failure without expanding each sub-agent's context window.

Given a multi-agent system producing conflicting outputs, identify the context propagation change that would most likely prevent the conflict.

Given a multi-agent Databricks workflow where the orchestrating agent is experiencing context saturation, identify the sub-agent output design change that would most reduce orchestrator context load without compromising task coherence.

Given a multi-agent system design where agent boundaries have been drawn and the resulting architecture is either exhibiting excessive handoff compression overhead or unmanageable context window growth within individual agents, diagnose which boundary placement failure is occurring.

Given a long-running Databricks agent task with documented performance failures, identify which long-horizon strategy mismatch is causing the observed failure, select the replacement strategy most appropriate for the task's dependency structure, and justify the selection by identifying the specific characteristic that makes the original strategy insufficient.