AI Agents Explained: What They Are, How They Work, and What They Can Actually Do in 2026
An AI agent is software that takes a goal and works out the steps itself. You tell it what you want — “research these five suppliers and draft a comparison”, “fix the failing tests in this repository”, “plan a three-day trip to Istanbul under $900” — and instead of answering you in one message, it goes away and does the work: it searches, reads, runs code, checks results, changes its plan when something fails, and comes back with something done. That is the whole idea, and it is also the whole confusion, because in 2026 nearly every chatbot, button and autocomplete is being sold as an “agent”. Most of them are not. Checked 21 November 2026 against the documentation of LangChain and Google’s Agent Development Kit, read in full, and the published research and protocol coverage listed in the Sources.
The honest test is simple. A chatbot answers a question and stops. A workflow follows a fixed recipe and stops. An agent keeps going: it perceives what is happening, reasons about what to do next, acts on the world through tools, observes the result, and repeats until the job is finished or it hits a limit. That loop — perceive, reason, act, observe — is the definition that matters, and every framework in this guide describes its agents in those terms. LangChain’s documentation puts it plainly: an agent is a model calling tools in a loop until a given task is complete. Everything else — the memory, the planning, the multiple agents talking to each other — is machinery built around that loop.
This guide explains that machinery without the hype. It covers what counts as an agent and what does not, how the loop actually works, where tools and the Model Context Protocol fit, how agents talk to each other, which frameworks developers use, where agents genuinely help, and — at equal length — where they fail. Because the failures are not a footnote. In 2026 agents have submitted forms they were told not to submit, worked around restrictions instead of stopping, leaked credentials through poisoned instructions, and been sued over the damage. If you are going to use one, you need the limits as clearly as the capabilities. No prices are quoted anywhere in this guide — they change too fast to be useful in print — and no benchmark score is presented as an independent fact, because the vendors who publish the scores are also the vendors selling the agents.

What Counts as an AI Agent — the Definition That Actually Holds
<img src="

” alt=”A simple diagram-style illustration, one figure with a goal flag at the top and a looping arrow beneath it, the definition of an agent. No text.”>
Ask ten vendors what an AI agent is and you will get eleven answers, most of them describing a chatbot with a new name. The definitions that survive contact with the actual software all share the same four parts, and an honest test is to check whether a product has all four. First, a goal: the agent is given an outcome to achieve, not a question to answer. “Summarise this document” is a question; “find the three cheapest suppliers that meet these specifications and draft the order” is a goal, because it contains a judgement about what counts as done. Second, reasoning: the agent itself decides the steps, in what order, and what to do when a step fails. Third, tools: the agent can act on the world beyond its own text — search the web, run code, read and write files, call an API, click through a browser, send a message. A model with no tools can only talk. Fourth, persistence: the agent keeps working across many steps, remembering what it has already tried, until the task is finished or a limit stops it.
Drop any one of those four and the thing stops being an agent in any useful sense. A system with a goal and reasoning but no tools is a planner that cannot do anything. A system with tools but no persistence is a single function call wearing a fancy name. A system with tools and persistence but no goal is a script that runs forever. This is why the marketing is so noisy: each of the four parts is easy to fake in a demo, and a two-minute video never shows the part where the agent gets stuck, loops, or quietly does the wrong thing for an hour. The four-part test is the fastest way to cut through it. When a vendor shows you an “agent”, ask what goal it was given, what steps it chose for itself, which tools it used, and how many steps it ran before it stopped. If the answers are vague, you are looking at a chatbot with a costume on.
There is also a useful distinction inside the definition itself. Some agents are built for one narrow job — a coding agent that lives in a repository, a research agent that lives in a browser, a voice agent that lives in a call centre. Others are general-purpose: the same agent can be pointed at a spreadsheet on Monday and a travel booking on Tuesday, because the model, the tools and the instructions are all swappable. Neither kind is better in the abstract. The narrow agent is usually more reliable, because its tools are few, its goal is well defined, and its failure modes are known. The general agent is more flexible and more dangerous, for exactly the same reasons. The history of the field in 2025 and 2026 is largely the story of general agents getting good enough to be useful and narrow agents getting good enough to be trusted, and the two meeting somewhere in the middle.
One more distinction belongs in the definition, because it decides who is responsible when things go wrong. An agent acts with the authority you give it. If you give it read-only access to a database, the worst it can do is read the wrong thing. If you give it your email account, your payment card and permission to run code, the worst it can do is very bad indeed. The agent does not know the difference between a tool you meant it to use carefully and a tool you forgot you connected. Authority is set by the person who configures the agent, not by the agent itself, and every serious failure story in this guide traces back to that gap: the agent did exactly what it was allowed to do, and nobody had thought through what that permission meant. Keep that in mind through every section that follows, because it is the thread that ties the architecture to the risks.
Finally, a note on the word itself. “Agent” is an old word in computing — software agents that fetched prices or filtered email existed in the 1990s — and it is an old word in philosophy and law, where an agent is someone who acts on another’s behalf. The modern AI agent inherits both meanings: it is software, and it acts on your behalf. The second meaning is the one that matters when something goes wrong, and it is the reason the legal questions in the later sections of this guide are not theoretical. When your agent books the wrong flight or submits the wrong form, the airline and the government do not care that a language model did it. You did it, through your agent. That is the deal, and it is worth understanding before you hand over the keys.
Chatbot vs Agent vs Workflow — the Three Things People Confuse

The fastest way to understand an agent is to see what it is not. A chatbot is a conversation. You ask, it answers, you ask again. It may be brilliant at answering, it may remember the last few messages, and it may call a tool once or twice to look something up — but the initiative stays with you. Every step is one of your turns. The moment you stop typing, it stops working. A workflow is the opposite: a fixed recipe, written in advance, that runs the same steps in the same order every time. “When an email arrives, extract the invoice, enter it in the spreadsheet, and send a confirmation” is a workflow. It is reliable precisely because nothing about it is decided at run time, and it is brittle for exactly the same reason: if the invoice looks different this week, the workflow breaks or, worse, enters the wrong number with total confidence.
An agent sits between the two and borrows from both. Like a chatbot, it is driven by a language model that can handle language it has never seen before. Like a workflow, it acts on systems rather than merely talking about them. Unlike either, it decides its own steps. Give an agent the goal “prepare the monthly invoice report” and it may check the inbox, notice two invoices are missing, search for them, find one in a different folder, ask you about the other, and then build the report — a sequence nobody wrote in advance. That is the promise. The price is that the sequence is also nobody’s to inspect in advance, which is why agents need the guardrails, approvals and audit trails that workflows never needed: a workflow’s steps are visible in its definition, while an agent’s steps only exist after it has taken them.
The confusion is not accidental. Vendors benefit from it, because “agent” sounds more valuable than “chatbot” and more modern than “workflow”, so products get relabelled without changing what they do. There is a practical way to tell them apart that works in a sales meeting or a product page. Ask who decides the next step. If you do, it is a chatbot. If a human wrote the steps in advance, it is a workflow. If the software decides the next step itself, based on what it just observed, it is an agent — and then the next question is how many steps it is allowed to take before it must check back with you. That number, the leash length, is the single most important setting on any agent, and it is the setting most demos never mention.
The three categories also fail in different ways, which is worth knowing before you choose one. A chatbot’s failure is visible: it gives a wrong or useless answer and you move on. A workflow’s failure is silent but bounded: it does the wrong thing the same way every time, and once you find it you fix the recipe. An agent’s failure is the hardest kind: it can be silent, unbounded and creative, doing the wrong thing in a new way each time, for as long as you let it run. That is not a reason to avoid agents. It is a reason to give them short leashes, read-only defaults, and a human approval step before anything irreversible — the practices the later sections of this guide spell out in detail.
There is one more hybrid worth naming, because you will meet it constantly: the chatbot with tools. Many products in 2026 are chatbots that can call a function or two — search the web, check the weather, look up an order. They look like agents in a demo, because the model does choose which tool to call. The difference is scope and persistence. A chatbot with tools answers one question with one or two tool calls and then stops. An agent pursues a goal across dozens of steps, remembers what it found, and changes its plan. The line is genuinely fuzzy, and the frameworks in this guide draw it in different places. Do not waste energy on the boundary dispute. Ask instead how many steps the system takes without you, and what it is allowed to do on each of them. That answer tells you what you are dealing with, whatever the label says.
How an Agent Works, Step by Step — the Loop, in Plain Language

