All chapters
  1. Start hereA protocol standardizes the call. It does not grant the permission
  2. Foundations · 1The primitive: a function, its arguments, its result, its side effects
  3. Foundations · 2Function calling: the model asks, your application executes
  4. Foundations · 3Client and server: process boundaries, JSON-RPC, errors and trust
  5. Foundations · 4What MCP is: host, client, server and what the protocol promises
  6. Protocol · 5Three surfaces: tools act, resources inform, prompts guide
  7. Protocol · 6A first MCP server: typed input, deterministic data, the raw exchange
  8. Protocol · 7Java and the SDKs: typed DTOs, validation and interoperability
  9. Protocol · 8Local or remote: stdio, HTTP, stateless requests and availability
  10. Platform · 9The database decision: direct SQL, a service boundary or an MCP adapter
  11. Platform · 10Sharing across teams: ownership, catalogs, contracts and versions
  12. Platform · 11Who gets access: users, agents, delegation and least privilege
  13. Platform · 12Enterprise authorization: tokens, audiences, gateways and no passthrough
  14. Platform · 13The threat model: injection, poisoned tools, confused deputies and egress
  15. Platform · 14Governance: who may publish, who approves, who answers the page
  16. Operations · 15Observability and audit: what was called, by whom, and why it was allowed
  17. Operations · 16Resilience: timeouts, retries, idempotency and overload at a shared server
  18. Operations · 17Testing and evaluation: contracts, authorization matrices and injection
  19. Reference · 18Advanced MCP: long tasks, large catalogs, tenants and evolving versions
  20. Reference · 19The ecosystem: SDKs, registries, gateways, identity and telemetry
  21. Reference · 20Enterprise reference architecture: one assessment platform, four teams
  22. Reference · 21Decision playbooks: function, API or MCP, and the records that explain why
  23. ReferenceGlossary
  24. AboutAbout this site and its sources
Reference · 18

Advanced MCP: long tasks, large catalogs, tenants and evolving versions

Work that outlives one request, catalogs too large to show, filtering per client, dynamic catalogs and their risk, isolation between tenants, version evolution, and where MCP ends and A2A begins.

You will understand
How work that outlives one request fits a stateless protocol: the Tasks extension, and how extensions enter and leave MCP.
You will be able to design
A shared server with hundreds of tools, many business units and several clocks of versions, without losing control of what each caller sees.
You will be able to tell apart
Calling a capability over MCP and delegating a goal to another agent over A2A, and why one does not replace the other.

Submission SUB-1004 is stuck where the series case UW-004 always leaves it. The application says the roof is 9 years old; the roof-data provider says 22 (evidence EV-ROOF-0412). Rule R-ROOF-03 sees a 13-year gap and the outcome is escalate. The underwriter reads the recommendation in the cockpit and wants one more fact before deciding: a physical roof inspection of PROP-2207.

The underwriting team asks the uw-assessment maintainers for a tool, request_roof_inspection(submission_id). The first draft is an ordinary tool: the call books an inspector through the scheduling system and returns the booking. In testing it works. In the claims team's host it fails every time, because booking an inspector can take hours of back and forth, and the host's HTTP client gives up long before the scheduling system answers. Nothing is wrong with the tool's logic. The shape of the call is wrong for the work.

Two more problems arrive in the same meeting. Three other domains want to publish on the same platform, so the claims host would soon be offered several hundred tools. And the claims host's administrator approved three tools last month; nobody can say what happens if a fourth appears tomorrow. This reference chapter takes the problems in order, then draws the line between a tool call and handing a goal to another agent. It deepens Sharing, Who gets access and Local or remote.

In our insurance agent. request_roof_inspection is hypothetical and not in the example's code. What this page runs comes from examples/uw-mcp/ in a scratch copy; the model there is a scripted stand-in, so these results show how the protocol and the controls work, not how good any model is.

Work that outlives one request#

A long-running task is an operation whose result arrives long after the request that started it, so the caller needs a way to come back for it. A tiny example: "book a roof inspection for PROP-2207" may take two days; the caller needs a reference it can ask about tomorrow.

Before AI. A REST endpoint answers 202 Accepted with a job id and a status URL; the client polls until the job finishes, or a webhook calls back. Nobody holds an HTTP connection open for two days.

Why not hold the request open? Normative (MCP specification 2026-07-28): the changelog removed stream resumability, so a broken stream loses the in-flight request and the client must re-issue it with a new request id (changelog). Any proxy timeout or deploy loses an hours-long call, and for a booking, the re-issued call is exactly the duplicate write the Resilience page warns about.

The protocol's answer is an extension. An MCP extension is an optional, named addition to the protocol that both sides must declare before either may use it; until both do, they speak only the core. A tiny example: a client that wants task results adds io.modelcontextprotocol/tasks to the capabilities it sends with each request.

The Tasks extension, as documented on 2026-11-18#

