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 set of candidate few-shot examples for a Databricks agent, evaluate each against canonical coverage criteria and select the minimal set that improves agent performance without inflating token cost. - 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 Vector 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 that is exhibiting degraded performance due to memory type mismatch, identify the mismatch and select the storage configuration that correctly aligns memory type with scope, retrieval pattern, and persistence requirements. - 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 Vector 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 the Databricks layered MCP architecture (discovery → planning → 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 the Databricks MCP layered architecture uses progressive disclosure to 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, identify which tool in a Unity Catalog-registered tool registry is most appropriate based on semantic similarity to the task description. - 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.