The Future of AI Agents

We've spent this book building agents, deploying them, and studying how they work in practice. Now let's look ahead. Where is this technology going? What should you build today to be ready for what's coming? And what responsibilities come with building systems that act autonomously in the world?

This isn't a chapter of wild speculation. It's grounded in trajectories that are already visible. Where I make a prediction, I label it as mine.

Where We Are Today: The State of the Art in Late 2026

Let's take stock. As of November 2026, here's my assessment of what's real (not hype):

What works well:

• Single-domain agents that follow well-defined workflows (customer support, code review, data analysis)
• Agents with 5-15 tool calls per task, completing in under 2 minutes
• Human-in-the-loop systems where agents draft and humans approve
• Agents operating on structured data with clear success criteria

What mostly works (with caveats):

• Multi-step coding agents that write, test, and debug across multiple files
• Research agents that synthesize information from many sources
• Agents that maintain context across very long conversations (hundreds of thousands of tokens of history)

What's still unreliable:

• Fully autonomous agents running for hours without supervision
• Agents that handle truly novel situations they weren't designed for
• Multi-agent systems that coordinate on complex, open-ended tasks
• Agents that reliably know when they don't know something

The gap between "works in a demo" and "works in production" has narrowed over the past two years, but it hasn't closed. The most important skill right now is knowing where agents are reliable enough to deploy and where they're not.

Emerging Capabilities

Better Reasoning

The reasoning capabilities of foundation models are improving on a steep curve. Models that struggled with multi-step logical reasoning in 2023 now handle long chains of inference far more reliably. What this means for agents:

• Fewer steps needed. Better reasoning means agents can plan more effectively upfront, reducing the back-and-forth tool-calling loops that eat time and money.
• Better error recovery. When a tool call fails, a reasoning-capable agent can figure out why and try a different approach, rather than blindly retrying.
• More complex tasks become feasible. Tasks that once needed dozens of fragile agent steps now finish in fewer, more reliable ones.

Longer Context Windows

Context windows have grown from 4K tokens in early 2023 to about 1 million tokens for current frontier models from Anthropic, OpenAI and Google (see the AI Models reference). This changes agent architecture fundamentally:

Before (4K context):    Agent remembers last 2-3 turns.
                        Needs RAG for everything.
                        Loses track of complex tasks.

Now (~1M context):      Agent holds a large codebase in context.
                        Full conversation history usually available.
                        Complex multi-step tasks stay coherent.

Still hard:             Attention degrades on very long inputs.
                        Cost grows with every token you send.
                        Memory across sessions still needs storage.

Multimodal Agents

Agents that can see, hear, and interact with visual interfaces are moving from research demos to practical tools:

• Vision + code: An agent that looks at a screenshot of a UI bug, reads the source code, and generates a fix. Current multimodal models from Anthropic, OpenAI and Google already accept screenshots as input.
• Vision + browsing: Agents that navigate websites by looking at them, like a human would, rather than parsing HTML.
• Audio + action: Agents that join a meeting, listen to the discussion, and create action items, update tickets, or draft follow-up emails.

The multimodal shift matters because it dramatically expands what agents can interact with. Today, agents are limited to systems with APIs. Tomorrow, any software with a screen becomes a tool.

Computer Use Agents

This deserves special attention because it represents a paradigm shift in how agents interact with software.

Traditional agents work through APIs: structured, predictable, fast. Computer use agents interact with software the way humans do: they see the screen, move the mouse, type on the keyboard. Anthropic released computer use in public beta in October 2024. OpenAI folded its Operator browser agent into ChatGPT agent in July 2025.

Why it matters:

1. Universal compatibility. Every piece of software ever built has a GUI. Most don't have APIs. Computer use agents can work with any of them.
2. No integration work. You don't need to build connectors, parse API docs, or handle authentication flows. The agent uses the software the same way you do.
3. Legacy system automation. That 20-year-old internal tool with no API? An agent can use it.

Current limitations:

• Speed: clicking through a UI is far slower than an API call
• Reliability: UI elements shift, modals appear, layouts change
• Security: giving an agent control of your screen is a significant trust decision

