Databricks Context-Engineer-Associate Practice Exam Questions & Answers

Context poisoning occurs when erroneous or untrustworthy information becomes incorporated into an agent's working context and subsequently influences its decisions as though it were established truth.

In this scenario, the failure originates at Step 2. The agent encounters an outdated, community-authored FAQ that contradicts the authoritative Billing-Policies tool. Rather than preserving the distinction between authoritative and non-authoritative information, the agent incorporates the incorrect refund statement into its conversation summary.

At Step 3, the agent relies on that contaminated summary to approve an ineligible refund. Step 4 establishes the defining characteristic of context poisoning: the incorrect information is repeatedly reinforced through subsequent decisions.

Context distraction would involve excessive context degrading attention. Context confusion would arise from irrelevant material being misapplied. Context clash concerns conflicting information or instructions. Although contradictory information exists here, repeated reliance on an established false statement makes poisoning the more precise diagnosis.

The appropriate remediation is to enforce source-authority rules during context construction, prevent unverified statements from being promoted into persistent summaries, and validate refund decisions against the authoritative policy.

Databricks MLflow Tracing supports this investigation by recording intermediate retrieval operations, tool responses, and model decisions, allowing engineers to identify where incorrect information entered and propagated through the workflow.

Official Databricks reference: Databricks MLflow 3 --- Tracing overview and Debug and analyze your app with tracing.

The underlying issue is ambiguity in the semantic descriptions of two valid production datasets.

Databricks Genie uses Unity Catalog table metadata, column names, descriptions, and other contextual information to interpret natural-language questions and generate SQL queries.

When two tables have similar names but represent different financial measures, insufficient metadata can cause Genie to select the incorrect source.

Option A resolves this problem by adding explicit, reusable semantic definitions directly to Unity Catalog.

For example, comments on revenue should identify the table as the net-revenue dataset and document applicable deductions, adjustments, currency units, and accounting conventions. Comments on revenue_gross should clearly explain its gross-revenue calculation and identify the adjustments excluded from that measure.

Column-level descriptions should similarly distinguish gross and net monetary amounts.

Option C could improve behavior within one Genie space, but its instructions would not automatically benefit other spaces or BI consumers. Options B and D introduce prioritization metadata rather than properly explaining the meaning of the datasets.

Because both tables remain valid and necessary, the appropriate solution is semantic clarification rather than deprecation.

Databricks specifically emphasizes comprehensive Unity Catalog documentation for improving Genie's accuracy and reliability.

Official Databricks reference: Databricks --- Genie Agents concepts, Curate an effective Genie Agent, and Add comments to data and AI assets.

A parameterized Unity Catalog SQL function provides the strongest mechanism for stabilizing complex, business-critical calculations across Genie sessions.

The underlying issue is that Genie independently generates SQL for each question, resulting in variations in currency conversion, accrual timing, and intercompany elimination.

Although comprehensive metadata and instructions improve query generation, they do not guarantee that a complex financial calculation will be reproduced identically on every request.

Option A encapsulates the approved revenue-calculation logic within a reusable SQL function.

The function can accept parameters representing fiscal periods, regions, or other approved filters while maintaining the prescribed accounting transformations.

Databricks Genie supports Unity Catalog SQL functions as trusted assets. Such functions are particularly appropriate for complex calculations that should not be independently reconstructed or modified during question answering.

Option B provides a reference query, but Genie may still generate variations when adapting that query to new requests. Option C offers further natural-language guidance without enforcing calculation consistency. Option D does not provide the same explicit executable boundary as a registered SQL function.

Access to the function must also be governed through the appropriate Unity Catalog permissions, including EXECUTE.

This architecture centralizes financial logic, improves maintainability, and reduces the likelihood of inconsistent revenue figures across sessions.

Official Databricks reference: Tune Genie Agent quality --- Trusted Assets and How Genie Uses SQL Functions.

The fundamental limitation is the absence of persistent, case-scoped memory across independent agent sessions.

The existing Databricks AI Search index retrieves source documents, including incident reports, transaction logs, and exhibits. However, retrieval of case documents is not equivalent to preserving the analytical conclusions reached during previous conversations.

The assistant must retain investigation-specific decisions, eliminated suspects, confirmed entities, financial pathways, and unresolved investigative actions.

