cert-bank

Guides

이 글을 한국어로 읽기

DBX-CEA Study Guide: Treat the Context Window as a Budget and Every Question Gets Easier

The Databricks Certified Context Engineer Associate exam (DBX-CEA) is about one scarce resource: the model's context window, and the attention the model can spread over it. Almost every question describes an agent that misbehaves and offers four sensible-sounding fixes. The right one is nearly always the fix that either keeps useless tokens out of the window or gets a missing fact in, with the smallest change. This guide sorts the exam into those two moves, plus a third question: where should each piece of information live?

Study guide · Databricks Certified Context Engineer Associate (DBX-CEA)

DBX-CEA Study Guide: Treat the Context Window as a Budget and Every Question Gets Easier

The exam

45 scored questions, multiple choice and multiple selection, in 90 minutes (the exam can also carry up to 10 unscored items). Databricks does not publish the pass mark. There are seven domains: Foundations of Context Engineering (16%), System Prompt and Instruction Design (9%), Knowledge Retrieval and Genie Configuration (20%), Memory Architecture with Lakebase and MLflow (18%), Tool Design, MCP, and Agent Context (13%), Context Compression and Compaction (11%), and Multi-Agent and Long-Horizon Task Design (13%).

We wrote 225 DBX-CEA questions for this question bank. 83 of them (37%) are troubleshooting scenarios, and 37 ask for more than one answer. The services named most often are Lakebase (34 questions), MLflow Tracing (23) and MCP (13). Tracing matters more than its count suggests, because many diagnoses start from a trace: 68 of the 225 question stems mention one.

One thing to know before you start: many of the exam's terms are the exam guide's own vocabulary, not Databricks settings. Context poisoning, distraction, confusion and clash, compaction, progressive disclosure, pre-inference versus just-in-time retrieval: the docs describe the tools around them, but you will not find a switch called "compaction". Do not hunt for a product feature behind every term.

Move 1: keep useless tokens out

A long context can degrade quality well before the window is full. The window size is a ceiling, not a target. So the first diagnosis is always the same: what is in the window that should not be there?

Symptom in the traceSmallest fix
A long, accurate history; the agent repeats old actions or ignores the latest constraint (distraction)Compact older turns into decisions, constraints, open tasks and identifiers; keep recent turns verbatim
The agent picks the wrong one of two look-alike tools (confusion)Rewrite the descriptions: what each returns, its key input, when to prefer it
Dozens of tool schemas load on every callDeselect unused MCP tools; stage the rest behind a short index (progressive disclosure)
A tool returns thousands of rowsScope at the source: filters, a row limit, only the needed columns, or a purpose-built aggregate tool
25 memories injected, two used (over-retrieval)A relevance gate plus a moderate cap; one distilled fact per memory entry

The arithmetic is worth knowing. A catalogue of 60 tools at about 500 tokens per schema costs 30,000 tokens on every call if it is dumped in full. A staged index of 60 short lines (about 20 tokens each) plus the three schemas actually used costs about 2,700, at the price of one extra round trip per tool. Tools used in nearly every conversation stay always loaded. Note that an MCP policy (a Beta feature) can deny a call, but the tool stays in the tool list. Only deselecting it removes its definition from the window.

Beginner tip: open one MLflow trace of any agent you have, even a toy one, and write down the input tokens of each span. Then find the single largest contributor: the system prompt, a tool result, retrieved passages or history. That one exercise turns "reduce attention budget pressure" from an abstraction into a habit, and it is exactly the method the exam expects: measure, then cut the biggest item at its source.

Move 2: get the missing fact in

The opposite failure is an agent that never received what it needed. The cause decides the fix:

  • Genie returns wrong SQL. Look for missing Unity Catalog column comments and undefined business terms first. They are cheap, durable and shared by every consumer. Example SQL queries and Unity Catalog SQL functions (trusted assets) come next. Free-text instructions are the last resort.
  • The answer is on-topic but incomplete. If RetrievalRelevance is high but RetrievalSufficiency is low, the authoritative source is probably not in the corpus. No chunk size or reranker can supply text that is absent, so onboard the missing source.
  • The agent "forgot" a preference. Check three things: what the store holds, what retrieval returned and what the answer used. If the fact is stored but never returned, the gap is in retrieval (a threshold that is too strict, or a query that never mentions the constraint). If it is not stored, the gap is in writing.
  • Sub-agents disagree. Each got a bare task message. Dispatch a compacted, relevant slice of the coordinator's trace with it, order dependent work, and send conclusions together with their assumptions.