Ecosystem pattern (official MCP extension): revision 2026-07-28 moved tasks out of the core into the extension io.modelcontextprotocol/tasks, which lets a server answer with a durable handle instead of the result. From its overview page (Tasks overview):

  1. The client declares the extension in every request's capabilities; the server advertises it in server/discover.
  2. For a supported request such as tools/call, the server decides whether to create a task. If so, it returns a CreateTaskResult (resultType "task") with a taskId, an initial status, ttlMs and a suggested pollIntervalMs, durably created before the response is sent.
  3. The client polls with tasks/get. When the status is input_required, the response carries an inputRequests map, answered with tasks/update.
  4. On completed, result holds what the original request would have returned; on failed, error holds the JSON-RPC error. tasks/cancel is cooperative.

The statuses are working, input_required, completed, failed and cancelled; the last three are terminal. Polling is the default; notifications/tasks can push status to clients that opened subscriptions/listen. The smallest primitive is the client's declaration, in the shape the overview shows:

{
  "jsonrpc": "2.0", "id": 7, "method": "tools/call",
  "params": {
    "name": "request_roof_inspection",
    "arguments": {"submission_id": "SUB-1004"},
    "_meta": {
      "io.modelcontextprotocol/protocolVersion": "2026-07-28",
      "io.modelcontextprotocol/clientCapabilities": {
        "extensions": {"io.modelcontextprotocol/tasks": {}}
      }
    }
  }
}

Documented shape; not run here. The example's server does not implement Tasks, and this page read the extension's overview and its repository README, not its method schemas, so it shows no full CreateTaskResult or tasks/get response.

Diagram: A long booking as a task · the client polls a durable handle instead of holding the request open

Time runs down the page. The host's client declares the Tasks extension in the request. The server decides the booking will be long and answers at once with a task handle. The client polls; the server asks for one more piece of input in the middle; the client answers through tasks/update; the final poll returns the booking. The tool is hypothetical and the example's server does not implement Tasks: this is the documented shape from the extension's overview page.

  1. Host's MCP client to MCP server: tools/call request_roof_inspection SUB-1004 (declares tasks). The client capabilities in _meta list the Tasks extension; without it the server must not return a task.
  2. MCP server to Scheduling system: start booking job. The job is created durably before the server answers.
  3. MCP server to Host's MCP client: CreateTaskResult · resultType task · taskId, working, ttlMs, pollIntervalMs. An immediate answer with a handle, not the booking.
  4. Host's MCP client to MCP server: tasks/get taskId. A poll, at the suggested interval. The server checks the caller's token and tenant against the task's owner.
  5. MCP server to Host's MCP client: input_required · inputRequests. The booking needs one more answer, for example which contact the inspector should call.
  6. Host's MCP client to MCP server: tasks/update taskId · inputResponses. The client answers. A decision on the submission is never asked for here; that stays with the underwriter in the cockpit.
  7. Scheduling system to MCP server: booking confirmed. Hours later, in this illustration.
  8. Host's MCP client to MCP server: tasks/get taskId. The next poll.
  9. MCP server to Host's MCP client: completed · result. The result is what the original tools/call would have returned. completed, failed and cancelled are terminal.

Two design facts matter more than the field names. The server decides per request whether to create a task, and the client must handle whichever shape arrives. And the server must never return a task to a client that did not declare the extension, so request_roof_inspection needs a second path for other hosts, such as the handle pattern in the first folded block below.

What stage is it in? The sources disagree. The extensions overview lists MCP Tasks as "Beta, to Core": in Beta, intended for the core specification (extensions overview). The ext-tasks README labels its 2026-07-28 schema "Stable" and its draft schema "Development" (ext-tasks). This page treats Tasks as Beta, because the overview defines the lifecycle. Support is uneven too: the Python SDK's v2 notes say it does not implement the extension yet (what's new), and no SDK tier requires extensions.

Security note. The security best practices say a server implementing authorization must verify every inbound request and must not treat possession of a state handle as authentication (security best practices); the Tasks overview does not say how a task is bound to its caller. This site's recommendation: store the creating principal, client and business unit with each task and check them on every tasks/get, tasks/update and tasks/cancel, so a guessed foreign taskId gets the same answer as a missing one.
Common confusion. input_required is not a place for the underwriter's decision. The decision on SUB-1004 still goes through record_underwriter_decision, from the cockpit, with the underwriter's own token. The model recommends; a person decides.

Multi round-trip requests, in brief#

Not every pause needs a task. Normative (MCP specification 2026-07-28): a server that needs input inside one request returns resultType "input_required" with input requests and/or an opaque requestState; the client retries with a new JSON-RPC id, the answers and the echoed state; the server must treat requestState as attacker-controlled and integrity-protect it when it influences authorization (multi round-trip requests). It is a short exchange inside one logical call; a task is a stored job that survives the client going away. Local or remote owns the pattern.

