Developer’s Guide · 2026
AI Agents Explained
AI isn’t just answering questions anymore. It’s reading codebases, planning multi-step workflows, calling APIs, and building entire applications autonomously. Welcome to the age of AI agents.
What Are AI Agents?
An AI agent is an AI system that can autonomously take actions to accomplish a goal. Unlike a chatbot that waits for your next message and responds with text, an agent can use tools, make decisions, and execute multi-step plans without human intervention at every step.
Think of the difference this way: a chatbot is like texting a knowledgeable friend. You ask a question, they answer. An agent is like hiring a contractor. You describe what you want built, and they go figure out the materials, the sequence, the tools, and build it — checking in only when they need clarification.
The key capabilities that make something an agent rather than a chatbot:
Tool Use
Agents call APIs, read files, run code, search the web, and interact with external systems.
Planning
Agents break complex goals into steps and decide which order to execute them.
Memory
Agents maintain context across many steps, remembering what they've done and what's left.
Autonomy
Agents operate independently — they don't need a human prompt between every action.
How AI Agents Work: The Agent Loop
Every AI agent — whether it’s writing code, researching a topic, or navigating a website — follows the same fundamental cycle. This is the agent loop, and understanding it is the key to understanding all agentic AI.
Observe
The agent gathers context. It reads files, checks tool outputs, parses error messages, or receives user instructions. This is the input phase.
Think
The agent reasons about what to do next. It considers the goal, evaluates options, and forms a plan. This is where the LLM's intelligence shines.
Act
The agent uses a tool: writes a file, runs a command, calls an API, or searches the web. This is the step that separates agents from chatbots.
Observe (again)
The agent checks the result of its action. Did the file compile? Did the test pass? Did the API return what was expected? Then the loop repeats.
The critical insight: This loop can run for hundreds of iterations. A coding agent might observe-think-act 200+ times to build a feature: reading files, writing code, running tests, reading errors, fixing bugs, and re-running tests until everything passes. That’s what makes agents powerful — and what makes them fundamentally different from a chatbot.
Types of AI Agents
The agent paradigm is being applied everywhere. Here are the major categories emerging in 2026:
Coding Agents
Read codebases, plan implementations, write code, run tests, fix bugs, and deploy. The most mature category of AI agents today.
Research Agents
Search the web, read dozens of sources, synthesize findings, and produce structured reports. They iterate on queries until they find what you need.
Computer-Use Agents
Control a mouse and keyboard to interact with any software — clicking buttons, filling forms, navigating websites. They see the screen like a human.
Task Agents
Automate business processes: scheduling meetings, sending emails, processing invoices, managing CRMs. They connect to APIs and execute workflows.
Multi-Agent Systems
Multiple agents collaborating on a complex task. One plans, another researches, another codes, another reviews. They communicate through shared context.
Claude Code: An AI Agent in Action
“Claude Code doesn’t just write code. It reads my entire codebase, plans what to build, creates files, runs tests, and deploys. It’s an agent, not a chatbot. This website has 800+ pages built by Claude Code agents working in parallel.”
— Glen Bradford, developer of glenbradford.com
When I tell Claude Code to “create a page about AI agents,” here’s what actually happens behind the scenes:
- 1
Reads CLAUDE.md to understand project rules — never run vercel deploy, use specific imports, follow the CSS variable system.
- 2
Scans existing pages to learn patterns — how ExploreMore is used, what JSON-LD schemas look like, the typical page structure.
- 3
Plans the implementation deciding on sections, data structures, metadata, and how to match the site's visual style.
- 4
Creates the file writing 700+ lines of TypeScript in a single pass, complete with metadata, schemas, and interactive components.
- 5
Verifies compilation checking for TypeScript errors, missing imports, and broken references.
- 6
Iterates on errors if anything fails, it reads the error, fixes it, and retries — all without human input.
That entire workflow is the agent loop in action: observe, think, act, observe, think, act — cycling until the task is complete. The human (me) writes one sentence. The agent does the rest.
Real Example: 12 Agents Building 12 Pages Simultaneously
This isn’t theoretical. Right now, as you read this page, it was built by an AI agent — one of multiple agents running in parallel, each creating a different page on this site simultaneously.
How parallel agent deployment works:
Shared context: Every agent reads the same CLAUDE.md file, which contains project rules, tech stack info, and deployment instructions. This ensures consistency.
Independent tasks: Each agent gets a different page to build. They don’t need to communicate with each other because their outputs are separate files.
Git worktrees: Each agent operates in its own git worktree — a separate working directory branched from master. This prevents file conflicts.
Merge and deploy: When all agents finish, their branches are merged into master and pushed. Vercel picks up the git push and builds automatically.
800+
Pages on this site
12
Parallel agents per session
~3 min
Per page creation time
Agent Frameworks: How to Build Your Own
You don’t have to build the agent loop from scratch. These frameworks handle tool orchestration, memory management, and agent coordination so you can focus on defining what your agent should do:
| Framework | Strength |
|---|---|
| Anthropic Agent SDK | First-party Claude integration, tool definitions, guardrails |
| LangChain / LangGraph | Largest ecosystem, model-agnostic, graph-based agent orchestration |
| CrewAI | Role-based multi-agent collaboration with minimal boilerplate |
| AutoGen | Multi-agent conversations, human-in-the-loop, enterprise patterns |
| OpenAI Assistants API | Built-in code interpreter, file search, persistent threads |
| Vercel AI SDK | Streaming-first, React Server Components, edge-ready, model-agnostic |
Getting started tip: If you’re new to agents, start with Anthropic’s Agent SDK or the Vercel AI SDK. They have the simplest mental model: define your tools, give the agent a system prompt, and let it loop. LangChain is more powerful but has a steeper learning curve.
The Future of AI Agents
We’re in the early innings of the agent era. Here’s where things are headed:
Autonomous Software Development
Now - 2027Entire features spec'd, built, tested, and deployed by agents. Human developers become reviewers and architects. Junior dev work gets automated first.
Deep Research Agents
Now - 2027Agents that spend hours reading hundreds of papers, synthesizing findings, and producing publication-quality reports. Academic and market research transformed.
Personal AI Assistants
2026 - 2028Agents that manage your calendar, email, finances, and tasks. They learn your preferences and make decisions on your behalf — with human approval for big choices.
Customer Service Agents
Now - 2027AI that resolves 90% of support tickets by actually accessing systems, making changes, issuing refunds, and escalating only the hard stuff to humans.
Multi-Agent Organizations
2027 - 2030Teams of specialized agents collaborating: a PM agent writes specs, a dev agent builds, a QA agent tests, a design agent reviews. Humans oversee the team.
Physical World Agents
2027 - 2035Robotics + LLMs = agents that operate in the physical world. Warehouse robots, autonomous vehicles, and home assistants that can reason and adapt.
Risks and Limitations
AI agents are powerful, but they’re not magic. Anyone building with agents needs to understand these failure modes:
Compounding Hallucinations
HighWhen an agent hallucinates in step 3 of a 10-step plan, every subsequent step builds on a false premise. Unlike a chatbot where you catch errors immediately, agent mistakes propagate silently across actions.
Runaway Agents
HighAn agent in an infinite loop can burn through API credits, make hundreds of unintended API calls, or modify dozens of files before anyone notices. Cost guardrails and step limits are essential.
Cost Management
MediumA single agent session can consume millions of tokens if it loops extensively. Running 12 agents in parallel multiplies that by 12. Without budgets and monitoring, a runaway session can cost hundreds of dollars.
Security Surface Area
MediumAgents with tool access can read files, execute code, and call APIs. Prompt injection attacks become more dangerous when the AI can take real-world actions, not just generate text.
Oversight Gaps
MediumThe more autonomous an agent becomes, the harder it is for humans to review every decision. Striking the right balance between autonomy and human approval is an unsolved design challenge.
Evaluation Difficulty
Low-MediumMeasuring whether an agent "did a good job" is harder than evaluating a single model response. Agent outputs depend on tool availability, execution order, and environment state.
For Developers: Building with Claude’s Agent SDK
If you want to build your own AI agent, Anthropic’s Agent SDK is the simplest place to start. The core concept is straightforward: you define tools (functions the agent can call), give the agent a system prompt describing its role, and let the SDK handle the agent loop.
// Minimal agent pattern (pseudocode)
const agent = createAgent({
model: "claude-sonnet-4-20250514",
tools: [readFile, writeFile, runCommand, searchWeb],
systemPrompt: "You are a coding assistant...",
maxSteps: 50,
});
const result = await agent.run("Build a landing page");
// The SDK handles the observe-think-act loop internally.
// The agent calls tools, reads results, and loops until done.
Key concepts to learn:
- •Tool definitions (input/output schemas)
- •System prompts for agent behavior
- •Step limits and cost budgets
- •Human-in-the-loop approval flows
- •Error handling and retry strategies
Frequently Asked Questions
What is an AI agent?+
An AI agent is an autonomous AI system that can observe its environment, make decisions, use tools, and take multi-step actions to accomplish goals — unlike a chatbot, which only responds to individual prompts.
How are AI agents different from chatbots?+
Chatbots respond to one message at a time with no ability to take action. AI agents can plan multi-step workflows, call APIs, read and write files, run code, search the web, and loop until a task is complete.
What is the AI agent loop?+
The agent loop is the core cycle every AI agent follows: Observe (gather context), Think (reason about the next step), Act (use a tool or produce output), then Observe the result and repeat until the task is done.
What are coding agents?+
Coding agents are AI agents specialized for software development. They can read codebases, plan implementations, write code, run tests, and fix bugs autonomously. Examples include Claude Code, Devin, Cursor, and GitHub Copilot Workspace.
Is Claude Code an AI agent?+
Yes. Claude Code is a full AI agent — it reads your entire codebase, plans what to build, creates and edits files, runs terminal commands, executes tests, and iterates on errors. It operates in the agent loop, not as a simple chat interface.
Can AI agents work in parallel?+
Yes. Multi-agent systems can run many AI agents simultaneously on different tasks. For example, 12 Claude Code agents can build 12 different pages at the same time, each reading shared context and working independently.
What frameworks exist for building AI agents?+
Major frameworks include Anthropic's Agent SDK, LangChain/LangGraph, CrewAI, Microsoft AutoGen, OpenAI's Assistants API, and Vercel's AI SDK. Each provides different abstractions for tool use, memory, and orchestration.
What are the risks of AI agents?+
Key risks include hallucinations compounded across multi-step tasks, runaway agents that take unintended actions at scale, high API costs from long-running loops, lack of oversight in autonomous workflows, and security vulnerabilities from tool access.
Get Glen's Musings
Occasional thoughts on AI, Claude, investing, and building things. Free. No spam.
Unsubscribe anytime. I respect your inbox more than Congress respects property rights.
Keep Exploring
Claude Code: The AI Coding Agent
Deep dive into the AI agent that built this entire website.
Read moreAIAI Safety Timeline
Key milestones in AI safety research, policy, and alignment.
Read moreAnalysisWhich Jobs Will AI Replace?
50 jobs ranked by AI replacement risk with data-driven analysis.
Read moreScreenplayTHE ALGORITHM: AI Hedge Fund Screenplay
What happens when an AI agent takes over a hedge fund? A dark comedy in 15 scenes.
Read moreBehind the ScenesBuilding with AI
How this site was built with AI tools and what the process actually looks like.
Read moreEnterpriseSalesforce + AI
How AI agents are transforming the Salesforce ecosystem.
Read more