What Are AI Agents — From Copilot to Autonomous Systems in 2026

A chatbot waits to be asked. An agent waits for no one — it sets its own steps, calls the tools it needs, and keeps going until it reaches its goal, even after you have closed your laptop. This seemingly subtle difference is the most significant paradigm shift in applied artificial intelligence since the emergence of transformer models in 2017: an AI agent is no longer an assistant that answers, but a software system that perceives its environment, plans sequences of actions, uses external tools, and operates autonomously until it achieves a defined objective. And the boundary between "a clever LLM call" and "a real agent" is exactly where most projects either generate real economic value or burn money with nothing to show for it.

From Chatbot to Agent: A Taxonomy of Autonomy

To understand what AI agents are, we must first establish a clear taxonomy of autonomy levels in systems built on large language models (LLMs). This taxonomy is not merely academic — it dictates the architectural decisions, the operating costs, and the risk profile of every system.

Level 0 — The LLM as a pure function (Stateless Completion). At this level, a model such as Claude Opus 4.8 or GPT-5.5 receives a prompt and returns a response. There is no memory between calls, no tools, no planning. Example: an API endpoint that translates text from English into Romanian. Every request is independent. Cost is predictable (input tokens + output tokens), and risk is minimal because the output triggers no action in the real world.

Level 1 — Copilot (permanent Human-in-the-Loop). GitHub Copilot, Cursor, or Claude Code in interactive mode operate at this level. The model suggests, but the human decides. Every potentially destructive action (deleting a file, executing a command) requires explicit approval. The system may have access to tools (terminal, file system), but delegation is granular and supervised.

Level 2 — Semi-autonomous agent (Human-on-the-Loop). The agent executes sequences of actions without individual approval, but operates under strict constraints: a maximum token budget, an allowlist of permitted tools, timeouts, and an escalation mechanism when uncertainty exceeds a threshold. The human monitors and intervenes only when the agent flags an exceptional situation. Most enterprise deployments in 2026 operate at this level.

Level 3 — Autonomous agent with self-governance. The agent sets sub-goals, allocates resources, selects strategies, and self-corrects without human intervention. This level is still experimental in production, except in low-risk domains (content generation, non-critical data analysis). Recent 2026 research from Anthropic and Google DeepMind explores formal verification mechanisms that would enable full autonomy in critical domains.

Level 4 — Multi-agent systems with coordinated emergence. Multiple autonomous agents collaborate, negotiate, and coordinate to solve complex problems. Each agent has specialized competencies, and the emergent collective behavior exceeds individual capabilities. The 2026 pilot projects (for example, the fully-agentic software development systems from Anthropic and OpenAI) demonstrate the potential of this level.

┌─────────────────────────────────────────────────────────┐
│  THE AUTONOMY TAXONOMY FOR LLM-BASED SYSTEMS            │
├─────────────────────────────────────────────────────────┤
│  Level 0: Stateless LLM    │  prompt → completion       │
│  Level 1: Copilot          │  suggestion → human OK     │
│  Level 2: Semi-Auto Agent  │  goal → supervised exec    │
│  Level 3: Autonomous Agent │  goal → self-governance    │
│  Level 4: Multi-Agent      │  mission → coordination    │
├─────────────────────────────────────────────────────────┤
│  Risk:    ▓░░░░  →  ▓▓▓▓▓                              │
│  Control: ▓▓▓▓▓  →  ▓░░░░                              │
│  Value:   ▓░░░░  →  ▓▓▓▓▓                              │
└─────────────────────────────────────────────────────────┘

The formal definition we will use throughout this course: an AI agent is a software system that (1) receives a high-level objective, (2) decomposes the objective into sub-tasks, (3) selects and invokes tools for each sub-task, (4) evaluates intermediate results, (5) adapts its plan based on feedback, and (6) operates within predefined safety constraints.

The Agentic Stack: The 5 Fundamental Components

Any AI agent, regardless of complexity, can be decomposed into five architectural components. This model — which we call The Agentic Stack — provides an analytical framework for evaluating, designing, and debugging agentic systems.

1. Brain — The LLM

The agent's brain is a large language model that serves as its reasoning engine. In 2026, model choice is a critical architectural decision:

