Agent Architectures

An agent architecture defines how an AI system perceives its environment, decides what to do, and takes actions — from simple ReAct loops to sophisticated multi-step planners with persistent memory and tool access.

Why Does This Exist?

An LLM that simply responds to prompts is not an agent — it's a sophisticated autocomplete system. An agent can perceive a situation, reason about what to do, take actions in the world (search the web, call APIs, write and run code), observe the results, and iterate until it achieves a goal. The architecture defines how these components connect and what the agent can remember, plan, and act on. Unlike traditional automation (see our AI Agents vs RPA comparison), agent architectures are dynamic and goal-driven.

Agent architectures matter because they determine what kinds of problems an agent can solve: one-shot reasoning vs. multi-step planning vs. long-horizon task execution.

Think of It Like This

A project manager vs. a consultant

A consultant gives you advice based on a single conversation — sharp but context-limited. A project manager does much more: they track multiple workstreams, maintain context across days or weeks, delegate to specialists, check on progress, and adapt plans when blockers emerge. Agent architectures are the difference: a simple prompt-response loop is the consultant; a full agentic system is the project manager.

How It Actually Works

The basic perception-action loop

Every agent architecture implements some version of:

1while goal_not_achieved:2    observation = perceive(environment)3    thought     = reason(observation, goal, history)4    action      = decide(thought)5    result      = execute(action)6    history.update(observation, thought, action, result)

The differences between architectures lie in how complex reason(), decide(), and history are.

ReAct (Reasoning + Acting)

ReAct (Yao et al., 2022) interleaves reasoning traces with actions:

1Thought: I need to find the current CEO of OpenAI.2Action: search("OpenAI CEO 2024")3Observation: Sam Altman is the CEO of OpenAI as of 2024.4Thought: I now have the answer.5Action: finish("Sam Altman")

The reasoning trace helps the LLM stay on track and makes the decision process transparent. The action space (search, finish, etc.) is pre-defined by the environment.

Plan-and-Execute architecture

More powerful than ReAct for complex tasks:

Planner: Given a goal, generate a structured multi-step plan.
Executor: For each step, invoke a specialized tool or sub-agent.
Replanner: Observe results; if a step failed or new information requires plan revision, replan.

Better for long tasks (>10 steps) where intermediate results should reshape the overall strategy.

Cognitive architecture components

A complete agent has:

Perception: Input processing (text, images, structured data, tool outputs)
Working memory: The current context window — immediate history, current task state
Long-term memory: External storage — vector DBs, key-value stores — for persistent knowledge
Planner: The reasoning engine that decides next steps
Tool executor: Calls APIs, runs code, searches the web
Output: Responses, artifacts, or actions in the environment

Code

For choosing a framework to build these architectures, see our LangChain vs LlamaIndex comparison.

1from langchain.agents import AgentExecutor, create_react_agent2from langchain_openai import ChatOpenAI3from langchain.tools import Tool4from langchain import hub5
6# ── Define tools ──────────────────────────────────────────────────────────────7def search_web(query: str) -> str:8    """Mock web search — replace with real search API."""9    return f"[Search results for: {query}] The answer is 42."10
11def calculate(expression: str) -> str:12    """Safe math evaluation."""13    try:14        result = eval(expression, {"__builtins__": {}}, {})15        return str(result)16    except Exception as e:17        return f"Error: {e}"18
19tools = [20    Tool(name="search", func=search_web, description="Search the web for current information"),21    Tool(name="calculator", func=calculate, description="Evaluate math expressions"),22]23
24# ── Build a ReAct agent ───────────────────────────────────────────────────────25llm   = ChatOpenAI(model="gpt-4o-mini", temperature=0)26prompt = hub.pull("hwchase17/react")27
28agent = create_react_agent(llm, tools, prompt)29agent_executor = AgentExecutor(30    agent=agent,31    tools=tools,32    verbose=True,33    max_iterations=10,34    handle_parsing_errors=True,35)36
37# Run the agent38result = agent_executor.invoke({39    "input": "What is 2 to the power of 20, and is that number prime?"40})41print(f"\nFinal answer: {result['output']}")

1# ── Minimal ReAct loop (without LangChain) ────────────────────────────────────2import json3
4def simple_react_agent(llm, tools: dict, goal: str, max_steps=10):5    """Minimal ReAct loop for illustration."""6    history = []7    8    for step in range(max_steps):9        # Build prompt with history10        prompt = f"Goal: {goal}\n\nHistory:\n"11        for h in history:12            prompt += f"  {h}\n"13        prompt += "\nNext Thought and Action (JSON: {thought, action, action_input} or {thought, finish}):"14        15        # Call LLM (placeholder)16        response = llm(prompt)17        18        try:19            parsed = json.loads(response)20        except Exception:21            break22        23        if "finish" in parsed:24            return parsed["finish"]25        26        # Execute tool27        tool_name = parsed.get("action")28        tool_input = parsed.get("action_input", "")29        30        if tool_name in tools:31            observation = tools[tool_name](tool_input)32        else:33            observation = f"Unknown tool: {tool_name}"34        35        history.append(f"Thought: {parsed.get('thought', '')}")36        history.append(f"Action: {tool_name}({tool_input})")37        history.append(f"Observation: {observation}")38    39    return "Max steps reached without finishing."

Watch Out For

Infinite loops without termination conditions

Agents can get stuck in loops — searching for information they won't find, retrying failed actions indefinitely, or oscillating between two states. Always set a max_iterations limit and implement explicit termination conditions. Monitor step counts in production; an agent exceeding 20+ steps on a typical task is probably stuck.

Unconstrained tool access

Giving an agent access to filesystem operations, database writes, or payment APIs without guardrails is dangerous. Apply the principle of least privilege: give agents only the tools necessary for the task, sandbox execution environments, and implement human-in-the-loop confirmation for irreversible actions.

The Quick Version

An agent = perception + reasoning + action + memory, in a loop until goal achieved.
ReAct: interleaves reasoning traces with tool actions — transparent and effective for multi-step tasks.
Plan-and-execute: explicit planning phase + adaptive replanning — better for long-horizon tasks.
Complete agents need working memory (context window), long-term memory (external storage), tools, and a planner.
Key safety requirements: iteration limits, sandboxed tool execution, human confirmation for irreversible actions.