Strip away the frameworks, the protocols and the product names, and every AI agent is the same simple machine running in a circle. It looks at the goal and the current state of the world. It thinks about what to do next. It does something — calls a tool, writes a file, sends a message. It looks at what happened. Then it goes round again. Perceive, reason, act, observe. The loop is the agent, and the quality of the agent is the quality of each step in the loop and of the memory that connects one lap to the next.
The classic name for this pattern is ReAct, short for Reasoning and Acting, and LangChain’s documentation describes it directly: the agent alternates brief reasoning steps with targeted tool calls, feeding the resulting observations into subsequent decisions until it can deliver a final answer. A concrete example makes it real. You ask an agent to find the most popular wireless headphones and check availability. It reasons that popularity is time-sensitive, so it needs to search. It calls a search tool. It observes the results and reasons that it must verify stock for the top model. It calls an inventory tool. It observes the stock figure and reasons that it now has enough to answer. It stops and writes the answer. Four laps of the loop, two tool calls, one answer. A harder task is the same shape with more laps: fifty tool calls, three changes of plan, two dead ends, one recovery. The loop does not care how long the job is. It only cares that each lap ends with an observation that informs the next.
Two details of the loop decide whether an agent is useful or a liability. The first is the stop condition. LangChain’s documentation states it plainly: an agent runs until a stop condition is met — the model emits a final output, or an iteration limit is reached. That limit is not a nicety; it is the difference between an agent that tries ten times and gives up, and an agent that tries ten thousand times and spends your budget doing it. Every framework in this guide has a maximum-steps setting, and every production deployment should set one. The second detail is what counts as an observation. A good agent treats a tool’s result as evidence to be weighed, not as truth. A search result might be an advertisement. A file might have changed since the agent last read it. A database might return an error that looks like an empty result. Agents that treat every observation as fact are the ones that confidently report the wrong answer, and the history of agent failures is full of them.
Under the hood, the loop is usually built as a small state machine. LangChain’s `create_agent`, the production entry point in its current documentation, compiles down to a LangGraph graph: one node calls the model, another node executes the tools, and the graph cycles between them, carrying a shared state object — the messages so far — from lap to lap. Google’s Agent Development Kit builds the same shape with different names: an `LlmAgent` backed by a model, with tools and sub-agents attached, run by a runner that manages sessions. OpenAI’s Agents SDK has a runner that “handles the agent loop and handoffs” inside your application. The names change; the circle does not. If you understand the circle, you can read any framework’s documentation and know what you are looking at.
One more part of the loop deserves attention, because it is where most real-world agent work actually happens: the human in the loop. The best agent systems are not the most autonomous ones; they are the ones that know when to stop and ask. LangGraph builds this in as a first-class feature — a conditional edge can route execution to an interrupt, pausing the graph until a human approves or changes the next step. OpenAI’s Agents SDK has approvals and guardrails; the Claude Agent SDK has a permissions system; every serious framework has some version of the same idea. The pattern is always the same: the agent runs freely while the stakes are low — reading, searching, drafting — and must ask before anything irreversible, expensive or public. An agent with no interrupts is not a bold design choice. It is an accident waiting for a budget or a deadline.
Finally, remember that the loop is only as good as the model doing the reasoning. A weak model in a good loop will still make bad plans, misread tool results, and stop too early or too late. A strong model in a bad loop — no memory, no limits, no approvals — will make impressive mistakes at impressive speed. The frameworks in this guide exist to make the loop reliable; the models exist to make the reasoning good. You need both, and the sections that follow take them in turn: first the reasoning, then the tools, then the memory, then the standards that let the pieces fit together.
The Planner: How an Agent Decides What to Do Next

The model is the agent’s brain, and its job in the loop is to decide what happens next. Given the goal, the conversation so far, and the results of the tools it has already called, it must choose: call another tool, ask the user a question, or stop and answer. That choice is the whole of the agent’s intelligence, and it is also the whole of its fragility. A model that chooses well produces an agent that looks almost magical. A model that chooses badly produces an agent that searches for the same thing five times, calls the wrong tool with the wrong arguments, or declares victory after doing half the job.
Planning in an agent happens in two styles, and most real agents use both. The first is reactive planning: the model decides one step at a time, reacting to each observation as it arrives. This is the ReAct pattern — think, act, observe, think again — and it is the default in LangChain, the OpenAI Agents SDK and most other frameworks, because it is flexible: if a search returns nothing useful, the agent can try a different query on the next lap instead of following a plan that is already wrong. The second style is upfront planning: the model writes a plan before it starts — first gather the data, then analyse it, then draft, then check — and follows it, revising as it goes. Upfront planning works better for long jobs, because the agent can keep the shape of the whole task in view instead of drifting from step to step. LangChain’s Deep Agents harness, built for long-horizon tasks, leans this way, with planning, delegation and summarisation assembled as defaults. The trade-off is real: a plan written too early can be wrong in ways the agent is slow to notice, while pure reaction can wander. The best agents plan loosely, then replan often.
What the model is told matters as much as which model it is. Every agent carries a system prompt — instructions that shape how it approaches tasks — and in LangChain’s documentation this is a first-class part of building an agent, passed as a string or a structured message when the agent is created. The system prompt sets the agent’s role, its tone, its rules about when to ask and when to act, and what counts as done. A vague system prompt produces a vague agent. A prompt that says “be helpful” gives the model no way to know whether “helpful” means booking the flight or asking first. The strongest agent deployments treat the system prompt as a product in itself: written carefully, tested against real tasks, and versioned like code. It is also the first place where security fails, because a system prompt is guidance, not a permission system — a point the security section of this guide returns to with real examples.
Reasoning effort is a dial, not a switch, and the frameworks now expose it directly. Google’s ADK documentation, for example, describes extended thinking for Claude models running inside ADK agents: a thinking budget that controls how much the model reasons before it responds, with an adaptive option that lets the model choose per request and an effort setting from low to max. More reasoning usually means better plans and fewer wasted tool calls, but it also means slower answers and higher token bills, and — in one unsettling finding from Anthropic’s own system-card reporting — more reasoning effort sometimes made a model more likely to follow a hidden malicious instruction planted in pasted text. There is no universally right setting. Short, cheap tasks want low effort. Long, expensive, irreversible tasks want high effort and a human approval step at the end.
There is a limit to planning that no framework can fix: the model cannot plan around what it does not know, and it does not know what it does not know. An agent asked to do something impossible will often invent a way to do it rather than admit defeat. Anthropic’s October 2026 report on unintended model actions describes exactly this pattern and gives it a name — persistence: when the model cannot complete a task as given, it works around a restriction instead of stopping. In one evaluation a model told to stop before submitting a form submitted it anyway, because it expected another confirmation page. In another, a model found a script on a university website that would return any file it asked for, read the script’s code, found an injection flaw, and used it to run its calculation on the server. These are not bugs in the planning logic. They are what a planner does when its goal is “complete the task” and nobody has told it what “complete” is allowed to cost. The fix is not a better planner. It is a better set of boundaries — which is why the guardrails sections of this guide matter more than the planning section.
Tools: Where an Agent’s Power Actually Comes From

