Browse the reference ⌄
Implementation Guide published

Govern MCP Connectors Through a Broker

Admit, tier, pin and enforce every MCP server through one registry and two enforcement points, keep tokens audience-bound, govern A2A delegation through its own registry and gateway, and expose client-facing agent channels only through the same policy layer.

Version
0.2.0
Owner
DEIXEI
Last reviewed
Reading time
52 min

For Cto · Ai Architect · Platform Engineer · Security Engineer · Risk And Assurance · Internal Audit

Sources and details
Source works
Book 1 · Book 2 · Book 3 · Research Series · Book 09
Source chapters
4, 5, 7, 11, 12, 13, 16, 26
Source appendices
04:B, 04:C
Refresh trigger
vendor release

Full source list ↓ Source index →

The Model Context Protocol (MCP) gives an agent a standard way to discover and call tools, resources and prompts exposed by a server. The Agent2Agent protocol (A2A) gives one agent a standard way to delegate a task to another. Neither protocol settles caller authorisation, server ownership, version currency, or how a credential is handled before it reaches a system of record. The MCP specification itself says that it cannot enforce its own security principles at the protocol level (Working Paper 10 §2.4). The institution is the host, and it has to supply those controls around the protocols.

This page specifies how. The connector broker holds the approved server registry, risk tier, review state and tool-level policy. Two enforcement points consume that registry: managed client configuration on workstations and agent runtimes, and the runtime gateway (the tool broker) in front of the servers. Agent-to-agent traffic gets its own registry and gateway. Client-facing agent channels are exposed only through the same policy layer.

The connector registry publishes an approved manifest to managed workstations and the runtime gateway, where tool calls are checked and recorded.

One registry, enforced twice: at the client by managed configuration and at the policy edge by the gateway. Source: Deploying Claude Safely (Book 3), Chapter 7, Figure 7.2.

How to read this page. Tier boundaries, approvers, SLAs, field names and checklist items are taken from Book 3 Appendix C and Chapter 7 unless marked otherwise; they are that book’s reference policy for a bank, not a regulatory requirement, and the institution should adopt or adjust them deliberately. The four platform products, the reuse rules and the threat model are the author’s proposal in Working Paper 10, not a tested standard. Vendor product behaviour is dated and marked for fact-checking. Where the books disagree, the difference is stated in Where the sources differ.

Why MCP is not just another API

Three properties make an MCP server a different risk from a REST API, and each drives a control below (Book 1 Ch 13 §4.1; Book 3 Ch 7 §4.2):

PropertyConsequenceControl on this page
The consumer is an agent that chooses which server and tool to call at run time.Reachability, not intent, decides what gets called.Per-agent allow-list at both enforcement points; per-tool rules.
One server usually wraps several tools.Trust granted to the server leaks to every tool it exposes, including write tools.Tier by the most powerful tool; split or strip write tools; read/act flag per tool.
The tool description is text the model reads to decide what to do.Whoever controls the description controls part of the agent’s reasoning (goal hijack).Review descriptions as code; validate the runtime surface against the registry’s own copy, never the server’s self-description.

Two further facts frame the rest. The protocol leaves consent, access control and output validation to the host. And, per Book 3 Ch 7 §2 (as of August 2026), Anthropic states that it does not security-audit or manage third-party MCP servers; its connector directory is a listing surface, not a security regime [FACT-CHECK: current wording on the Claude Code MCP documentation page]. Treat every server, first-party, vendor or community, as software accepted into the sub-processor inventory, with diligence proportional to the data class it reaches.

The boundary: one enforcement point, several jobs

The sources describe the same boundary at two levels of detail. Use both; they do not conflict.

Book 1 (Ch 13 §5): one boundary, three sub-planes. Every agent call passes through an identity-aware gateway (authenticates the agent, enforces scope, rate limit and conditional access, writes the audit record), an MCP broker (fronts the curated tool servers, holds owner, scopes and lifecycle), and a tokenisation gate (decides per invocation which fields reach the model in plain form). None is optional; removing any one reopens a failure the other two cannot catch. The tokenisation decision itself is specified on the model gateway page.

Gateway, MCP and the API boundary: every agent call passes through an identity-aware gateway, an MCP broker and a tokenisation gate.

One boundary, three sub-planes: identity-aware gateway, MCP broker and tokenisation gate. Source: Building Organizations for the Age of AI (Book 1).

Working Paper 10 (§4): four platform products in the integration layer. Delivery teams own agents; the platform team owns:

ProductJobMinimum content
MCP server catalogue (the broker’s registry)The governed list of servers that wrap the firm’s systems, and the place a second team discovers the first team’s work.Owner, semantic version, data classification, published tool contract, lifecycle state.
MCP gateway (tool broker)Policy enforcement point in front of catalogued servers.Authenticate the calling agent; allow or deny per caller and per tool; exchange the caller’s token for one the target server accepts; rate-limit; log request and response; inspect content against the data class.
A2A agent registryThe firm’s directory of Agent Cards; the only discovery source for agents.A card is listed only after evaluation, security review and a named human owner. Signatures are checked here where cards are signed.
A2A gateway (agent gateway)Enforcement point for agent-to-agent traffic.Mutual authentication of both agents; audit trail keyed on task and context identifiers; policy on which domains’ agents may delegate to which; egress control for any agent outside the firm.

Two design rules follow (WP10 §4; Book 1 Ch 13 §5.1):

  • The tool gateway and the AI (model) gateway may share infrastructure but not a policy model. A model call and a write to a ledger are different risks. Book 1’s stated preference (marked as the author’s preference) is a dedicated API-management instance for AI tooling, separate from the customer-facing instance, for a different blast radius and operating tempo.
  • The gateways are availability-critical and see sensitive content. Give them the classification of the most sensitive data they carry, put them in the failure-mode analysis, and operate them as products with service levels. Teams route around a gateway that is slower or flakier than going direct, and a routed-around gateway does more harm than having none, because the firm still thinks it is in control.

One joined record per call. The audit record for a tool call should let an investigator start from a gateway log line and reach, through one correlation ID, the policy decision, the agent identity and its wrangler, the MCP server and tool called, and the tokenisation decision that applied. Book 1 Ch 13 §5.4 sets the bar at under a minute; if the join takes longer, the registries are fragmented. The record fields are specified on audit evidence.

Build or buy. As of November 2026, each large cloud provider sells versions of all four products (WP10 §2.5) [FACT-CHECK: current Foundry Agent Service, Bedrock AgentCore Gateway/Runtime and Gemini Enterprise Agent Platform MCP and A2A support]. A vendor’s registry and gateway govern what runs on that vendor’s platform. Own the model regardless: the catalogue schema, the per-agent authorisation matrix and the listing criteria should be the firm’s documents, implemented in a product, so that a second platform or an exit does not mean starting again.

Decide first: tool or agent

Before wrapping anything, decide which protocol it belongs behind (WP10 §3; Book 2 Ch 12):

  • MCP server if the counterpart executes a well-defined function and returns: a balance lookup, a document search, a sanctions check, a ledger posting.
  • A2A agent if it reasons, plans, holds state across turns, or may come back with questions: a claims-triage agent that may ask for a missing document, a research agent that works for twenty minutes.

Surfacing an agent as an MCP tool flattens its task lifecycle: the agent cannot ask a clarifying question, long-running work gets no handle, and the caller’s record shows a function call instead of the delegation that actually took place. MCP’s Tasks extension recovers a durable handle and input pauses, but not an Agent Card, context grouping, distinct artefacts or “rejected” and “authentication required” states. Three qualifications keep the heuristic honest: it is a default (a bounded classifier can sit behind MCP without loss); it runs one way only (wrapping a deterministic function as an agent adds a lifecycle nobody needs and a second authorisation point); and the choice goes in the capability’s design record with the reason, so a later reviewer can tell whether flattening was a decision or an accident.

