AI Agents

An AI Agent is a system that uses an LLM as its reasoning engine to autonomously plan actions, select and execute tools, observe results, and iterate until a goal is achieved. Unlike a single prompt-response interaction, an agent runs a loop: think → act → observe → repeat.

Think of a very capable assistant you can give a complex task to. You say: "Research the top five competitors of Company X, summarize their pricing, and put it in a spreadsheet." A human assistant would break this down: search for competitors, visit each website, read the pricing pages, extract the numbers, and write them up. They use different tools at each step and make decisions along the way. An AI Agent works the same way. You give it a goal. It uses an AI model (like ChatGPT or Claude) as its brain, and it has access to tools: web search, code execution, file reading, database queries, and API calls. It thinks about what to do, uses a tool, reads the result, thinks again, and keeps going until the job is done. The difference from a chatbot is that an agent acts — it doesn't just answer.

The problem LLMs are powerful but passive. Ask a question, get an answer. But most real tasks require multiple steps, external information, and decisions based on intermediate results. A single LLM call can't browse the web, run code, or take actions. What AI Agents are An AI Agent is a system that puts an LLM inside a loop: 1. The agent is given a goal 2. The LLM reasons about what to do next 3. The LLM selects and calls a tool (function, API, search, code runner) 4. The tool result is fed back to the LLM as observation 5. The LLM decides whether the goal is complete or what to do next 6. Repeat until done The ReAct Pattern The foundational paper (Yao et al., 2022) described this as Reasoning + Acting (ReAct). The LLM interleaves "Thought: I need to find X" with "Action: search(X)" with "Observation: result" — building a chain of reasoning grounded in real tool outputs. A concrete example Goal: "What is the current weather in Tokyo and should I bring an umbrella?" Agent step 1: Thought → "I need current weather data. I'll call the weather API." Agent step 2: Action → weather_api("Tokyo") Agent step 3: Observation → {"temp": 18, "condition": "rainy", "precipitation_chance": 80} Agent step 4: Thought → "80% chance of rain. Answer: yes, bring an umbrella." Agent step 5: Final response to user.

Core components 1. LLM (reasoning engine): Interprets goals, generates plans, decides tool calls, synthesizes final responses 2. Tool registry: Functions available to the agent, defined with name, description, and parameter schema (JSON Schema) 3. Execution environment: Safely runs tool calls and returns results 4. Memory: Short-term (context window) + optionally long-term (vector DB, structured store) 5. Agent loop controller: Manages the iteration, stopping conditions, and error handling Tool calling protocol Modern LLMs support structured tool/function calling: the model generates a JSON object specifying which function to call and with what arguments. The host application executes the function and appends the result to the conversation. This is more reliable than parsing free-text action strings. Planning strategies - ReAct: Interleaved reasoning + tool use in a single prompt chain - Plan-and-execute: LLM generates a full plan upfront, then executes steps (can parallelize) - Tree of Thoughts: Explores multiple reasoning branches, selects best path - Reflection: Agent critiques its own output and revises Memory architecture - In-context memory: Everything in the current prompt window (limited, expensive) - External memory: Vector databases for semantic retrieval (RAG over past interactions or documents) - Structured memory: Databases for facts, entities, task state - Episodic memory: Logs of past agent runs for later retrieval Multi-agent systems Complex tasks are decomposed across specialized agents: an orchestrator agent routes to sub-agents (research agent, coding agent, writing agent). Agents communicate via messages, shared memory, or task queues. Frameworks: AutoGen (Microsoft), CrewAI, LangGraph. The Model Context Protocol (MCP) MCP (Anthropic, 2024) is a standard for connecting agents to tools and data sources via a defined server/client protocol. An MCP server exposes tools and resources; any MCP-compatible agent client can discover and use them without custom integration code.

Reliability and failure modes Agent loops are fundamentally non-deterministic. Common failure modes: - Infinite loops: Agent fails to recognize completion; must impose max_iterations - Tool call failure spirals: One bad tool result leads to cascading wrong decisions - Context exhaustion: Long agent runs fill the context window; compaction or summarization needed - Hallucinated tool calls: Model invents tool names or parameters that don't exist - Prompt injection via tools: Tool results containing adversarial instructions that redirect the agent Determinism and observability Unlike a stateless API call, agent runs are long-lived and stateful. Critical requirements: - Full logging of every LLM call, tool call, and observation (for debugging and audit) - Structured trace output (LangSmith, Arize Phoenix, or custom) - Idempotent tool implementations where possible - Human-in-the-loop checkpoints for high-stakes actions Security surface - Principle of least privilege: agents should only have access to tools they need - Sandboxed code execution (containers, E2B, Daytona) for code-running agents - Tool call authorization: sensitive operations (email, payments, writes) should require explicit confirmation - Prompt injection from external content (web pages, documents) is a significant and unsolved risk Scaling multi-agent systems - Use message queues (not direct function calls) between agents for resilience - Define clear interfaces between agents: what they accept, what they produce - Implement circuit breakers for failing sub-agents - Consider stateless agent workers with state externalized to a store When not to use agents - When a single well-crafted prompt is sufficient - When determinism is required (agents are inherently variable) - When latency is critical (agent loops add seconds or minutes) - When the task doesn't require external information or multi-step action Cost management Agent loops can make many LLM calls. Use smaller/cheaper models for planning steps and reserve frontier models for synthesis. Cache tool results where safe. Set token budgets per run.