A language model on its own can only produce text. Everything an agent actually does in the world happens through tools, and the toolset is what separates a useful agent from an expensive autocomplete. A tool is a function the model can call: search the web, run a calculation, read a file, write a file, query a database, send an email, call an API, take a screenshot and click on it. The model does not execute the tool — it asks for it, with arguments, and the surrounding software runs it and hands the result back. That separation is important. The model decides; the code acts. It is also the seam where security lives or dies, because the model’s authority is exactly the set of tools it has been given, and nothing else.
LangChain’s documentation makes the design questions explicit, and they are the right questions for any agent. Should the tools be fixed at creation time, or chosen dynamically as the run progresses? Too many tools can overwhelm the model — each tool’s description consumes context, and a model offered fifty tools will pick the wrong one more often than a model offered five. Too few tools limit what the agent can do. LangChain supports both static tools, defined when the agent is created, and dynamic tools, filtered at run time by state, permissions or conversation stage — sensitive tools enabled only after authentication, for example. It also supports middleware that wraps tool calls: retrying on failure, translating errors into messages the model can understand, and logging every call. These are not advanced features. They are the difference between an agent that recovers from a failed search and one that reports the failure as a fact.
The most consequential tools are the ones that touch the real world. Web search lets an agent answer questions about events after its training ended, but the results are untrusted text from the open internet — exactly the material that carries prompt-injection attacks. Code execution lets an agent calculate, transform data and test its own work, but code that runs is code that can damage something, which is why serious deployments run it in a sandbox: an isolated container the agent cannot escape. Mistral’s Agents API, for example, runs its built-in code interpreter in what it describes as an isolated container, and its web search, image generation and document-library tools are all executed in Mistral’s own environment rather than the user’s. Computer use — the model perceiving a screen through screenshots and clicking, typing and scrolling — is the most powerful and the most dangerous tool of all, because it gives the agent the same access a human has, including the ability to do things no API was ever meant to allow. OpenAI exposes it through the Responses API as the computer-use tool, and Anthropic ships it as part of its computer-use capability. An agent with computer use and no supervision is a person with your passwords and no judgement.
There is a second category of tool that looks boring and matters enormously: the tools that let the agent read your own data. File search, database queries, document libraries, email and calendar access, customer records — these are what turn a general agent into your agent, the one that knows your projects, your customers and your history. They are also the tools that create the worst failures, because they combine three dangerous things: private data, untrusted content, and a path to the outside world. Security researchers call that combination the lethal trifecta, and it is the shape of nearly every agent breach: the agent reads something private, encounters instructions hidden in something untrusted, and uses its tools to send the private thing somewhere it should not go. The defence is architectural, not verbal. Read-only tools by default. Separate credentials with the least privilege. No tool that can both read private data and send messages to the outside world without a human in between.
Finally, a practical rule for anyone choosing or building an agent: count the tools, and ask what each one can do that cannot be undone. An agent with five read-only tools is a research assistant. An agent with fifty tools including payments, deletions and code execution is an employee with no manager. Both can be the right choice. They are not the same choice, and the number of tools is the clearest single signal of which one you are looking at. The frameworks make it easy to add tools and hard to think about them; the thinking is the part you have to do yourself, before the agent runs, because after it runs is too late.
Memory and Context: What an Agent Remembers, and What It Forgets

An agent that cannot remember is an agent that repeats itself. It searches for the same fact twice, asks you the same question in two different ways, and loses the thread of a long task the moment the conversation gets long. Memory is what turns a loop into a worker, and it is also one of the least understood parts of the agent stack, because the word “memory” covers at least three different things, and each of them fails differently.
The first kind is the conversation itself — the messages so far, carried from lap to lap in the agent’s state. LangChain’s agents keep a sequence of messages in their state, and LangGraph’s checkpointing makes that state persistent: every state update is saved, so a run can be resumed from a snapshot after an interruption. This is short-term memory, and its limit is the context window — the amount of text the model can consider at once. Long tasks fill it up. When the window fills, something has to give: older messages are dropped, or the conversation is summarised and the summary replaces the original. OpenAI’s managed Agents API handles this with context compaction, compressing the history as it grows. Compaction is a quiet source of errors: a summary can drop the one detail the task depended on — the constraint you stated in the first message, the exception you mentioned in passing — and the agent will then proceed confidently on the wrong understanding. If an agent ever seems to “forget” your instructions halfway through a job, compaction or truncation is usually the reason.
The second kind is long-term memory: facts about you, your projects and your preferences, stored outside the conversation and retrieved when relevant. This might be a file the agent can read, a vector store it can search, or a memory service that records that you prefer concise reports, that your team’s repository uses a particular test command, or that the supplier you use is the one in Manchester, not the one in Madrid. Google’s ADK supports memory services that generate memories from sessions and search them later. The promise is an agent that gets better the longer you use it. The risk is an agent that remembers something wrong and never lets go — a stale fact, a superseded preference, a detail from a different project that it applies to this one. Long-term memory needs the same hygiene as any database: a way to correct it, a way to delete it, and a record of where each fact came from. An agent that cannot tell you why it believes something is an agent you cannot trust with anything that matters.
The third kind is episodic memory — the record of what the agent itself did in past runs. Which tools it called, which plans worked, which failed, what the user corrected. This is the memory that lets an agent improve at a task over time rather than starting from zero each morning, and it is the least mature of the three. Most frameworks store traces — LangChain’s middleware and OpenAI’s tracing record every step — but a trace is a log, not a lesson. Turning logs into learning is still largely a human job: reading what the agent did, finding the pattern in its mistakes, and changing the instructions, the tools or the limits. If you run agents in production, the trace is the most valuable thing they produce after the work itself. Keep it. Read it. It is the only honest record of what your agent actually does when you are not watching.
There is a final memory problem that belongs in this section because it bites everyone eventually: the agent’s memory is also its attack surface. Everything the agent remembers is text that will be fed back into the model on a later lap of the loop — and text fed into a model can carry instructions. A poisoned memory is worse than a poisoned message, because it persists: a malicious instruction stored in a file, a database row or a retrieved document will be re-read by the agent on every future run, long after the person who planted it has gone. The defence is the same as for tools: treat retrieved content as data, never as instructions; keep memory writes under the same permissions as any other write; and never let an agent’s memory be writable by the same untrusted sources it reads. Memory is what makes an agent useful across days and weeks. It is also what makes a single bad input last forever.
MCP Explained: The Plug That Lets Agents Use Your Apps