Wrap once and build the catalogue from manifests

These reuse rules are the author’s proposal (WP10 §5; adopted in Book 2 Ch 12):

  1. Wrap once, at the right layer. Each system of record has a single MCP server, with a semantic version in the catalogue and the team nearest the system as owner. A second wrapper is a contribution to the first by inner-source pull request, never a fork. Where two teams dispute ownership, the pattern arbiter decides. Very large systems (a core banking platform) may warrant one server per bounded domain; the rule then applies per domain.
  2. Expose business capability, not one consumer’s workflow. A tool named for one bot (get_policy_summary_for_renewals_bot) shows consumer logic leaking into the wrapper.
  3. Version tool contracts like APIs. Additive change is a minor version. A breaking schema change is a major version with a migration window, and both versions are served until the window closes. MCP’s own minimum twelve-month deprecation window for protocol features is a reasonable model. Each tool carries a read/act flag; the gateway treats reading and acting tools differently. Book 2 Ch 12 adds two points: the flag is what the broker authorises against (an agent on the advisory rung can be granted every reading tool on a server and none of the acting ones), and a migration notice must reach the standing context agents read, because an agent does not subscribe to release notes.
  4. Manifest-driven discovery. Every repository that ships an MCP server or A2A agent carries a machine-readable manifest (name, tools or skills, data classification, owner, and for agents the card location). The catalogue and registry are built from manifests by pipeline, never maintained by hand. This also lets a coding agent find the existing server before writing a new one. Book 2 Ch 16 §4.5 enforces wrap-once at this publication step: when the pipeline meets a second manifest claiming a system that already has a server, it lists nothing and opens a question for the pattern arbiter, whose usual answer is a contribution to the first server. The templates, manifest schema and publication step belong to the platform team; each server belongs to the team closest to its system.
  5. Composition before construction. A new use case is first written as a composition of existing servers and agents plus new domain logic; the team builds only the difference.

The platform team supplies the reusable parts: an MCP server template (authentication, audience validation, logging, tracing, error handling and pipeline pre-wired), an A2A agent template (card generation, task lifecycle, streaming and push plumbing, the publication step), an evaluation harness (contract tests per tool, task-level evaluations per agent, run before any listing), and a policy pack built with the risk function (reference scopes, classification mappings, audit schema). The per-client endpoints and agent definitions on the agent channel are catalogue components on a bill of material like any other (BOM and recipes).

Failure mode: the second wrapper. A squad finds the owning team’s backlog slow and stands up its own server over the same system. Detect it when the catalogue lists two servers for one system, or one server while the broker’s logs show traffic to two. Recover by merging the new tools into the owner’s server, retiring the fork, and having the broker refuse a route to any server not in the catalogue.

Tier every server: R0, R1, R2

Book 3 Appendix C §4 and §6 define three bounded tiers. The tier sets the approval body, required artefacts, SLA, monitoring and review cadence. Map the tiers to the institution’s own scale on risk tiers.

R0R1R2
BoundaryRead-only on public or internal-classification dataRead access to confidential or regulated dataAny write or action-taking operation, on any data class, including triggering downstream workflows
Approval bodyBrokerBroker + DPO + named data-class ownerBroker + DPO + data-class owner + Virtual CAB + named wrangler
Required artefactsIntake form + 25-item security checklistR0 artefacts + DPIA reference (or exemption justification) + data-flow diagram + classification cross-check + supplier entry in the third-party register for vendor or community serversR1 artefacts + policy-decision-point integration evidence (a sandbox test showing the callout fires and returns a reasoned decision) + suspension rehearsal report + Virtual CAB minutes + documented exit strategy
SLA from complete form5 working days (3 for first-party Anthropic connectors)10 working days15 working days
MonitoringStandard pre- and post-tool-call hook telemetry into the SIEMHooks classify the data class per call and emit structured events; SIEM rules for anomalous query patternsPer-action policy-decision callout at the gateway
Access reviewAnnual owner attestationQuarterly by the data-class ownerMonthly access review; quarterly suspension drill

Rules that make the tiers hold:

  • Straddling admits at the higher tier. A connector that reads R1 data and writes a single status field is R2, unless the write is removed from the tool surface and the server is re-registered at R1. Alternatively split it into two registrations.
  • Re-tier up freely, down only by fresh registration. Downward re-tiering is never an edit to the existing row.
  • Interface or skills extensions set a floor of R1 regardless of data class (Book 3 Ch 7 §5.6, PR-1 step 3): a server that renders interactive UI (MCP Apps) or delivers procedure rather than tools needs an explicit per-server permission and evidence bound to the action payload.
  • R2 also needs an explicit per-tool allow-list, an entry with the agent governance body for any production agent using the server, and elicitation (in-band human confirmation) on irreversible operations (Ch 7 PR-1 step 4).
  • First-party Anthropic connectors may use published vendor certifications in place of an externally commissioned audit (App C §6, as of May 2026) [FACT-CHECK: Anthropic’s current certification list on its trust centre]. This does not remove the institution’s third-party diligence for any server that processes customer data.
  • Transitive sub-processor changes (for example, a parent vendor adding a model provider as sub-processor) are reviewed as a new sub-processor disclosure.

Book 1 Ch 13 step 7 uses a four-level scale (low / medium / high / critical by data class, blast radius and critical-function touchpoint), with critical requiring Virtual CAB review. If the institution already runs that scale, map critical and high to R2-style gates; do not run two tier vocabularies for the same server.

Transport and authentication policy

From Book 3 Appendix C §2 and §4 and Chapter 7 §4.1:

ChoiceRule
HTTP (Streamable HTTP)Default for anything beyond a developer pilot. OAuth 2.x through the institution’s IdP is the target.
SSEDeprecated; not a valid value for new registrations.
stdioEngineering pilots only: status experimental, registered against the workstation user identity, matched by command, confined to development environments by managed configuration, auto-expiry after 60 days unless the team lead re-attests. A stdio server seen in production fires a SIEM detection and a broker review.
auth_mechanism: noneOnly at R0 on read-only public data, or for experimental pilots.
api-keyOnly with a helper that issues short-lived keys; no long-lived secrets in configuration files. Book 1 Ch 13 additionally requires CISO sign-off for API keys.

Book 1 Ch 13 §8 goes further on in-process and local servers: an agent that declares an MCP at localhost, stdio: or an in-process module cannot have a gateway in front of it, so refactor it into an HTTP server behind the gateway (a private endpoint in the agent’s subnet where latency matters). The page follows Book 3 for workstation pilots and Book 1 for production agent runtimes: no stdio or in-process MCP in production.

Intake: the registration form and the SLA clock

The proposing team submits a sixteen-question intake through the institution’s service-request tool (Book 3 App C §3). The broker acknowledges within one working day and triages within three. The SLA clock in the tier table starts only when all sixteen answers are present; incomplete forms are returned. The form is stored immutably with the register row.

#QuestionWhat the broker checks
1Server name and version; new, version bump, or re-registration after deprecationName collision with existing entries (typo-squat check)
2Source: Anthropic, named vendor (with registration number), community, experimental, internalDiligence depth
3Use case and originating business teamA real consumer exists
4Owner and backup owner, with directory identifiersBoth active employees with third-party-risk training in the last 12 months
5Transport and authentication mechanismPolicy table above
6OAuth scopes requested, exact stringsAny read:all-style scope needs a two-sentence justification
7Tools exposed, verbatim from the spec, one line eachBecomes the registry’s own tool-surface copy
8Data classes read (name the dataset for confidential and regulated)Sets R0 vs R1
9Data classes written, if anyAny write is R2
10Sub-processor status (default for any external vendor: yes)Supplier register entry
11Data processing agreement reference and date, or procurement path and expected dateBlocking item 1
12External security audit (ISO/IEC 27001 or SOC 2 Type II report)Attach report
13Traffic estimate: calls per day, peak per hour, outage sensitivityRate limits and capacity
14Rollback plan if compromised: suspension procedure, authority, dependent-agent impact, alternativeExit and fallback
15Wrangler (named owner of behaviour) for the agents that will use itAccountability
16Proposed tier with reasoningBroker may re-tier up

