CCDV-F - Agents and Workflows (14.7% of the exam) - Section 1.3
Select common agent design patterns and agentic abstraction frameworks for multi-step tasks.
Published skill weight 4.9 percent. Covers tool-use loops, sub-agents, memory and context-window management as recurring design patterns, plus agentic abstraction frameworks such as Strands, LangGraph and PydanticAI for building agents and workflows that span several steps.
Five teams in one company are each building a multi-step agent. Every team has separately written its own tool-call loop, retry handling, state passing and tracing, and a platform review finds the five implementations diverge in how they resume an interrupted run. The platform group must give all five a common orchestration substrate with shared tracing, without prescribing the business logic of any one agent. Which approach fits that requirement?
AAsk each team to copy the loop, retry and tracing code from whichever of the five implementations the review judged the most complete, then maintain that copy inside its own service.
BHave the platform group write a company system prompt describing the required loop, retry and resume behaviour, and require every team to include that prompt block in its agent's instructions.
CAdd a coordinating agent above the five agents that receives each request, decides which team's agent should handle it, and supervises that agent through to completion on every single run.
DStandardise on an established agentic abstraction framework such as Strands, LangGraph or PydanticAI, so the loop, state passing and tracing are shared while each team writes only its own steps and tools.check_circle Correct
An agentic abstraction framework supplies the shared loop, state and tracing substrate that several teams would otherwise reimplement separately. What the five teams duplicated is orchestration mechanics: driving the tool-call loop, carrying state between steps, retrying, resuming and emitting traces. That is the layer an agentic framework provides as a common substrate, so adopting one removes the divergence at its source while each team keeps ownership of its own steps and tools. Copied code drifts, and a shared prompt cannot control code paths at all.
Why A is wrong: Tempting because it spreads the best current implementation quickly, but five copies drift the moment one team patches its own, which reproduces the divergence the review was called in to fix.
Why B is wrong: Tempting because a shared prompt is quick to distribute, but orchestration and resumption are properties of the code that drives the loop, so a prompt cannot make an interrupted run resume consistently.
Why C is wrong: Tempting because coordination sounds like the shared layer, but routing between five unrelated agents is not the duplicated concern, and it buys a supervisory hop the requirement does not ask for.
Why D is correct: Correct, because these frameworks exist to supply the orchestration layer being duplicated, giving one shared substrate with common tracing while leaving each agent's business logic to its own team.
Answers that look right on this material and are not. Each one is a distractor from a different question in the CCDV-F bank for this domain.
They supply ready-made connectors to common enterprise systems, so the team declares which systems it needs and the framework handles authentication and the query surface for each.
errorWhy it is wrong: Tempting because some frameworks ship example integrations, but the team's own systems still need tools written and authenticated by the team itself.
Raise the token limit for each request so the assistant has enough room to finish its reply before the loop reads the text it has produced so far.
errorWhy it is wrong: Truncation from a low token limit is a real failure with similar symptoms, but here the reply is complete and the loop simply returns before running the tool it asked for.
An agent cannot write to a database table, because tool execution in an agent loop is restricted to read operations and any mutation has to run outside the loop.
errorWhy it is wrong: Cautious tool design does often separate reads from writes, but nothing prevents an agent tool from mutating state, so this objection rests on a rule that does not exist.