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
- Section
- Build the platform
- 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
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.

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):
| Property | Consequence | Control 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.

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:
| Product | Job | Minimum 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 registry | The 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):
- 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.
- 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. - 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.
- 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.
- 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.
| R0 | R1 | R2 | |
|---|---|---|---|
| Boundary | Read-only on public or internal-classification data | Read access to confidential or regulated data | Any write or action-taking operation, on any data class, including triggering downstream workflows |
| Approval body | Broker | Broker + DPO + named data-class owner | Broker + DPO + data-class owner + Virtual CAB + named wrangler |
| Required artefacts | Intake form + 25-item security checklist | R0 artefacts + DPIA reference (or exemption justification) + data-flow diagram + classification cross-check + supplier entry in the third-party register for vendor or community servers | R1 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 form | 5 working days (3 for first-party Anthropic connectors) | 10 working days | 15 working days |
| Monitoring | Standard pre- and post-tool-call hook telemetry into the SIEM | Hooks classify the data class per call and emit structured events; SIEM rules for anomalous query patterns | Per-action policy-decision callout at the gateway |
| Access review | Annual owner attestation | Quarterly by the data-class owner | Monthly 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:
| Choice | Rule |
|---|---|
| HTTP (Streamable HTTP) | Default for anything beyond a developer pilot. OAuth 2.x through the institution’s IdP is the target. |
| SSE | Deprecated; not a valid value for new registrations. |
| stdio | Engineering 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: none | Only at R0 on read-only public data, or for experimental pilots. |
api-key | Only 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.
| # | Question | What the broker checks |
|---|---|---|
| 1 | Server name and version; new, version bump, or re-registration after deprecation | Name collision with existing entries (typo-squat check) |
| 2 | Source: Anthropic, named vendor (with registration number), community, experimental, internal | Diligence depth |
| 3 | Use case and originating business team | A real consumer exists |
| 4 | Owner and backup owner, with directory identifiers | Both active employees with third-party-risk training in the last 12 months |
| 5 | Transport and authentication mechanism | Policy table above |
| 6 | OAuth scopes requested, exact strings | Any read:all-style scope needs a two-sentence justification |
| 7 | Tools exposed, verbatim from the spec, one line each | Becomes the registry’s own tool-surface copy |
| 8 | Data classes read (name the dataset for confidential and regulated) | Sets R0 vs R1 |
| 9 | Data classes written, if any | Any write is R2 |
| 10 | Sub-processor status (default for any external vendor: yes) | Supplier register entry |
| 11 | Data processing agreement reference and date, or procurement path and expected date | Blocking item 1 |
| 12 | External security audit (ISO/IEC 27001 or SOC 2 Type II report) | Attach report |
| 13 | Traffic estimate: calls per day, peak per hour, outage sensitivity | Rate limits and capacity |
| 14 | Rollback plan if compromised: suspension procedure, authority, dependent-agent impact, alternative | Exit and fallback |
| 15 | Wrangler (named owner of behaviour) for the agents that will use it | Accountability |
| 16 | Proposed tier with reasoning | Broker 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:
| Step | Action | Owner | Output / acceptance |
|---|---|---|---|
| 1 | Onboarding request raised in the developer portal | Wrangler | Audit trail starts; Book 3 intake form attached |
| 2 | Identification: name, gateway URL pattern, source, purpose, data classification | Requesting team | Registry draft row |
| 3 | Identity model: managed identity by default; OAuth on-behalf-of or client credentials by exception; API keys need CISO sign-off | Platform + security | Identity decision recorded |
| 4 | Allowed consumers: named agent identities and user populations, as an allow-list (not a deny-list) | Wrangler | Per-agent authorisation entries |
| 5 | Tool surface: tool list, descriptions, input/output schemas; descriptions get their own security review | Security reviewer | Registry tool-surface copy; read/act flag per tool |
| 6 | Logging level set against data class; personal data triggers gateway redaction before forwarding | Platform | Logging policy |
| 7 | Risk classification (R0–R2 on this page) | Broker | Tier with reasoning |
| 8 | Threat model against tool misuse, identity and privilege abuse, supply chain, and inter-agent communication where another agent consumes the output | Security | Threat model document |
| 9 | Security 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 body | Signed approvals with timestamps |
| 10 | Gateway publication: scopes, rate limits, policies attached; gateway URL allocated | Platform | Gateway route live in non-production |
| 11 | Catalogue registration: owner, status approved, surfaced in the developer portal; the portal flags name collisions | Broker | Registry row; signed manifest published |
| 12 | Telemetry wiring: gateway → monitoring → SIEM, with the MCP correlation field verified by a test invocation | Platform | Test call visible end-to-end in the SIEM |
| 13 | Lifecycle ownership: review cadence scheduled, retirement criteria recorded, wrangler accepts on-call | Wrangler | Status 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 |
|---|---|
| 1 | Data processing agreement on file, or contractual sub-processor designation in place, meeting the mandatory contractual clauses for ICT services (see regulatory map) |
| 2 | Sub-processor declared and acceptable to the DPO; cross-checked against the prohibited-sub-processor list |
| 3 | OAuth scopes pinned at the minimum for the declared tool surface; no read:all or equivalent unless justified and time-bound |
| 4 | Transport certificate chains to a CA accepted by the institution’s PKI policy; self-signed intermediates rejected |
| 5 | Tool descriptions reviewed for injection; the runtime validates against the broker’s registry, not the server’s self-description |
| 6 | Tool-output sanitisation verified; every output treated as untrusted input; agent-directed instructions stripped before re-injection |
| 7 | Owner and backup owner verified in the directory, both active and holding the MCP-owner role |
| 8 | Proposed 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 |
|---|---|
| 9 | Server URL or stdio command added to the managed client allow-list, distributed by device management |
| 10 | Per-tool permission rules captured in managed settings; managed deny rules precede any hook allow |
| 11 | Trust-dialog grant authority recorded for project-scoped registrations; refreshed quarterly |
| 12 | SIEM detection rule for the server: unexpected scope upgrades, high-frequency calls outside business hours, clustered denied calls |
| 13 | Audit evidence schema fields present in every pre- and post-tool-call event from this server |
| 14 | Data-classification labels match the data dictionary; mismatches block admission |
| 15 | Network egress allow-list covers only the server’s endpoints, at workstation and gateway; un-inspected TLS noted as residual risk |
| 16 | Credential lifecycle documented: refresh-token rotation, short-lived key helper TTL, no long-lived secrets in project configuration, secrets resolved from a vault |
| 17 | Zero-data-retention posture for downstream model calls confirmed (see vendor note below) |
| 18 | Gateway rate-limit and circuit-breaker policy for R1 and R2; mandatory for state-mutating tools |
| 19 | Server-side logging and retention where the institution controls the server; internal servers log at the engine and join the broker audit feed |
| 20 | Supplier reflected in the third-party Register of Information where it supports a critical or important function |
| 21 | Procurement confirms the vendor’s DPA template was reviewed and non-standard clauses negotiated |
| 22 | Exit strategy documented (unavailable, compromised or terminated server; dependent-agent fallback) for R1 and R2 |
| 23 | Suspension rehearsal executed once in non-production for R2; mean time to suspension recorded |
| 24 | Review date populated and accepted by the owner |
| 25 | Deprecation 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:
| # | Field | Type / values | Rule |
|---|---|---|---|
| 1 | server_id | system-generated, immutable | Join key across audit, gateway and SIEM |
| 2 | server_name | unique text | Canonical name used in mcp__<server_name>__<tool> permission rules. Never the sole match key for enforcement |
| 3 | vendor | first-party-anthropic / vendor / community / experimental / internal | Drives diligence depth |
| 4 | version | semver where available | Updated on each admitted release |
| 5 | transport | http / sse-deprecated / stdio | sse-deprecated invalid for new entries |
| 6 | auth_mechanism | oauth2-dcr / oauth2-preconfigured / api-key / kerberos / mtls / none | none only at R0 public read-only or experimental |
| 7 | oauth_scopes_pinned | exact IdP scope strings | Pinned at registration; enforced at the IdP and in managed config |
| 8 | tools_exposed | list, transcribed at admission | Basis for per-tool rules; diffed on every version change |
| 9 | data_classes_exposed | FK to the data dictionary | Drives the tier |
| 10 | risk_tier | R0 / R1 / R2 | Up by resubmission; never down without fresh registration |
| 11 | owner | named human | Auto-flag on a directory leaver event |
| 12 | approved_by | named human + role | Co-signed by DPO (R1+) and Virtual CAB chair (R2) |
| 13 | dpa_reference | document ID, date, contract-register URL | Required for vendor and community servers |
| 14 | sub_processor_flag | boolean | If true, the supplier appears in the third-party register |
| 15 | registered_date | date, auto | |
| 16 | last_review_date | date, auto | Most recent attestation |
| 17 | deprecation_date | date or null | Set on exit from active |
| 18 | traffic_last_30_days | number, auto from the SIEM | Feeds the disuse trigger |
| 19 | status | active / experimental / deprecated / rejected / suspended | Transitions 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_key | The literal serverUrl or serverCommand the allow-lists match on; no environment-variable expansion |
backup_owner | Carries the row during an owner-departure window (App C §3 and §7 require one; §2 has no field for it) |
spec_revision | MCP revision the server implements |
extensions_negotiated | For example MCP Apps, Tasks; any change is a change event |
allowed_consumers | Named agent identities and user populations (Book 1 step 4) |
dependency_manifest_ref | Frozen resolved-versions manifest and its digest (see supply chain below) |
read_act per tool | Whether each tool reads or acts |
design_record_ref | Tool-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:
- 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.
- 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.
- 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.
- 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).
- 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.
- 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):
- 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).
- 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.
- 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 point | Enforce | Evidence to keep |
|---|---|---|
| Managed workstation or runtime configuration | Only registered servers and approved transports load; local configuration cannot broaden access. | Configuration version, device/runtime identity, effective policy, rejected changes. |
| Connector registry | Owner, approved version, enforcement key, data scope, operations, tier, lifecycle state. | Admission record, tool-surface snapshot, dependency manifest, risk decision, review history. |
| Runtime gateway | Each 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 service | Server 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.jsonloads only the servers it lists; users cannot add others, plugin servers included, and claude.ai connectors are suppressed unlessallowAllClaudeAiMcpsis true. An empty map disables MCP. It cannot be delivered through server-managed settings, and it is world-readable, so no credentials inenvblocks. - Allow/deny filtering:
allowedMcpServersanddeniedMcpServersfilter 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 withallowManagedMcpServersOnly: true.allowManagedPermissionRulesOnlydoes not cover MCP. - Match on
serverUrlorserverCommand, neverserverName. The name is a user-assigned label; anyone can call a servergithub, 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 literalmcp__<server>__prefix; managed deny rules beat any hook allow. - Project trust: servers in a repository’s
.mcp.jsonprompt 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), usingenabledMcpjsonServers/disabledMcpjsonServers; a grant outside the list is a signal. Run a quarterly repository scan for.mcp.jsonfiles 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
initializehandshake 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 underttlMsandcacheScope. - Servers no longer send requests to clients. A server needing the user returns
input_requiredand 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_serversconnector 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):
| Threat | Vector | Controls (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 agent | Treat all output as data; output filtering at both gateways; least-privilege scopes; read/act separation; human approval on side-effecting actions | Red-team description and output hijack; diff advertised surface against the registry copy on every version change |
| Token passthrough / confused deputy | Server forwards a token not issued for it | Gateway token exchange; audience validation in every server; no system-of-record credentials in agents | Wrong-audience token refused |
| Rogue or spoofed servers and agents | Unvetted endpoint or forged card impersonates a known capability | Catalogue and registry as the only discovery sources; signed manifests and signed Agent Cards; mutual authentication on agent traffic | Rename-spoof and typo-squat registration attempts fail |
| Excessive agency (tool misuse, cascading failures) | Agent chains tools or delegations beyond its mandate; one delegation fans out | Per-agent authorisation matrix at both gateways; task-level budgets; a kill switch per agent, drilled | Out-of-mandate tool call and over-budget task are denied |
| Data exfiltration | Classified data leaves in a tool result or artefact | Data class on every catalogue and registry entry; content inspection at both gateways; egress control for external agents | Classified 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 status | Book 1 lifecycle equivalent | In manifest? | Entry / exit |
|---|---|---|---|
| (intake, not yet a row) | proposed | No | Complete intake form starts the SLA clock |
experimental | approved, conditions open | Pilot scope only | Conditional items 9–25 open, or stdio pilot (60-day expiry) |
active | approved → in production | Yes | Book 1: moves to in production automatically on the first verified production call |
suspended | (no equivalent) | Removed | Security finding or owner departure; back to active only with Virtual CAB approval |
deprecated | deprecated | Removed | Disuse or failed attestation |
| (retained record) | retired | Removed | Book 1: only after 30 days of measured zero traffic (not attested); permanent; return means a new onboarding |
rejected | (no equivalent) | Never | Retained 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)
- Disuse. No audit-channel traffic for 30 days and no owner attestation for 30 days → deprecation notice to owner, backup owner and wrangler →
deprecatedafter a 14-day grace period, during which any traffic or attestation rescinds it. Removed from both allow-lists on the next manifest publication. - 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). - Owner departure. No successor within 14 days of the directory leaver event →
suspendeduntil a new owner is assigned and blocking item 7 is repeated; the backup owner carries the window. If both owner and backup leave →suspendedimmediately.
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: 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:
| # | Question | Decision rule | Owner |
|---|---|---|---|
| 1 | What capability? | Must already be a clean, versioned, identity-aware API (data and API integration). If not, fix the contract first. | Product + platform |
| 2 | Which 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 |
| 3 | Whose 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 |
| 4 | Personalised 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 |
| 5 | What must stay a document? | Signed, dated records of record stay; the channel supplements them. | Compliance |
| 6 | How 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
- The endpoint is identity-bound and consent-scoped by the firm’s own gateway policy, not by anything the protocol promises.
- The channel is inventoried as a regulated AI system with the disclosure and evidence posture applied.
- 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:
| Phase | Scope | Exit criterion |
|---|---|---|
| 1. Foundations | MCP gateway running; server template and manifest schema available; two or three high-value systems wrapped; one production use case routed through the gateway | The 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 scale | Inner-source contributions to the catalogue accepted; catalogue servers are the default for new projects; listing requires the evaluation harness | The catalogue meets most new integrations; every system of record has one wrapper only |
| 3. A2A inside the firm | A2A gateway and agent registry running; first delegations between internal agents; task audit and approval steps working | At least two agent workflows spanning teams run in production with full task traces |
| 4. Federation | Chosen partner and supplier agents reached over A2A through third-party risk; external MCP servers admitted one at a time | External 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:
| Measure | Target / reading |
|---|---|
| Servers with a complete onboarding record | Size of the registry; should grow to cover all known servers |
| Servers present in agent runtimes or workstations but not in the registry | Close to zero and falling |
| Elapsed time from request to first verified call for a low-risk server | About two business days; over three is a constraint, hours suggests a skipped step |
| How long a senior engineer would need to bypass the gateway today | Closed 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 catalogue | Rising (WP10; no measured baseline exists) |
| Runtime MCP call count vs gateway MCP call count | Equal; a gap is a bypass |
| Rejection count | Non-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_consumersis 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
| Topic | Book 1 (Ch 13) | Book 3 (Ch 7, App B, App C) | Page follows |
|---|---|---|---|
| Risk scale | Low / medium / high / critical | R0 / R1 / R2 | R0–R2; map Book 1 scale onto it |
| Approvers | Two minimum (line manager + security; data governance for critical) | Tiered: broker; + DPO + data owner; + Virtual CAB + wrangler | Book 3 tiers, with Book 1’s two-approver floor |
| Lifecycle states | proposed, approved, in-production, deprecated, retired | active, experimental, deprecated, rejected, suspended (Ch 7 §5.1 lists four, without suspended) | Book 3 enum, Book 1 mapped onto it |
| Retirement rule | 30 days zero traffic, measured not attested, deprecated → retired | 30 days no traffic and no attestation → deprecated after 14-day grace | Both: Book 3 for deprecation, Book 1 for final retirement |
| Review cadence | Six-monthly | Quarterly attestation (Ch 7 §5.7, field 16); App C §4 sets annual attestation for R0 | Quarterly, annual for R0 |
| Owner departure | Not specified | Ch 7 §5.7: manager re-attests within 30 days; App C §7: suspended after 14 days without successor | App C (stricter) |
| R1 / R2 gate | n/a | Ch 7 §5.2: R1 second-line review; R2 Agent Control Board entry. App C: R1 data-class owner; R2 Virtual CAB + wrangler | App C, plus the governance-body entry for production agents |
| MCP revision | n/a | App C written against 2025-11-25 (May 2026); Ch 7 and WP10 against 2026-07-28 | 2026-07-28 |
| Allow-list key | Registry pins identity and signature | App B Block 3 keys on serverName; Ch 7 §5.3 and PR-4 forbid it | serverUrl / serverCommand (App B is a manuscript error) |
| Local / stdio servers | Refactor to HTTP behind the gateway | Permitted as 60-day pilots | Pilots 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
Related research
Related guidance
-
Identity, Secrets and Configuration for Agent WorkloadsGive every actor one owned identity, size its authority for the worst case, separate runtime from deployment, federate instead of holding keys, refuse impersonation and silent fallback, govern configuration by class, and audit the estate until flagged identities decline. -
Design and Operate the Model GatewayBuild the model gateway as the governed edge for every model call: per-client identity, per-request highest-class routing, tokenisation, pinned models, a conformant wire contract, a correlated evidence record, a tested concentration answer, and day-two cost, latency and reliability operations across two estates and three meters. -
Govern APIs, Data Products and Retrieval Agents Can TrustTurn interfaces and data into owned, versioned capabilities that applications and agents consume under identity, entitlement and evidence controls, and give agents access to meaning, limits and authority, not only bytes. -
Coding-Agent Workstation Baseline (Claude Code)Put Claude Code on developer workstations and build agents as privileged automation: one device-delivered managed policy per surface, lock flags that stop rules merging upward, command hooks for enforcement and HTTP hooks only for evidence, the OS sandbox where it runs, telemetry by policy, and the workstation recorded as a processing location. Dated to November 2026. -
The Enterprise Agent Control PlaneThe firm-owned services that make every agent action identifiable, decidable, approvable and reconstructable: the ownership boundary, six planes and their contracts, the Policy Decision API with its latency budget, the persistence schema, the build sequence and the tests that show it works. -
Classify Use Cases into Risk TiersThe T0–T4 use-case taxonomy as a working decision reference: the prohibited-use gate, four intake questions, data and action boundaries per tier, the twelve-area control matrix, retention and payload rules, runtime enforcement, approval gates, regulatory routing and re-tiering. -
Change Governance for Agent-Enabled DeliveryRoute agent-speed change by risk without losing the approver: control values that always reach a person, a routing gate that reads the right signals, autonomy earned per change family, a Virtual CAB that prepares a complete dossier, and three bodies with defined escalation. -
The Audit Spine and the Evidence RecordHow to capture, join, protect, retain and prove per-action evidence: the AES v0.1.0 record contract, three capture points and one correlation ID, tiered immutable storage, retention and legal hold, replay rehearsal, the route-approval evidence gate, and the Claude-specific ways evidence goes missing. -
Route Regulatory Questions to Obligations and EvidenceA dated, article-level reference that routes AI design questions to the EU AI Act, DORA and its RTS, GDPR and sectoral rules, and turns each obligation into a control, an owner and evidence: change records under RTS 2024/1774 Art 17, the 4 h / 72 h / one-month incident clocks, the CIF hinge and its five artefacts, the three-count Register of Information reconciliation, Art 14(4) oversight controls, the Art 26(5) discharge, the FRIA gate, Art 49 and Art 50, SCHUFA-grade review and supplier controls. -
Respond to Agent IncidentsSort an agent failure into one of four incident shapes, suspend it in three verified layers, keep humans on every classification and disclosure decision, route one playbook to every authority that needs a cover sheet, and close each incident with a named control change.