Tell poisoning from clash by counting sources. Poisoning is one false item that keeps being trusted. If it reached durable memory, fix the stored entry. Clash is two items that disagree, so retrieve only the authoritative one or state a precedence rule.

Going deeper: why compaction loses exactly the things you need

A summariser without guidance keeps the story and drops what looks like detail: exact error strings, file paths, identifiers, figures, prohibitions, the list of remaining steps and the approaches that already failed. None of these can be rebuilt from a paraphrase, so each loss shows up as a recognisable symptom later (the agent asks again for a stack trace, writes to the table it was told to avoid, or retries a failed approach). The fix is a compaction prompt that requires those categories verbatim. Tune it for recall first (do the facts that later steps need survive?) and precision second (how much of the summary is noise?). A short summary hides its gaps, while noise in a long one is easy to see and cut.

Move 3: decide where each piece of information lives

Domain 4 is 18% and turns on one test: must this information still be available after the conversation ends and a different one begins?

StoreHolds
In-context scratchpadSmall working notes for this task only. Lost on restart and can be compacted away
Agent sessions (Lakebase)One interaction's transcript and state, so it survives a restart
Agent memory (Lakebase)Durable facts about a subject such as a user, recalled by semantic search in later conversations
Delta table "state object"Exact, shared, auditable task state: multi-day progress, counters, parallel agents

Memory is scoped to a subject, not to a chat. Keying memories by the chat id makes them behave like session state. The stores are independent, so deleting a session does not delete memories. Use structured queries for exact values with a known key, and semantic search for paraphrased recall. Ownership is a filter on the query, never a prompt instruction. For timing, load small facts that are always needed before inference (static, pre-inference), and put knowledge whose need depends on the conversation behind a retriever tool (dynamic, just-in-time).

Going deeper: why a prompt rule is never an access control

By the time the model reads "only discuss this customer", the other customer's memories or the unapproved document are already in its context. The instruction only asks the model to behave, and a model cannot reliably separate instructions from data. Real controls act before the tokens arrive: grants on the stores and on the governed corpus, a dedicated service principal with least privilege, a metadata filter on the retrieval query. The same holds for Unity Catalog's certified tag: it signals trust but does not block reads. That is why options built on wording, emphasis or certification labels lose to options that change what can reach the window.

DBX-CEA: where each piece of information lives
In-context scratchpad
Small working notes for this task only · Lost on restart · Can be compacted away
Agent sessions (Lakebase)
One interaction's transcript and state · Survives a restart
Agent memory (Lakebase)
Durable facts about a subject, such as a user · Recalled by semantic search later · Scoped to the subject, not the chat
Delta table state object
Exact, shared, auditable task state · Multi-day progress, counters, parallel agents
From top to bottom the store lasts longer and is shared more widely; pick the first one that still holds the fact when it is needed.

Traps that repeat across all seven domains

  • A bigger window. It delays the problem and keeps the noise. If the stem says the window cannot grow, the right option respects that.
  • Preview, Beta and Legacy features. AI Search full-text search is Beta. The Genie multi-agent page is Public Preview. The older Unity Catalog-governed agent memory is Legacy. None of them is the stable answer.
  • Lower temperature, another model or a review pass for a missing-context cause. None of them supplies the missing fact.
  • Raising the thinking budget when the real problem is an oversized prompt. Reduce the context instead.

A study order

  1. Retrieval and Genie configuration plus memory architecture together (38% between them).
  2. Foundations: the four failure modes, attention budget, reasoning modes.
  3. Tools and MCP, then multi-agent and long-horizon design.
  4. Compaction, then a last skim of system prompt design. Then mixed practice sets.

Practise

Practise in the question bank: every question explains each option, right and wrong. Start with the domain you just studied, then take a timed mock exam.

Domains and weights as listed in the Databricks exam guide for the Context Engineer Associate certification. Features named here change quickly; check the current exam guide and documentation.