A context engineer is evaluating a target-landscape research agent at a pharmaceutical R & D organization.
Discovery scientists ask the agent to prepare a structured landscape memo about a proposed drug target: what has been studied, who else is in the space, at what clinical phase, and with what regulatory history.
The agent runs as a single agent on Agent Bricks Custom Agents. It retrieves from a Databricks AI Search index built over PubMed, ClinicalTrials.gov, internal program memos, and FDA review documents, and produces the memo in one pass within a single context window.
Narrow queries (one target, one indication) produce accurate memos. Broader landscape queries return with competitor programs missing that the agent had named earlier in its own reasoning, quoted evidence attached to the wrong study, and cross-document fields partially filled. The MLflow trace shows window utilization rising toward the cap before drafting begins. One agent runs throughout.
What change should the AI engineer make to the agent architecture's boundaries?

• A. Split the agent into sub-agents that scope exploration separately from synthesis, with summaries (not raw evidence) crossing the boundary into the synthesis step.
• B. Keep the single-agent boundary and lower the within-agent compaction trigger threshold so compaction fires before the memo is drafted.
• C. Split the agent along the document-source axis (PubMed, ClinicalTrials.gov, internal memos, FDA reviews) and merge per-source outputs in the orchestrator.
• D. Split the agent into a chain of single-step sub-agents (parse, retrieve, summarize, cluster, verify, cite, draft) connected by sequential handoffs.

A context engineer is investigating an AI agent deployed on Databricks that handles customer support operations. The agent has two MCP tools registered: one described as "Searches customer support tickets and open case records for a given customer", and another described as "Looks up customer issue history and unresolved case details by customer ID".
When users ask whether a customer has any open issues, the agent randomly chooses between the two tools across repeated identical requests. When users ask about a customer's past resolved issues, the agent similarly misfires between the two tools. The engineer has reviewed the tool call logs and confirmed that the agent cannot reliably distinguish which tool to invoke.
Which overlap between the two tool descriptions is causing the agent to select tools ambiguously?

• A. Both descriptions omit the data source or system name, so the agent cannot determine which backend database each tool queries when forming a retrieval plan.
• B. Both descriptions reference a customer identifier as the lookup parameter, making the input signature indistinguishable to the agent when resolving tool selection.
• C. Both descriptions use action verbs (Searches and Looks up) that belong to the same semantic category, causing the agent to treat the tools as interchangeable retrieval operations.
• D. Both descriptions claim the same functional scope: each covers open cases (open case records and unresolved case details) and historical records (support tickets and issue history), leaving no functional differentiator.

A context engineer is building a retrieval-augmented generation agent on Databricks to answer questions about a large collection of legal contracts. Each contract is a structured PDF averaging 40 pages, with clearly defined sections such as "Definitions," "Obligations," and "Termination Clauses." The embedding model in use has a 512-token context window. User queries are highly targeted, such as "What are the termination conditions in the indemnification clause?", and require precise, clause-level retrieval rather than broad document summaries.
Which chunking strategy should the context engineer use?

• A. Use structure-aware chunking that splits documents at section boundaries, then further subdivides sections exceeding 400 tokens to stay within the embedding model's context window.
• B. Split each contract into fixed-size chunks of 512 tokens with 50-token overlaps, ignoring document structure, keeping chunks within the embedding model's context window.
• C. Embed each contract section as a single chunk without further subdivision, preserving full section context even when sections exceed the embedding model's context window.
• D. Apply paragraph-level chunking across all contracts, splitting each section into individual paragraphs, to maximize retrieval granularity for targeted clause queries.

A context engineer is designing an MCP server for a Databricks agent that connects to a catalog of 30 tools.
The server uses a progressive disclosure architecture to manage a strict token budget. At startup, the agent loads only the tool names and one-sentence descriptions. After receiving a user request to query a specific Unity Catalog table, the agent evaluates the catalog, identifies one tool as the likely match, and needs to move to the next stage of the architecture.
What should the agent do in the inspect layer?

• A. Call the selected tool using parameter values inferred from the short description, since the catalog layer has already confirmed the tool identity.
• B. Retrieve an enriched summary for the selected tool that includes usage examples and defers loading parameter types until the execution layer.
• C. Fetch the full schemas and documentation for the single identified tool, then use that retrieved schema to construct a valid tool call.
• D. Load the full schemas for all 30 available tools so it can cross-validate the selected tool's parameters against similar tools before constructing the call.

A context engineer is reviewing a Databricks agent pipeline designed for a contract review assistant. Users submit queries such as "Can I get out of this?" and "What does this cover?". The pipeline retrieves syntactically valid contract clauses through a vector search index, but generated responses consistently address the wrong contractual context. Tracing logs confirm that the vector search index, prompt assembly, and LLM generation stages all execute without errors. The pipeline stages are: input ingestion, pre-retrieval enrichment, context retrieval, prompt construction, and response synthesis.
At which pipeline stage should the context engineer intervene to ensure that retrieval operates on a grounded representation of the user's contractual request?

• A. The pre-retrieval enrichment stage, where vague natural-language queries are rewritten into contract- domain representations so that the vector search index embeds a grounded query signal.
• B. The prompt construction stage, where retrieved contract clauses are inserted into a structured template and formatted before being passed to the LLM.
• C. The response synthesis stage, where the LLM is instructed via system-prompt constraints to restrict output to the contractual domain most relevant to the user's session history.
• D. The context retrieval stage, where a multi-route dispatcher selects among domain-partitioned vector indexes based on query embedding similarity scores.