Update May 28, 2026 — Claude Opus 4.8 (the top of the Opus family). Anthropic released Opus 4.8 as the peak of the Opus family, with the same pricing as the previous 4.7 generation ($5/$25 per 1M tokens), 1M context, 128K output. The most capable Anthropic model overall, however, is Claude Fable 5 (GA June 9, 2026, $10/$50, a tier above Opus), while Claude Sonnet 5 (June 30, 2026, $2/$10 intro) is the new default for everyday tasks. The 4.7 generation (April 16, 2026) had already introduced a new tokenizer that can use more tokens for the same text (a range of roughly 1.0–1.35x depending on content) — that change carries over into 4.8. The most relevant improvements for agent developers in 4.8: (1) code with unhandled errors is significantly less likely versus Opus 4.7 (per Anthropic's announcement), (2) adaptive thinking (the successor to "Extended Thinking") with a tighter thinking-to-action bridge — plans stay coherent through long execution, (3) tool use reliability sustained across dozens of consecutive turns without drift. Knowledge cutoff: January 2026. In practice, long-horizon agents become production-viable with the 4.7/4.8 generation, not just demos.

Update April 23, 2026 — GPT-5.5. OpenAI released GPT-5.5 at $5/$30 per 1M tokens (Pro $30/$180), with a context on the order of 1M tokens. It is natively omnimodal end-to-end (text + voice + image + video processed in a single prompt), with strong results on agentic/terminal benchmarks and improved token efficiency per task in Codex. It supports native computer use, integrated tool search, and the Responses API. For agents, omnimodality means a single call can receive a screenshot + voice memo + text without separate pre-processing.

A common practice in 2026 is tiered model selection: the agent uses a fast, cheap model (Haiku 4.5) for routine decisions and escalates to a powerful model (Opus 4.8 or GPT-5.5) for complex reasoning. This reduces costs by 60-80% without compromising decision quality. The recommended 2026 pattern for agents: Sonnet 5 as the hot path (fast, cheap tool calling — $2/$10 intro pricing until Aug 31, 2026, then $3/$15), escalating to Opus 4.8 for edge cases and for steps that require long-horizon reasoning. The new tokenizer (introduced in 4.7 and kept in 4.8, roughly 1.0–1.35x more tokens for the same text, depending on content) makes attention to caching (5-minute TTL, 90% off) and context pruning critical — a multi-turn agent without caching burns through its budget fast.

# Example: Tiered Model Selection with fallback
import anthropic

client = anthropic.Anthropic()

def select_model(task_complexity: str) -> str:
    """Selects the optimal model based on task complexity."""
    MODEL_TIERS = {
        "trivial": "claude-haiku-4-5",      # Classification, simple extraction
        "standard": "claude-sonnet-4-6",     # Synthesis, moderate analysis
        "complex": "claude-opus-4-8",        # Multi-hop reasoning, critical decisions
    }
    return MODEL_TIERS.get(task_complexity, "claude-sonnet-4-6")

def agent_call(prompt: str, complexity: str = "standard") -> str:
    model = select_model(complexity)
    response = client.messages.create(
        model=model,
        max_tokens=4096,
        messages=[{"role": "user", "content": prompt}]
    )
    return response.content[0].text

# Automatic complexity triage
def classify_complexity(task_description: str) -> str:
    classification = agent_call(
        f"Classify the complexity of this task as 'trivial', "
        f"'standard' or 'complex'. Answer with a single word.\n\n"
        f"Task: {task_description}",
        complexity="trivial"  # The triage itself is trivial
    )
    return classification.strip().lower()

2. Tools — Function Calling

Tools turn an LLM from a "stochastic parrot" into an agent capable of interacting with the real world. A tool is a function with a precise JSON schema that the agent can invoke. Anthropic's official documentation (https://docs.anthropic.com/en/docs/build-with-claude/tool-use/overview) details the complete specifications of the tool use protocol.

The main categories of tools:

• Read tools: database queries, web search, external API access, file reading
• Write tools: creating/modifying files, sending emails, updating databases
• Compute tools: code execution (sandboxed), mathematical operations, simulations
• Communication tools: notifications, escalation to humans, reporting

# Defining a tool with JSON Schema
tools = [
    {
        "name": "query_database",
        "description": (
            "Executes a read-only SQL query against the production "
            "database. Returns a maximum of 100 rows. "
            "Does NOT support DDL or DML statements (INSERT/UPDATE/DELETE)."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "A valid SQL SELECT query"
                },
                "database": {
                    "type": "string",
                    "enum": ["analytics", "users", "orders"],
                    "description": "The target database"
                }
            },
            "required": ["query", "database"]
        }
    },
    {
        "name": "send_notification",
        "description": (
            "Sends a Slack notification to a specified channel. "
            "Use only for critical alerts or requested reports."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "channel": {
                    "type": "string",
                    "description": "The Slack channel name (e.g.: #incidents)"
                },
                "message": {
                    "type": "string",
                    "description": "The notification content (max 2000 characters)"
                },
                "severity": {
                    "type": "string",
                    "enum": ["info", "warning", "critical"],
                    "description": "The severity level"
                }
            },
            "required": ["channel", "message", "severity"]
        }
    }
]