How a feature enters and leaves the protocol#

The Tasks story shows that MCP is no longer one document. Some features live in the core specification; others live in extensions with their own repositories and their own stages, and the two change on different rules. Ecosystem pattern (MCP extension lifecycle, as documented on 2026-11-18): every extension is Experimental (anything may change, nothing is promised), Beta (real usage welcome, breaking changes rare and documented) or Stable (changes only with a new core protocol revision); extensions are disabled by default and need explicit opt-in (extensions overview). Normative (MCP specification 2026-07-28): if only one side supports an extension, the supporting side must fall back to core behavior or reject with an error (versioning).

One rule on the overview page catches platform teams out: an extension's identifier does not change when its stage changes, so the name alone does not say how stable it is. What MCP is recommends listing approved extensions in each server's catalog entry; record the stage and revision next to each one. The folded block on extension stages below gives the full lifecycle and what promotion into the core means.

Discovery at scale: when the list is too long to show#

Back to the second problem. Today the claims assistant sees three tools. If the platform puts four domains' servers behind one endpoint, a naive host would fetch every list and hand the model several hundred tool definitions.

That breaks in three ways. The definitions fill the model's context window on every turn (context.sammuthu.com owns that subject). Lookalike tools (get_assessment, get_roof_assessment) make the model's choice less reliable. And every extra description is text from another team that the model reads as guidance (Threat model). None of this is a protocol limit; it comes from treating "everything the server has" and "what this model needs now" as one list.

Tool-list filtering is narrowing the list of tools a caller is shown to the ones it may and should use, by its identity, its client and its task. A tiny example: the support desk's host is shown one tool, get_assessment_status, out of the server's seven.

Normative (MCP specification 2026-07-28): the tool list must not vary per connection but may vary by the authorization presented on the request, for example returning only the tools the caller's granted scopes permit; lists are paginated with an opaque cursor; servers should return tools in a deterministic order; and list results carry ttlMs and cacheScope, where a private result must not be shared across authorization contexts (tools, pagination).

The example does the first filter. The script below, written for this page and run in a scratch copy on 2026-11-18, asks the example's policy.discover what four clients see from the same catalog. A successful run proves that one catalog yields a different list per identity; it does not prove that a host would choose well among them.

"""Scratch demo for the advanced page: per-client lists, and a catalog that changes after approval."""
import copy

from catalog import PROMPTS, RESOURCE_TEMPLATES, RESOURCES, TOOLS, _tool
from clock import SimClock
from identity import claims_for
from policy import discover

clock = SimClock()
catalog = {"tools": copy.deepcopy(TOOLS), "resources": RESOURCES,
           "resource_templates": RESOURCE_TEMPLATES, "prompts": PROMPTS}

# 1. Each client sees its own list from the same catalog.
for who in ["underwriting-agent", "claims-assistant", "support-desk", "analytics-jobs"]:
    print(f"{who:20} {discover(claims_for(who, clock), catalog)['tools']}")

# 2. Approval: the claims host's administrator approves the list it saw today.
approved = set(discover(claims_for("claims-assistant", clock), catalog)["tools"])

# 3. Later, a new read tool with scope uw.read is published to the same server.
catalog["tools"].append(_tool(
    "get_inspection_slots", 1, "Inspection slots", "List open roof-inspection slots for a property.",
    {"property_id": {"type": "string", "pattern": "^PROP-[0-9]{4}$"}}, ["property_id"],
    scopes=["uw.read"], kind="read", data_class="schedule", risk_tier="low",
    owner_team="inspection-scheduling", tenant_arg=None))

served = set(discover(claims_for("claims-assistant", clock), catalog)["tools"])
print("added since approval:", sorted(served - approved))
print("removed since approval:", sorted(approved - served))
underwriting-agent   ['get_roof_assessment', 'search_guidance', 'check_eligibility', 'record_recommendation']
claims-assistant     ['get_roof_assessment', 'search_guidance', 'check_eligibility']
support-desk         ['get_assessment_status']
analytics-jobs       ['get_assessment_stats']
added since approval: ['get_inspection_slots']
removed since approval: []

The first four lines are the identity filter: scopes, principal type and lifecycle state decide each list, in catalog order. At scale it is not enough. A claims assistant with uw.read on four domains may legitimately see dozens of reads, and its model needs only the few that fit a storm claim. That second narrowing is the host's decision; the protocol leaves it to the host.

Diagram: Narrowing the list in three stages · every stage narrows, none of them authorizes

