Design & Implement Agentic Loops for Autonomous Task Execution

🍳 The Big Picture: A Real-World Analogy

This is exactly how an agentic loop works with Claude. The model receives a task, decides which tool to call, gets the result, reasons about what to do next, and keeps looping until it decides it's done. Your code is the kitchen manager — you handle the tool execution plumbing, but Claude drives the decision-making.

🔄 The Agentic Loop Lifecycle

Every agentic loop — regardless of complexity — follows the same four-stage cycle. Understanding each stage precisely is what separates architects who pass this exam from those who don't.

🤖 AI Fluency: The 3 Modes of Interaction

Before diving into the loop mechanics, it's critical to understand how Agentic Loops fit into the overarching AI Fluency Framework. We interact with AI via three distinct modes:

• Automation: AI executes specific tasks based on exact human instruction (e.g., standard API calls).
• Augmentation: Humans and AI collaborate as thinking partners.
• Agency (The Agentic Loop): Humans configure AI to independently perform future tasks on their behalf. The model drives the decisions dynamically.

Phase 1 — Building and Sending the Request

Every iteration begins by constructing a request containing three things: a system prompt (the agent's role & instructions), the current conversation history (messages array), and a list of available tools. For subsequent iterations, this growing conversation history is the critical mechanism by which Claude maintains context (working memory).

Phase 2 — Claude's Reasoning Process

When Claude receives the request, it processes the entire conversation history along with the tool definitions. This reasoning is holistic — it natively considers what the user originally asked, what it has already attempted, what the results of prior tool calls were, and what logical next step would move the task forward. This invisible reasoning emerges as either a tool_use block, a text response, or both.

Phase 3 — The stop_reason Gate

Claude generates a response returning the stop_reason field. This is the single most important signal your control loop reads to know what to do next. The definitive signal about what to do next is always the stop_reason, not the presence of text content.

• "tool_use" — Claude wants to execute one or more tools before continuing. The loop MUST continue.
• "end_turn" — Claude has finished reasoning; the response is complete. Extract final text and END the loop.
• "max_tokens" — The response was truncated. Treat this as a continuation or error, NOT a completed task.

Phase 4 — Tool Execution and Result Appending

When stop_reason == "tool_use", your orchestrator code reads the tool_use content blocks, calls the actual function/API/database, and collects results. Claude never directly executes tools. Your application performs the exact action. Most critically, you must append the results formatted as tool_result blocks matched to the specific tool_use_id.

Phase 5 — Loop Termination on end_turn

When Claude returns stop_reason = 'end_turn', it decides it has sufficient information to produce a complete, final response. Return this to the user and stop the loop. This is a model-driven decision, where Claude alone decides it is finished.

Stage 4 — Append Results and Loop

You take the tool result and append it to the conversation history as a tool_result message with the matching tool_use_id. Then you send the entire updated history back to Claude as the next API request. Claude reads its own prior reasoning and the fresh tool result to decide the next action.

🚦 Deep Dive: stop_reason — The Control Signal

stop_reason is arguably the most important field in the entire Claude API response for agentic systems. It's the foundation of your loop's control flow. Let's be precise about every possible value:

🧠 Conversation History as Working Memory

The Message Structure: What Gets Appended

After each tool call, your code must append two new entries to the messages array before looping:

1. The assistant's message (Claude's response, including the tool_use content block with id, name, and input)
2. A user message containing a tool_result content block (with the matching tool_use_id and the actual result content)

# After Claude responds with stop_reason = "tool_use":

messages.append({
    "role": "assistant",
    "content": response.content  # Contains tool_use block
})

for block in response.content:
    if block.type == "tool_use":
        result = execute_tool(block.name, block.input)
        
        messages.append({
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": block.id,   # MUST match the tool_use block's id
                "content": str(result)
            }]
        })

Why the tool_use_id Matters

Claude can request multiple tools simultaneously in a single response (parallel tool calls). Each tool_use block has a unique id. When you return results, Claude uses the tool_use_id to match each result back to its specific tool request. Getting the ID wrong causes Claude to misinterpret results — a subtle but devastating bug.

⚖️ Model-Driven Decision-Making vs Pre-Configured Decision Trees

The exam distinguishes sharply between two architectural philosophies for agent decision-making. Understanding the tradeoffs is essential.

💻 Implementation: Complete Agentic Loop Pattern

Below is the canonical agentic loop implementation pattern. Study this structure carefully — the exam tests whether you can identify correct vs incorrect implementations.

import anthropic

client = anthropic.Anthropic()

def run_agent(user_task: str, tools: list) -> str:
    messages = [{"role": "user", "content": user_task}]
    
    while True:  # Loop continues until break
        
        # STEP 1: Send request to Claude with full history
        response = client.messages.create(
            model="claude-opus-4-5",
            max_tokens=8096,  # Set high enough for complex tool use responses
            tools=tools,
            messages=messages
        )
        
        # STEP 2: Append Claude's response to history
        messages.append({
            "role": "assistant",
            "content": response.content
        })
        
        # STEP 3: Inspect stop_reason — the ONLY correct termination check
        if response.stop_reason == "end_turn":
            # Task complete — extract and return text response
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text
        
        elif response.stop_reason == "tool_use":
            # STEP 4: Execute each requested tool
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    result = dispatch_tool(block.name, block.input)
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": str(result)
                    })
            
            # Append all tool results as a user message
            messages.append({
                "role": "user",
                "content": tool_results
            })
            # Loop continues — back to STEP 1
        
        elif response.stop_reason == "max_tokens":
            # Response was truncated — do NOT treat as end_turn
            # Options: increase max_tokens, summarise context, or raise an error
            raise RuntimeError("Response truncated (max_tokens hit). Increase token budget or reduce prompt size.")
        else:
            # stop_sequence or other unexpected stop reason
            raise RuntimeError(f"Unexpected stop_reason: {response.stop_reason}")

⛔ Anti-Patterns to Avoid

The exam explicitly calls out three anti-patterns. Memorise these — they appear in distractor answers:

## ❌ WRONG — Parsing natural language
if "task complete" in response.content[0].text.lower():
    break  # DON'T DO THIS

## ❌ WRONG — Arbitrary cap as primary stop
for i in range(10):
    response = client.messages.create(...)
    # This exits after 10 rounds regardless

## ❌ WRONG — Checking for text as terminal indicator
if any(b.type == "text" for b in response.content):
    return response.content[0].text  # Text can exist alongside tool_use!

## ✅ CORRECT — Use stop_reason exclusively
while True:
    response = client.messages.create(...)
    if response.stop_reason == "end_turn":
        break     # The API told us we're done
    elif response.stop_reason == "tool_use":
        # Execute tools, append, continue
        ...

🎯 Exam Readiness & Key Takeaways