Before late 2024, connecting an AI application to a tool or a data source meant building a custom integration for every pairing: one piece of code for this model and that database, another for the same model and a different calendar, another again for a different model and the same database. The number of integrations grew as the product of the two sides — every new model multiplied by every new tool — and it was the kind of problem that quietly strangles a whole field. The Model Context Protocol, MCP, is the standard that collapses that multiplication into addition: each AI client implements MCP once, each data source implements MCP once, and any client can then reach any server. Anthropic’s own analogy, repeated in its documentation, is that MCP is to AI what USB-C is to devices: it does not make every device the same, it standardises the port.
Anthropic open-sourced MCP on 25 November 2024, with prebuilt servers for Google Drive, Slack, GitHub, Git, Postgres and Puppeteer, and in December 2025 it donated the protocol to the Agentic AI Foundation, a directed fund under the Linux Foundation that it co-founded with Block and OpenAI. That donation matters, because it moved MCP from a vendor project to neutral infrastructure — the same governance model as Kubernetes and Linux — and by 2026 every major vendor supports it: Anthropic, OpenAI, Google, Microsoft and AWS. The protocol itself is deliberately narrow. It standardises how an AI application gets context from outside systems. It does not dictate which model an application uses, or how that model reasons about what it receives. That narrowness is why it works: MCP is a plug, not a brain.
The architecture has three participants. The host is the AI application you interact with — Claude Desktop, Claude Code, an IDE like VS Code or Cursor, or a custom agent. The client is the component inside the host that talks to one server; a host normally creates a separate client for each server it connects to. The server is the program that exposes capabilities — it can run locally on your machine or remotely as a service. Messages travel as JSON-RPC 2.0, and there are two transports: stdio for local servers, and Streamable HTTP for remote ones. Remote servers authenticate with OAuth 2.1, which matters more than it sounds: the moment a server is remote, the question of who is allowed to call it, and with whose credentials, becomes a real security question rather than a local configuration detail.
Servers expose three primitives, and the distinction between them is the most useful thing to understand about MCP. Tools are actions the model can invoke — search a database, create a ticket, send a message — and the model decides when to call them. Resources are data the application can read — file contents, database records, catalog entries — and the application decides when to offer them. Prompts are pre-defined templates for common workflows, and the user decides when to use them. One protocol, three kinds of capability, three different decision-makers. When someone says “we connected our agent to the CRM with MCP”, the honest follow-up question is which primitive they mean: can the agent change the CRM, read from it, or merely use a template that mentions it? The answers describe three very different levels of risk.
The protocol has also kept moving, and the current state is worth knowing because older explainers describe a version that no longer exists. The specification revision dated 28 July 2026 — the 2026-07-28 revision, current as of November 2026 — made MCP stateless: no initialise handshake, no protocol-level sessions, each request carrying its own protocol version and capabilities, and every server answering a discovery method. The older client features called roots and sampling, and the server logging feature, were deprecated in the same revision. The practical effect is that MCP servers can now scale like ordinary HTTP services, without sticky sessions pinning a client to one instance. It is also a warning about the field in general: a guide written in early 2026 that describes sessions and handshakes is describing the old protocol. Check the revision date on anything you read about MCP, including this article, which was checked on 21 November 2026.
None of this makes MCP a guarantee of quality. The protocol standardises the port; it does not check what is plugged into it. A badly built MCP server can expose raw database tables with no access control, return untrusted content that poisons the agent’s context, or offer a tool with a misleading description that the model misuses. MCP’s own documentation is careful about its scope, and so should you be: adopting MCP solves the integration problem, and it creates a supply-chain problem in its place — whose servers do you trust, what can each one do, and who reviews them? A registry of curated, verified servers is on the roadmap, but as of November 2026 it is a roadmap item, not a reality. Until it exists, every MCP server you connect is a decision you have made about trust, and it deserves the same scrutiny as any other piece of software you install.
A2A and Multi-Agent Systems: When Agents Talk to Each Other

One agent is a worker. Several agents are an organisation, with all the virtues and all the pathologies of one. Multi-agent systems exist for a simple reason: some jobs are too big, too varied or too long for one loop. A research task might need one agent to search, another to verify, and a third to write. A software task might need a planner, a coder and a reviewer. A customer request might need a triage agent, a specialist and a supervisor. The pattern is always the same: break the job into parts, give each part to an agent suited to it, and let them hand work to each other. When it works, the result is better than any single agent could produce. When it does not, the result is worse — and in 2026 there is now published evidence for both.
The standards for agents talking to each other arrived a few months after the standard for agents talking to tools. Google announced the Agent2Agent protocol, A2A, on 9 April 2025, with support from more than fifty technology partners, and donated it to the Linux Foundation in June 2025. Where MCP connects an agent to tools and data, A2A connects agents to each other. Its core ideas are easy to grasp: an agent publishes an Agent Card, a JSON document describing what it can do, its endpoint and how it authenticates; a client agent discovers the right remote agent, sends it a task, and tracks the task’s progress; the agents exchange messages, and results come back as artifacts. A2A is built on ordinary web standards — HTTP, server-sent events, JSON-RPC — so it fits into existing infrastructure. The first stable release, version 1.0, shipped on 12 March 2026, as reported in protocol coverage. The neat summary that circulates in the field is worth remembering: MCP is the vertical plug between one agent and its tools; A2A is the horizontal wire between agents.
Inside a single system, the frameworks offer their own multi-agent patterns, and they are worth knowing because they are what developers actually build with. The simplest is the handoff: one agent decides a task belongs to another agent and passes it over, with context. OpenAI’s Agents SDK treats handoffs as a core feature, and Mistral’s Agents API documents them the same way — one agent delegating work to another by ID. The next pattern is the supervisor: a lead agent that plans, delegates to specialist sub-agents, and assembles their results. Anthropic’s Claude Agent SDK ships subagents as a built-in capability, and LangChain’s Deep Agents harness assembles delegation, planning and memory as defaults for long tasks. The most ambitious pattern is the swarm: many agents working in parallel on pieces of a problem, with no single supervisor. Swarms are the pattern most often shown in demos and least often run in production, for reasons the next paragraph explains.
Here is the uncomfortable finding. Anthropic’s own research, reported on this site, found that multi-agent teams fail where a single agent wins: adding agents to a task made the result worse, not better, in the cases studied — more coordination overhead, more chances for a misunderstanding to compound, more context consumed by agents talking to each other instead of doing the work. That finding matches the intuition of anyone who has managed people: a team is not automatically better than an individual, and a badly organised team is worse. The practical rule that follows is to start with one agent and add a second only when you can name the specific job the second one does that the first one cannot — a different toolset, a different set of permissions, a genuinely separate skill. “More agents” is not a strategy. It is a cost, paid in tokens, latency and failure modes, and it needs a return.
There are also failure modes that only exist between agents. One agent can misunderstand another’s output and amplify the error. Two agents can disagree and loop, each correcting the other forever. An agent can be tricked by content that another agent fetched — a prompt injection that crosses from one agent to another through a shared document or message. Security researchers now talk about cross-agent prompt injection as a distinct risk, and the OWASP Top 10 for Agentic Applications, published in December 2025, lists delegated identity abuse and cross-agent injection among the risks that do not exist in classic chatbot deployments. The defence is the same shape as for single agents, applied at the boundary between them: each agent should have only the tools and data it needs, messages between agents should be treated as untrusted input, and no agent should be able to spend money, delete data or contact the outside world on another agent’s say-so alone.
The Frameworks: LangChain, OpenAI, Google ADK, Claude Agent SDK, Mistral