Onboarding: thirteen steps from request to production

Book 1 Ch 13 §5.2 specifies a thirteen-step onboarding that produces the supply-chain evidence; Book 3 supplies the intake, review and approval artefacts inside it. The combined sequence:

StepActionOwnerOutput / acceptance
1Onboarding request raised in the developer portalWranglerAudit trail starts; Book 3 intake form attached
2Identification: name, gateway URL pattern, source, purpose, data classificationRequesting teamRegistry draft row
3Identity model: managed identity by default; OAuth on-behalf-of or client credentials by exception; API keys need CISO sign-offPlatform + securityIdentity decision recorded
4Allowed consumers: named agent identities and user populations, as an allow-list (not a deny-list)WranglerPer-agent authorisation entries
5Tool surface: tool list, descriptions, input/output schemas; descriptions get their own security reviewSecurity reviewerRegistry tool-surface copy; read/act flag per tool
6Logging level set against data class; personal data triggers gateway redaction before forwardingPlatformLogging policy
7Risk classification (R0–R2 on this page)BrokerTier with reasoning
8Threat model against tool misuse, identity and privilege abuse, supply chain, and inter-agent communication where another agent consumes the outputSecurityThreat model document
9Security review (the 25 items below) and approval by the tier’s approval body. Book 1’s floor is two approvers (line manager + security reviewer; data governance added for critical)Approval bodySigned approvals with timestamps
10Gateway publication: scopes, rate limits, policies attached; gateway URL allocatedPlatformGateway route live in non-production
11Catalogue registration: owner, status approved, surfaced in the developer portal; the portal flags name collisionsBrokerRegistry row; signed manifest published
12Telemetry wiring: gateway → monitoring → SIEM, with the MCP correlation field verified by a test invocationPlatformTest call visible end-to-end in the SIEM
13Lifecycle ownership: review cadence scheduled, retirement criteria recorded, wrangler accepts on-callWranglerStatus moves to in production (active)

Time target. Book 1 states that, with templates in place, a senior engineer completes the path for a low-risk server in about two business days. Use the measure both ways: more than three business days from request to first verified call is a constraint to remove, because slow onboarding drives engineers to install the public version locally; a turnaround of hours suggests a step was skipped. The thirteen steps survive in a small firm; only the approval layer collapses (for example, one combined sign-off by the head of platform, with the rationale in the evidence record). The gateway does not shrink away.

Retrofit. When standing the broker up, run every existing server through all thirteen steps retrospectively. Some will fail the threat-model step and need redesign or retirement; grandfathering them carries unmeasured risk.

The security review: 25 items, 1–8 blocking

Walk the checklist top to bottom and record a decision per item on the register entry (Book 3 App C §5). Any “no” on items 1–8 blocks approval. Items 9–25 may be accepted as conditions with a named owner and a hard deadline; the entry stays in experimental status until every condition is closed.

Blocking items

#Check
1Data processing agreement on file, or contractual sub-processor designation in place, meeting the mandatory contractual clauses for ICT services (see regulatory map)
2Sub-processor declared and acceptable to the DPO; cross-checked against the prohibited-sub-processor list
3OAuth scopes pinned at the minimum for the declared tool surface; no read:all or equivalent unless justified and time-bound
4Transport certificate chains to a CA accepted by the institution’s PKI policy; self-signed intermediates rejected
5Tool descriptions reviewed for injection; the runtime validates against the broker’s registry, not the server’s self-description
6Tool-output sanitisation verified; every output treated as untrusted input; agent-directed instructions stripped before re-injection
7Owner and backup owner verified in the directory, both active and holding the MCP-owner role
8Proposed tier matches data and action class (R0 with confidential data, or R1 with writes, is rejected for resubmission)

Conditional items (may close after approval, entry held in experimental)

#Check
9Server URL or stdio command added to the managed client allow-list, distributed by device management
10Per-tool permission rules captured in managed settings; managed deny rules precede any hook allow
11Trust-dialog grant authority recorded for project-scoped registrations; refreshed quarterly
12SIEM detection rule for the server: unexpected scope upgrades, high-frequency calls outside business hours, clustered denied calls
13Audit evidence schema fields present in every pre- and post-tool-call event from this server
14Data-classification labels match the data dictionary; mismatches block admission
15Network egress allow-list covers only the server’s endpoints, at workstation and gateway; un-inspected TLS noted as residual risk
16Credential lifecycle documented: refresh-token rotation, short-lived key helper TTL, no long-lived secrets in project configuration, secrets resolved from a vault
17Zero-data-retention posture for downstream model calls confirmed (see vendor note below)
18Gateway rate-limit and circuit-breaker policy for R1 and R2; mandatory for state-mutating tools
19Server-side logging and retention where the institution controls the server; internal servers log at the engine and join the broker audit feed
20Supplier reflected in the third-party Register of Information where it supports a critical or important function
21Procurement confirms the vendor’s DPA template was reviewed and non-standard clauses negotiated
22Exit strategy documented (unavailable, compromised or terminated server; dependent-agent fallback) for R1 and R2
23Suspension rehearsal executed once in non-production for R2; mean time to suspension recorded
24Review date populated and accepted by the owner
25Deprecation criteria explicit: 30 days with no traffic and no owner attestation auto-deprecates

When to reject

Book 3 Ch 7 PR-1 step 5 gives the rejection rule: a third-party server with no DPA, no sub-processor designation acceptable to the institution, or a transport that fails the PKI policy is rejected, with the rationale in the registry, a remediation path offered, and escalation to procurement and legal if the gap is material. Rejected entries are retained for five years (App C §7).

Composite example (Book 3 Ch 7 §6, “Insurer I” and “Vendor V” are composites). An insurer’s first review board approved six of seven internal servers (tiers R0 and R1, one with a per-tool rule restricting a five-tool finance connector to the two operations the team needed) and rejected a vendor fraud-scoring server for three reasons, in order of weight: the vendor routed customer personal data to an undisclosed downstream sub-processor and refused to designate it (the binding objection); its TLS chain used a self-signed intermediate; and its tool surface included writes back to the vendor’s case system, which would have made it R2 with no policy-decision pattern available. The vendor later fixed the certificate and split the tools into a read-only baseline plus an optional write extension; the contractual objection remained and went to contract renegotiation. The lesson Book 3 draws: a broker that has never rejected a server has not yet operated.

The register: one row per server, published as a signed manifest

The register is the source of truth for both enforcement points. Hold it as a structured store behind the broker’s admission API (Book 3 names Cosmos DB on Azure, DynamoDB on AWS, Firestore or Spanner on GCP), never a spreadsheet. On every status change the broker publishes a signed manifest to the gateway and to the managed client configuration distribution; a drifting spreadsheet means drifting enforcement.

Book 3 App C §2 defines nineteen fields:

#FieldType / valuesRule
1server_idsystem-generated, immutableJoin key across audit, gateway and SIEM
2server_nameunique textCanonical name used in mcp__<server_name>__<tool> permission rules. Never the sole match key for enforcement
3vendorfirst-party-anthropic / vendor / community / experimental / internalDrives diligence depth
4versionsemver where availableUpdated on each admitted release
5transporthttp / sse-deprecated / stdiosse-deprecated invalid for new entries
6auth_mechanismoauth2-dcr / oauth2-preconfigured / api-key / kerberos / mtls / nonenone only at R0 public read-only or experimental
7oauth_scopes_pinnedexact IdP scope stringsPinned at registration; enforced at the IdP and in managed config
8tools_exposedlist, transcribed at admissionBasis for per-tool rules; diffed on every version change
9data_classes_exposedFK to the data dictionaryDrives the tier
10risk_tierR0 / R1 / R2Up by resubmission; never down without fresh registration
11ownernamed humanAuto-flag on a directory leaver event
12approved_bynamed human + roleCo-signed by DPO (R1+) and Virtual CAB chair (R2)
13dpa_referencedocument ID, date, contract-register URLRequired for vendor and community servers
14sub_processor_flagbooleanIf true, the supplier appears in the third-party register
15registered_datedate, auto
16last_review_datedate, autoMost recent attestation
17deprecation_datedate or nullSet on exit from active
18traffic_last_30_daysnumber, auto from the SIEMFeeds the disuse trigger
19statusactive / experimental / deprecated / rejected / suspendedTransitions per lifecycle below

Add these fields from Book 3 Ch 7 PR-2 and Book 1 Ch 13, because the nineteen alone do not support enforcement or provenance:

Field (page name)Purpose
enforcement_keyThe literal serverUrl or serverCommand the allow-lists match on; no environment-variable expansion
backup_ownerCarries the row during an owner-departure window (App C §3 and §7 require one; §2 has no field for it)
spec_revisionMCP revision the server implements
extensions_negotiatedFor example MCP Apps, Tasks; any change is a change event
allowed_consumersNamed agent identities and user populations (Book 1 step 4)
dependency_manifest_refFrozen resolved-versions manifest and its digest (see supply chain below)
read_act per toolWhether each tool reads or acts
design_record_refTool-or-agent decision and reason

The field names in this second table are the page’s labels for content the sources require; they are not a published schema.

Supply chain: provenance, IDE inheritance and vendor bundles

Authentication proves an endpoint is who it claims to be; provenance proves it should be running at all (Book 1 Ch 13 §1, §4.2). Public package registries gained several hundred MCP server packages in late 2025 with no procurement step, and OWASP’s agentic supply-chain category names a compromised MCP or registry server as a priority sub-risk. Book 1 cites three public incidents as the reference library: the typo-squatted Postmark email server (September 2025), the Heroku MCP app ownership hijack (June 2025) and an MCP OAuth response exploit (October 2025). In the Postmark case the impostor was perfectly authenticatable; only a registry that already held the legitimate identity could say no.

Controls:

  1. Known origin, known version, known dependency tree. At approval, record provenance and freeze a resolved-versions manifest of the server’s transitive dependencies, stored by digest. A clean server with a poisoned dependency three levels down is the same risk as a poisoned server. A high or critical vulnerability on any dependency is a suspension trigger (lifecycle below), so the manifest must be scannable.
  2. Pin identity and signature. The registry pins the server’s identity and signature; Book 1 Ch 4 §6.2 (composite) has the gateway block an npm impostor because the registry had pinned the legitimate server. The catalogue flags name collisions at registration.
  3. Treat IDE installs as the highest-blast-radius path. A server installed inside a developer IDE or desktop client picks up the developer’s own credentials, environment and local files by default. Workstation controls are on coding-agent workstation and below.
  4. Lock agent designer surfaces. Configure agent builders so the tool-URL field accepts only hostnames inside the gateway domain (Book 1 Ch 13 §7, for Azure AI Foundry; apply the same to every runtime the firm’s identity issues).
  5. Vendor-bundled MCP servers go through the same thirteen steps. SaaS vendors increasingly ship MCP servers inside their product, and they arrive as procurement questions. No skip rule: the vendor remains the operator, but the server is registered and reached through the firm’s gateway. Book 1’s position: a vendor unwilling to put its server behind a customer’s gateway is unwilling to be governed.
  6. Server-delivered skills and interactive UI. Book 3 Ch 7 §4.2 and §5.6 treat a skill pushed by a server as unreviewed behavioural instruction, shaped exactly like a prompt injection. Refuse skills-from-server until signing, review and pinning exist [FACT-CHECK: status of the MCP server-delivered skills extension]. For UI-bearing servers, permit per server and audit the action payload, never the rendered preview [FACT-CHECK: MCP Apps isolation model and whether admins can disable it per connector].

The MCP-only supplier tier

Book 1 Ch 4 §6.2 and Ch 5 §4.2 (composite firm) add a supplier category alongside core, significant and commodity: MCP-only suppliers, who provide a tool invoked inside the firm’s runtime rather than a hosted service. Output liability, data residency and security-testing terms differ from a SaaS platform contract, so the supplier register tracks them separately and the board’s third-party risk committee receives the MCP supplier register quarterly. Structure contracts as if a future critical-provider designation could apply; restructuring after the fact costs more.

The catalogue is not the third-party register

Working Paper 10 §7 draws a line the page follows: the MCP catalogue and A2A registry are inventories of interfaces (what can be called, by whom, at which version and data class). They can feed the documentation of ICT assets and dependencies. They do not record contracts. Where a supplier operates a server, or a partner’s agent is reached over A2A, a third-party ICT service sits behind the interface; it goes through third-party risk and into the Register of Information like any other arrangement. The catalogue’s job is to reveal that such an interface exists. Whether an arrangement supports a critical or important function is a legal and risk decision. AI-Act logging and oversight obligations attach to high-risk AI systems, not to a gateway; gateway logs and A2A task records are raw material for them, not compliance. Article-level detail and dates are on the regulatory map.

Identity and tokens: no passthrough, no confused deputy

OAuth at the gateway

Authentication and authorisation for every MCP call are enforced at the gateway against the firm’s IdP; the server never owns token validation, scope decisions or audit logging (Book 1 Ch 13 §4.3). The chain is agent → gateway → server: token validation on the first hop, mutual authentication on the second (typically a managed identity for the gateway, scoped to the servers it fronts). Letting an agent call a server directly with its own token makes identity and privilege abuse routine.

Vendor detail, as of May 2026 per Book 1 Ch 13 §4.3–4.4: Azure API Management’s MCP server feature exposes registered servers at https://<instance>.azure-api.net/mcp/<server-id>, validates tokens against Entra ID and evaluates scope claims before proxying; Azure API Center provides the tenant-wide catalogue and developer portal. Apigee API Hub and API Gateway with Bedrock AgentCore Gateway are the GCP and AWS equivalents [FACT-CHECK: current APIM MCP feature behaviour and API Center MCP support].

Token passthrough and the confused deputy

MCP’s security guidance defines token passthrough as a server accepting a token not issued to it and forwarding it downstream; the authorisation specification requires a server to validate that tokens were issued specifically for it and not to accept or transit any other token (WP10 §6.1, as of revision 2026-07-28). The failure is a confused deputy: the server lends its position to a caller without checking the caller’s authority. Rate limits and request validation are bypassed, the server cannot tell clients apart, downstream logs show the wrong identity, and a stolen token can be replayed through the server. For a regulated firm, the unattributable action on a system of record is the audit finding.

Do not rely on dozens of independently written servers each getting this right. Three controls work together (WP10 §6.1; Book 2 Ch 11; Book 09 Ch 5):

  1. The gateway mediates token exchange. The agent presents a token issued for the gateway. The gateway authorises caller, tool and data class, logs, then obtains a short-lived downstream token whose audience is the one target server and whose scope is the one purpose. When the agent acts for a person, the exchange carries both identities (on-behalf-of).
  2. Every server validates the audience claim and refuses any token not issued for it, however valid it otherwise looks. Implement this in the server template so no team writes it twice.
  3. Agents never hold system-of-record credentials. Only the server holds a credential for its system; an agent’s context, memory and configuration contain nothing that would open that system without going through the gateway.

Acceptance test: before any server is listed, the evaluation harness sends a wrong-audience token and the server must refuse it. Phase 1 of adoption is not complete until the risk function has seen that rejection in the audit log. The same rule applies on A2A: a client agent authenticates to a remote agent with a credential issued for that agent, under a scheme its card declares, and never forwards the token it was called with.

Cloud note (Book 2 Ch 11, as of November 2026): Entra ID implements on-behalf-of natively; AWS’s nearest equivalent is trusted identity propagation; on Google Cloud teams assemble it from token exchange and service-account impersonation, which bounds the call by the service account’s rights, so entitlement must be enforced at the capability itself [FACT-CHECK: current delegation support per cloud].

Scope pinning and per-tool rules

  • Pin exact OAuth scopes at registration, record them in the registry, configure them in managed client configuration and enforce them at the IdP.
  • Flag any registry row whose scope is read:all (or equivalent) and whose registered date is more than 90 days old (Book 3 Ch 7 §7): “we will tighten later” never happens. Review scopes quarterly and add a deny-by-default per-tool rule set on top of the OAuth grants.
  • Use the move to OIDC-aligned authorisation in the current MCP revision to run a deliberate re-registration campaign putting the firm’s own IdP in every connector’s path, rather than letting it happen server by server (Ch 7 §5.4).
  • The broker accepts calls only from enrolled agent principals whose mandate names the broker as a permitted means, never from the wrangler’s human identity (Book 3 Ch 5 PR-3). Identity design is on identity and secrets.

Connector authorisation through the IdP

Book 3 Ch 5 §4.3 (as of August 2026): Anthropic’s enterprise-managed authorisation for MCP connectors lets administrators provision connectors through the IdP, scope by group, revoke centrally, enforce IdP-only connections and shorten token lifetimes, replacing per-user OAuth grants central IAM never sees. At that date it was beta, waitlisted and Okta-only, with Entra ID support announced as coming [FACT-CHECK: current availability and supported IdPs]. Until the institution’s IdP is supported:

  • run a monthly manual connector-access review with a named owner against the connector register;
  • record the gap on the risk register as a known control weakness with a review date;
  • include connectors in the quarterly access review, with evidence retained.

Two credential regimes in one workspace. In collaboration-tool integrations (Book 3 discusses Slack), channel activity may run under an agent service account while direct messages run on the individual’s personal credentials. An access review that covers channels and not direct messages has covered half the surface; name an owner for the personal-credential path in the connector register.

Enforce the approved set twice

The registry does not stop a process from connecting to an unapproved server. Publish the signed manifest to both enforcement points.

Control pointEnforceEvidence to keep
Managed workstation or runtime configurationOnly registered servers and approved transports load; local configuration cannot broaden access.Configuration version, device/runtime identity, effective policy, rejected changes.
Connector registryOwner, approved version, enforcement key, data scope, operations, tier, lifecycle state.Admission record, tool-surface snapshot, dependency manifest, risk decision, review history.
Runtime gatewayEach call matches a registered server and tool, the caller’s identity and entitlements, and current policy; tier policy applied.Correlated request, policy decision, approval, outcome, returned-data reference.
Downstream serviceServer identity least-privileged; audience validated; actions constrained at the service boundary.Authentication, authorisation and operation logs linked to the gateway event.

At the gateway

Per Book 3 Ch 7 §5.8: every agent calling the model API runs through the gateway; it logs MCP server name and tool name in every audit record, rejects calls to servers absent from the registry, and for R2 calls the policy decision point before forwarding. Because MCP revision 2026-07-28 is stateless request/response, the gateway stamps the correlation identifier that ties a sequence of calls into one reconstructable episode; nothing below the gateway will. The gateway also owns the supported-protocol-version policy: it can see each request’s declared version and refuse clients that are too old or too new for the estate (WP10 §4, §8). Broker and gateway share one audit channel into the SIEM so one query joins them.

On the workstation: Claude Code specifics

As of August 2026, per Book 3 Ch 7 §5.3–5.5 and PR-3 [FACT-CHECK: re-verify every key and behaviour against the current Claude Code MCP and settings documentation]. Workstation baselines are owned by coding-agent workstation; the broker contributes these rules:

  • Exclusive control: a device-managed managed-mcp.json loads only the servers it lists; users cannot add others, plugin servers included, and claude.ai connectors are suppressed unless allowAllClaudeAiMcps is true. An empty map disables MCP. It cannot be delivered through server-managed settings, and it is world-readable, so no credentials in env blocks.
  • Allow/deny filtering: allowedMcpServers and deniedMcpServers filter servers configured elsewhere. Deny is evaluated first, merges from every source and cannot be overridden (a usable emergency kill-switch). They are a control only with allowManagedMcpServersOnly: true. allowManagedPermissionRulesOnly does not cover MCP.
  • Match on serverUrl or serverCommand, never serverName. The name is a user-assigned label; anyone can call a server github, and Anthropic’s documentation says a name entry is not a security control. Write enforcement entries as literal URLs and commands; ${VAR} expansion in a policy entry resolves to whatever the user’s environment holds.
  • Per-tool rules: mcp__<server>__<tool> patterns; deny rules accept globs (mcp__* denies every MCP tool); allow globs only after a literal mcp__<server>__ prefix; managed deny rules beat any hook allow.
  • Project trust: servers in a repository’s .mcp.json prompt for approval on first use. Govern who may grant trust (a small named group, typically the wrangler and a platform engineer) and on which projects (an authorised-project list refreshed quarterly), using enabledMcpjsonServers / disabledMcpjsonServers; a grant outside the list is a signal. Run a quarterly repository scan for .mcp.json files and user-scope entries the registry cannot account for.
  • Roll-out: start with allow/deny plus the lock flag for the first quarter; move to exclusive control once the registry is stable and the second line signs off. Tell users first: a blocked server silently disappears from /mcp.

Source error to be aware of. Book 3 Appendix B, Block 3 (the managed-settings baseline) writes its MCP allow and deny entries as serverName values. That contradicts Book 3 Ch 7 §5.3 and PR-4 and the vendor warning. This page follows Chapter 7: key every entry on serverUrl or serverCommand. The manuscript is flagged for correction; do not copy Block 3 as written.

Close the bypass routes

If an agent can reach a server around the gateway, the broker is advisory. Test for local processes, unmanaged clients, direct APIs, inherited credentials, browser access and broad egress. Book 1 Ch 13 §8 gives the signal and the recovery: the gateway sees fewer MCP calls than the agent runtimes emit. Reconcile call counts between runtime telemetry and gateway logs; harden runtimes to refuse non-gateway URLs; block the alternative path at the egress firewall; audit IDE and desktop-client installs; and run an amnesty week to register existing unregistered servers. Punishment first drives the bypass deeper.

Protocol facts the broker depends on (dated)

Evidence as of 10 November 2026, from Working Paper 10 §2; re-check before relying on it [FACT-CHECK: MCP “Key Changes” and “Deprecated Features” pages; A2A latest released specification].