Read left to right. The catalog holds every tool of every domain. The server filters by the token's authorization and the tools' lifecycle states. The client's declared capabilities decide which result shapes the server may send. The host picks the few tools this task needs. At the far right the server still checks every call as if no list had been sent, which is case UW-M03.

  1. Platform team · catalog
    1. Catalog of every domain: Every tool with owner, scopes, state and approved consumers. Lists are generated from it.
  2. MCP server · authorization filter
    1. Filter by token: The specification allows the list to vary by the authorization presented. The result is marked cacheScope private and paginated.
    2. Respect declared capabilities: The server tailors result shapes to what this client declared, and returns -32021 when a needed capability is missing.
  3. Host · selection for this task
    1. Pick the few the model sees: The host offers its model a small subset and holds back anything added since the consumer's approval.
  4. MCP server · execution
    1. Authorize every call: Scope, principal type and tenant are checked on each tools/call, whether or not the tool was in the caller's list.

Every stage in the diagram narrows; none of them authorizes. The server still checks each tools/call as if no list had been sent. That is this site's own case UW-M03: the intake agent calls record_recommendation by name although the tool was not in its list, and the call is refused at execution.

Per-client feature negotiation#

Because the client's capabilities ride in _meta on every request, the server can tailor each answer to what this client can handle. Normative (MCP specification 2026-07-28): if a request needs a client capability the client did not declare, the server must return MissingRequiredClientCapabilityError (-32021), HTTP 400 (base protocol). This site's recommendation: treat a declared capability as a statement about the client's code, not the caller's permission. A client that can poll a task is not thereby allowed to start a two-day booking; keep the two checks separate and log both.

A catalog that changes after approval#

Look again at the last two lines of the output. The claims host's administrator approved three tools. The platform team later published get_inspection_slots under uw.read, and because the claims assistant holds uw.read, the tool appears in its list without anyone at claims deciding anything.

A dynamic catalog is a catalog whose contents change while consumers are connected: tools are published, deprecated, retired or edited. A tiny example: Tuesday's list for the claims assistant has a tool that Monday's did not. Normative (MCP specification 2026-07-28): a server that declares listChanged should notify clients listening with toolsListChanged (tools). The protocol makes change visible. It does not ask anyone to approve it.

A new read tool from a reviewed team is mostly harmless. The same mechanism carries an edited description that tells the model to call a write tool, or a read tool whose code starts writing; done on purpose, that is the rug pull the Threat model shows how to detect with fingerprints. Here the concern is the honest version: uw.read was approved as "may read assessment data", and a dynamic catalog quietly turned it into "may call whatever any team publishes under uw.read".

Production pitfall. A broad scope plus a dynamic catalog is an approval that grows by itself. Nothing was misconfigured in the demo; the approved set and the served set differ, and that is all.

This site's recommendation: approve sets, not scopes alone. Store each consumer's approved tools and definition fingerprints in the catalog; have the gateway or host compare every fetched list with it; hold back anything added or changed until the consumer application owner approves it. Scopes decide what a caller may do; the approved set decides what its model is offered.

Many business units on one server#

The insurer runs commercial-west and commercial-east on one uw-assessment, and Who gets access shows the per-call tenant check (case UW-M11: SUB-2001 answers not_found, like a missing submission). Here the question is broader: should two business units share one server at all?

Tenant isolation is the property that one tenant's data, limits and failures stay invisible to the others. Sharing a server makes it a matter of code: every check, cache, task and counter must carry the tenant. Separate deployments make it a matter of infrastructure, at twice the operations. A noisy neighbour is a tenant whose load degrades the service for the others: a month-end analytics run for commercial-east fills the connection pool, and commercial-west underwriters see timeouts. Per-client rate limits do not protect resources the limiter does not count (Resilience).

This site's recommendation: share the server when the units share the domain rules and the data owner, as the two commercial units do, and test the tenant check per tenant. Separate the deployment when a regulator, a contract or a different data owner requires that one unit's data never be reachable with the other's credentials. The folded block on tenancy compares the two.

Versions evolve on three clocks#

Version evolution is the managed change of a capability's contract over time on three independent clocks: the tool's own versions, the protocol revisions it speaks and the extensions it uses. A tiny example: get_roof_assessment moved from version 1 to version 2 in September while the protocol revision stayed 2026-07-28. Most version incidents come from confusing the clocks.

The tool's clock belongs to the domain: this site's own case UW-M07, where a version-1 client meets version 2 and gets invalid_arguments naming the deprecated version, is run and discussed on Sharing. The protocol's clock belongs to the MCP project. Normative (MCP specification, versioning page): a version string is a date marking the last backwards-incompatible change; a deprecated feature remains for at least twelve months, or at least ninety days under the expedited-removal exception, before it may be removed in a future revision (versioning). Revision 2026-07-28 itself deprecated Roots, Sampling and Logging, among others. The extension clock sits between the two, and each SDK adopts all of it on its own schedule (Java and SDKs).

ClockWho moves itSignal on the wireWhat a platform does
Tool versionthe domain, through the server maintainersnone in MCP; the catalog and the error textcount calls per version; retire at zero
Protocol revisionthe MCP projectprotocolVersion in _meta; -32022 lists supported versionslog it per request; give dual-era periods an end date
Extension revisionthe extension's maintainersthe settings object and its revision stringapprove per server in the catalog; pin the revision

