Quizzes

Agent Architectures quiz

24 questions from the Agent Architectures track. Score 80% or higher to unlock a certificate.

1. Anatomy of an Agent

   1. Which component turns model text into a typed tool call?

   • The executor
   • The context assembler
   • The parser
   • The stop predicate

2. The Assembler Has a Budget

   2. What should the assembler put in the prompt?

   • Every tool the company has ever shipped
   • Goal, a short recent window, and only the tools legal in this state
   • The full week of Slack
   • Yesterday’s stack traces in full

3. Parse, Then Fail Closed

   3. What should happen if the model emits an unknown tool name?

   • eval the name as Python
   • Return unknown_tool and do not execute
   • Guess a nearby name
   • Call every tool

4. Stop Conditions and Budgets

   4. The agent used its last step and still has no final answer. What should it return?

   • A confident guess
   • cannot: step budget (or handoff) — do not invent success
   • One more unpaid search
   • An empty string

5. ReAct: Thought, Action, Observation

   5. In ReAct, who should generate the Observation?

   • The same model, so it can stay in character
   • The executor, by actually running the tool
   • The user, in the system prompt
   • A second model that invents search snippets

6. Observe Before You Finish

   6. When is finish legal in a ReAct-style loop?

   • As the first action, always
   • After the executor has written at least one observation (unless the goal is already solved in context)
   • Whenever the thought feels confident
   • After any number of thoughts with no tools

7. Plan and Execute

   7. When is plan-and-execute a bad default?

   • Research with three known sources
   • Live incidents where each observation can invalidate the rest of the plan
   • A refund that always needs lookup, then policy, then write
   • A checklist with no tools

8. Plans Are Data, Not Poetry

   8. Why store a plan as a list of objects instead of a paragraph?

   • Paragraphs score better on vibe evals
   • You can skip, retry, and show status on typed steps
   • JSON is always shorter
   • Models cannot write lists

9. Reflection and Self-Critique

   9. What is a safe critic for agent output?

   • exec() the model’s Python
   • A function (or model call) that scores a draft against a checklist, with a retry cap
   • A second agent with no stop
   • Asking the same model “are you sure?” with no rubric

10. Ground the Critic

    10. What must a critic see to be more than a vibe rater?

    • Only the draft prose
    • The draft plus the same evidence the user will see (snippets, tool JSON, tests)
    • The model’s private thoughts only
    • Yesterday’s Slack

11. Working Memory in the Loop

    11. When the scratchpad window is full, what should happen to older turns?

    • Delete them forever
    • Roll them into a summary (and retrieve later if needed)
    • Paste them into every future prompt
    • Write them to the system prompt as law

12. Typed State Beats a Blob

    12. Why keep agent state as a typed dict instead of a paragraph?

    • Paragraphs are easier to log
    • The assembler and parser can allow tools by phase and field
    • Models cannot read dicts
    • Typed state is only for compilers

13. State Machines for Agents

    13. What does a guard do in an agent state machine?

    • Replace the model
    • Block a transition even if the tool name is allowed, unless the observation passes a check
    • Hide tools from the schema forever
    • Retry the model forever

14. Human in the Loop

    14. What should a human approve?

    • The model’s latest thought
    • A frozen copy of tool name plus arguments
    • A blank check for any follow-up tool
    • The entire week of traces

15. Freeze the Approval Payload

    15. The loop mutates the args dict after pause. What did you freeze?

    • A deep copy (JSON round-trip) plus a hash, not a live reference
    • The Python object the worker still holds
    • The model’s thought about the amount
    • Nothing — trust resume

16. Long-Running Agents

    16. How should a loop that waits overnight be stored?

    • Keep the HTTP request open
    • A job record with serialized state and a wakeup condition
    • Only in the model’s context window
    • In the user’s clipboard

17. Checkpoints You Can Replay

    17. After a crash at step 5, what should you load?

    • Always step 1 and every search again
    • The last good checkpoint, and only re-run non-idempotent tools with care
    • An empty state and a pep talk
    • The model’s last thought only

18. Error Recovery

    18. A tool timed out twice. What should the loop do next?

    • Retry forever
    • Open a circuit (or handoff) — do not keep paying the same failure
    • Switch to eval() as a fallback
    • Pretend the tool returned success

19. Computer Use in the Loop

    19. When should an agent click a Pay button on a screenshot?

    • When the thought says the invoice is done
    • Never — Pay is banned; use a typed money tool with HITL
    • If the pixel color looks green
    • After three failed API calls

20. Router, Specialist, Verifier

    20. Who should call the refund tool in this pattern?

    • The router, to save a hop
    • The billing specialist, after the router picked billing — and only if the verifier (or HITL) agrees
    • The verifier
    • Every specialist, just in case

21. Traces You Can Debug

    21. What belongs in a debug trace?

    • Only the final sentence the user saw
    • Per-step advertised tools, raw model text, parse, tool, observation, stop
    • The full production database
    • Nothing — traces are a privacy bug by definition

22. Detect Tool Thrash

    22. The agent searched the same query three times. What should the loop return?

    • A fourth search
    • cannot: tool thrash
    • finish with a guessed answer
    • Open a new browser tab

23. Handoff Is a First-Class Stop

    23. What should a handoff include?

    • Only “ask a human”
    • Why, what you tried, and any frozen pending args
    • The model’s chain of thought as the ticket body
    • A new infinite agent

24. When Not to Agent

    24. A process is always validate, then tax, then send. What should you ship?

    • A ReAct agent that might skip validate
    • A workflow (checklist) in code
    • Computer use on the accounting GUI
    • A swarm of invoice agents