Agent composability
Build AI agents from parts you can swap.
Models, tools and standards change every few months. An agent system that treats each of them as a separate part, behind an open interface, keeps working when one part changes. That is agent composability. This page explains why it is the right design for this era, with sources and with the objections.
Definition
What agent composability means
Agent composability is the ability to build an AI agent system from separate parts (models, tools, skills, sub-agents and other agents) that connect through open, shared interfaces. You can then replace one part without rebuilding the others.
This wording combines the three sources below.
“In technology, composability is the act of combining modular components to create a flexible, scalable solution that can adapt to change.”
Focus area 2: Design for composability and collaboration. No date on the page, checked 2026-10-07.
The same page names MCP and A2A as standard communication protocols for agents.
“Agent composability is the ability to build an AI system out of smaller and independent agents, tools, or resources that can be assembled, swapped, and recombined.”
What Is Agent Composability?. Published 2026-09-11, updated 2026-09-21, checked 2026-10-07.
“Consistently, the most successful implementations use simple, composable patterns rather than complex frameworks.”
Building effective agents. Published 2024-12-19, checked 2026-10-07.
01 / Why now
The model is the part that changes fastest.
For the same capability, the price of a model falls fast. Epoch AI measured declines “ranging from 9x to 900x per year”, depending on the task, and adds that it is “less clear” that the fastest drops will last. Stanford’s AI Index found that the cost of GPT-3.5-level performance “dropped over 280-fold” between November 2022 and October 2024.
Most teams do not leave their vendor. They upgrade. In a mid-2025 survey of 150 builders, 66% upgraded to a newer model from the same vendor and only 11% changed providers. Either way, the model under the system changes, again and again.
In a composable system that change is a configuration change. In a monolith it is a rewrite.
Sources: Epoch AI; Stanford AI Index; Menlo Ventures
02 / The parts
An agent is a recipe of parts.
Anthropic describes the basic building block of an agent as “an LLM enhanced with augmentations such as retrieval, tools, and memory.” Each augmentation is a part. Give each part one job and one interface, and you can replace it alone.
Source: Anthropic
Behind a gateway, not hard-coded.
A model gateway puts one endpoint in front of many providers, with fallback, logging and budgets. The application names a model in configuration.
Sources: Cloudflare AI Gateway; Vercel AI Gateway
Behind the Model Context Protocol (MCP).
MCP connects any agent to tools and data through one protocol. Stripe runs one internal MCP server, Toolshed, with “more than 400 MCP tools”, and gives each agent a curated subset.
Source: Stripe
In files and stores that you own.
Instructions in
AGENTS.md, memory in files or your own database, and retrieval on demand. Anthropic’s advice is to find “the smallest set of high-signal tokens” for each step.Sources: agents.md compatibility list; Anthropic
Packaged procedures that load when needed.
An Agent Skill is a folder with a
SKILL.mdfile. “At startup, the agent pre-loads the name and description of every installed skill”; it reads the rest only when a task needs it.Sources: Anthropic; Agent Skills overview
Workflows first, agents where they pay.
Workflows follow “predefined code paths”; agents “dynamically direct their own processes and tool usage”. The patterns combine: prompt chaining, routing, parallelization, orchestrator-workers and evaluator-optimizer. Agents can call other agents as tools or hand off a task.
Sources: Anthropic; OpenAI Agents SDK; OpenAI Agents SDK
Evaluations, traces and permissions per part.
A test set for each part, a trace for each model call and tool call, and a scoped token for each tool. Under the MCP authorization specification, servers “MUST NOT accept or transit any other tokens”.
Sources: Anthropic; OpenTelemetry; MCP specification
03 / The standards
Open standards make the parts fit.
Parts are only swappable when their interfaces are shared. Since 2024 the industry has agreed on a small set: AGENTS.md for instructions, MCP for tools and context, Agent2Agent (A2A) for agents that talk to agents, and Agent Skills for packaged procedures.
On 9 December 2025 the Linux Foundation formed the Agentic AI Foundation (AAIF) to host several of them. Anthropic counted “more than 10,000 active public MCP servers” that day. A2A joined the AAIF on 17 August 2026. No single vendor owns the interfaces, so no single vendor owns your system.
The standards page has the full table, and a dated matrix of which agents support each standard.
Sources: AAIF formation announcement; Anthropic; AAIF: A2A joins AAIF
04 / The case
Six reasons composition wins.
Adopt a better model in days, not quarters.
Anthropic: “Evals also shape how quickly you can adopt new models.” Tests per part plus a model behind a gateway make an upgrade a measured change.
Source: Anthropic
Keep your context out of any one vendor.
Forrester predicts that “vendor fragmentation will force a majority of enterprises to compose ‘agentlakes.’” Your instructions, procedures and memory are the asset. Kept in open formats, they move with you.
Source: iTWire (Forrester)
Give each part only the access it needs.
At Block, “MCP allows us to define which models can invoke which tools, and lets us annotate tools as ‘read-only’ or ‘destructive’ to require user confirmation when necessary.”
Source: Block
Build a part once, use it in every agent.
Stripe’s Toolshed serves its coding agents and its other agents from one MCP server. LinkedIn keeps a central skill registry, where “skills encapsulate both what and how”.
Sources: Stripe; InfoQ (LinkedIn)
Ride the ecosystem instead of building it.
Every MCP server, skill and A2A agent that someone else builds is a part that your system can use. GitHub’s Agent HQ runs coding agents from several vendors in one place, with an MCP registry and custom agents through AGENTS.md.
Source: GitHub
05 / The pattern
This idea has won before.
Every era of computing met the same problem and chose the same answer: small parts, one shared interface, and the freedom to replace a part without touching the rest. Agents are the latest case.
“Expect the output of every program to become the input to another, as yet unknown, program.”
Hide what will change behind an interface.
Parnas: begin with “design decisions which are likely to change. Each module is then designed to hide such a decision from the others.” Today the decision most likely to change is the model.
Source: Parnas 1972
Small programs, one universal interface.
“Make each program do one thing well.” Text streams joined the programs. For agents, tool schemas, MCP messages and
SKILL.mdfiles do the same job.Source: Bell System Technical Journal
A uniform interface lets each side evolve alone.
Fielding on REST: “Implementations are decoupled from the services they provide, which encourages independent evolvability.” He also names the cost: “a uniform interface degrades efficiency.”
Source: Fielding 2000
Components you can replace one at a time.
Lewis and Fowler define a component as “a unit of software that is independently replaceable and upgradeable.”
Source: Lewis and Fowler
From one model to compound systems.
Berkeley researchers: “state-of-the-art AI results are increasingly obtained by compound systems with multiple components, not just monolithic models.” Agent standards turn those components into parts that anyone can build and swap.
Source: BAIR
06 / In production
Teams that already build this way.
Each case below is a company describing its own system (own claims). Each one composes separate parts behind shared interfaces.
Coding agents on a shared tool server.
Minions run on a fork of goose, reach “more than 400 MCP tools” through Toolshed, mix agent loops with fixed steps (git, linters, tests) and produce “more than a thousand pull requests merged each week”.
Source: Stripe
One agent, many models, many MCP servers.
goose connects models from more than one vendor to MCP servers for Snowflake, GitHub, Jira, Slack, Google Drive and internal systems, with per-tool permissions.
Source: Block
A supervisor agent and a skill registry.
The Hiring Assistant uses a supervisor that calls sub-agents as tools, a central skill registry, an inference layer that changes models by configuration, and a grading rubric per component.
Source: InfoQ (LinkedIn)
Few tools per agent, judges calibrated against people.
Sidekick’s team found that with “50+ tools” a system becomes “difficult to reason about”, and its advice is to “Avoid multi-agent architectures early”. Composable, but simple.
Source: Shopify
A cloud sells the parts separately.
Amazon Bedrock AgentCore offers runtime, memory, gateway, identity and observability as “composable AgentCore services that can be used together or independently”, with any model or framework.
Source: AWS
07 / The objections
Composable does not mean many chatty agents.
The strongest critics of multi-agent systems are right about what they criticize. Their point is that agents which talk freely to each other fail. A composable system is a different design: one coordinator owns the decisions and the writes, and the parts behind it have narrow jobs and narrow interfaces.
Here are the objections, each with its source, and the design answer to each one.
“Running multiple agents in collaboration only results in fragile systems.”
Cognition, June 2025. In April 2026 it reported what does work: setups “where agents contribute intelligence while writes stay single-threaded.” Answer: one coordinator writes; the parts read, check and advise.
Multi-agent systems fail in 14 known ways.
The MAST study found “14 unique modes, clustered into 3 categories”: system design issues, inter-agent misalignment and task verification. Answer: typed interfaces between parts, and an explicit verification step.
Source: MAST (arXiv 2503.13657)
Independent agents multiply errors.
Google Research found that “independent multi-agent systems amplify errors by up to 17.2x”, and that on sequential planning “every multi-agent variant we tested degraded performance by 39-70%.” Answer: a central coordinator, and no split of tasks that are sequential by nature.
Source: Google Research
Multi-agent systems burn tokens.
Anthropic’s research system used about 15 times the tokens of a chat, and scored 90.2% higher than a single agent on Anthropic’s own research evaluation. Answer: split only wide, read-heavy work; send small steps to small models.
Sources: Anthropic; Microsoft Learn
Every new part is a new door.
In tool poisoning, “malicious instructions are embedded within MCP tool descriptions that are invisible to users but visible to AI models.” Simon Willison warns that MCP “encourages users to mix and match tools from different sources”, and names a lethal trifecta: private data, untrusted content and external communication. This is the strongest objection. Answer: pinned versions, scoped tokens per part, and no single agent that holds all three.
Sources: Invariant Labs; Simon Willison
Most agent projects may not survive.
Gartner predicts that over 40% of agentic AI projects will be canceled by the end of 2027. Answer: small parts with a test and a cost each show early which part fails, before the whole project does.
Source: W.Media (Gartner)
Teams rarely switch, and agents make switching harder.
a16z found that “the rise of agentic workflows has started making it more difficult to switch between models.” That is the case for composability, not against it: the cost of a switch comes from tight coupling.
Source: a16z
Better models will make scaffolding obsolete.
Sutton’s bitter lesson: “general methods that leverage computation are ultimately the most effective, and by a large margin.” Answer: keep the model layer swappable and the scaffolding thin, so that each better model makes the system better without a rebuild.
Source: Sutton
08 / The checklist
Ten checks for a composable agent system.
A gateway sits between your code and the models.
A model change is a configuration change, with fallback.
Source: Cloudflare AI Gateway
Instructions and memory live in files you own.
Source: agents.md compatibility list
Fixed code steps wrap the agent loops.
Tests, linters and checks run as code, not as prompts.
Source: Stripe
Every part has an evaluation before you swap it.
Source: Anthropic
Every model call and tool call leaves a trace.
Source: OpenTelemetry
Every agent has its own identity and scoped access.
Destructive tools need a human approval.
Sources: MCP specification; Block
Questions
Short answers
What is agent composability?
Agent composability is the ability to build an AI agent system from separate parts that connect through open, shared interfaces. You can replace one part without rebuilding the others. Amazon Web Services describes composability as “the act of combining modular components to create a flexible, scalable solution that can adapt to change.”
Sources: AWS Prescriptive Guidance; Atlan
Why is composability the right design for AI agents now?
Because the parts change faster than the systems. Epoch AI measured model price declines “ranging from 9x to 900x per year”, depending on the task, and most teams upgrade their model within months. A system built from parts with open interfaces takes each new model, tool or standard as a configuration change instead of a rewrite.
Sources: Epoch AI; Menlo Ventures
Does a composable agent system mean many agents?
No. A composable system can have one agent. What makes it composable is that its model, tools, context and skills are separate parts behind shared interfaces. When a system does use several agents, the designs that work keep one coordinator that owns the writes: Cognition reports that what works is “where agents contribute intelligence while writes stay single-threaded.”
What does “composable agents” mean?
Composable agents are agents that you build as independent units, so that you can combine, swap and reuse them. Amazon Web Services states the goal like this: “Let me build agents like I build services – modular and testable, so that they can be composed and orchestrated as needed.” In practice, an orchestrator agent can split a task and send the parts to specialized sub-agents.
Sources: AWS Prescriptive Guidance; Atlan
Is composability the same as interoperability?
No, but the two are linked. Interoperability lets independent agents discover one another, communicate and exchange work across systems. Composability is the design property that uses this: you build a system from parts that you can combine and replace.
Sources: AAIF: A2A joins AAIF; Atlan; AWS Prescriptive Guidance
How do MCP and A2A differ?
MCP connects an agent to tools, data sources, applications and services. A2A connects agents to other agents, so that they can discover one another, delegate tasks and exchange results. The A2A project calls the two protocols complementary: “A2A connects the agents to each other; MCP connects each agent to its own tools.”
What are Agent Skills?
Agent Skills are “a lightweight, open format for extending AI agent capabilities with specialized knowledge and workflows.” A skill is a folder with a SKILL.md file that holds metadata and instructions, and it can also hold scripts and other resources. At startup, an agent loads only the name and description of each skill, and it reads the full instructions when a task needs them.
Source: Agent Skills overview
Next
Want this designed for your company?
We design composable agent systems for companies in the United States: models you can swap, tools behind open standards, context you own and permissions you can audit. Your team owns the result.