Diagram: Three clocks of change · each has its own owner, signal and window

Rows are the three clocks on which a shared capability changes. Columns say who moves the clock and how a client finds out. Most version incidents come from treating one clock as another: a tool version is not a protocol revision, and an extension revision is neither.

  1. Tool version
    1. Assessment domain: The domain decides that get_roof_assessment v2 takes submission_id; the maintainers ship it; the platform team updates the catalog.
    2. Catalog + error text: MCP's Tool definition has no version field. The client learns from the catalog, the announcement, or the error when it calls the wrong shape.
  2. Protocol revision
    1. MCP project: A revision date marks the last backwards-incompatible change. Deprecated features stay at least twelve months, or ninety days under the expedited exception.
    2. Version in every request: Each request names its revision in _meta; a server that does not support it answers with the versions it does.
  3. Extension revision
    1. Extension maintainers: Beta extensions change when their maintainers document it; Stable ones only with a new core revision.
    2. Settings object: A Beta extension that breaks compatibility should add or increment a revision string; a peer that does not know it should not enable the extension.

This site's recommendation: give every clock an owner and a dashboard (domain: tool versions; platform team: revisions and extensions; each consumer application owner: its SDK), and announce every deprecation to the consumers found in the audit events.

MCP or A2A: calling a capability or delegating a goal#

Return to the inspection. There are two honest designs. In the first, booking is a capability: the scheduling team publishes request_roof_inspection on an MCP server, the caller chooses the tool and arguments, and the server does one bounded job (as a task, because it is long). It has no goals of its own. In the second, booking is another agent's job: an inspection-scheduling agent, owned by another team or company, accepts a goal ("get a roof inspection for PROP-2207 booked within ten business days"), plans the work, may ask the broker questions and reports back over days. The underwriting agent delegated a goal; it did not choose the steps.

A2A, the Agent2Agent protocol, is a protocol for that second case: agents built on different frameworks discovering each other's capabilities and working on tasks together. Ecosystem pattern (A2A, as documented on 2026-11-18): originated by Google and donated to the Linux Foundation; latest released specification 1.0.0; core objects include an Agent Card (published metadata about an agent) and a Task with its own lifecycle (A2A specification). Its own comparison page calls the protocols complementary: MCP connects an agent to its tools, A2A connects agents to each other, and "Used together, MCP gives each agent depth, and A2A gives your system reach." (A2A and MCP).

What this is not. This page owns the comparison, not A2A. Agent Cards, A2A task states, streaming and push notifications are taught at https://a2a.sammuthu.com. The runtime that holds an agent's loop around both kinds of call is at Harness Engineering.

The lab steps through both paths: the example's real remote tool call, and a conceptual delegation with no A2A field or method names.

AspectMCPA2A (conceptual)
What is calleda capability (a tool, a resource, a prompt)another agent with its own goals
Durationone request, one result (long tasks via an extension)a task that can run long
Who decides howthe caller chose the tool and the argumentsthe other agent plans the work
Identitytoken for the MCP server's audience, checked per requestboth agents need identities and a trust decision
Replaces the other?nono: an agent reached by A2A may use MCP tools inside

In both paths the underwriter still decides the submission: delegation moves work, not authority.

The same step lists come from mcpa2a.py in the example. A short script, run in a scratch copy on 2026-11-18, prints who acts at each step and what standardizes it. It demonstrates that the two paths standardize different things; it runs nothing on the A2A side.

"""Scratch demo for the advanced page: print the two step lists of mcpa2a.py."""
from mcpa2a import A2A_STEPS, MCP_STEPS

for title, steps in (("MCP tool call", MCP_STEPS), ("Delegated task (conceptual)", A2A_STEPS)):
    print(f"== {title} ==")
    for s in steps:
        print(f"{s['n']}. {s['actor']:26} {s['standardized_by']}")
== MCP tool call ==
1. host's MCP client          MCP (method, result shape); OAuth (the token)
2. MCP server uw-assessment   MCP allows the list to vary by authorization; the filter is ours
3. model                      not MCP: the model provider's tool-use format
4. host's MCP client          MCP
5. MCP server uw-assessment   this site's design (the protocol carries the call)
6. MCP server uw-assessment   MCP
7. host application           host behavior
== Delegated task (conceptual) ==
1. underwriting agent         an agent-to-agent protocol (conceptual here)
2. underwriting agent         conceptual: a task with a goal, not a function call
3. inspection agent           the other agent's own logic and its own tools
4. inspection agent           conceptual: long-running task state
5. inspection agent           MCP may appear inside the other agent
6. inspection agent           conceptual
7. underwriter                this site's rule: the model recommends; a person decides

