The Agentic Loop & Tool Use CCAR-F Domain 1 · Agentic Architecture (highest-weighted) · ~25 min

Your code stops being the decision-maker

As a senior, your instinct is to own control flow: if this, call that. In an agent, you hand the branching decision to the model and your code becomes the loop harness around it. That single inversion is the whole mindset shift — everything else follows from it.

The loop, precisely

# the harness you write — not the intelligence, the plumbing
while True:
    resp = model.send(messages, tools)
    if resp.stop_reason == "tool_use":        # model decided to act
        result = run_tool(resp.tool_calls)     # YOU execute + validate
        messages.append(tool_result(result))  # feed it back
        continue                              # loop again
    if resp.stop_reason == "end_turn":        # model is done
        break

Read it as a sentence: send → check stop_reason → if it wants a tool, run it and feed the result back → repeat → stop when it's done. The model never touches your systems directly; it requests, your harness executes. That gap is where all your leverage (and all the risk) lives.

The four footguns (where seniors actually get burned)

• Reading the prose, not the structure. Don't scan the reply text for "I'll call search()". The response tells you structurally via stop_reason + tool_use blocks. Parsing prose is guessing.
• Assuming schema-valid = correct. A typed tool schema stops malformed calls (syntactic), not wrong-but-well-formed ones (semantic). A valid account_id can still be the wrong account. You validate values in the tool.
• No budget = runaway. Without a turn/tool cap and a done-condition, a loop can spin 40 times burning tokens — or take an irreversible action it shouldn't. This is OWASP LLM03 Excessive Agency (LLM06 in the 2025 edition): bound it, gate high-risk actions, keep a kill switch.
• Fighting non-determinism. Same input can take a different tool path. Don't chase a deterministic path — judge outcomes with evals and constrain behavior with guardrails.

Mastery check

Your spaced-repetition schedule

Items you missed resurface sooner; items you nailed return on a longer interval. That's the forgetting curve being managed for you — recall right before you'd forget.

A real corrective turn

Illustrative transcript: a learner picks "lower the temperature" to stop a runaway loop (a very common senior conflation). A good tutor doesn't say "wrong" — it finds the misconception, ties it to what you already know, and hands the loop back.

Learner

For the runaway-loop one I went with lowering temperature — fewer random detours should mean it stops looping, right?

Coach

Quick gut-check first: what does temperature actually control? It biases token sampling — how adventurous the next-token pick is. It has zero authority over how many times your loop runs. So the runaway isn't a sampling problem; it's a control-flow problem — your harness never told the loop when to stop.

The fix lives in your code, not the model's decoding params: a turn/tool-call budget, an explicit done-condition, and a human escalation when you hit the cap. You already do exactly this with rate-limiters and circuit-breakers — same instinct, new decider. Want to redo that item with the control-flow lens?

Keep going

Track 0 (The Mindset Shift) and the Track 0 coach allowance are free with an account, no card. The full curriculum, mock exams and the coach on every track come with membership.