3. Memory — Persistent Context

An agent's memory operates on three distinct levels:

Working Memory — the context window of the current conversation. Limited by the model's context window (1M tokens for Claude Opus 4.8 and GPT-5.5, 2M for Gemini 3.1 Pro). It holds the conversation history, tool results, and the current reasoning. With Opus 4.8, 1M context effectively becomes an extended cross-session memory for agents — you can keep entire days of tool use history in the prompt, validated by the long-horizon reliability improvement. Caution: a large context window does not mean it must be filled up — Lost-in-the-Middle remains a reality (notable retrieval degradation for information in the middle of the context).

Episodic Memory (Short-term Persistent) — information about recent sessions, stored in a vector database or key-value store. It allows the agent to "remember" previous interactions with the same user or about the same project.

Semantic Memory (Long-term Knowledge) — the agent's knowledge base, implemented through RAG (Retrieval-Augmented Generation). It includes internal documentation, operating procedures, and domain-specific knowledge bases.

# Three-level memory architecture
from dataclasses import dataclass, field
from datetime import datetime
from typing import Any

@dataclass
class AgentMemory:
    """Three-level memory system for an AI agent."""

    # Level 1: Working memory (inside the context window)
    working_context: list[dict] = field(default_factory=list)
    max_working_tokens: int = 100_000

    # Level 2: Episodic memory (vector database)
    episode_store: Any = None  # ChromaDB, Pinecone, etc.

    # Level 3: Semantic memory (RAG)
    knowledge_base: Any = None  # Persistent vector index

    def add_to_working_memory(self, role: str, content: str) -> None:
        """Adds a message to working memory with overflow handling."""
        self.working_context.append({
            "role": role,
            "content": content,
            "timestamp": datetime.now().isoformat()
        })
        self._compact_if_needed()

    def _compact_if_needed(self) -> None:
        """Compacts working memory when it approaches the limit."""
        # Simplified estimate: ~4 characters per token
        total_chars = sum(len(m["content"]) for m in self.working_context)
        estimated_tokens = total_chars // 4

        if estimated_tokens > self.max_working_tokens * 0.8:
            # Strategy: summarize old messages, keep the recent ones
            old_messages = self.working_context[:-10]
            recent_messages = self.working_context[-10:]

            summary = self._summarize(old_messages)
            self.working_context = [
                {"role": "system", "content": f"Summary of the previous conversation: {summary}"}
            ] + recent_messages

    def recall_episodes(self, query: str, k: int = 5) -> list[dict]:
        """Retrieves relevant episodes from episodic memory."""
        if self.episode_store is None:
            return []
        results = self.episode_store.query(query_texts=[query], n_results=k)
        return results

    def search_knowledge(self, query: str, k: int = 10) -> list[str]:
        """Searches the semantic knowledge base."""
        if self.knowledge_base is None:
            return []
        return self.knowledge_base.similarity_search(query, k=k)

    def _summarize(self, messages: list[dict]) -> str:
        """Placeholder for summarization — in production, use an LLM."""
        return f"[Summary of {len(messages)} previous messages]"

4. Planning — Goal Decomposition

Planning is the agent's ability to break a complex objective down into executable sub-tasks and to determine the optimal execution order. We will explore planning patterns in detail (ReAct, Plan-and-Execute, Reflexion) in the next lesson. Here we present the role of planning conceptually:

Objective: "Generate the monthly sales report for March 2026"
    │
    ├── Sub-task 1: Extract the data from the database (tool: query_database)
    │       └── Query: SELECT ... FROM orders WHERE month = '2026-03'
    │
    ├── Sub-task 2: Compute aggregate metrics (tool: code_interpreter)
    │       └── Python script: revenue, growth, top products
    │
    ├── Sub-task 3: Generate visualizations (tool: code_interpreter)
    │       └── matplotlib charts: revenue trend, category breakdown
    │
    ├── Sub-task 4: Compose the report narrative (LLM reasoning)
    │       └── Text analysis with insights and recommendations
    │
    └── Sub-task 5: Format and distribute (tools: file_write, send_email)
            └── PDF + email to stakeholders

5. Guardrails — Constraints and Control

Guardrails are the mechanisms that prevent unwanted agent behavior. In a production system, they are not optional — they are critical. Without them, an autonomous agent can generate uncontrolled costs, corrupt data, or make decisions with irreversible consequences.

Categories of guardrails:

• Budget enforcement: a hard cap on tokens/API calls per session
• Tool access control: an allowlist/denylist of permitted tools per context
• Output validation: verifying the output before execution (e.g., SQL injection prevention)
• Circuit breakers: automatic shutdown when anomalies are detected (e.g., too many consecutive errors)
• Human escalation triggers: conditions that force human intervention
• Rate limiting: limiting the frequency of actions to prevent infinite loops

# Guardrails implementation with budget and circuit breaker
from dataclasses import dataclass
from enum import Enum

class AgentState(Enum):
    RUNNING = "running"
    PAUSED = "paused"
    ESCALATED = "escalated"
    TERMINATED = "terminated"

@dataclass
class GuardrailConfig:
    max_iterations: int = 50
    max_tokens_budget: int = 500_000
    max_tool_calls: int = 100
    max_consecutive_errors: int = 3
    allowed_tools: list[str] | None = None
    require_human_approval: list[str] | None = None  # tools needing approval

class AgentGuardrails:
    def __init__(self, config: GuardrailConfig):
        self.config = config
        self.iterations = 0
        self.tokens_used = 0
        self.tool_calls = 0
        self.consecutive_errors = 0
        self.state = AgentState.RUNNING

    def check_before_iteration(self) -> AgentState:
        """Checks all conditions before each iteration."""
        if self.iterations >= self.config.max_iterations:
            self.state = AgentState.TERMINATED
            return self._terminate("Iteration limit reached "
                                   f"({self.config.max_iterations})")

        if self.tokens_used >= self.config.max_tokens_budget:
            self.state = AgentState.TERMINATED
            return self._terminate("Token budget exhausted "
                                   f"({self.config.max_tokens_budget})")

        if self.consecutive_errors >= self.config.max_consecutive_errors:
            self.state = AgentState.ESCALATED
            return self._escalate("Too many consecutive errors "
                                  f"({self.consecutive_errors})")

        self.iterations += 1
        return AgentState.RUNNING

    def check_tool_call(self, tool_name: str) -> bool:
        """Checks whether the tool call is allowed."""
        if self.config.allowed_tools is not None:
            if tool_name not in self.config.allowed_tools:
                raise PermissionError(
                    f"Tool '{tool_name}' is not on the allowlist"
                )

        self.tool_calls += 1
        if self.tool_calls > self.config.max_tool_calls:
            self.state = AgentState.TERMINATED
            raise ResourceWarning("Tool call limit reached")

        if (self.config.require_human_approval and
                tool_name in self.config.require_human_approval):
            self.state = AgentState.PAUSED
            return False  # Requires human approval

        return True

    def report_success(self) -> None:
        self.consecutive_errors = 0

    def report_error(self) -> None:
        self.consecutive_errors += 1

    def record_tokens(self, count: int) -> None:
        self.tokens_used += count

    def _terminate(self, reason: str) -> AgentState:
        print(f"[GUARDRAIL] Agent terminated: {reason}")
        return AgentState.TERMINATED

    def _escalate(self, reason: str) -> AgentState:
        print(f"[GUARDRAIL] Escalating to a human: {reason}")
        return AgentState.ESCALATED