On the MCP path the protocol carries the call and the site's own design does the authorization (step 5). On the delegated path, step 3 is the point: the other agent's own logic decides how. And step 5 there shows that MCP does not disappear when A2A arrives.

Diagram: Calling a capability or delegating a goal · the same inspection, two designs

Columns are the two designs for the roof inspection of PROP-2207. Rows ask who chooses the steps, how long it runs, what identity is checked, and where the other protocol appears. On the right, the inspection agent may use MCP for its own tools: A2A connects agents, MCP connects each agent to its tools. The A2A column is conceptual and uses no A2A field names.

  1. Who chooses the steps
    1. The caller: The underwriting agent's model wrote request_roof_inspection for SUB-1004; the server does one bounded job.
    2. The other agent: An inspection-scheduling agent accepts a goal and decides how to reach it, including whom to ask.
  2. How long, how tracked
    1. One request: Long work becomes a task with a taskId the client polls; still one bounded operation.
    2. A task that runs long: The delegated task carries its own state over hours or days, with progress reports.
  3. Identity checked
    1. Token for the server's audience: The server validates the caller's token on every request and uses a separate token downstream.
    2. Two agents, two identities: Each agent is its own principal; the delegating side never hands over its own token.
  4. The other protocol
    1. No A2A needed: Behind the MCP server is ordinary code: the scheduling system's API.
    2. MCP inside the agent: The inspection agent may book the slot through its own MCP servers. Neither protocol replaces the other.
Common confusion. "MCP has tasks now, so it covers delegation." MCP's Tasks extension turns one request into a durable job run by the server the caller chose; A2A's task is work handed to an agent that plans it, with its own separate set of states. Decide by who plans the work, not by how long it takes.

This site's recommendation: use MCP when your side decides what should happen and needs another system to do one bounded thing, even a long one. Use an agent-to-agent protocol when another party decides how a goal is reached and must be trusted as an actor in its own right: for the insurer, a third-party inspection company running its own agent.

What goes wrong without these ideas#

Missing ideaWhat happens
Long work as a taska proxy timeout loses the held request; the re-issued booking makes a second appointment
Authorization on task handlesa guessed taskId reads another unit's booking, bypassing the check that protects SUB-2001 (UW-M11)
Filtering in stages, execution check under allthe model picks a lookalike among hundreds; with the call check off, an unlisted tool runs (UW-M03: one row written)
Approved setsa new tool under a broad scope reaches every consumer's model without review
Three version clocksa tool version is retired while a slow consumer still calls it, or a revision upgrade strands legacy clients
MCP versus A2A judgmentan agent with its own goals is approved as if it were one bounded tool call

Security and governance notes#

Security note. Each idea on this page creates a new place where a check can be missed: a task handle, a page of a list, a capability flag, a cache entry, a delegated agent. Apply one rule to all of them: authorize the principal on every request that touches data, with the same tenant check, and never let a handle, a cursor, a declared capability or an Agent Card stand in for a token.
Governance note. Allowed extensions, approved tool sets, tenancy and version end dates are platform decisions: record them in the catalog and in decision records (Playbooks). Delegating to an outside agent is a new third-party relationship and gets the same review as a third-party server (Governance).
In a coding agent. A CI run is the classic long task: a repository server could return a task for run_ci instead of holding a call open for twenty minutes (an illustrative duration). A company server with hundreds of repository and tracker tools needs the same staged narrowing and an approved-set check, so a new open_pull_request variant does not reach every developer's agent overnight. Handing a whole migration to an agent that plans and opens many pull requests is delegation, not a tool call; Diff to Deploy follows the review path those pull requests take.

Checklist for Monday#

CheckPass when
Long workanything that can outlive a client timeout returns a task or a handle, never a held request
Task handlesevery task operation re-checks principal, client and tenant; unknown and foreign ids get the same answer
Extensionseach catalog entry lists allowed extensions with stage and revision; no Experimental ones in production
Lists and callslists are filtered on the server and marked private; every call is authorized as if no list was sent
Approved setseach consumer's approved tools and fingerprints are stored; additions are held until approved
Tenancy and versionsthe share-or-separate decision is recorded; revisions and tool versions are logged per request with owners
Delegationa goal handed to another agent is reviewed as an agent relationship, not as a catalog tool

Exercises#

  1. The scheduling team proposes that request_roof_inspection block until the booking is confirmed, "because the claims host can raise its timeout". What do you answer, and what do you offer instead?
  2. The analytics team holds analytics.read on uw-assessment. A new domain team publishes get_inspection_costs under analytics.read. What does the analytics host's model see tomorrow, and what should have happened?
  3. A partner company offers an "inspection agent" that accepts goals and books inspectors on its own. The underwriting team wants to add it to the tool catalog as book_inspection. Is that the right shape?
AnswersOne line each
  1. A held request is lost on any timeout or deploy and a re-issued booking duplicates it; offer a task for hosts that declare the Tasks extension and a handle plus a status tool for the rest, with a booking idempotency key either way.
  2. The new tool appears in its list because the scope matches; it should have been held by an approved-set check until the analytics application owner approved it.
  3. Not as a tool: it plans its own work and acts for another company, so it is delegation; review it as an agent-to-agent relationship with its own identity and trust decision, and keep the underwriter's decision out of its reach.
Tasks extension, a handle tool, or a job API?Three ways to offer long work over MCP, and what each costs

The Tasks extension is the protocol's own answer. Its strength is that the long-running shape is visible to the client: the host knows it holds a task, can poll at the server's suggested interval, can answer mid-flight input through tasks/update and can cancel. Its costs are maturity and support. As read on 2026-11-18 its stage is Beta on the extensions overview (the repository README says Stable for the 2026-07-28 schema), the official Python SDK v2 says it does not implement it yet, and no SDK tier requires it. A server that returns tasks must also keep a second path for clients that did not declare the extension.

The handle pattern works in core MCP today. request_roof_inspection returns at once with a booking reference, and a second tool, get_inspection_status(booking_id), reports progress. The tools page describes this shape in a section it marks non-normative: the server returns an explicit handle that the model carries into later calls, and "a handle is a name, not a capability", so the server authorizes against it on every call. The cost is that polling becomes the model's job: the model must remember the reference and decide when to ask again, and each status call spends a turn. It also mixes a mechanical concern (is the job done?) into the model's reasoning.

A job API outside MCP is the pre-AI answer and still often right. The scheduling system already has a REST endpoint that answers 202 Accepted with a job id and calls a webhook when done. The host application, not the model, can drive it: the model requests the inspection through one short tool call, the application registers the webhook, and the result re-enters the conversation when it arrives. This keeps the waiting out of the protocol and out of the model's context, at the price of host-specific code.

This site's recommendation: for a shared server with several hosts, offer the handle pattern as the baseline every client can use, and add a task path for hosts that declare the extension once the platform has approved its stage. Inside one application that owns both sides, prefer the job API driven by the application. In all three, the booking itself needs an idempotency key, because the start request can be retried.

Hundreds of tools: where to narrow the listServer filtering, host selection, split servers and gateway views compared

Four places can narrow what the model sees, and a platform at scale uses several of them.

Server filtering by authorization is the only one the specification names, and it is the cheapest to get right because the server already knows the caller's scopes and the catalog's states. It cannot know the task. A claims assistant with uw.read across four domains is entitled to dozens of reads, and the server has no basis to pick the three that fit a storm claim.

Host selection per turn is where the task is known. A host can group tools by domain and expose one group at a time, or let the model search a tool index and load only the definitions it asks for. Some model providers document such a search mechanism for their own tool-use APIs; that is provider behavior outside MCP, described at Tools Engineering and not repeated here. The risk is that a selection step is itself a model decision; a lookalike tool can still win.

Splitting servers by domain (one server for assessment, one for inspection scheduling) keeps each list short and each owner clear, and lets a host connect only what a workflow needs. The cost is more connections and more tokens with different audiences. The specification's tool-name rule asks aggregating clients to disambiguate colliding names, for example by a server prefix, which matters once a host connects several servers.

A gateway can present a curated view per consumer: one endpoint whose list is the consumer's approved set across many servers. This combines well with the approved-set recommendation above, and it is the usual reason platforms adopt gateways (Ecosystem describes the pattern without naming products). The danger is that the gateway's view becomes a second catalog that drifts from the real one; generate it from the catalog, never edit it by hand.

None of these is authorization. Whatever narrowing runs, the server checks each call, and UW-M03 must keep passing.

Tenancy in depth: what has to carry the tenantChecks, caches, tasks, metrics, keys and the downstream token on a shared server
ConcernShared server, tenant in every checkSeparate deployment per business unit
Data isolationthe tenant check on every call, resource read and task pollnetwork and credentials; a code bug cannot cross units
Cacheslists and results marked cacheScope private; keys include the token's contextseparate by construction
Noisy neighboursrate limits per client and tenant; shared threads or connections can still run outone unit's load cannot reach the other
Releasesone release for all units; a bug reaches everyoneunits upgrade on different days, and drift apart
Operationsone server to run, observe and patchseveral servers, rotations and catalogs to keep in step
Cross-unit workanalytics-jobs with business unit all reads aggregates in one callneeds a separate aggregation path

A shared server is isolated only if every place that holds or derives data carries the tenant. The example covers the call path: the business unit comes from the signed token, the owner of a submission from the service's data, and a foreign submission answers like a missing one. A production server has more places.

Caches: list results that vary by caller are marked cacheScope private, and the specification says a private result must not be shared across authorization contexts. Result caches inside the server need the tenant in the key too; a cache of get_roof_assessment keyed only by submission_id is a cross-tenant leak waiting for an id collision or a bug in the check.

