Agentic Loops

An agentic loop is the core execution cycle behind every Claude-based agent. It is deterministic control flow that you define in code - not a prompt trick, not a chatbot turn, and not a retry wrapper. Each pass through the loop calls the Messages API, inspects the model's stop_reason, and decides whether to run tools and continue or to return the final answer. Understanding this cycle precisely is the foundation of the entire CCAR-F exam.

The four-step lifecycle

Every iteration of the loop follows the same four steps. The loop repeats until the model signals it is finished:

1. 1Send the request. Call the Messages API with the full conversation history: the system prompt, prior messages, and any tool results appended on previous iterations.
2. 2Inspect `stop_reason`. Read the authoritative signal that tells you what to do next. tool_use means Claude wants to call tools; end_turn means Claude is done.
3. 3Handle `tool_use`. Execute the requested tools, append their results to the conversation history as a new message, then resend the updated conversation.
4. 4Handle `end_turn`. Extract Claude's final response and present it to the user - the loop terminates.

A subtle but critical detail: tool results must be appended to the conversation history. If you execute a tool but forget to add its output back into messages, Claude cannot reason about the new information on the next iteration, and the loop stalls or repeats itself. This is one of the most common production bugs.

Beyond tool_use and end_turn

Production loops must handle more than the two common values. Any non-end_turn result means the turn is not cleanly complete:

Model-driven vs. pre-configured control

In a model-driven loop, Claude reads the task, weighs the available tools, and selects the appropriate one based on context. This adapts to unforeseen situations and allows flexible tool chaining. A pre-configured decision tree hard-codes the execution sequence - less flexible, but sometimes required for deterministic compliance in financial, security, or regulatory contexts (covered in lesson 1.4). The exam generally favors model-driven approaches for their adaptability.

import anthropic

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "What is 47 * 89, then search for the result?"}]

for _ in range(20):  # safety cap only, NOT the primary control
    resp = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        tools=TOOLS,
        messages=messages,
    )
    # The authoritative control signal:
    if resp.stop_reason == "end_turn":
        print(resp.content[-1].text)
        break

    if resp.stop_reason == "tool_use":
        messages.append({"role": "assistant", "content": resp.content})
        tool_results = []
        for block in resp.content:
            if block.type == "tool_use":
                result = run_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,
                })
        # Tool results MUST be appended back to history:
        messages.append({"role": "user", "content": tool_results})

if "done" in resp.content[0].text.lower():
    break  # brittle: text != completion

if resp.stop_reason == "end_turn":
    break  # authoritative

One more trap: forcing tool_choice: "any" on every call. It guarantees Claude always calls a tool, which creates an infinite loop when the agent is genuinely finished and should have returned end_turn.