MCP revision 2026-07-28 (previous: 2025-11-25):

  • Stateless. No initialize handshake or protocol sessions; each request carries its protocol version and client capabilities in _meta. Consequence: correlation lives above the protocol, at the gateway.
  • Discovery is a request: servers must implement server/discover; results are cacheable under ttlMs and cacheScope.
  • Servers no longer send requests to clients. A server needing the user returns input_required and the client retries. Elicitation is the one client feature not deprecated, and is the protocol-native place for an in-band approval; but a consent dialog is not the institution’s authorisation control (see below).
  • Roots, Sampling and Logging are deprecated, eligible for removal from the first revision released on or after 28 July 2027. Inventory servers that depend on them and schedule the migration.
  • Tasks extension (optional, both sides opt in) for long-running work; MCP Apps for interactive UI. Every negotiated extension is a capability the broker must be able to enumerate, permit or strip; a change in the set is a change event.
  • Authorisation is optional; over HTTP it follows the OAuth 2.1 draft with mandatory audience validation. Client and server names exchanged in requests are self-reported and must not be used for security decisions.
  • Transports: stdio and Streamable HTTP.

A2A 1.0.0 (previous: 0.3.0): Agent Card at /.well-known/agent-card.json, optionally signed; work is a Task with states including working, completed, failed, canceled, rejected, input required and authentication required; related tasks share a contextId; operations such as SendMessage, GetTask, CancelTask over JSON-RPC, gRPC or HTTP+JSON bindings. A description using message/send method names is of an earlier version.

Vendor route notes (Book 3 Ch 7 §4.1–4.3, as of May–August 2026):

  • The Claude Messages API mcp_servers connector parameter was not zero-data-retention eligible; using it takes that call out of ZDR [FACT-CHECK: re-confirm after the 2026-07-28 revision].
  • Third-party routes differed: Bedrock lagged beta features; Vertex AI disabled the MCP tool-search beta by default (so all tool definitions load up front and the broker should trim to a per-agent allow-list); Microsoft Foundry carried MCP through a separate Foundry MCP Server in preview [FACT-CHECK: current status of each route and which adopted 2026-07-28].
  • MCP tunnels (announced May 2026, research preview): an outbound-only gateway in the customer network with credentials injected at the boundary. The tunnel gateway is where the institution should terminate, inspect and log MCP exchanges. Preview status is itself a control: no production reliance for a critical or important function until general availability with contractual commitments, and the ability to insert the firm’s own policy enforcement must be a stated contract requirement [FACT-CHECK: tunnel GA status, transport security and log format].

Human approval must bind to the payload

Elicitation, MCP Apps previews and consent prompts do not prove that a human saw an accurate description of the action. Bind approval to the structured action payload the gateway will execute, keep the approved parameters and the result, and ensure the interface cannot substitute a different action after review. Audit the payload, never the pixels.

Threat model

Working Paper 10 §6 (author’s synthesis; the token row rests on the MCP specification) and Book 2 Ch 26 §4 give the same five threats. The Test column is the page’s recommendation, drawn from WP10 §6.1 (wrong-audience token) and Book 3 Ch 7 §7 and PR-4 (description hijack, surface diff, rename-spoof):

ThreatVectorControls (where enforced)Test
Injection through tool or agent output (goal hijack; memory poisoning once written to memory)Content in a resource, tool result or A2A artefact steers the calling agentTreat all output as data; output filtering at both gateways; least-privilege scopes; read/act separation; human approval on side-effecting actionsRed-team description and output hijack; diff advertised surface against the registry copy on every version change
Token passthrough / confused deputyServer forwards a token not issued for itGateway token exchange; audience validation in every server; no system-of-record credentials in agentsWrong-audience token refused
Rogue or spoofed servers and agentsUnvetted endpoint or forged card impersonates a known capabilityCatalogue and registry as the only discovery sources; signed manifests and signed Agent Cards; mutual authentication on agent trafficRename-spoof and typo-squat registration attempts fail
Excessive agency (tool misuse, cascading failures)Agent chains tools or delegations beyond its mandate; one delegation fans outPer-agent authorisation matrix at both gateways; task-level budgets; a kill switch per agent, drilledOut-of-mandate tool call and over-budget task are denied
Data exfiltrationClassified data leaves in a tool result or artefactData class on every catalogue and registry entry; content inspection at both gateways; egress control for external agentsClassified test record blocked at egress

A2A listing as a release step. An Agent Card is issued only for a registered agent with a named wrangler, versioned with the agent, and (for client channels) published per relationship rather than into an open directory. Track listing state in the registry (for example: submitted, evaluated, security-reviewed, listed, withdrawn); the source requires the gates but does not name the states. A2A tasks that lead to consequential actions route through a human approval step, using the interrupted task states to wait. Accountability attaches to the named human owner recorded in the registry, never to the agent (accountability).

Routing, not orchestrating. The agent gateway routes; it does not orchestrate. In a department process the durable workflow still holds state and approvals, and A2A carries the hand-off (workflow pattern). A design in which a model directs other agents is a higher-autonomy shape that needs its own decision record.

Observability specific to MCP

A gateway that logs MCP calls as ordinary HTTP (destination, status, latency) misses the attacks: a malicious tool description is in the request body, a personal-data argument escapes a redaction policy not configured for MCP framing, and chains cannot be reconstructed without correlation IDs (Book 1 Ch 13 §8). Require:

  • JSON-RPC parsing at the gateway: method, server, tool, arguments (redacted per data class) and result reference as structured fields;
  • an MCP correlation field in the SIEM schema, verified by a test invocation at onboarding step 12;
  • MCP anomalies routed to the agent-incident queue (incident response);
  • per-server detection rules (security item 12) and a trailing 30-day traffic count written back to traffic_last_30_days;
  • the joined per-call record described above.

Lifecycle: states, triggers, retention

States

The two books use different state models. The page uses Book 3’s status enum for enforcement and maps Book 1’s onboarding states onto it. The “In manifest?” column is the page’s reading of App C §5 and §7 (conditions held in experimental; stdio pilots confined to development environments; deprecated and suspended entries removed from both allow-lists), not a column either book publishes:

Book 3 statusBook 1 lifecycle equivalentIn manifest?Entry / exit
(intake, not yet a row)proposedNoComplete intake form starts the SLA clock
experimentalapproved, conditions openPilot scope onlyConditional items 9–25 open, or stdio pilot (60-day expiry)
activeapproved → in productionYesBook 1: moves to in production automatically on the first verified production call
suspended(no equivalent)RemovedSecurity finding or owner departure; back to active only with Virtual CAB approval
deprecateddeprecatedRemovedDisuse or failed attestation
(retained record)retiredRemovedBook 1: only after 30 days of measured zero traffic (not attested); permanent; return means a new onboarding
rejected(no equivalent)NeverRetained five years

Book 1 requires a timestamped transition with a named approver at each step, and two approvers for proposed → approved. Transitions to suspended or deprecated emit a broker notice on the audit channel.

Triggers out of active (Book 3 App C §7)

  1. Disuse. No audit-channel traffic for 30 days and no owner attestation for 30 days → deprecation notice to owner, backup owner and wrangler → deprecated after a 14-day grace period, during which any traffic or attestation rescinds it. Removed from both allow-lists on the next manifest publication.
  2. Security finding → immediate suspended: a vendor advisory naming the server, a high or critical CVSS finding on a dependency, an OWASP advisory or MITRE ATLAS technique affecting the server’s class, or a confirmed true-positive detection. The broker publishes the manifest, the gateway rejects new calls, managed client configuration drops the entry on next refresh, and dependent agents fall back to their documented alternative. A Virtual CAB convenes within five working days to decide remediation, conditional re-admission or permanent rejection (change governance).
  3. Owner departure. No successor within 14 days of the directory leaver event → suspended until a new owner is assigned and blocking item 7 is repeated; the backup owner carries the window. If both owner and backup leave → suspended immediately.

Change events. Book 3 Ch 7 §5.7 names a change in negotiated extensions as a change event, not a silent upgrade, and the register diffs the tool surface on every version change. The page recommends treating any change in tool schema, scopes, transport, ownership or dependency manifest the same way: it re-enters review.

