AI Agents: Core Concepts

Concept Map

Here's how the 6 building blocks connect to form a working agent:

1. LLM Brain

The LLM is the agent's reasoning engine. It reads the current state, decides what to do next, and generates the output (text, code, or tool calls). The choice of model matters enormously:

• Larger models (Claude Opus, GPT-4) — better at complex reasoning and planning, but slower and more expensive
• Smaller models (Claude Haiku, GPT-4o-mini) — faster and cheaper, good for simple tool-calling tasks
• System prompts shape the agent's personality, constraints, and behavior

# The LLM brain is configured via system prompt + model choice
import anthropic

client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system="You are a helpful coding agent. Break tasks into steps. Use tools when needed.",
    messages=[{"role": "user", "content": "Find and fix the bug in auth.py"}]
)

2. Reasoning Loop

The reasoning loop is the heartbeat of every agent. It's a cycle: observe the current state, think about what to do, act (call a tool or generate output), then observe the result and repeat. Most agents run this loop until they either complete the task or hit a stopping condition.

# Simplified agent loop (pseudocode)
def agent_loop(goal, tools, max_steps=10):
    messages = [{"role": "user", "content": goal}]

    for step in range(max_steps):
        # THINK: Ask the LLM what to do next
        response = llm.generate(messages)

        # CHECK: Did the agent finish?
        if response.stop_reason == "end_turn":
            return response.text  # Task complete

        # ACT: Execute the tool call
        tool_call = response.tool_use
        result = execute_tool(tool_call.name, tool_call.input)

        # OBSERVE: Feed the result back
        messages.append({"role": "assistant", "content": response})
        messages.append({"role": "user", "content": result})

    return "Max steps reached"

3. Tools

Tools are what make agents useful. Without tools, an agent is just a chatbot. Tools let agents interact with the real world:

# Tools are defined as JSON schemas that tell the LLM what's available
tools = [{
    "name": "read_file",
    "description": "Read the contents of a file at the given path",
    "input_schema": {
        "type": "object",
        "properties": {
            "path": {"type": "string", "description": "Absolute file path"}
        },
        "required": ["path"]
    }
}]

4. Memory

Memory lets agents maintain context across steps and sessions. There are three types:

• Short-term (working) memory — the conversation history within one session. Limited by the LLM's context window.
• Long-term memory — persisted knowledge stored in files, databases, or vector stores. Survives across sessions.
• Episodic memory — records of past task executions. Helps agents learn from experience ("last time this approach failed, try something else").

# Short-term memory = conversation messages list
messages = [
    {"role": "user", "content": "Fix the login bug"},
    {"role": "assistant", "content": "I'll read auth.py first..."},
    {"role": "tool", "content": "# contents of auth.py..."},
    # This list IS the agent's working memory
]

# Long-term memory = external storage
# Claude Code uses MEMORY.md files
# Other agents use vector databases (Pinecone, Chroma)

5. Planning

Planning is how agents break complex goals into manageable steps. Without planning, agents stumble through tasks reactively. With planning, they work systematically:

• Task decomposition — break "build a REST API" into "design schema → create routes → add auth → write tests"
• Plan-and-execute — create the full plan first, then execute steps one at a time
• Adaptive planning — adjust the plan as new information emerges

# Plan-and-execute pattern
plan = llm.generate("Break this task into steps: " + goal)
# plan = ["1. Read the existing code", "2. Identify the bug", "3. Write fix", "4. Run tests"]

for step in plan:
    result = agent_loop(step, tools)
    if not result.success:
        # Re-plan based on what went wrong
        plan = llm.generate(f"Step failed: {result.error}. Revise plan: {plan}")

6. Orchestration

Orchestration controls how the agent executes — sequential steps, parallel operations, error handling, and multi-agent coordination. Key patterns: