A context engineer is developing a multi-agent research pipeline on Databricks. A coordinator agent divides an incoming scientific literature query into two parallel subtasks: a citation-retrieval agent and a methodology- analysis agent. Both agents independently receive only the original user query, produce their outputs, and return them to the coordinator, which then invokes a synthesis agent. The synthesis agent produces a final report that contradicts the citation-retrieval findings because it relies solely on the methodology-analysis output and has no visibility into retrieved citations.
Which two context propagation changes would prevent the conflicting outputs in the synthesis agent?
Choose two

• A. Replace the parallel dispatch pattern with a sequential chain so the methodology-analysis agent runs first, and the citation-retrieval agent runs afterward, without changing what context is forwarded to the synthesis agent.
• B. Configure the coordinator to forward only a high-level methodology summary into the synthesis agent's context while omitting the underlying citation-retrieval data, to keep the context window small.
• C. Broadcast every agent's full raw interaction history, including intermediate prompts and tool calls, directly to the synthesis agent, allowing the LLM to self-structure citation results from methodology analysis.
• D. Configure the coordinator agent to merge outputs from the citation-retrieval and methodology-analysis agents into a single context payload before invoking the synthesis agent.
• E. Update the synthesis agent's input schema to accept a structured context object containing both citation- retrieval results and methodology-analysis results as named fields.

A context engineer is troubleshooting a Databricks agent responsible for a multi-month clinical trial data processing pipeline. The agent uses a fixed sequential chaining strategy, running each processing stage in a predetermined order regardless of which stages have already completed successfully. When upstream data sources are delayed or partially available, the agent restarts the entire chain from the beginning, discarding all previously completed stage outputs. Logs show that stages with no dependency on the delayed source are being blocked unnecessarily, and total pipeline runtime has grown to an unacceptable length because of repeated full restarts on partial failures.
Which two changes should the context engineer make to resolve the observed failure pattern?
Choose two

• A. Replace the fixed sequential chain with a dependency-graph-aware strategy that allows independent stages to execute without waiting for unrelated delayed stages.
• B. Replace the agent's task planner with a reactive event-driven model that triggers each stage only when a new data file lands in the source directory.
• C. Introduce checkpointing so that successfully completed stages are persisted and the agent resumes from the last valid checkpoint rather than restarting the full chain.
• D. Increase the agent's retry limit and timeout thresholds so the sequential chain has more time to wait for delayed upstream data before failing.
• E. Switch to a parallel decomposition strategy so all stages execute simultaneously, eliminating the sequential bottleneck caused by delayed upstream sources.

A context engineer is developing a Databricks agent for a retail inventory management system. The system prompt and tool descriptions consume 1,800 tokens of a 4,096-token context window, and the engineer reserves 1,000 tokens for the user turn and model response. The remaining tokens are used for few-shot examples, each costing approximately 250 tokens, so the engineer includes exactly five examples.
The agent uses three tools: inventory_lookup, reorder_check, and supplier_lead_time.
Six candidate examples are available:
Example 1: A warehouse manager asks whether a depleted SKU needs reordering; the agent calls inventory_lookup, confirms depletion, calls reorder_check, and returns a binary reorder decision.
Example 2: A procurement officer asks when a low-stock item can be replenished; the agent calls reorder_check, calls supplier_lead_time, and returns a replenishment recommendation.
Example 3: A store associate asks for the current stock count of a single product; the agent calls inventory_lookup and returns a scalar quantity.
Example 4: A store associate asks for the current stock count of a single product; the agent calls inventory_lookup and returns a structured status object containing the quantity and a restocking flag.
Example 5: A store associate asks whether a forecasted shortfall requires immediate action; the agent calls inventory_lookup, compares against minimums, calls reorder_check, and returns a binary reorder decision.
Example 6: A logistics coordinator asks how long a specific supplier takes to fulfill an order; the agent calls supplier_lead_time and returns a scalar lead-time value.
Which example should the engineer omit to preserve the token budget while maximizing behavioral coverage?

• A. Example 3, because another example in the set covers the same user role and tool path, but the output of the other example is richer.
• B. Example 5, because its forecasting logic duplicates the threshold-check pattern already established in Example 1, and its user role (store associate) appears elsewhere in the set.
• C. Example 1, because the same tools are exercised across Examples 2 and 5, making its specific decision path redundant.
• D. Example 6, because supplier_lead_time is already invoked in Example 2, and a standalone lead-time lookup does not add new tools to the demonstrated call space.

A context engineer supports a research agent at a financial services firm that operates across multiple sessions over several days to compile competitor profiles. Within a single session, conversation compaction is configured and functions as expected. However, MLflow traces show that whenever one session ends and another begins for the same task, the agent loses progress: it re-explores companies that previous sessions already analyzed, and it re-derives the same research framework from scratch. The team has determined that no single session should contain the entire multi-day workload in its own context window.
How should the engineer enable the agent to resume coherent work across sessions under this constraint?

• A. Raise the compaction trigger threshold so each session's compaction summary captures more of the prior conversation before the session is reinitialized.
• B. Copy each session's full message history into the next session's system prompt so the agent has access to all prior context before continuing the task.
• C. Have the agent, at the end of each session, write structured progress notes to a durable external memory store, then reload those notes into the context window at the start of each subsequent session.
• D. Store each session's full conversation transcript in a Databricks AI Search index and retrieve all prior chunks into the context window at the start of each new session to reconstruct the complete conversation history.

A context engineer is developing an agent to support legal teams reviewing multi-part pharmaceutical trial protocols. Each protocol document includes a narrative background section, nested dosage tables with footnote qualifiers, cross-referenced section identifiers, and figure captions describing study design diagrams.
The agent must answer precise questions such as which protocol section governs a specific dosage threshold and what footnote conditions apply to that threshold.
Available data sources include:
A PDF binary store in Unity Catalog Volumes.
A Delta table of plain-text chunks extracted from the protocols, each tagged with page number and document identifier, indexed in a Databricks AI Search index.
A Delta table of protocol structure metadata at the page level, containing table summaries, figure captions, and section hierarchy, accessible through Unity Catalog functions.
Which context elements should the context engineer include to answer structural and footnote-level questions accurately?

• A. The structure metadata Delta table loaded entirely into the prompt as a hierarchy, combined with the Databricks AI Search index, so the model can resolve table and footnote references from the full metadata.
• B. The Databricks AI Search index over plain-text chunks alone, relying on semantic similarity to surface table and footnote content without consulting the structure metadata Delta table.
• C. The PDF binary store in Unity Catalog Volumes and the structure metadata Delta table, using document identifiers to locate source files and extract table content through a preprocessing step at query time.
• D. The Databricks AI Search index over plain-text chunks to retrieve relevant passages, then a scoped lookup into the structure metadata Delta table for table summaries and figure context on the matched pages.