Option A introduces a durable memory store keyed by case_id, allowing the investigation's working knowledge to persist independently of the analyst conducting the session.

At the end of each session, the agent records a structured summary containing relevant conclusions and supporting references. At the beginning of the next session, the agent retrieves the active case's memory and incorporates it into its context.

Option B incorrectly associates memory with individual analysts rather than investigations. Option C expands document retrieval without necessarily retrieving previous analytical conclusions. Option D improves source-data freshness but does not establish cross-session reasoning memory.

Databricks distinguishes session state from long-term memory and supports durable agent state using Lakebase. A Unity Catalog Delta table, as proposed here, is also a viable application-managed persistence design.

Case-level access controls and evidence references should be maintained to prevent unauthorized access and unsupported conclusions.

Official Databricks reference: Agent memory and sessions and Self-managed agent memory (Lakebase).

Preloading customer profile information into the session context provides the required balance between data availability, consistency, and retrieval efficiency.

The scenario establishes three important constraints: profile attributes must be available before the first interaction, their values remain unchanged during a session, and those values may change between sessions.

Option B meets these requirements by retrieving the relevant records from Lakebase during session initialization.

The agent stores the plan tier, region, and entitlement flags in a session-scoped context object. Because the object is available to every turn handler, subsequent interactions can reuse the information without executing additional database queries.

This eliminates repeated Lakebase round-trips and reduces both latency and database workload.

Option A introduces a shared cache that may return stale values when account information changes between sessions. Option C adds unnecessary database access to individual turns. Option D introduces periodic refresh operations despite the explicit guarantee that the values do not change during an active session.

Databricks supports stateful agent architectures through session management and Lakebase-backed persistence. Session-specific context is appropriate for information needed repeatedly within a single interaction.

The implementation should retrieve the profile using the authenticated user identity, perform initialization before processing the first turn, and create a fresh context object for each new session.

Official Databricks reference: Agent memory and sessions and Agent sessions.

The most probable cause is incomplete transfer of relevant contextual information from the coordinating agent to the specialized sub-agents.

In a multi-agent architecture, each agent typically operates within its own execution context. Information established by the coordinator does not automatically become available to downstream agents unless the application explicitly transmits it.

The scenario provides a decisive diagnostic observation: individual sub-agents produce accurate results when they are manually supplied with the complete context.

This indicates that the agents possess the necessary capabilities but are operating with incomplete information during normal orchestration.

Option B therefore identifies the central failure.

The coordinator should provide each sub-agent with a structured context package containing the assigned task, relevant prior conclusions, applicable constraints, selected evidence, and important tool results.

This ensures that specialized agents interpret their assignments consistently with the broader workflow.

Option A suggests model randomness, but the scenario does not identify unstable dispatch instructions. Options C and D conflict with the confirmed retrieval-index configuration and successful isolated tests.

Databricks supports orchestrated multi-agent systems in which specialized agents are invoked through a coordinating component.

MLflow Tracing can record the inputs and outputs of each agent invocation, allowing engineers to inspect precisely which context was transferred and identify missing information at agent boundaries.

Official Databricks reference: Build a multi-agent system on Databricks Apps, Core concepts for agent observability, and Tracing AG2.

The correct approach is to update the existing durable memory entry rather than introduce additional conflicting records.

Databricks Agent Memory stores persistent information using an identity structure that includes actor_id, optional session_id, and path.

An entry is uniquely identified by the combination of these attributes.

For preferences intended to persist across conversations, the session_id should remain unset. This allows the entry to represent user-level knowledge rather than information associated with only one session.

Option B uses memory_store.put() to update the existing memory at the same actor and path.

Databricks documents that add() fails with ALREADY_EXISTS when an entry already exists at the specified location, whereas put() can create or update an entry.

Reusing /preferences/flight-class.md replaces the outdated preference with the user's newly confirmed choice.

Option A risks retaining contradictory information in separate entries. Option C creates session-specific memory rather than updating the durable cross-session preference. Option D loses the updated preference when the active session ends.

The application should also restrict memory retrieval and updates to the authenticated user's actor_id.

This design supports consistent personalization while preventing stale preferences from contaminating future recommendations.

Official Databricks reference: Agent memory --- Memory Entries, Retrieval, and the memory_store.put() operation.