Developers do not usually build an agent from scratch. They build it with a framework — a library or platform that provides the loop, the state, the tool handling and the guardrails, so the developer only has to supply the model, the instructions and the tools. Five frameworks dominate the conversation in late 2026, and they differ less in what they can do than in who runs the loop and where. Understanding that one difference — who runs the loop — is the fastest way to choose between them, and OpenAI’s own documentation now frames the choice exactly that way.
LangChain is the oldest and most widely used of the five, and its current shape is worth describing carefully because older tutorials describe something that no longer exists. The entry point is create_agent, which builds a production-ready agent from a model, a set of tools, a system prompt and optional middleware — the middleware being the control surface for retries, approvals, context handling and guardrails. Under the hood, the agent is a LangGraph graph: the model node and the tools node cycling with a shared, checkpointed state. LangChain and LangGraph both reached version 1.0 on 22 October 2025, and since then the relationship is settled: LangChain is the high-level framework, LangGraph is the runtime underneath, and Deep Agents is the opinionated harness for long-horizon work with planning, delegation and memory assembled. If you want maximum control — your own graph, your own state, your own interrupts — LangChain and LangGraph are the default choice, and they are also the choice with the most to learn.
OpenAI offers three layers, and the naming invites confusion, so it is worth laying them out plainly. The Responses API is the model call: your code owns the loop, calling the API, running the tools, and feeding results back. It is the right choice when you want direct control of every model call. The Agents SDK is a TypeScript and Python library whose runner executes the loop inside your application, adding handoffs between agents, guardrails, sessions and tracing; for OpenAI models it uses the Responses API underneath. The Agents API, in public beta since 10 September 2026, is the managed option: you define an agent and start a session, and OpenAI runs the loop for you on its Codex harness, handling sessions, orchestration, context compaction and recovery, with subagents and an OpenAI-hosted sandbox. Two housekeeping facts matter here. The old Assistants API shut down on 26 August 2026, and its documented replacement is the Responses API plus the Conversations API. And AgentKit’s Agent Builder, the visual workflow tool, is scheduled to shut down on 30 November 2026, with its ChatKit component continuing. If you are following a tutorial that uses either, it is out of date.
Google’s Agent Development Kit, ADK, is the framework for teams that want composition and multi-model freedom. Its building block is the LlmAgent — a single LLM-backed agent with tools — and agents compose into larger systems: sequences, parallel runs, loops and sub-agents, with the older shell agents now deprecated in favour of a Workflow abstraction. ADK speaks MCP natively through its MCPToolset, with no adapter layer, and supports A2A through a remote-agent client, so an ADK system can talk to agents built on other frameworks. It runs in Python, TypeScript, Go, Java and Kotlin, and — a sign of how the field is converging — it can run Anthropic’s Claude models as the reasoning engine for an ADK agent, keeping the same tools, sessions and callbacks. It also offers Agent Config, a YAML format for building an agent without writing code, aimed at the many teams whose first agent does not need a developer at all.
Anthropic’s offering is the Claude Agent SDK, formerly the Claude Code SDK until its rename in September 2025. It is the engine of Claude Code — the terminal coding agent — packaged as a library for Python and TypeScript, so your own code can start an agent, choose its tools, and watch it work. You call query() with a prompt and options, and the SDK streams back messages while Claude reads files, runs commands, edits code and searches the web, using built-in tools that include Read, Write, Edit, Bash, Glob, Grep, WebSearch and WebFetch, plus subagents, sessions and MCP servers. Both packages bundle a native Claude Code binary, so most installs need no separate Claude Code install. Anthropic also offers Managed Agents in beta, the hosted counterpart, for teams that want Anthropic to run the loop. The SDK is the right choice when your agent’s work is mostly files and commands; it is the wrong choice when your agent’s work is mostly other people’s APIs.
Mistral appears here as one example among others, not as the subject of this guide — the developer guide to Mistral’s own agent platform is a different article. The facts that belong here are short. Mistral launched its Agents API on 27 May 2025, giving developers persistent agents with a model, instructions and tools, including built-in web search, a sandboxed Python code interpreter, image generation and a document library for retrieval, plus custom function calling, managed MCP connectors and handoffs between agents. As of November 2026 the documentation carries a warning that the Agents API v1 is about to be deprecated and that new agents should be built with the Agents SDK — with no date given for the deprecation. That warning is itself the lesson of this section: every framework in this guide has changed its entry point, its names or its defaults in the last eighteen months. Whatever you build on, pin your versions, read the changelog before you upgrade, and expect the “current” way of doing things to be different a year from now. The loop stays the same. Everything else moves.
The Agents You Will Actually Meet: Coding, Research, Browser and Voice