Comparison with Traditional Automation

It is essential to understand the fundamental difference between an AI agent and a traditional automation system (workflow engine, RPA, cron jobs). This distinction is frequently confused in the industry, which leads to suboptimal implementations.

The golden rule: Use traditional automation for well-defined, repetitive, and stable flows. Use AI agents for tasks that require reasoning, adaptation to varied contexts, or where the exception space is too large to be codified exhaustively.

Applied Scenario: Autonomous DevOps Incident Resolution

Let us examine a concrete scenario in which an AI agent generates substantial value: autonomous resolution of infrastructure incidents. This example is representative of 2026 enterprise deployments.

Context: A SaaS company with 50 microservices on Kubernetes receives a PagerDuty alert at 3:00 AM — the payment service's latency has jumped from 200ms to 4500ms.

Without an agent: An on-call engineer wakes up, logs in, checks dashboards, reads logs, forms hypotheses, tests, applies the fix, verifies. Average time: 45-90 minutes.

With an AI agent (Level 2 — semi-autonomous):

# Pseudocode: DevOps agent for incident resolution
import anthropic
from datetime import datetime

client = anthropic.Anthropic()

SYSTEM_PROMPT = """You are a DevOps agent specialized in incident resolution.
You have access to the following tools:
- query_metrics: Query Prometheus/Grafana
- query_logs: Search Elasticsearch/Loki
- kubectl_read: Read-only kubectl commands (get, describe, logs)
- kubectl_write: Mutating kubectl commands (scale, rollout, restart)
- create_ticket: Create a Jira ticket
- notify_slack: Send a Slack notification
- run_playbook: Execute a predefined runbook

CRITICAL CONSTRAINTS:
1. kubectl_write requires human approval for any operation on the 'production' namespace
2. Maximum 20 API calls per incident
3. If you cannot diagnose within 10 minutes, escalate
4. Document EVERY action in the incident timeline
5. NEVER modify the database configuration directly
"""

INCIDENT_TOOLS = [
    {
        "name": "query_metrics",
        "description": "Query metrics from Prometheus. Returns time series.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "PromQL query"},
                "duration": {"type": "string", "description": "e.g.: '1h', '30m'"}
            },
            "required": ["query", "duration"]
        }
    },
    {
        "name": "query_logs",
        "description": "Search the logs. Returns the latest N relevant entries.",
        "input_schema": {
            "type": "object",
            "properties": {
                "service": {"type": "string"},
                "query": {"type": "string"},
                "severity": {"type": "string", "enum": ["info", "warn", "error"]},
                "limit": {"type": "integer", "default": 50}
            },
            "required": ["service", "query"]
        }
    },
    {
        "name": "kubectl_read",
        "description": "Executes read-only kubectl commands.",
        "input_schema": {
            "type": "object",
            "properties": {
                "command": {"type": "string", "description": "e.g.: 'get pods -n payments'"},
                "namespace": {"type": "string"}
            },
            "required": ["command"]
        }
    }
    # ... other tools
]