Reactivation. A suspended or deprecated server returns only through a fresh intake, a fresh 25-item review and the tier’s approval gate; the new row references the prior server_id.

Retention. Suspended and deprecated rows: at least 12 months, longer if the dependent workload’s audit lifecycle requires. Rejected rows: five years with rationale, to show due diligence to a supervisor. Internal Audit reads the same table; there is no separate audit register.

Suspension must survive deployment. A redeploy must not quietly restore a suspended server; the pre-flight check and post-deploy verification are specified on incident response.

The agent channel: pointing the catalogue outward

Book 2 Ch 26 extends the broker to clients. The same governed capability many internal agents call can be exposed to a client’s own agent as a per-client MCP endpoint, bound to the business relationship and scoped to that client’s data, plugged into the surface the client already uses (Claude Desktop, Teams, a voice assistant or their own code, as of 2026). The integration contract and the customer channel become one artefact, which is why the channel is cheap once the factory exists. It is also a regulated AI system from the first client who connects; the transparency and consumer-protection analysis is on the regulatory map and is not restated here.

The agent channel: factory capabilities reach each client through a per-client, identity-bound MCP endpoint, and usage flows back to intake.

The agent channel: a per-client, identity-bound MCP endpoint in front of the factory’s capabilities. Source: The AI Delivery Factory, Chapter 26, Figure 26.2.

Architecture

  • Every inbound call, tool call or delegated task, terminates at the firm’s gateway: identity resolved, consent scope checked, policy decision made per request, evidence record emitted before anything downstream runs.
  • The endpoint, the agent definition behind it and its prompts are catalogue components with an owner, version and certification tier.
  • Agent cards for the channel are issued only from the catalogue, per relationship.
  • The protocols describe capability and delegation, not governance: an Agent Card has no field for what this agent may do for this client, under this consent, at this autonomy rung, over this data class, with this evidence retention. Those five constraints live in the firm’s policy layer.
  • Azure, AWS and GCP assemblies (as of August 2026, per Book 2 Ch 26): API Management + MCP endpoint + Entra (including agent identity) with API Center as the endpoint catalogue; Bedrock AgentCore Gateway behind API Gateway with Cognito or IAM; Apigee with Gemini Enterprise Agent Platform identity [FACT-CHECK: current product names and capabilities].

The six-question exposure decision

Run once per client-facing capability, and again whenever the factory makes that capability cheaper. In order:

#QuestionDecision ruleOwner
1What capability?Must already be a clean, versioned, identity-aware API (data and API integration). If not, fix the contract first.Product + platform
2Which surface?The one the client already uses, not the one the firm would prefer to build. Each surface is a governance, consent and support obligation.Product
3Whose identity, whose consent?Caller resolves to this relationship, these mandates, this data, this scope of action, with consent recorded, enforced in the firm’s policy layer. A surface the firm does not control (for example a consumer voice assistant) between client and data is a different risk; if you cannot scope and log the caller on that surface, do not expose it there.Identity + DPO
4Personalised or targeted?Per-client endpoint for a book of large, distinct relationships; one targeted product for a mass segment. Decide with product and marketing.Product + marketing
5What must stay a document?Signed, dated records of record stay; the channel supplements them.Compliance
6How is usage measured back?Named signals, a named reader, and how they drive the next change. A channel without this is a novelty.Adoption lead

Three non-negotiables before the first client connects

  1. The endpoint is identity-bound and consent-scoped by the firm’s own gateway policy, not by anything the protocol promises.
  2. The channel is inventoried as a regulated AI system with the disclosure and evidence posture applied.
  3. An adoption lead is named and reading usage before release.

If any is missing, it does not ship.

Rollout: read before act, last and lowest

  • Reporting before actions. Open a read-only channel under a scoped identity first. Actions (buy, activate, change a standing instruction) are a separate controlled step, opened only after the reading channel has earned trust and its usage shows which actions clients want.
  • Last in sequence, lowest rung longest. Book 2 places the agent channel last in the factory’s sequence and keeps it on the lowest autonomy rung longest, because client trust compounds slowly, collapses on one mistake and has a blast radius measured in relationships. Widen per step against evidence: a pilot book before the estate, usage evidence before each widening.
  • One capability, one segment, one loop. Large firm: one capability already behind a clean API, one segment small enough to watch and large enough per relationship to justify personalisation, one read-only per-client endpoint, existing document channel untouched. Small firm: one segment, one surface; add a second only when usage on the first earns it.

Composite example (“Asset Manager X”, Book 2 Ch 26 §6): one capability (cross-mandate ESG-exclusion reporting), top 40 institutional relationships, one read-only endpoint per client scoped to its mandates, quarterly PDF kept. Usage showed portal logins falling, MCP calls rising, and one dominant query nobody had predicted; the next increment promoted that view and opened a first controlled action.

Personalisation versus targeting

Per-person endpoints are not free: each is a scoped endpoint, a consent record, a usage signal, a support surface and a token bill. Thin, uniform usage across thousands of near-identical relationships means the individuals are not behaving as individuals: collapse to a targeted product for the segment and keep personalised endpoints for relationships that are genuinely distinct and material.

The usage loop and token economics

Name the adoption lead before shipping, not after, and agree the two or three usage signals they will read; instrument from day one (Book 2 Ch 26 §7). The adoption lead reads channel usage against the old channel (for example portal logins against MCP calls, most-asked queries) and drives the next change. Every client query runs an agent, so the loop also tracks tokens spent serving the channel against the manual work removed and relationship value protected. A channel whose token cost nobody can see can become unprofitable as soon as usage shifts. Cost metering is on the model gateway.

Partners, federation and the “agent mesh”

A partner’s agent that the firm’s agents delegate to is an ICT third-party service, reached over A2A. Onboard it through third-party risk first (risk assessment, register entry, concentration look, contractual access, audit and exit provisions), and only then list its card, per relationship, behind egress control. A2A’s opacity cuts both ways: less leaves the boundary, but the firm cannot inspect what the partner’s agent does with what did leave.

Book 2 refuses the vendor term “agent mesh” (an emergent, peer-negotiated topology of agents discovering each other). Keep the productisation (capabilities behind contracts, discoverable, identity resolved at every hop); refuse the topology. Every hop is a provisioned seam with a named owner and evidence emission. If a vendor architecture has agents discovering each other outside the registry, it is the ungoverned estate under a new name.

Adopt in four phases

Working Paper 10 §8 sequences the build; each phase has an exit criterion and no duration, by design:

PhaseScopeExit criterion
1. FoundationsMCP gateway running; server template and manifest schema available; two or three high-value systems wrapped; one production use case routed through the gatewayThe use case is in production, and the risk function has checked a sample of audit-log entries, one of them a refused wrong-audience token
2. MCP at scaleInner-source contributions to the catalogue accepted; catalogue servers are the default for new projects; listing requires the evaluation harnessThe catalogue meets most new integrations; every system of record has one wrapper only
3. A2A inside the firmA2A gateway and agent registry running; first delegations between internal agents; task audit and approval steps workingAt least two agent workflows spanning teams run in production with full task traces
4. FederationChosen partner and supplier agents reached over A2A through third-party risk; external MCP servers admitted one at a timeExternal delegation runs under contract and egress control and is recorded in the third-party register

MCP comes before A2A because the tool estate is where reuse pays first and where the credential risk sits. Do not build the A2A pair until agents genuinely need to delegate. Skipping a phase (opening the catalogue before the gateway exists, or admitting external agents before the internal gateway has been exercised) produces sprawl with protocol names attached. Use official SDKs, and check per SDK which protocol version it implements; pin protocol versions at the gateway so a revision is a planned change.

Measure whether governance is working

