Agentic Loop

The agentic loop is the runtime pattern at the heart of every autonomous AI agent. The loop has four phases: perceive (read the current state and any new inputs), reason (let the LLM decide the next action), act (execute the chosen tool, write to a file, send a message), and observe (capture the result of the action and feed it back as new state). The loop continues until the model declares the task complete, a maximum iteration count is hit, or a guardrail triggers a stop. Anthropic's "Building Effective Agents" essay and the OpenAI Agents SDK both describe this exact cycle as the fundamental abstraction.

In practice, the perceive and observe phases are often merged into a single message-append step (the tool result becomes the next observation). The model never sees the loop itself. From its perspective, it just answers a sequence of messages. The loop lives in your code, around the model. Two production patterns matter most. First, always cap iterations (10 to 50 depending on task) so a misbehaving agent cannot run forever. Second, log every iteration with input, decision, and output. Without that audit trail, debugging an agent that "sometimes does the wrong thing" is nearly impossible.

The four phases of the agentic loop. The cycle continues until the LLM signals task completion, a max-iteration cap is hit, or a guardrail trips.

# The agentic loop in 12 lines
async def run_loop(goal: str, tools: list, max_iters=20) -> str:
    messages = [{"role": "user", "content": goal}]
    for i in range(max_iters):
        response = await llm.complete(messages=messages, tools=tools)
        if response.stop_reason == "end_turn":
            return response.text  # Done
        # Act on every tool call, then observe
        for call in response.tool_calls:
            result = await execute_tool(call)
            messages.append({"role": "tool", "content": result})
    raise IterationLimit("Agent did not converge in 20 turns")

Production loops also add per-iteration logging, retry on tool failure, and cost tracking.

Every agent that needs to call multiple tools or take multiple steps runs an agentic loop. Single-shot LLM calls (one prompt, one answer) do not. As soon as you have a tool, you have a loop.

• Anthropic: Building Effective Agents
• OpenAI Agents SDK docs

Related Terms