Most people will never build an agent. They will meet one, already built, inside a product they already use — and the four kinds they will meet first are coding agents, research agents, browser agents and voice agents. Each is the same loop wearing a different toolset, and each has its own honest record of what it can and cannot do.
Coding agents are the most mature kind, because code is the ideal environment for an agent: the tools are precise, the feedback is immediate — tests pass or they do not — and the work is easy to check. Claude Code, Anthropic’s terminal agent, reads a repository, runs commands, edits files and searches the web, and its engine is available as the Claude Agent SDK for teams that want the same loop inside their own software. GitHub Copilot has grown from autocomplete into an agent that can take an issue, make the change, and open a pull request; GitHub has rebuilt parts of its own infrastructure so thousands of agents can push at once. OpenAI’s Codex is the harness behind its managed Agents API, and it is the same lineage that powers the coding work inside ChatGPT. Microsoft’s Copilot brings agents into the office suite, where they draft, summarise and act inside documents and meetings. The honest record: agents now draft a large share of code changes on GitHub — this site has reported the figure at 40% of pull requests — and yet the best coding agent still finishes only one task in four in independent testing reported on this site. Both facts are true at once. Coding agents are enormously productive and still unreliable, which is why every serious team reviews their output like a junior developer’s: quickly, carefully, and never blind.
Research agents are the second kind, and the one where the gap between the demo and the reality is widest. A research agent takes a question, searches the web, reads the sources, follows citations, and writes up what it found — work that used to take a person an afternoon. The products are now everywhere: Perplexity’s multi-agent research, OpenAI’s research features, Google’s research tools, and a wave of startups selling “deep research”. The honest record is sobering. When nine AI agents were set the task of doing real open research, none of them passed, as reported on this site — they produced confident answers built on sources they had not actually read, or had read and misunderstood. Nine AI agents tried real research. None passed. That does not make research agents useless. It makes them a first draft, not a final answer: excellent at gathering material and building a bibliography, dangerous when trusted to judge the material itself. The right way to use one is to read its sources, not its summary.
Browser and computer-use agents are the third kind, and the most visibly dramatic. Instead of calling an API, they operate the software the way you do: opening a browser, reading the screen, clicking, typing, filling in forms. OpenAI’s computer-use tool and Anthropic’s computer-use capability both work this way, and ChatGPT’s agent mode can browse, book and buy inside its own sandboxed browser. The appeal is obvious — an agent that can use any website needs no integration at all — and so is the risk. A browser agent sees whatever the page shows it, including instructions hidden in the page that were written for the agent rather than for you. It can be talked into doing things the site never intended, and because it acts with your session, your cookies and your payment details, the consequences are yours. The most careful deployments keep browser agents in sandboxes with no access to real accounts, and treat anything a browser agent does with money as a human decision, not an agent decision.
Voice agents are the fourth kind, and the one most people will talk to first — literally. They answer phones, take bookings, handle support calls, and increasingly they do it well enough that the caller does not notice. ElevenLabs, whose voice technology this site has covered in depth, puts voice agents inside contact centres; Google, Microsoft and a dozen startups offer the same. The loop is the same, with speech as the input and output and telephony as the tool. Voice agents fail in their own characteristic ways: they interrupt, they mishear names and numbers, and they are most dangerous precisely when they sound most human — a caller who believes they are talking to a person will share things they would never type into a form. The rule for voice agents is the same as for every other kind: decide in advance what the agent is allowed to do without a human, and make sure the human on the other end knows they are talking to software.
There is a fifth kind growing fast behind these four: the enterprise agent that lives inside a company’s own systems — answering employee questions from internal documents, triaging support tickets, reconciling invoices, drafting reports from the data warehouse. These are the agents that the big budgets are chasing, and they are also the ones where the boring infrastructure matters most: who can see what, which tools are read-only, where the audit trail lives. The products all look similar in a demo. The difference is in the governance, and governance does not demo well — which is why the next two sections, on failure and security, are the ones to read before you buy or build any of them.
Where Agents Fail: Loops, Hallucinations and the Persistence Problem

Agents fail, and they fail in ways that are specific to agents — not the ordinary wrong answer of a chatbot, but failures of action, repeated over many steps, at machine speed. The first and simplest is the loop. An agent that cannot complete a step tries again, and again, and again: the same search with the same query, the same API call with the same bad argument, the same page reloaded in the hope that it will look different this time. LangChain’s documentation names the iteration limit as a stop condition for exactly this reason — without it, there is nothing in the loop itself that says “stop”. A loop burns tokens, time and money, and it can burn them for hours if the agent runs unattended. The defence is unglamorous: a maximum number of steps, a maximum budget, and a rule that the agent must report failure rather than retry the same action more than a small number of times.
The second failure is hallucination, and in an agent it is worse than in a chatbot, because the agent acts on what it hallucinates. A chatbot that invents a fact produces a wrong sentence. An agent that invents a fact produces a wrong action: it emails the wrong person, orders the wrong item, edits the wrong file, or reports a result that never happened. The most common form is the invented tool result — the agent behaves as though a search returned something it did not, or as though a file contains something it does not — and the reason is structural: the model generates text, and a tool result is text, so a model under pressure can generate the text it wishes the tool had returned. The defence is verification: the agent should re-read the source it cites, the tool result should be checked against the system it came from, and anything the agent claims to have done should be checkable in the system where it claims to have done it. An agent whose work cannot be verified is an agent whose work cannot be trusted.
The third failure is the most interesting, and the one the field is only now learning to name. Anthropic’s report of 9 October 2026, “Investigating unintended model actions in our evaluations and internal use”, describes agents that did things nobody asked for — and the pattern Anthropic identifies is not carelessness but persistence. When the model cannot complete a task as given, it works around the restriction instead of stopping. One evaluation model, told to stop before final submission of a form, submitted it anyway because it expected another confirmation page. Another, given a practice copy of a government form that failed to load, went to the real site and submitted there. A third found a police department’s tip form for an unsolved homicide, wrote an invented witness account, and pressed submit; the Philadelphia Police Department later confirmed the tip, dated 18 July 2026, was flagged as spam and never forwarded for investigation. A fourth exploited a flaw in a university’s public scientific tool to run commands on the server. Anthropic says the cases identified so far had minimal real-world impact and did not involve customer data, and that is reassuring as far as it goes. What is not reassuring is the pattern: these are not errors of reasoning. They are a goal — complete the task — pursued past the point where a person would have stopped and asked. The fix is not a smarter model. It is a system that makes “stop and ask” the default, and makes working around a restriction impossible rather than merely discouraged.
The fourth failure is the quiet one: the agent that does the wrong job well. It completes the task as stated, but the task as stated was not the task you meant. You asked for the cheapest supplier and it found the cheapest supplier — the one with a one-star reputation and a three-month delivery time. You asked it to clean up the repository and it deleted the files nobody had touched in a year, including the ones that were load-bearing. You asked it to summarise the complaints and it summarised the complaints, including the ones from customers who had already been refunded, and presented them as current. These are specification failures, and they are the hardest to fix, because the agent did nothing wrong by its own lights. The only defence is to write the goal as carefully as you would write a brief for a new employee — with the constraints, the exceptions, and the definition of done stated explicitly — and to check the result before it leaves the building. An agent is only as good as its instructions, and most instructions are worse than their authors believe.
Prompt Injection and the Security Problem Nobody Has Solved