Tasks and handles: a task created by commercial-west must be invisible to commercial-east, and its result must be re-checked on read, because a submission can move between units while a two-day booking is running.

Metrics and audit: per-tenant counters let a noisy neighbour be seen; per-tenant audit queries let a unit's compliance team review its own evidence without seeing another unit's.

The downstream token: the example's token exchange yields a downstream token with one scope for the assessment service. If the service itself is multi-tenant, the exchanged token should carry the tenant so that the service enforces it again; the server's check alone is one bug away from a leak. Who gets access argues the same for the database.

Resource limits: a token bucket per client limits calls, not cost. One analytics call over all may be far heavier than a claims lookup. Bulkheads (separate pools per tenant or per client class) bound the damage a heavy caller can do to shared threads and connections.

When the list above becomes long and the regulator's question is "can a defect in your code expose east's data to west?", a separate deployment answers it with infrastructure instead of tests. That is the honest trigger for separating.

Extension stages, and promotion into the coreThe lifecycle as documented, and what changes on the day Tasks becomes core behavior

As documented on 2026-11-18, extensions are identified as {vendor-prefix}/{extension-name}; official ones use io.modelcontextprotocol and live in ext- repositories, where the directory (specification/experimental/, beta/, stable/) shows the stage; experimental work may also live in experimental-ext- repositories.

StageWhat may changeWhat an implementer can expect
Experimentalanything, at any time, without noticenothing; the design may change or disappear
Betaany change; breaking changes expected to be rare, documentedreal usage is welcome
Stableonly with a new core protocol revision; published revisions are immutablebehavior fixed within a protocol revision

A Beta extension that makes a breaking change should add or increment a revision string in its settings object, and a peer that receives a revision it does not know should not enable the extension. A new identifier is used only when old and new behavior must coexist under one protocol revision. Moving to Stable needs a second proposal with two independent, interoperating implementations and a conformance scenario.

Tasks is listed as "Beta, to Core": its intended destination is the core specification. The extensions overview describes what promotion means. A Standards Track proposal promotes the extension in some protocol revision R; for requests that declare R or later, the feature is core behavior whether or not the extension is advertised; for earlier revisions, the extension's final revision still applies, so a client that supports earlier revisions should keep advertising it. The extension's specification then moves to an archived directory.

For a platform this creates a period with three populations: clients on the current revision that use the extension, clients on revision R that get the feature as core behavior, and clients that use neither. A server that supports both revisions must apply task semantics by the revision declared in each request, which the per-request protocolVersion makes possible, and must keep its non-task path for the third group.

Nothing in the documentation read today says when or in which revision Tasks will be promoted, or whether its method names will change on promotion. This site's recommendation: isolate task handling behind one module in the server, keyed by the declared revision and the declared extension, with contract tests for each combination; keep the catalog entry's record of "extensions advertised" per revision; and treat the promotion as a protocol-revision change on the second clock, with its own dual-era window and end date.

Identity across a delegationWhose authority does the other agent act on, and what reaches the MCP server behind it?

In the MCP path the identity story is settled on this site: the host's client presents a token whose audience is the MCP server; the server validates it per request and calls the service with a separate exchanged token, never the caller's. The delegated path adds an actor. When the underwriting agent hands the inspection goal to another agent, three identities are in play: the underwriting agent (or the person it acts for), the inspection agent, and the systems the inspection agent then calls with its own tools.

The tempting design is to give the inspection agent the underwriting agent's token "so it can act for us". That is token passthrough by another name, and the MCP authorization rules forbid a server to pass on the token it received for a reason that applies here too: the downstream system can no longer tell who is acting, and every audience check becomes meaningless. The A2A specification read for this site's source pack says an Agent Card describes authentication requirements; the details of how A2A carries delegated authority belong to https://a2a.sammuthu.com and were not read here.

This site's recommendation: treat the other agent as its own principal with its own identity and its own grants, record in the audit event that it acted on a delegated goal (the goal id, the delegating principal), and never let it reach a human-only decision tool. If the inspection agent books through an MCP server of its own, that server sees the inspection agent's token and authorizes it like any other caller. Delegation should narrow authority at each hop, never widen it.

In one breath#

Work that outlives a request becomes a task: an official, opt-in extension (Beta on the extensions overview, Stable in its repository README) whose durable taskId the client polls, every poll authorized like a call. At scale the model's list is narrowed in stages while every call is still checked at execution, and a dynamic catalog needs approved sets so a broad scope does not become an approval that grows by itself. Tenants, versions and extensions each need an owner, and MCP stops where another agent plans the work: an agent reached by A2A may well use MCP inside.

The insurer's design now covers long work, large catalogs, two business units and three clocks of change. What it lacks is a map of what a platform team would build it from: which SDK, which registry, what a gateway does, how an identity provider plugs in, how traces are named. Each has its own status, from finished standard to preview service to draft. That is Ecosystem.