def handle_incident(alert: dict) -> dict:
    """Entry point for autonomous incident resolution."""

    guardrails = AgentGuardrails(GuardrailConfig(
        max_iterations=30,
        max_tokens_budget=200_000,
        max_tool_calls=20,
        max_consecutive_errors=3,
        require_human_approval=["kubectl_write"]
    ))

    messages = [
        {"role": "user", "content": (
            f"INCIDENT ALERT:\n"
            f"Service: {alert['service']}\n"
            f"Severity: {alert['severity']}\n"
            f"Description: {alert['description']}\n"
            f"Timestamp: {alert['timestamp']}\n\n"
            f"Diagnose and resolve this incident. "
            f"Start by investigating the metrics and the logs."
        )}
    ]

    timeline = []

    while guardrails.check_before_iteration() == AgentState.RUNNING:
        response = client.messages.create(
            model="claude-sonnet-4-6",  # Sonnet for speed
            max_tokens=4096,
            system=SYSTEM_PROMPT,
            tools=INCIDENT_TOOLS,
            messages=messages
        )

        guardrails.record_tokens(response.usage.input_tokens
                                 + response.usage.output_tokens)

        if response.stop_reason == "tool_use":
            for block in response.content:
                if block.type == "tool_use":
                    tool_name = block.name
                    tool_input = block.input

                    # Guardrails check
                    if not guardrails.check_tool_call(tool_name):
                        # Requires human approval
                        timeline.append({
                            "time": datetime.now().isoformat(),
                            "action": f"AWAITING APPROVAL: {tool_name}",
                            "input": tool_input
                        })
                        # In production: send a notification and wait
                        break

                    # Tool execution
                    result = execute_tool(tool_name, tool_input)
                    timeline.append({
                        "time": datetime.now().isoformat(),
                        "action": tool_name,
                        "input": tool_input,
                        "result_summary": str(result)[:200]
                    })

                    messages.append({"role": "assistant", "content": response.content})
                    messages.append({
                        "role": "user",
                        "content": [{"type": "tool_result",
                                     "tool_use_id": block.id,
                                     "content": str(result)}]
                    })

        elif response.stop_reason == "end_turn":
            # The agent has finished — extract the conclusions
            final_response = response.content[0].text
            timeline.append({
                "time": datetime.now().isoformat(),
                "action": "RESOLUTION",
                "summary": final_response[:500]
            })
            break

    return {"timeline": timeline, "tokens_used": guardrails.tokens_used}

The typical outcome: Within 3-5 minutes the agent identifies that a recent deployment introduced an unoptimized SQL query causing full table scans, temporarily scales the database replica, rolls back to the previous deployment, and creates a Jira ticket with a complete root-cause analysis. The on-call engineer receives a Slack notification summarizing the actions, reviews, and confirms. Total time: 5-8 minutes vs. 45-90 minutes manually.

Common Pitfalls: Anti-patterns in Agent Development

The experience accumulated from 2024 to 2026 across enterprise deployments has crystallized a set of anti-patterns that every practitioner must know:

1. Over-agentification

Symptom: Every feature becomes "an agent". The contact form is "a communication agent", the login is "an authentication agent".

Problem: Not every task requires LLM reasoning. If a flow can be fully specified through deterministic rules, an agent adds latency, cost, and unpredictability without added value.

Rule: If you can draw a complete flowchart of the decision logic without branches conditioned on natural-language content, you probably do not need an agent.

2. Missing Circuit Breakers

Symptom: The agent enters an infinite retry loop or generates uncontrolled costs.

Problem: LLMs can "hallucinate" a strategy that fails repeatedly, yet the model keeps insisting with minimal variations of the same approach.

Solution: Mandatorily implement: an iteration limit, a token budget, a global timeout, and loop detection (if the last N actions are similar, stop).

3. Zero Human-in-the-Loop for Irreversible Actions

Symptom: The agent deletes resources, sends emails to customers, or modifies production data without any human approval.

Problem: Even the best models of 2026 have a non-zero error rate. For irreversible actions, the consequences of an error can be catastrophic.

Solution: Classify tools into risk tiers. Tier 1 (read) = free execution. Tier 2 (reversible write) = log + notification. Tier 3 (irreversible actions) = mandatory human approval.

4. Ignoring Observability

Symptom: The agent "did something" but no one knows exactly what, in what order, with which parameters.

Problem: Without detailed traces, debugging an agent is nearly impossible. The non-deterministic behavior of LLMs makes debugging even harder than in traditional systems.

Solution: Log every iteration in full: the prompt sent, the response received, tool calls with parameters and results, tokens consumed, time per operation. Recommended tools: LangSmith, Braintrust, Arize Phoenix, or custom solutions built on OpenTelemetry.

5. Insufficiently Specific Prompts

Symptom: The agent interprets objectives in surprising ways, uses unexpected tools, or ignores implicit constraints.

Problem: A vague system prompt leaves room for interpretation. LLMs optimize for "helpfulness", which can mean actions you did not anticipate.

Solution: An agent's system prompt must be a precise specification document: what it can do, what it must NOT do, in what order to proceed, when to escalate, what tone to adopt, what formats to use.

Official Guides: Perspectives from Anthropic and OpenAI

Two essential resources for anyone building AI agents:

Anthropic — "Building Effective Agents" (https://docs.anthropic.com/en/docs/build-with-claude/agentic-systems): This guide emphasizes the "keep it simple" principle — in many cases, an implementation based on a single LLM loop with tools is sufficient and preferable to a complex framework. Anthropic recommends the augmented LLM as the starting point, not multi-agent systems. Likewise, the official tool use documentation (https://docs.anthropic.com/en/docs/build-with-claude/tool-use/overview) provides complete specifications for implementing function calling with Claude models.

OpenAI — Agents Documentation (https://platform.openai.com/docs/guides/agents): OpenAI offers a comprehensive guide for building agents with GPT-5.5, including best practices for tool calling, function definitions, and structured outputs. OpenAI puts the emphasis on "function calling reliability" and on strict output validation through JSON Schema.

Common principles from both guides:

1. Start simple: A loop with an LLM and a few well-defined tools solves 80% of cases.
2. Iterate on real failures: Do not architect "to perfection" before you have data on the failure modes.
3. Prioritize observability: Every agent decision must be auditable.
4. Test adversarially: Simulate malicious inputs, edge cases, timeouts.
5. Implement graceful degradation: When the agent cannot solve the task, escalation must be smooth and informative.

Complete Pseudocode: The Architecture of an Agent with Budget Enforcement

Let us integrate all the components into a complete agent architecture. This example demonstrates how the 5 components of the Agentic Stack work together:

# Complete architecture of an AI agent with all 5 components
import anthropic
import json
import time
from dataclasses import dataclass, field
from typing import Callable

@dataclass
class AgentConfig:
    """The agent's complete configuration."""
    name: str
    system_prompt: str
    model: str = "claude-sonnet-4-6"
    escalation_model: str = "claude-opus-4-8"
    max_iterations: int = 50
    max_tokens_budget: int = 300_000
    max_tool_calls: int = 50
    tools: list[dict] = field(default_factory=list)
    tool_handlers: dict[str, Callable] = field(default_factory=dict)
    escalation_threshold: float = 0.7  # Complexity above which the model escalates

class AutonomousAgent:
    """
    Autonomous AI agent with the 5 components of the Agentic Stack:
    1. Brain (LLM with tiered selection)
    2. Tools (Function calling with validation)
    3. Memory (Context management with summarization)
    4. Planning (Implicit ReAct loop)
    5. Guardrails (Budget, circuit breaker, escalation)
    """

    def __init__(self, config: AgentConfig):
        self.config = config
        self.client = anthropic.Anthropic()
        self.messages: list[dict] = []
        self.tokens_used = 0
        self.tool_calls_count = 0
        self.consecutive_errors = 0
        self.iteration = 0
        self.trace: list[dict] = []

    def run(self, objective: str) -> dict:
        """Runs the agent with a given objective."""
        self.messages = [{"role": "user", "content": objective}]
        self._log("START", {"objective": objective})

        while True:
            # GUARDRAIL: Budget check
            if self.iteration >= self.config.max_iterations:
                return self._finalize("Iteration limit reached")
            if self.tokens_used >= self.config.max_tokens_budget:
                return self._finalize("Token budget exhausted")
            if self.consecutive_errors >= 3:
                return self._finalize("Too many consecutive errors — escalating")

            self.iteration += 1

            # BRAIN: Model selection (tiered)
            model = self._select_model()

            try:
                # LLM call
                response = self.client.messages.create(
                    model=model,
                    max_tokens=4096,
                    system=self.config.system_prompt,
                    tools=self.config.tools,
                    messages=self.messages
                )
                self.tokens_used += (response.usage.input_tokens
                                     + response.usage.output_tokens)
                self.consecutive_errors = 0

            except Exception as e:
                self.consecutive_errors += 1
                self._log("ERROR", {"error": str(e)})
                continue

            # PLANNING: Response processing (implicit ReAct loop)
            if response.stop_reason == "tool_use":
                self._handle_tool_calls(response)
            elif response.stop_reason == "end_turn":
                final_text = ""
                for block in response.content:
                    if hasattr(block, "text"):
                        final_text += block.text
                self._log("COMPLETE", {"response": final_text[:500]})
                return self._finalize("Completed successfully", final_text)
            else:
                self._log("UNEXPECTED_STOP", {"reason": response.stop_reason})
                return self._finalize(f"Unexpected stop reason: {response.stop_reason}")

        return self._finalize("Loop terminated")

    def _select_model(self) -> str:
        """BRAIN: Selects the model based on the iteration's complexity."""
        if self.iteration > 10 and self.consecutive_errors > 0:
            # Escalate to a stronger model after failures
            return self.config.escalation_model
        return self.config.model

    def _handle_tool_calls(self, response) -> None:
        """TOOLS: Processing and executing tool calls."""
        self.messages.append({"role": "assistant", "content": response.content})

        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                self.tool_calls_count += 1

                # GUARDRAIL: Tool call limit check
                if self.tool_calls_count > self.config.max_tool_calls:
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": "ERROR: Tool call limit reached.",
                        "is_error": True
                    })
                    continue

                handler = self.config.tool_handlers.get(block.name)
                if handler is None:
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": f"ERROR: Unknown tool '{block.name}'",
                        "is_error": True
                    })
                    self.consecutive_errors += 1
                    continue

                try:
                    result = handler(**block.input)
                    self._log("TOOL_CALL", {
                        "tool": block.name,
                        "input": block.input,
                        "result_preview": str(result)[:200]
                    })
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": json.dumps(result, ensure_ascii=False)
                    })
                except Exception as e:
                    self.consecutive_errors += 1
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": f"ERROR during tool execution: {str(e)}",
                        "is_error": True
                    })

        self.messages.append({"role": "user", "content": tool_results})

    def _log(self, event: str, data: dict) -> None:
        """GUARDRAILS/OBSERVABILITY: Complete logging."""
        entry = {
            "iteration": self.iteration,
            "timestamp": time.time(),
            "event": event,
            "tokens_used": self.tokens_used,
            "tool_calls": self.tool_calls_count,
            **data
        }
        self.trace.append(entry)

    def _finalize(self, reason: str, result: str = "") -> dict:
        """Generates the final execution report."""
        return {
            "status": reason,
            "result": result,
            "metrics": {
                "iterations": self.iteration,
                "tokens_used": self.tokens_used,
                "tool_calls": self.tool_calls_count,
                "estimated_cost_usd": self.tokens_used * 0.000015  # Estimate
            },
            "trace": self.trace
        }