# Conceptual: computer use agent navigating a web app
async def file_expense_report(agent, expenses: list):
    await agent.navigate("https://expenses.company.com")
    await agent.click("New Report")

    for expense in expenses:
        await agent.fill_field("Description", expense.description)
        await agent.fill_field("Amount", str(expense.amount))
        await agent.select_dropdown("Category", expense.category)
        await agent.upload_file("Receipt", expense.receipt_path)
        await agent.click("Add Item")

    await agent.click("Submit for Approval")

My expectation: computer use keeps getting faster, more reliable, and more secure, and becomes the standard fallback when no API is available.

Agent-to-Agent Communication

Today, most agents are isolated: a customer support agent can't ask a billing agent to look something up. That's starting to change.

Standardized Protocols

The industry is converging on standard ways for agents to discover and communicate with each other. The leading example is the Agent2Agent (A2A) protocol. Google introduced it in April 2025 and handed it to the Linux Foundation in June 2025, with AWS, Cisco, Microsoft, Salesforce, SAP and ServiceNow among the backers. Version 1.0 of the specification was frozen in March 2026, and in August 2026 A2A became a hosted project of the Linux Foundation's Agentic AI Foundation, alongside MCP. A2A covers agent-to-agent calls; MCP (below) covers agent-to-tool calls. The flow looks like this:

Agent A (Customer Support)
    │
    ├── "I need billing information for customer X"
    │
    ├── Discovery: What agents/tools are available?
    │   └── Registry: billing-agent, inventory-agent, shipping-agent
    │
    ├── Request: POST /agents/billing/query
    │   {
    │       "action": "get_customer_billing",
    │       "customer_id": "X",
    │       "requesting_agent": "support-agent",
    │       "auth_context": { ... }
    │   }
    │
    └── Response: Customer billing summary

The key challenges being worked on:

• Trust and authorization: Which agents can talk to which? What data can they share?
• Schema standardization: How do agents describe their capabilities to other agents?
• Error handling: What happens when Agent B is down or returns garbage?
• Conversation context: How much context from the original conversation should Agent A share with Agent B?

Agent Marketplaces

Think app stores, but for agent capabilities. You'll publish an agent that's great at data analysis. Someone else publishes one that's great at visualization. A third party's orchestration agent combines them to create end-to-end reporting.

This is still early, but the economics are compelling. Building everything from scratch is expensive. Composing specialized agents is efficient.

The Model Context Protocol (MCP)

MCP deserves specific attention because it addresses one of the most practical problems in agent development: tool integration.

Before MCP, every agent framework had its own way of defining tools. A tool built for LangChain didn't work in CrewAI, and a tool wired to one provider's function-calling format had to be rewritten for another. That fragmentation wasted a lot of developer effort.

MCP standardizes the interface between agents and tools:

┌─────────────────┐     MCP Protocol     ┌─────────────────┐
│                 │◄────────────────────►│                 │
│   Agent Host    │  • Tool discovery    │   MCP Server    │
│   (any client)  │  • Tool invocation   │   (any tool)    │
│                 │  • Resource access   │                 │
└─────────────────┘  • Prompt templates  └─────────────────┘

What MCP provides:

Capability	Description
Tool Discovery	Agent asks "what tools do you have?" and gets structured schemas
Tool Invocation	Standard request/response format for calling any tool
Resource Access	Standardized way to expose data (files, DB records, API data)
Prompt Templates	Reusable prompt patterns that tools can provide to agents
Elicitation	Servers can ask the user for more information mid-task
Tasks	Long-running work tracked through an official extension

These features come from the current MCP specification (version 2026-07-28). That revision made the protocol stateless: there is no initialize handshake and no session ID, and each request carries its own protocol version and client capabilities. Server-initiated requests were replaced by Multi Round-Trip Requests, and Sampling, Roots and Logging were deprecated; they still work during the deprecation window, but new implementations should not add them. Remote servers use the Streamable HTTP transport, which replaced the older HTTP+SSE transport.

The practical impact: you build a tool server once, and it works with Claude, GPT, Gemini and open models: any agent that speaks MCP. Similarly, you build an agent client once, and it can use any MCP-compatible tool.

# MCP server example: exposing a database as a tool
# (official Python SDK, v2; run with: uv run mcp run server.py --transport streamable-http)
import json
from mcp.server import MCPServer

server = MCPServer("database-tools")