The first four rows are Book 1 Ch 13 §7’s four questions, asked six weeks after standing the broker up. The catalogue-share row is from Working Paper 10 §5.4 (which also names elapsed time to first governed call, the third row). The call-count row is Book 1 Ch 13 §8’s bypass signal, and the rejection row follows Book 3 Ch 7 §6:

MeasureTarget / reading
Servers with a complete onboarding recordSize of the registry; should grow to cover all known servers
Servers present in agent runtimes or workstations but not in the registryClose to zero and falling
Elapsed time from request to first verified call for a low-risk serverAbout two business days; over three is a constraint, hours suggests a skipped step
How long a senior engineer would need to bypass the gateway todayClosed when the answer is “they could not”: runtimes refuse non-gateway URLs and egress blocks the alternative
Share of a project’s integrations met from the catalogueRising (WP10; no measured baseline exists)
Runtime MCP call count vs gateway MCP call countEqual; a gap is a bypass
Rejection countNon-zero over time; a broker that never rejects has not been tested

Acceptance tests before production

Record each result, with the client and gateway versions tested, in the broker’s control-evidence file.

  • On a managed laptop, adding an unapproved remote server fails with an enterprise-policy error.
  • Rename-spoof: an unapproved server renamed to match an approved server name still fails, because matching is on URL or command (Book 3 Ch 7 PR-4).
  • The client’s diagnostic command shows no managed entries stripped as invalid.
  • An unregistered server is denied at the gateway; a registered server with the wrong version, endpoint, tool schema or dependency digest is denied or held.
  • A read-only agent cannot invoke a write tool or change its own allow-list.
  • A wrong-audience token is refused by the server; the downstream log shows the server’s own identity and the gateway event carries the agent (and person, if delegated).
  • An agent outside a server’s allowed_consumers is denied; an out-of-mandate A2A delegation is denied at the agent gateway.
  • Caller, agent, purpose, server, tool, parameters, policy decision, tokenisation decision and result join on one correlation ID in the SIEM.
  • Malicious descriptions, outputs and interactive content cannot override the mandate or change an approved payload.
  • Emergency suspension blocks new calls at both points, revokes credentials and preserves evidence; for R2 the mean time to suspension is recorded.
  • A missing attestation triggers the deprecation path; a stdio pilot expires at 60 days.
  • A redeploy does not restore a suspended server.

Where the sources differ

TopicBook 1 (Ch 13)Book 3 (Ch 7, App B, App C)Page follows
Risk scaleLow / medium / high / criticalR0 / R1 / R2R0–R2; map Book 1 scale onto it
ApproversTwo minimum (line manager + security; data governance for critical)Tiered: broker; + DPO + data owner; + Virtual CAB + wranglerBook 3 tiers, with Book 1’s two-approver floor
Lifecycle statesproposed, approved, in-production, deprecated, retiredactive, experimental, deprecated, rejected, suspended (Ch 7 §5.1 lists four, without suspended)Book 3 enum, Book 1 mapped onto it
Retirement rule30 days zero traffic, measured not attested, deprecated → retired30 days no traffic and no attestation → deprecated after 14-day graceBoth: Book 3 for deprecation, Book 1 for final retirement
Review cadenceSix-monthlyQuarterly attestation (Ch 7 §5.7, field 16); App C §4 sets annual attestation for R0Quarterly, annual for R0
Owner departureNot specifiedCh 7 §5.7: manager re-attests within 30 days; App C §7: suspended after 14 days without successorApp C (stricter)
R1 / R2 gaten/aCh 7 §5.2: R1 second-line review; R2 Agent Control Board entry. App C: R1 data-class owner; R2 Virtual CAB + wranglerApp C, plus the governance-body entry for production agents
MCP revisionn/aApp C written against 2025-11-25 (May 2026); Ch 7 and WP10 against 2026-07-282026-07-28
Allow-list keyRegistry pins identity and signatureApp B Block 3 keys on serverName; Ch 7 §5.3 and PR-4 forbid itserverUrl / serverCommand (App B is a manuscript error)
Local / stdio serversRefactor to HTTP behind the gatewayPermitted as 60-day pilotsPilots on workstations only; none in production

Source status. Tiers, the intake form, the checklist, the register schema and the lifecycle are Book 3’s reference policy for a bank. The three sub-planes, thirteen-step onboarding and supply-chain controls are Book 1’s. The four platform products, reuse rules, threat model and adoption phases are the author’s proposal in Working Paper 10 and have not been tested in a controlled comparison. The agent-channel framework is Book 2’s. Banks, insurers and asset managers named by letter are composites. Vendor features are dated and marked for checking. This is a working draft.

Source material

  • Book 1 (Building Organizations for the Age of AI), Chapter 4, The Unified Control Map (§6.2 third-party risk on an MCP-tooled SaaS agent)
  • Book 1, Chapter 5, The Framework Backbone and the Cloud Control Plane (integration pillar; MCP-only supplier)
  • Book 1, Chapter 13, Gateway, MCP, and the API Boundary
  • Book 2 (The AI Delivery Factory), Chapter 11, Identity, Secrets, and Configuration (tool broker token exchange; delegation per cloud)
  • Book 2, Chapter 12, APIs, Data, and Integration (wrap once; tool contract versioning; tool-or-agent heuristic)
  • Book 2, Chapter 16, The Automation Factory (§4.5 manifest-driven catalogue and publication step)
  • Book 2, Chapter 26, The Agent Channel
  • Book 3 (Deploying Claude Safely), Chapter 5, Identity and Access (connector authorisation)
  • Book 3, Chapter 7, MCP and the Connector Broker (including Practitioner Reference PR-1 to PR-4)
  • Book 3, Appendix B, Claude Code Enterprise Settings Baseline (Block 3, MCP lockdown)
  • Book 3, Appendix C, MCP Server Registration and Approval Checklist
  • Book 09 (Everything Is Green), Chapter 5, Whose Name Goes Here (confused deputy)
  • DEIXEI Research Series, Working Paper 10, MCP and A2A: Interoperability Protocols for the Enterprise AI Factory

← All AI Delivery Factory guidance

On this page

  1. Why MCP is not just another API
  2. The boundary: one enforcement point, several jobs
  3. Decide first: tool or agent
  4. Wrap once and build the catalogue from manifests
  5. Tier every server: R0, R1, R2
    1. Transport and authentication policy
  6. Intake: the registration form and the SLA clock
  7. Onboarding: thirteen steps from request to production
  8. The security review: 25 items, 1–8 blocking
    1. When to reject
  9. The register: one row per server, published as a signed manifest
  10. Supply chain: provenance, IDE inheritance and vendor bundles
    1. The MCP-only supplier tier
    2. The catalogue is not the third-party register
  11. Identity and tokens: no passthrough, no confused deputy
    1. OAuth at the gateway
    2. Token passthrough and the confused deputy
    3. Scope pinning and per-tool rules
    4. Connector authorisation through the IdP
  12. Enforce the approved set twice
    1. At the gateway
    2. On the workstation: Claude Code specifics
    3. Close the bypass routes
  13. Protocol facts the broker depends on (dated)
    1. Human approval must bind to the payload
  14. Threat model
  15. Observability specific to MCP
  16. Lifecycle: states, triggers, retention
    1. States
    2. Triggers out of active (Book 3 App C §7)
  17. The agent channel: pointing the catalogue outward
    1. Architecture
    2. The six-question exposure decision
    3. Three non-negotiables before the first client connects
    4. Rollout: read before act, last and lowest
    5. Personalisation versus targeting
    6. The usage loop and token economics
    7. Partners, federation and the “agent mesh”
  18. Adopt in four phases
  19. Measure whether governance is working
  20. Acceptance tests before production
  21. Where the sources differ

All pages in Build the platform →