Industry Examples: AI Agents in Production (2026)

A few verifiable examples of enterprise deployments:

1. Klarna — Customer Service Agent: Klarna reported that their AI agent handles the equivalent of the work of 700 full-time employees, resolving 2/3 of customer interactions. The agent operates at Level 2 (semi-autonomous) with automatic escalation to humans for complex cases.

2. Devin / Cognition Labs — Software Engineering Agent: The first commercial software development agent operates at Level 3, capable of reading specifications, writing code, running tests, and debugging autonomously. Public evaluations report that it can autonomously resolve a portion of medium-complexity GitHub issues — the exact figures vary significantly across benchmarks; consult current independent evaluations before relying on any percentage.

3. Harvey AI — Legal Agent: Used by large law firms, Harvey operates as a semi-autonomous agent for legal research, contract analysis, and due diligence. The agent searches legal databases, synthesizes precedents, and generates memoranda — all under a lawyer's supervision.

Recap and Preparation for the Next Lesson

In this lesson we established the conceptual foundations of AI agents:

1. The autonomy taxonomy: 5 levels, from stateless LLM to multi-agent systems
2. The Agentic Stack: Brain, Tools, Memory, Planning, Guardrails
3. Agent vs. traditional automation: adaptive reasoning vs. deterministic flows
4. Critical anti-patterns: over-agentification, missing circuit breakers, zero HITL
5. The complete architecture: end-to-end implementation with budget enforcement

You now hold the agent's map — the five levels of autonomy, the five pillars of the agentic stack, and the anti-patterns that make the difference between a demo and a system that endures. But an agent stands or falls on one single thing: how well it thinks before it acts. This is where Planning comes in — and it is precisely what separates the agent that carries a task through to the end from the one that goes in circles, burning budget without making progress. In the next lesson we dive deep into exactly this component, with the ReAct, Plan-and-Execute, and Reflexion patterns, complete implementations, and a comparative analysis of costs and performance — and from there, each lesson adds another piece until you can build, on your own, an agent worth putting into production.