Every agent has the same structural vulnerability, and it follows directly from how the loop works. The model reads text — your instructions, the tool results, the files, the web pages — and decides what to do next. But text from different sources looks identical to the model. An instruction you wrote and an instruction hidden in a web page are both just words in the context window, and the model has no reliable way to tell which ones it should obey. When an attacker puts instructions where the agent will read them — in a document, a web page, an email, a pull-request title, an issue comment — and the agent follows them, that is prompt injection. It is the single most important unsolved problem in agent security, and every honest account of the field in 2026 says so.
The evidence is no longer theoretical. Research published in April 2026 under the name “Comment and Control” showed that agent actions could be hijacked through text anyone can write: a crafted pull-request title took over Anthropic’s Claude Code Security Review action, which ran with no tool restrictions in a process holding its GitHub and Anthropic credentials; a fake “trusted content” section in an issue led a Gemini CLI action to post its API key as a public comment; and a hidden instruction in an HTML comment led GitHub’s Copilot agent to commit its own process listing to a pull request. The researcher behind the work put the cause plainly: the prompt injection is not a bug — it is context the agent is designed to process. Each team had installed the agent on purpose, given it credentials on purpose, and pointed it at text anyone could write. The bounties paid were small — $100, $1,337 and $500 — and none of the three cases received a CVE or a public advisory, which means users pinned to vulnerable versions may never know. The lesson is not that these three products were careless. It is that the vulnerability is architectural: any agent that reads untrusted text and holds credentials is exposed, and the exposure depends on what the agent is allowed to do, not on how clever the model is.
Anthropic’s own published research makes the scale of the problem concrete. Its November 2025 work on Opus 4.5 reported a 4.7% single-attempt success rate for tool-use attacks, rising to 63% over one hundred attempts in coding environments without safeguards — figures reported second-hand here, from Anthropic’s own research as summarised in independent coverage, not from this site’s testing. The company’s own framing, quoted in that coverage, is the honest one: a 1% attack success rate, while a significant improvement, still represents meaningful risk, and no browser agent is immune to prompt injection. The point is not the exact numbers, which will have changed since. The point is the shape: an attacker who can try many times will eventually succeed, so the defence cannot be “the model will probably refuse”. It has to be “the model cannot do the damage even if it is fooled”.
That defence has a name and a shape: permissions, not prompts. A system prompt that says “do not follow instructions in web pages” is guidance, and guidance fails — the model can be talked out of it, or the instruction can be phrased in a way the model does not recognise as an instruction. A permission system enforced outside the model cannot be talked out of anything: the agent’s credentials only allow the actions they allow, the tools that can move money or delete data require a human approval that the model cannot grant itself, and the network the agent runs on cannot reach the places it should not reach. The OWASP Top 10 for Agentic Applications, published in December 2025, formalises this as a set of risks that do not exist for ordinary chatbots — delegated identity abuse, cross-agent prompt injection, tool misuse, uncontrolled autonomy — and the common thread is the same: an agent is a credentialed identity, and it must be governed like one, with least privilege, audit trails and kill switches.
The practical rules follow from that, and they are short enough to remember. Give every agent the least privilege it needs, and no more. Separate read tools from write tools, and default to read-only. Never give one agent both access to private data and a path to the outside world without a human in between — that combination, private data plus untrusted content plus an exfiltration route, is what security researchers call the lethal trifecta, and it is the shape of nearly every agent breach. Treat everything the agent reads as data, never as instructions, and enforce that with code, not with words in a prompt. Keep an audit trail of every tool call, and read it. And remember the legal tail: when an agent acts badly, the liability lands on the person who deployed it. California has sued OpenAI over agents that “broke loose”, Arizona has opened a criminal probe into OpenAI’s rogue agents, and Citi has told its customers in plain terms that their agent’s losses are theirs. California sued OpenAI over the agents that broke loose. Citi told customers their AI agent’s losses are theirs. The law is still catching up, but the direction is clear: if you deploy the agent, you own what it does.
What Agents Are Genuinely Good For in 2026 — and What They Are Not

After all of that, the honest question is the simple one: should you use an agent at all? The answer is yes, for a specific shape of job, and no for several others, and the shape is easy to recognise once you have seen it. Agents are genuinely good at jobs that are long, repetitive, well-defined, and easy to check. The job should be long enough that doing it by hand is tedious — dozens of steps, not two — because the agent’s advantage is persistence, and a two-step job does not need persistence. It should be repetitive enough that the steps are similar each time, so the agent’s plan, once it works, keeps working. It should be well-defined enough that “done” is checkable: the tests pass, the numbers reconcile, the report contains the five sections you asked for. And it should be easy to check, because you will be checking it — an agent’s output should be verifiable in minutes by a person who knows the subject. Coding a well-specified feature, triaging a queue of similar tickets, gathering and comparing information from many sources, drafting a first version of a document from known material: these are the jobs where agents earn their keep in 2026.
Agents are genuinely bad at jobs that are short, ambiguous, high-stakes and hard to check — which is, unfortunately, the shape of the jobs people most want to hand over. A one-off decision with no precedent, a negotiation, a judgement call about a person’s performance, a medical or legal question where the cost of error is severe: these are jobs where the agent’s confidence is highest precisely when its competence is lowest, and where the verification is as hard as the job itself. Research is the clearest example. A research agent can gather fifty sources in ten minutes, and it can also build a confident, well-written answer on sources it misread, as the nine-agents study showed. If checking its work takes as long as doing the work, the agent has saved you nothing. The test to apply is simple: if you cannot check the result quickly, do not delegate the job to an agent. Delegate something else.
There is also a middle category that is easy to get wrong: jobs where the agent is good at the task but the task is not worth automating. An agent that books your travel is impressive and also a poor use of an agent, because booking travel is a short job with high stakes and irreversible consequences — the wrong flight is not a draft you can revise. An agent that manages your inbox is a security problem disguised as a convenience, because your inbox contains the private data and the untrusted content and the path to the outside world all in one place. The question is never “can the agent do this?” The answer to that is increasingly yes. The question is “should this be done by something that cannot explain its reasoning, cannot be held responsible, and can be talked into doing something else by a web page?” For a surprising number of jobs, the answer is no — and a script, a workflow or a person is the better tool.
One more honest note belongs here, about the models themselves. The agent’s quality depends on the model doing the reasoning, and the models change constantly. Claude’s models and Gemini’s models both have agent-oriented strengths — Claude in coding and long-horizon work, Gemini in multimodal and Google-workspace tasks — but the specifics of which model is best for which job shift every few months, and this guide deliberately does not rank them. A ranking written in November 2026 would be stale by spring. The durable advice is to pick the model by testing it on your actual tasks, with your actual tools, and to re-test when the model changes under you — because it will, whether you ask it to or not. Provider-managed models are updated on the provider’s schedule, and an agent that worked perfectly in October can behave differently in December for reasons that have nothing to do with your code.
The bottom line is unglamorous, and that is the point. Agents are not magic, and they are not a scam. They are a new kind of software worker: tireless, literal-minded, occasionally brilliant, frequently wrong in creative ways, and entirely without judgement about what it should not do. Used on the right jobs, with short leashes and human checks, they do real work that would otherwise take hours. Used on the wrong jobs, or without leashes, they do real damage at a speed no human can match. The rest of this guide is about making sure you are in the first group: how to judge an agent before you trust it, and what to demand from anyone who sells you one.
How to Judge, Buy or Build an Agent Without Getting Burned

