The Agent Loop What Makes an Agent an Agent

​

Single-pass vs. multi-step tasks

• Prompt: “What’s a good flight to New York City?”
• Model: returns a single answer.

• “Find me a flight to New York City for under $300 and book it.”

​

Core idea: start with a goal

• Decide (model produces a textual instruction about the next action).
• Act (a tooling/executor layer performs the action).
• Observe (results are returned to the model).
• Repeat (model uses the observation and goal to decide the next step).

​

How the loop works in practice

1. Decide
   • The model generates a textual instruction (for example, “Search flights for 2026-12-15 to 2026-12-20, return lowest fares”).
   • Remember: pretrained LLMs are token-prediction engines — they output text. They do not by themselves perform network requests or invoke APIs.
2. Act (tooling/executor)
   • A separate software component parses the model’s decision and executes it: API calls, web searches, database queries, booking APIs, etc.
   • This component bridges the model’s text and the real-world operation.
3. Observe
   • The executor returns structured results (observations) to the system (e.g., “cheapest flight found: $340”).
   • The model receives the observation and the original goal, then decides the next action (try different dates, another airline, or conclude).
4. Repeat
   • This cycle continues until the model determines the goal is met or a stopping condition is reached.

goal = "book flight under $300"
state = {}

while True:
    decision = model.plan(goal, state)   # returns structured text describing next action
    if decision.get("type") == "done":
        break
    result = executor.execute(decision)  # perform API calls, searches, etc.
    state.update(result)                 # observations fed back to the model

​

Common decision patterns from models

​

Termination and stopping conditions

• The model will typically output an instruction that indicates completion (e.g., “Done: booked flight under $300” or “Done: unable to find a flight under$300”).
• Stopping conditions are often determined by the model’s judgment rather than an externally hard-coded counter like “stop after 3 tries.” This grants flexibility, but systems should still enforce external limits:
  • maximum iterations
  • timeouts
  • rate limits
  • safety filters

​

Agent components at a glance

​

Why this distinction matters

• An agent is not a distinct model type — it’s a pattern: model decisions + external tool executions + returned observations in a loop.
• Any LLM can be part of an agent if it participates in this Decide → Act → Observe cycle.
• Because models can suggest actions with real-world effects, you must design safety controls:
  • validate model outputs before execution
  • sandbox or simulate risky actions
  • require human approval for critical operations
  • log actions and decisions for auditing

​

Practical guidance for building safe agent executors

• Validate and sanitize every decision output before mapping to an API call.
• Limit the scope of actions the executor can perform.
• Implement role-based permissions and explicit human-in-the-loop checkpoints for sensitive tasks (payments, sensitive data access).
• Use timeouts and iteration caps to prevent runaway loops.

​

Links and references

• ReAct: Synergizing Reasoning and Acting in Language Models
• LangChain — tools and orchestration patterns for LLM agents: https://langchain.com/
• Best practices for safe API design and auditing — apply standard security hygiene to agent executors.