@server.tool()
async def query_database(sql: str) -> str:
    """Execute a read-only SQL query against the analytics database.

    Args:
        sql: A SELECT query to run. No mutations allowed.
    """
    # Validate: only SELECT statements
    if not sql.strip().upper().startswith("SELECT"):
        raise ValueError("Only SELECT queries are allowed")

    result = await db.execute(sql)
    return format_results(result)

@server.tool()
async def list_tables() -> str:
    """List all available tables and their schemas."""
    tables = await db.get_table_schemas()
    return json.dumps(tables, indent=2)

Anthropic introduced MCP in November 2024. OpenAI added remote MCP server support to its Responses API in May 2025, building on MCP support in its Agents SDK. In December 2025 Anthropic donated MCP to the Agentic AI Foundation, a Linux Foundation fund co-founded with Block and OpenAI. If you're building tools for agents, building them as MCP servers is the safe default.

Autonomous Coding: From Copilot to Colleague

The progression in coding agents tells a larger story about how agent autonomy increases:

2022: Autocomplete      → Finish the line I'm typing
2023: Copilot           → Suggest the next block of code
2024: Agent-assisted    → Write this function, I'll review
2025: Semi-autonomous   → Implement this feature across files, tests included
2026: Issue-to-PR        → Take this issue, open the PR, I'll review and merge

We're currently in the "semi-autonomous" phase. Tools like Claude Code can make complex multi-file changes, write tests, and debug issues. But they work best with a human guiding the high-level strategy and reviewing the output.

The next phase, fully autonomous software engineering, requires solving several hard problems:

1. Specification understanding. Correctly interpreting what a vague issue description actually means in the context of a specific codebase.
2. Architecture decisions. Making good design choices, not just implementing the obvious solution.
3. Testing adequacy. Knowing when tests are sufficient, not just that they pass.
4. Failure recovery. When the approach isn't working, recognizing it and trying something fundamentally different.

Agent Operating Systems

Here's a concept that's gaining traction: what if an agent wasn't something you invoked for a specific task, but something that ran continuously in the background, managing your digital life?

Imagine an always-on agent that:

• Monitors your email, Slack, and calendar
• Notices when a meeting has no agenda and drafts one from recent context
• Detects when a deadline is at risk and proactively alerts the team
• Keeps your task list updated based on what happened in meetings
• Identifies information you need before you know you need it

This isn't science fiction: the individual capabilities exist today. The challenges are:

1. Cost: An always-on agent making continuous LLM calls is expensive. This requires efficient model routing and smart triggering (only invoke the expensive model when something important happens).
2. Privacy: This agent sees everything. The security and privacy implications are enormous.
3. Control: How do you configure preferences for something this broad? How do you correct it when it gets things wrong?

The first practical implementations will be domain-specific. An "agent OS" for development that monitors your IDE, Git, CI/CD, and project management tools. Or one for sales that monitors CRM, email, and call transcripts. General-purpose agent OSes are further out.

The Trust Problem

The biggest barrier to agent adoption isn't technical; it's trust. And trust is earned, not declared.

How Trust Develops

Phase 1 - Visibility:    "Show me what you would do"
Phase 2 - Suggestion:    "Here's what I recommend, approve?"
Phase 3 - Supervised:    "I'll do it, but you can see everything and override"
Phase 4 - Autonomous:    "I'll handle it, you'll see the results"
Phase 5 - Trusted:       "I've been handling this for months, you stopped checking"

In my experience, most organizations sit between phases 2 and 3 for most use cases. Moving to phase 4 requires:

• Audit trails: Every action the agent takes is logged and reviewable.
• Bounded autonomy: The agent can do X and Y but never Z without asking.
• Track record: Demonstrable history of correct decisions over weeks/months.
• Reversibility: Actions can be undone if the agent makes a mistake.

Verification Mechanisms

The field is developing better tools for verifying agent behavior:

• Constitutional AI: Anthropic's method of training models against a written set of principles (Bai et al., 2022), which makes the intended behavior explicit and reviewable.
• Formal verification: Mathematical proofs that an agent won't violate certain constraints (early research, but promising for high-stakes domains).
• Red teaming: Adversarial testing where humans try to make the agent misbehave.
• Continuous evaluation: Running eval suites against production traffic to catch quality regressions.

Economic Impact

Let's be direct about what agents mean for work. What follows is my expectation, not a forecast backed by labor data.

Jobs That Will Be Augmented

These roles will use agents as power tools, becoming more productive:

• Software engineers: Spend less time on boilerplate, more on architecture and design
• Data analysts: Ask questions in English, get answers in seconds instead of hours
• Security analysts: Process far more alerts with agent-assisted triage
• Customer support leads: Manage agent fleets instead of agent teams, focus on complex cases
• Researchers: Synthesize literature in hours instead of weeks

Jobs That Will Be Substantially Automated

Some roles will see significant reduction in headcount:

• Tier-1 customer support: Fewer people handling routine text-based tickets
• Manual data entry and processing: Large reductions as agents process documents
• Basic code generation: Junior-level CRUD development becomes agent territory
• Report generation: Routine reporting becomes fully automated

The New Roles

Agent deployment creates new jobs that don't exist today:

• Agent architects: Design multi-agent systems and their interaction patterns
• Prompt engineers / agent behavior designers: Shape how agents communicate and decide
• Agent operations / reliability engineers: Monitor, tune, and fix production agents
• AI safety engineers: Ensure agents behave within defined boundaries

Open Source vs. Proprietary

The agent ecosystem is splitting along familiar lines:

Aspect	Open Source	Proprietary
Models	Open-weight: Llama, Mistral, Qwen, DeepSeek	Claude, GPT, Gemini
Frameworks	LangGraph, CrewAI, Microsoft Agent Framework, OpenAI Agents SDK	Vendor-hosted agent platforms
Tools	MCP servers, community tools	Vendor-specific integrations
Deployment	Self-hosted, full control	Managed services, less ops burden
Cost	Lower per-token, higher ops cost	Higher per-token, lower ops cost
Capability	Usually a step behind the frontier (my read)	Leading edge
Privacy	Full data control	Depends on vendor and deployment

My take: the winning strategy is to build on open standards (MCP, OpenTelemetry) while being model-agnostic. Use the best model for each task today, and be ready to swap when something better comes along. The frameworks and protocols will outlast any specific model.

What You Should Build Today

If you're reading this book and wondering "where do I start?", here's a practical roadmap:

Right now (this month):

1. Build a single-purpose agent for your most painful repetitive task
2. Set up proper evaluation metrics from day one
3. Learn one agent framework deeply (I'd start with your model provider's own SDK, such as the Claude Agent SDK or the OpenAI Agents SDK)

Next quarter:

1. Deploy that agent to production with proper observability
2. Build a second agent, integrate them if it makes sense
3. Implement MCP for your tool interfaces

This year:

1. Develop an internal platform for agent development at your organization
2. Build shared tool libraries that any agent can use
3. Start experimenting with more autonomous agent workflows

What NOT to build:

• Don't build a "general purpose AI assistant"; the frontier model apps already do that
• Don't build your own agent framework unless your needs are genuinely unique
• Don't build agents for problems that aren't painful enough to justify the maintenance cost

The Ethical Dimension

Building systems that act autonomously in the world comes with responsibilities that go beyond technical correctness.

Transparency

Users should always know when they're interacting with an agent, not a human. This isn't just ethics. In the EU, the AI Act's transparency rules apply from August 2026. Beyond disclosure, agents should be able to explain their reasoning when asked.

Accountability

When an agent makes a mistake (sends a bad email, writes incorrect code, gives wrong advice), who is responsible? The answer must be clear before you deploy:

• The organization deploying the agent is responsible for its behavior
• "The AI did it" is never an acceptable explanation to a customer
• Every autonomous action should have a clear accountability chain

Bias and Fairness

Agents inherit the biases of their training data and the systems they interact with. A hiring agent trained on historical hiring data will perpetuate historical biases. A lending agent using biased credit models will make biased decisions. Testing for bias isn't optional; it's a core part of agent evaluation.

Data Privacy

Agents process sensitive data: conversations, personal information, business secrets. The principles are clear even if the implementation is complex:

• Minimize data collection: don't store what you don't need
• Encrypt data at rest and in transit
• Respect data residency requirements
• Give users control over their data
• Be transparent about what data the agent accesses and retains

Predictions for 2027 and Beyond

These are my expectations, not data-backed forecasts. Hold me to them.

By end of 2027:

• MCP stays the default way agents connect to tools, with A2A or a successor used for agent-to-agent calls
• Computer use agents become reliable enough for routine back-office processes, with human review
• The cost of a typical agent task keeps falling as small models improve and prompt caching spreads
• Multi-agent systems work reliably for well-defined workflows
• Agent identity (who an agent acts for, and with which delegated permissions) becomes a standard procurement question

By 2029:

• Agents write and maintain a large share of new code, with human review
• Most knowledge workers have at least one always-on agent assistant
• Agent-to-agent commerce emerges (your purchasing agent negotiates with a vendor's sales agent)
• The legal and regulatory framework for autonomous agents takes clearer shape
• Fully autonomous agents handle end-to-end processes in narrow domains

The big uncertainty: How fast will models improve at genuine reasoning and planning? This is the rate-limiting factor for agent capability. If reasoning takes another leap like the one from GPT-3 (2020) to the reasoning models of 2024 and 2025, many of the "2029" items will arrive early.

Final Thoughts: Building Responsibly

We're at the beginning of the agent era. The tools are new, the patterns are still being established, and the potential impact, both positive and negative, is enormous.

If you've read this far, you have the technical knowledge to build agents that work. That's the easy part. The harder part is building agents that should be built: systems that genuinely help people, that fail gracefully when they're wrong, and that respect the autonomy and privacy of the humans they serve.

Here's what I'd leave you with:

1. Start small, learn fast. Your first agent should be embarrassingly simple. Your tenth will be impressively capable. You can't skip the steps in between.

2. Measure everything. If you can't measure whether your agent is helping, you don't know whether it's helping. Intuition is not sufficient at scale.

3. Keep humans in the loop. Not because the technology requires it (increasingly, it doesn't), but because trust is built gradually and mistakes are inevitable.

4. Build on open standards. The specific models and frameworks will change. The protocols, patterns, and evaluation methodologies will endure.

5. Take responsibility. When your agent acts in the world, its actions are your actions. Build with the same care you'd give to any system that affects people's lives.

The future of AI agents isn't something that will happen to us. It's something we're building, right now, with every design decision, every deployment, and every line of code. Make it count.

Resources for Continued Learning

Frameworks and Tools

Resource	Description	URL
Anthropic SDK	Official Python SDK for Claude	github.com/anthropics/anthropic-sdk-python
Claude Agent SDK	The agent harness behind Claude Code	code.claude.com/docs/en/agent-sdk
OpenAI Agents SDK	Lightweight multi-agent framework (Swarm's successor)	openai.github.io/openai-agents-python
Model Context Protocol	Open standard for agent-tool communication	modelcontextprotocol.io
Agent2Agent (A2A)	Open standard for agent-to-agent communication	github.com/a2aproject/A2A
LangChain and LangGraph	Popular agent frameworks with extensive integrations	langchain.com
LangSmith	Observability and evaluation platform for agents	smith.langchain.com
CrewAI	Multi-agent orchestration framework	crewai.com
Weights & Biases Weave	LLM monitoring and evaluation	wandb.ai/site/weave

Papers and Research

• Toolformer (Schick et al., 2023): Foundational paper on teaching LLMs to use tools
• ReAct (Yao et al., 2022): The reasoning-and-acting framework that underpins most agents
• Reflexion (Shinn et al., 2023): Agents that learn from their mistakes through self-reflection
• Voyager (Wang et al., 2023): Continuous learning agent in open-ended environments
• SWE-bench (Jimenez et al., 2024): Benchmark for evaluating coding agents on real software engineering tasks

Communities

• Anthropic Discord: Active community of Claude developers and agent builders
• LangChain community forums: Large community of agent builders
• r/LocalLLaMA: Open source model community with strong agent focus
• AI Engineer Summit: Annual conference focused on building with AI (not just research)
• Latent Space podcast: Excellent coverage of agent development trends

Staying Current

The field moves fast. Here's how to keep up without drowning:

1. Follow the benchmarks: SWE-bench, GAIA, and AgentBench track agent capabilities over time
2. Read the changelogs: Model providers publish capability updates, and these directly affect what your agents can do
3. Build side projects: Nothing teaches like building. Pick a small problem, build an agent for it, deploy it, and learn from the real-world behavior
4. Join a community: The collective knowledge of agent builders is the most valuable resource available. Ask questions, share what you learn, help others

This book is a snapshot in time. The technology will evolve. The principles (measure, iterate, keep humans informed, build with care) will not. Go build something useful.