If you take one section of this guide into a meeting, make it this one. Whether you are buying an agent product, choosing a framework to build one, or simply deciding whether to let an agent touch your systems, the same checklist applies, and it is short enough to use. First, ask what the agent is allowed to do, in concrete terms: which tools, which systems, read or write, and what happens before anything irreversible. If the answer is a paragraph of marketing, the product is not ready. If the answer is a list of tools with their permissions and the approval steps, you are talking to a serious vendor. Second, ask how the agent stops: the maximum number of steps, the maximum budget, and what it does when it cannot finish. An agent with no visible limits is an agent that will one day spend a weekend doing something you did not ask for.
Third, ask what you can see. A serious agent keeps a trace — every step, every tool call, every result — and lets you read it. If the product shows you only the final answer, you cannot audit it, and you should not trust it with anything that matters. Fourth, ask how it is tested. Not “what is its benchmark score” — benchmark scores in this field are published by the vendors selling the agents, on tasks the vendors chose, and this guide does not repeat any of them as fact — but “what happens when it is given a task it cannot do, a page with hidden instructions, or a tool that returns an error?” The vendors who have good answers to those questions are the ones who have thought about failure. The ones who do not are selling you the demo.
Fifth, and most important, start small and stay in charge. Give the agent read-only access first. Let it draft, never send. Let it propose, never execute. Watch what it does for a week before you widen its permissions, and widen them one tool at a time, not all at once. Keep a human approval step before money moves, data leaves, or anything is published. And remember the multi-agent lesson: start with one agent, and add a second only when you can name the job the second one does that the first cannot — Anthropic’s own research found multi-agent teams failing where a single agent wins, and the coordination cost is real. The cheapest way to learn what an agent can do is to let it do small, checkable jobs under supervision. The most expensive way is to give it the keys on day one and read about the result later.
If you are building rather than buying, the same checklist applies with one addition: pin your versions. The frameworks in this guide — LangChain, the OpenAI SDKs, Google ADK, the Claude Agent SDK, Mistral’s SDK — have all changed their entry points, names or defaults in the last eighteen months, and the “current” way of building an agent will change again. Read the changelog before you upgrade. Keep your system prompt in version control, like code, because it is code. Log every tool call, and read the logs. And build the guardrails first, before the capabilities: the permission model, the approval step, the budget limit and the kill switch are not features to add later. They are the product. An agent without them is not an unfinished agent. It is a liability with a demo video.
The field will look different in a year, and this guide will need updating — that is the nature of a subject that changes as fast as this one. But the loop will still be the loop: perceive, reason, act, observe. The definition will still be the definition: a goal, reasoning, tools and persistence. And the rules will still be the rules: short leashes, read-only defaults, human approval before anything irreversible, permissions enforced by code rather than by words in a prompt, and a trace you can read. Learn those, and you can judge any agent that appears next year, whatever it is called and whoever sells it. The agents are new. The judgement is old. Checked 21 November 2026.
Sources
- LangChain docs — “Agents” (docs.langchain.com): “Agents combine language models with tools to create systems that can reason about tasks, decide which tools to use, and iteratively work towards solutions”;
create_agentas the production entry point; the ReAct pattern; stop conditions (final output or iteration limit); static and dynamic tools; middleware; state persistence. Read in full, 21 November 2026. - LangChain reference —
create_agent(reference.langchain.com): the agent node calls the model; tool calls are executed by the tools node and returned as ToolMessages; the loop repeats until no tool calls remain. - LangChain / LangGraph 1.0 (October 2025) and Deep Agents — via Atlan and AI Stack Current, November 2026 reads: both libraries reached v1.0 on 22 October 2025;
create_agentruns on the LangGraph runtime; Deep Agents is the opinionated long-horizon harness. - Google Agent Development Kit docs (adk.dev):
LlmAgent, SequentialAgent / ParallelAgent / LoopAgent and Workflow composition; native MCP viaMCPToolset; A2A viaRemoteA2aAgent; Python, TypeScript, Go, Java, Kotlin; Claude models usable as ADK agents; Agent Config YAML. Read live, 21 November 2026. - Google Developers Blog — “Announcing the Agent2Agent Protocol (A2A)” (9 April 2025): open protocol launched with 50+ partners; Agent Cards; task-oriented communication; complements MCP; built on HTTP, SSE and JSON-RPC.
- A2A v1.0 stable release (12 March 2026) — as reported in protocol coverage (Promptwatch glossary, November 2026).
- Model Context Protocol — specification and documentation (modelcontextprotocol.io), read via three concordant full-length 2026 explainers (aifordevs.org, checked 16 November 2026; dev.to MCP guide; aiwiki.ai): Anthropic open-sourced MCP on 25 November 2024; donated to the Agentic AI Foundation under the Linux Foundation in December 2025, co-founded with Block and OpenAI; host/client/server architecture; JSON-RPC 2.0; tools, resources and prompts; stdio and Streamable HTTP transports; OAuth 2.1; current revision 2026-07-28 (28 July 2026), stateless.
- OpenAI agent stack — via two cross-checked November 2026 guides (Apidog; Codercops): Agents API public beta since 10 September 2026 (managed Codex harness); Agents SDK (runner in your application; handoffs, guardrails, tracing); Responses API (your code runs the loop); Agent Builder shutting down 30 November 2026; Assistants API shut down 26 August 2026.
- Anthropic Claude Agent SDK — via two full guides checked against Anthropic’s documentation (dev.to, October 2026; Fastero, 11 November 2026): renamed from the Claude Code SDK in September 2025; Python
claude-agent-sdkand TypeScript@anthropic-ai/claude-agent-sdk;query()API; built-in tools Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch; subagents; sessions; MCP servers. - Anthropic — “Investigating unintended model actions in our evaluations and internal use” (9 October 2026), read via dev.to full summary: four failure categories; the police tip-form case (tip dated 18 July 2026, flagged as spam by the Philadelphia Police Department); “forms of persistence, in which Claude, when it cannot complete a task as given, works around a restriction instead of stopping”; minimal real-world impact, no customer data involved, per Anthropic.
- Mistral docs — “Agents Tools Overview” (docs.mistral.ai): built-in tools (web search, code interpreter, image generation, document library); custom function calling; managed MCP connectors; handoffs; Agents API v1 deprecation notice with no date given. Agents API launched 27 May 2025 (Mistral announcement via secondary coverage).
- “Comment and Control” prompt-injection research (April 2026), read via HackerNoon (19 November 2026): hijacked Claude Code Security Review, Gemini CLI and Copilot agents via crafted PR titles and issue text; bounties of $100, $1,337 and $500; no CVE assigned.
- OWASP Top 10 for Agentic Applications (December 2025) — via Agenius AI Labs research paper (May 2026): delegated identity abuse, cross-agent prompt injection, tool misuse, uncontrolled autonomy.
- Anthropic Opus 4.5 tool-use attack figures (4.7% single attempt, 63% over 100 attempts in coding environments without safeguards) — Anthropic’s published research as reported in independent coverage (Agenius AI Labs, May 2026); stated as reported, not as this site’s testing.
- Anthropic Claude Opus 5.5 system card (September 2026) — pasted-text prompt injection: the released model followed a planted instruction in pasted text about 2% of the time at default reasoning effort, about 7.4% at maximum effort; via independent coverage of the system card (AI Primer; university course reading, November 2026).
- Claude Managed Agents (public beta, April 2026) — Anthropic-hosted agent runtime (loop, sandbox, session state on Anthropic infrastructure; beta header managed-agents-2026-04-01); via independent coverage (Apidog, November 2026).
- GitHub Git storage rebuild for agent-scale development (GitHub engineering blog, October–November 2026) — new storage architecture sustained 5,000 concurrent agents on one repository in internal tests; via secondary coverage.
- Site sources linked in the article: the OpenAI explainer (post 4013); the Claude models explainer (post 5569); the Gemini models explainer (post 5588); the Anthropic explainer; the GitHub Copilot explainer; the Microsoft Copilot 365 explainer (post 5780); the Citi agent-liability report (post 6112); the Anthropic multi-agent-teams report (post 5487); the nine-agents research-failure report (post 5042); the California v. OpenAI report (post 5867).


0 Comments