On a Friday afternoon the support team asks for a small favor. Brokers keep phoning about roof ages, and the support desk's tool, get_assessment_status, only says where a submission is in assessment. Could it also return the roof age? One of the uw-assessment maintainers agrees: it is one field, the data is already in the service, and the change ships at four o'clock.
On Monday, a reviewer in audit and compliance notices that the support desk's client now receives roof ages and evidence ids for every submission in its business unit. She asks who approved it. The maintainer assumed the domain data owner would have objected if it mattered. The domain data owner never heard about it. Security had approved support.read months ago for "a status summary" and saw no new scope. The platform team saw no new tool, so nothing went through the catalog. The support team assumed that if the server returned it, they were allowed to have it. Five teams, each acting reasonably, and nobody decided.
This scenario is hypothetical; in the example get_assessment_status returns a summary only, and its catalog record says data class summary. It shows the problem this page solves. On a shared capability, the dangerous changes are often small, and the question "who may make this change?" has to have one answer before the change is proposed.
Governance is decisions with names#
Governance, on this site, means three things written down: which decisions exist around a shared capability, which role makes each one, and what happens when someone disagrees or something breaks. It is not a committee that meets about everything. Most changes should pass with one review by the right person; the work is knowing who that person is.
Before AI. Backend teams have done this for years. A service has an owner and an on-call rota. A change to a shared database goes through the data owner. Access to an LDAP group needs an approver named on the group. A risky production change goes to a change advisory board. MCP changes none of this; it adds a new kind of consumer, an agent, and a new kind of change that looks harmless: editing a description the model reads.
The first primitive of this site applies with full force here. A protocol standardizes the call. It does not grant the permission. MCP defines how the support desk's host lists and calls get_assessment_status. It says nothing about who may change what that tool returns, and it cannot. Those decisions live in the catalog, the authorization policy and the people behind them.
Six roles around one capability#
The specification for this site names six roles, and the example uses them throughout. Each owns a different kind of decision.
The domain data owner is the team that owns the data and the business rules behind a capability, and therefore what every field means. For example, the property-risk data team owns roof_age_years, the rule R-ROOF-03 and the database schema; it decides whether support may see roof ages at all.
The server maintainer is the team that writes and releases the MCP server: tool names, schemas, descriptions, versions and the server's authorization code. For example, the uw-assessment maintainers froze version 2 of get_roof_assessment with the argument submission_id. A maintainer owns the contract's form, not its meaning, which is the line the Friday change crossed.
The other four are introduced on earlier pages, and their governance duties are what matter here.
| Role | Owns | A decision it makes in the example |
|---|---|---|
| Domain data owner (property-risk data team) | data, rules, meaning, schema | reviews a draft tool and its data class; deprecates get_roof_assessment v1 |
Server maintainer (uw-assessment maintainers) | tool schemas, descriptions, versions, server code | freezes a version and ships it in the server |
| Platform team | catalog, gateway policy, shared metrics, server operations | publishes a version, puts it under monitoring, retires it |
| Identity and security governance | scopes, which principals may hold them, risk tier | approves uw.recommend for agents only; keeps uw.decide human-only |
| Consumer application owner (each team) | its host, client id, token, use of results | claims registers claims-assistant and shows roof ages to adjusters |
| Audit and compliance | evidence that the rest happened | reviews refusals and grants; asks "who approved this?" |
The platform team runs how a capability is reached; the domain owns what it means. Who gets access explains the identities that identity and security governance approves. The new part on this page is how these roles hand work to each other.
The smallest primitive: one transition, one role#
The smallest governance rule is a state machine in which each move needs one role. The example's catalog.transition is that rule in ten lines. It is pure, so the lab in the browser ports it and the tests check both against each other.
def transition(state: str, action: str, role: str) -> dict[str, Any]:
"""One lifecycle step. Pure: the JavaScript lab ports this function. Returns {ok, new_state, reason}."""
t = TRANSITIONS.get(action)
if t is None:
return {"ok": False, "new_state": state, "reason": f"unknown_action: {action}"}
if state != t["from"]:
return {"ok": False, "new_state": state, "reason": f"wrong_state: {action} needs state {t['from']}, not {state}"}
if role != t["role"]:
return {"ok": False, "new_state": state, "reason": f"wrong_role: {action} needs {t['role']}, not {role}"}
return {"ok": True, "new_state": t["to"], "reason": t["why"]}
Quoted verbatim from examples/uw-mcp/catalog.py. Notice what it refuses: an unknown action, a move from the wrong state, and the right move by the wrong role. It does not know who the person is; in a real system the role comes from the reviewer's identity in the change tool, and the transition is recorded with that identity. The function shows the rule, not the workflow engine around it.
The publishing lifecycle, draft to retired#
The publishing lifecycle is the sequence of states a tool passes through, from a proposal to its removal, with the role that moves it at each step. In the example the states are draft, reviewed, approved, versioned, discoverable, monitored, deprecated and retired.
Each state answers a question. Reviewed: does the domain data owner agree on what the tool means and which data it exposes? Approved: does security accept its scopes, principal types and risk tier? Versioned: is the schema frozen and shipped? Discoverable: is it in the catalog and the gateway policy, so callers with the right scopes see it? Monitored: are there dashboards, alerts and an on-call owner? Deprecated: is a replacement and a retirement date named? Retired: has every consumer stopped calling it?
The script below walks one tool through the happy path with the right role at each step, then tries four other moves. It shows that the rule accepts the documented sequence and refuses the others; it does not show reviews happening, which are people's work.
"""Scratch demo for the governance page: walk a tool from draft to retired, then try four wrong moves."""
from catalog import HAPPY_PATH, TRANSITIONS, transition
state = "draft"
for action in HAPPY_PATH:
role = TRANSITIONS[action]["role"]
step = transition(state, action, role)
print(f"{action:<10} {role:<20} {state:>12} -> {step['new_state']}")
state = step["new_state"]
for state, action, role in [("reviewed", "approve", "server-maintainer"),
("draft", "publish", "platform-team"),
("monitored", "deprecate", "platform-team"),
("reviewed", "reject", "security-governance")]:
step = transition(state, action, role)
print(step["ok"], step["new_state"], step["reason"])
Run in a scratch copy of examples/uw-mcp on 2026-11-18:
review domain-data-owner draft -> reviewed
approve security-governance reviewed -> approved
version server-maintainer approved -> versioned
publish platform-team versioned -> discoverable
monitor platform-team discoverable -> monitored
deprecate domain-data-owner monitored -> deprecated
retire platform-team deprecated -> retired
False reviewed wrong_role: approve needs security-governance, not server-maintainer
False draft wrong_state: publish needs state versioned, not draft
False monitored wrong_role: deprecate needs domain-data-owner, not platform-team
True draft Security sends it back: a scope, a risk tier or a data class is wrong.
The maintainer cannot approve the tool they wrote. The platform team cannot publish a draft, and cannot deprecate a tool on its own, because deprecation is a decision about meaning and consumers, which belongs to the domain owner. Security can send a reviewed tool back to draft. Those four refusals are the separation of duties the Friday change skipped.
Diagram: The publishing lifecycle · eight states, and the one role that may move each step
Read left to right, then follow the arrows down to deprecation and retirement. Each lane is a role; a state sits in the lane of the role that moves the tool into it. The domain data owner reviews and deprecates, security approves or sends back, the maintainer freezes a version, the platform team publishes, monitors and retires. A wrong role is refused, so nobody writes, approves and publishes the same tool.
- Domain data owner · meaning
- draft: A proposed tool record: name, description, schemas, scopes, data class. Not listed, not callable.
- reviewed: The data owner confirms what the tool means and which data it exposes.
- deprecated: Replacement and retirement date named; still callable and self-explaining, no longer listed.
- Security governance · scopes and tier
- approved: Scopes, principal types and risk tier accepted; reject sends the tool back to draft.
- Server maintainer · form
- versioned: The schema is frozen as a version and shipped in the server.
- Platform team · reach and operations
- discoverable: In the catalog and the gateway policy; listed to callers whose scopes allow it.
- monitored: Dashboards, alerts and an on-call owner in place. Every live tool in the example is here.
- retired: No consumer calls it; it leaves the catalog and the server. A call by name is unknown.
The lab starts at draft; the second copy starts at reviewed, the point where security decides. Try approving as the server maintainer, then as security-governance, then rejecting. People in roles act here; no model or agent takes part.
| Action | From → to | Role | Why |
|---|---|---|---|
| review | draft → reviewed | domain-data-owner | the data owner confirms what the tool means and which data it exposes |
| reject | reviewed → draft | security-governance | a scope, a risk tier or a data class is wrong |
| approve | reviewed → approved | security-governance | security approves scopes, principal types and risk tier |
| version | approved → versioned | server-maintainer | the schema is frozen as a version and shipped in the server |
| publish | versioned → discoverable | platform-team | added to the catalog and the gateway policy |
| monitor | discoverable → monitored | platform-team | dashboards, alerts and an on-call owner are in place |
| deprecate | monitored → deprecated | domain-data-owner | the replacement and a retirement date are named |
| retire | deprecated → retired | platform-team | no consumer calls it; it leaves the catalog and the server |
A tool is listed in tools/list only when discoverable or monitored, still callable when deprecated, and unknown when retired. The lifecycle is this example's assignment of roles; the MCP specification defines no lifecycle for tools. This site's recommendation: keep the four roles distinct even in a small organization, so that no single person writes, approves and publishes the same tool.
Risk tiers: how much review a tool needs#
Not every tool deserves the same ceremony. A risk tier is a label on a catalog record that says how much harm a misuse of the tool could cause, and therefore how much review, testing and operational care it needs. In the example the tiers are low, medium, high and critical. search_guidance and the two summary tools are low; get_roof_assessment and check_eligibility are medium (record-level data); record_recommendation is high (a write, by an agent); record_underwriter_decision is critical (a person's binding decision).
The tier is assigned at approval, by security with the domain data owner, and it is the lever that keeps governance proportionate. What each tier requires is this site's recommendation, not something the example enforces:
| Tier | Typical tool | Approvals before discoverable | Change advisory | Operations |
|---|---|---|---|---|
| low | guidance search, aggregates, status summary | domain owner + security (light review) | not needed for compatible changes | shared on-call; standard alerts |
| medium | record-level reads | domain owner + security; data class checked | any change to the data returned | on-call named; per-consumer metrics |
| high | agent writes such as record_recommendation | domain owner + security; idempotency and audit tested | every change, including descriptions | on-call named; write-specific alerts; quarterly grant review |
| critical | human-only decisions | as high, plus a test that every agent principal is refused | every change; two approvers | as high; any refusal anomaly pages |
The Friday change moved get_assessment_status from summary data to record data. Under these rules that is a change of data class, which raises the tool from low to medium and needs the domain owner and security again. The tier is not paperwork; it is what makes the question "does this change need review?" answerable by reading the catalog.
Who approves scopes, and who grants a team access#
Two decisions are easy to blur. Approving a scope means deciding that a permission exists and which kinds of principal may ever hold it: uw.recommend for agents, uw.decide for people with the underwriter role. Granting access means giving one consumer's client that permission. The example keeps them apart in its RACI: identity and security governance is accountable for both, but the platform team does the grant, and the domain data owner and the consumer application owner are consulted.
Normative (MCP specification 2026-07-28): a server names the scopes a request needs and should answer a missing one with 403 insufficient_scope (authorization). Who decides that a scope exists, and who may hold it, is outside the specification.
The MCP security best practices page, which accompanies the specification, lists "silent scope semantic changes without versioning" among common mistakes (security best practices). The Friday change was one: support.read kept its name and quietly came to mean more.
The RACI matrix of the six roles#
A RACI matrix lists activities in rows and roles in columns, and marks each cell R (responsible: does the work), A (accountable: answers for the outcome, exactly one per row), C (consulted before) or I (informed after). For example, "Approve scopes and risk tier" has security as A, the domain owner and the maintainer as C, everyone else as I.
The example ships a RACI in catalog.RACI. The script prints it and checks the rule that matters most, one accountable role per activity; it proves the table is well formed, not that anyone follows it.
"""Scratch demo for the governance page: print the RACI of catalog.py, one column per role."""
from catalog import RACI, RACI_ROLES
short = ["data-owner", "maintainer", "platform", "security", "consumer", "audit"]
assert len(short) == len(RACI_ROLES)
print(f"{'activity':<36}" + "".join(f"{s:<11}" for s in short))
for row in RACI:
print(f"{row['activity']:<36}" + "".join(f"{x:<11}" for x in row["raci"]))
accountable = [row["raci"].count("A") for row in RACI]
print("exactly one A per activity:", all(n == 1 for n in accountable))
activity data-owner maintainer platform security consumer audit
Define the capability and its data A R I C C I
Approve scopes and risk tier C C I A I I
Publish to the catalog A C R C I I
Run the server (on-call) I A R I I I
Grant a team access C I R A C I
Respond to an incident C R R A I I
Review audit evidence I C C C I A
Deprecate and retire A R R C C I
exactly one A per activity: True
The table below repeats the example's eight rows and adds four that the example does not have. The extension is this page's, marked as such; each one closes a gap the threat model or the Friday story opened.
| Activity | Data owner | Maintainer | Platform | Security | Consumer owner | Audit |
|---|---|---|---|---|---|---|
| Define the capability and its data | A | R | I | C | C | I |
| Approve scopes and risk tier | C | C | I | A | I | I |
| Publish to the catalog | A | C | R | C | I | I |
| Run the server (on-call) | I | A | R | I | I | I |
| Grant a team access | C | I | R | A | C | I |
| Respond to an incident | C | R | R | A | I | I |
| Review audit evidence | I | C | C | C | I | A |
| Deprecate and retire | A | R | R | C | C | I |
| Change what a tool returns or says (extension) | A | R | I | C | I | I |
| Emergency-disable a tool (extension) | I | C | R | A | I | I |
| Approve a third-party server for a host (extension) | C | I | R | A | C | I |
| Review a usage-policy breach (extension) | C | I | C | A | R | C |
The first extension row is the Friday change. Changing a description, an annotation or the fields a tool returns is a change to the contract's meaning, so the domain owner is accountable and the maintainer does it; security is consulted because a description is text the model reads (Threat model). The second gives the platform team the power to stop a tool at once and security the accountability for when it comes back.
Owners, on-call and the escalation path#
A capability with many consumers fails for all of them at once, so "who answers the page?" needs one answer per kind of failure. The example splits it: the platform team is responsible for running the server and is first on call; the maintainers are accountable for the server; security is accountable for incidents; the domain owner is consulted when the failure is about data or rules.
An incident in this sense is anything that breaks a promise of the catalog: a tool unavailable, a tool returning wrong data, a refusal that should not happen, or an allowed call that should have been refused. The escalation path below is this site's recommendation, built on the example's RACI.
Diagram: An allowed call that policy should refuse · stop first, then decide, then inform
Time runs down the page. An alert reaches the platform team, which disables the tool at the gateway without a meeting. The maintainer diagnoses the server. Security decides whether it is a security incident and owns re-enabling. The domain data owner checks data already written. Consumer owners and audit are informed, from the audit events.
- Platform team on call: alert: record_recommendation allowed for intake-agent. A call the catalog says must be refused (compare UW-M03).
- Platform team on call: disable the tool at the gateway and at execution. Fast stop by one role; no advisory needed to stop.
- Platform team on call to Server maintainer: page: diagnose. Policy code, catalog record or a misgranted scope?
- Server maintainer to Security governance: cause: execution check skipped in a release. Hypothetical cause for the drill.
- Security governance to Domain data owner: which rows were written?. Recommendations stored by the wrong principal may need review.
- Security governance to Consumer owners + audit: incident record; affected clients informed. Evidence comes from audit events by client_id.
- Security governance to Platform team on call: re-enable after the fix and a passing test. Two people to start: the stopper does not restart alone.
The order matters. The platform team can act within minutes without a meeting: rate-limit a consumer, hide a tool from discovery, or refuse it at the gateway. The maintainer diagnoses the server. Security decides whether an allowed call that should have been refused is a security incident, and owns re-enabling. The domain owner decides whether stored recommendations built on wrong data must be revisited. Every consumer application owner whose client called the tool is informed, found from the audit events by client_id (Observability). Audit and compliance is told, and later checks that the record of the incident is complete.
| Trigger | First responder | Escalates to | Within (illustrative) |
|---|---|---|---|
| Error rate or latency alert on one tool | platform team on call | server maintainer | one hour |
| A consumer reports wrong data | server maintainer | domain data owner | one business day |
| An allowed call that policy should refuse | platform team (disable at the gateway) | security governance, then domain owner | immediately |
| Repeated refusals from one agent principal (possible injection) | platform team | security governance; consumer owner informed | same day |
| A tool definition differs from its pinned fingerprint | platform team (hide the tool) | security governance, server maintainer | immediately |
Change advisory: which changes need a second look#
A change advisory is a review of a proposed change by the roles it affects, before it is deployed, scaled to the change's risk. For example, adding an optional field to a low-tier tool's output needs only the maintainer's release notes; changing the meaning of roof_age_years needs the domain owner, security and every consumer application owner.
The rule of thumb on a shared capability: a change needs advisory when it can change what a consumer is allowed to see, what a field means, or what the model reads. That makes some small diffs heavy and some large ones light.
| Change | Advisory? | Who must agree |
|---|---|---|
| Bug fix that keeps every field's meaning | no | maintainer (release notes) |
| New optional output field, same data class | no for low and medium; yes for high and critical | maintainer; domain owner informed |
| New field from a stricter data class (the Friday change) | yes | domain owner, security; consumers informed |
| Description or annotation edit | yes for every tier above low | domain owner, security |
| New scope, or a scope given new meaning | yes | security, domain owner |
| New consumer team | yes | security (grant), domain owner (data), consumer owner |
| New major version or deprecation | yes | domain owner, consumer owners, platform team |
The description row is the one teams forget, because the diff is prose. On an MCP server, prose is part of the contract: it is what the model reads to decide whether to call. An unreviewed description change is how a rug pull looks from the inside.
Usage policy and review#
A usage policy states what a consumer may do with what it receives: the support desk may tell a broker the status of a submission, not quote a roof age; analytics may publish aggregates, never one submission's facts. The policy belongs to the domain data owner, is agreed with each consumer application owner when access is granted, and is written into the catalog entry or the ADR that granted access (Playbooks).
Policies decay unless someone reviews them. This site's recommendation: review grants on a schedule set by the tier (quarterly for high and critical, yearly for low), with audit and compliance accountable for running the review and the evidence coming from audit events: which clients called which tools, which calls were refused and why. A team that holds a scope and has not used it for a review period loses it. Access that nobody can explain is removed until someone can.
Deprecation and retirement#
Deprecation is announcing that a tool version will stop working on a named date, naming its replacement, and keeping it working and self-explaining until then. In the example, version 1 of get_roof_assessment is deprecated: not listed, still recognized, and when a version-1 client calls version 2 the error names the deprecated version and its replacement (case UW-M07, on Sharing across teams).
The domain owner deprecates because the decision is about meaning and consumers; the platform team retires because removal is an operations act, done when the per-version call count has been zero for the agreed period. Playbooks has the retirement checklist. Two outside reference points show the same shape. Normative (MCP specification 2026-07-28): the specification project adopted its own feature lifecycle (Active, Deprecated, Removed) with a minimum twelve-month window and a registry of deprecated features (changelog).
Ecosystem pattern: in the public MCP Registry, server metadata is immutable except its status, which can become deprecated or deleted, as documented on 2026-11-18. Neither applies to an organization's tools directly; both show that announced, dated deprecation is how shared interfaces keep their consumers.
Many teams, no database credentials#
The governance model above only works if the capability has one place where rules and data live. The example keeps that place in the assessment service, and only the service holds database credentials. Its scoped accounts are narrow on purpose: uw_reader reads only, uw_rec_writer may insert into recommendations only, uw_decision_writer may insert into decisions only, and owner runs migrations (The database decision).
No agent, host or MCP server holds any of them. The claims assistant, the support desk and analytics reach the data through the MCP server, which calls the service with an exchanged token; the service checks its own rules, including that only a person with role underwriter causes a decision. That has three governance consequences. Access is granted by scope, per client, and revoked in one place (case UW-M05). A new consumer never triggers a database grant, so the domain owner's schema stays private. And an agent that is fooled, as in UW-M09, has no credential that could bypass the server even in principle.
A standard protocol is not a trusted one#
It is tempting to treat "it speaks MCP" as a qualification, the way "it has an OpenAPI document" once was. It is not one. Normative (MCP specification 2026-07-28): the specification states that MCP itself cannot enforce its security principles at the protocol level (specification), and it asks clients to treat tool annotations as untrusted unless they come from trusted servers. The registry verifies a namespace, not code and not control of a remote URL (registry). The NSA's guidance concludes that MCP security "remains uneven and highly dependent on implementation discipline rather than protocol guarantees" (https://media.defense.gov/2026/Jun/02/2003943289/-1/-1/0/CSI_MCP_SECURITY.PDF, archived copy read 2026-11-18).
Standardization makes a server easy to connect. It does not tell you who wrote it, who runs it, what it does with arguments, or whether it will behave the same next week. Trust is given by the organization, per server and per tool, through the lifecycle on this page, and authentication and authorization remain independent of the protocol: every call to uw-assessment carries a token checked on its own, whatever the host believes.
Governing the human decision path#
One decision on this platform is not delegated to any agent: the underwriting decision. Playbooks records it as ADR-003, "no agent may record an underwriting decision". Governance keeps that record true over time. record_underwriter_decision is in the critical tier. Its catalog record allows principal type user, role underwriter and client uw-cockpit only; the domain service checks the same rule again. Any change to that record needs two approvers, and a fitness check fails the build if any agent principal can call it, even with uw.decide granted by mistake.
When the underwriter decides through the cockpit with their own delegated token (case UW-M10), the decision is recorded for the person and the agent's recommendation stays a recommendation, linked to it. The model recommends; a person decides. The governance question is never whether an agent may decide; it is who may change the rule that says it may not.
Security and governance notes#
Security note. Separation of duties is a security control. The maintainer who writes a tool must not approve its scopes, and the team that can disable a tool at the gateway must not be the one that re-enables it alone. The lifecycle and the extended RACI encode both.
Governance note. Store the governance facts where the system can read them: owner team, maintainer, risk tier, data class, state, approved fingerprint and the ADR that granted each consumer, all in the catalog record. A rule that lives only in a wiki is checked only when someone remembers it.
In a coding agent. A company that gives coding agents shared MCP servers needs the same roles. The repository server's maintainers writeread_fileandsearch_code; security approves which agents may callopen_pull_requestand on which repositories; a person merges. A public server from a marketplace enters through the same lifecycle as an internal one, starting at draft. Diff to Deploy follows such a pull request through review.
What this is not. This page covers who decides around a shared capability. How the platform records evidence of those decisions and of every call belongs to Observability; logs, metrics and traces as a discipline belong to Observe Engineering. Catalog records, names and versioning are on Sharing across teams.
What would have stopped the Friday change#
Replay the opening with the pieces of this page in place. The maintainer's change adds a field from a stricter data class, so the catalog's change rules route it to the domain owner and security before release. The domain owner declines roof ages for support and offers a narrower field, such as "roof age verified: yes or no". If the change had shipped anyway, the gateway's fingerprint of the approved output schema would have differed, the tool would have been hidden, and the platform team would have paged security. And the quarterly review would have found it at the latest, from audit events showing roof ages flowing to support-desk.
Checklist for Monday#
| Check | Pass when |
|---|---|
| Six roles named | Every catalog entry names the domain owner, maintainer and platform contact; security and audit are known by team |
| Lifecycle enforced | No tool reaches discoverable without review by the domain owner and approval by security |
| Separation of duties | Nobody can write, approve and publish the same tool |
| Risk tier | Every tool has a tier, and the tier decides approvals, change advisory and alerting |
| One accountable role | Every RACI row has exactly one A, including incidents and emergency disable |
| Change rules | Description, annotation, data-class and scope changes are reviewed like schema changes |
| Escalation | Triggers, first responders and escalation targets are written and tested in a drill |
| Review | Grants are reviewed on a tier-based schedule from audit evidence; unused scopes are removed |
| Deprecation | Every deprecated version has a replacement, a date and a falling call count |
| No database credentials outside the service | No agent, host or MCP server holds a database account |
Exercises#
- Marketing asks for
get_roof_assessmentfor a campaign. Walk the request through the extended RACI: who is accountable, who is consulted, and what is the likely first offer? - A maintainer argues that a description edit is "documentation, not code" and should skip review. What do you answer?
- An alert shows
record_recommendationbeing called successfully byintake-agent. Who acts first, what do they do, and who decides when the tool comes back?
AnswersOne line each
- "Grant a team access": security accountable, platform responsible, domain owner and marketing's application owner consulted; the likely first offer is
get_assessment_stats(aggregates), as ADR-005 did for analytics. - The description is text the model reads to decide whether to call; editing it changes behavior, so it is a contract change with the domain owner accountable and security consulted.
- The platform team disables the tool at the gateway at once (an allowed call that policy should refuse); security investigates and is accountable for re-enabling it, with the domain owner checking stored recommendations.
Central platform or federated domains?Where approval power sits as the number of servers grows, and what each design breaks
A central model puts every approval with one platform and one security group: every tool on every server passes the same reviewers. It is consistent, easy to audit, and becomes a queue. At a handful of servers it works; at fifty, the reviewers approve descriptions they do not understand for domains they do not know, which is the review equivalent of nobody deciding.
A federated model gives each domain its own approval power for its own tools, inside rules the platform sets: the domain owner reviews, a security champion in the domain approves low and medium tiers, and only high and critical tiers go to central security. The catalog is still central, so names, scopes and risk tiers stay comparable across domains. The cost is drift: domains interpret "medium" differently, and a weak domain approves weak tools.
The example's RACI is compatible with both; what changes is who fills the security column for which tier. This site's recommendation: federate low and medium tiers once there are more than a few domains, keep high and critical central, and let audit and compliance sample federated approvals each quarter. Whatever the model, the scope namespace and the catalog stay central, because two domains that each invent read scopes make every later authorization decision ambiguous.
Emergency disable and break-glass accessFast stops need wide permission; fast starts need a second person
The platform team can hide a tool from discovery or refuse it at the gateway without a meeting. That power must be fast and broad, because the cost of a wrong call by an agent at scale grows by the minute. Hiding is not enough on its own: a client that cached the list, or calls by name, still reaches the server, so the refusal must also apply at execution, as UW-M03 teaches.
Re-enabling is the dangerous direction. A tool that was stopped because an agent could write what it should not is re-enabled only when security agrees the cause is fixed, and the re-enable is recorded with both identities. The asymmetry, one person to stop and two to start, is the standard pattern from production change management and fits here unchanged.
Break-glass access is the mirror case: a person who needs data during an incident that their role does not normally grant. It should exist, be time-limited, require a reason, page security when used, and produce audit events that the next review must explain. A break-glass path that is never reviewed becomes the normal path within a year. Agents never get break-glass access; an agent that needs more permission in an emergency is a design bug, and the fix is a person in the loop.
Calibrating risk tiers so they mean somethingFour questions that place a tool, and the failure modes of tiering by feel
Tiers decay into labels when they are assigned by feel. Four questions place a tool consistently. Does it write, and can the write be undone? What is the strictest data class it returns or accepts? Which principal types may call it (people only, agents, services)? What happens downstream if its answer is wrong, a display, a recommendation or a decision? In the example, record_recommendation writes, but the write is idempotent and only a recommendation, so it is high; record_underwriter_decision writes a person's binding decision, so it is critical, and the principal type is part of its definition.
Two failure modes are common. The first is tier inflation: everything becomes high because nobody wants to be the one who rated a tool low, and then the extra review is skipped for everything because it cannot be done for everything. The second is tier freeze: a tool keeps the tier it had when it was created, while its data class, consumers or downstream use change around it. The Friday change is tier freeze in one afternoon.
Tie the tier to facts in the catalog (kind, data class, principal types) and recompute it whenever one of them changes. A change that raises the computed tier then cannot ship under the old one, because the release check compares them. That turns "is this risky?" from an opinion into a diff.
In one breath#
A shared capability is governed by named decisions: the domain data owner decides meaning and data, the server maintainer decides form, security decides scopes and risk tier, the platform team publishes, runs and retires, each consumer owns its use, and audit checks that it all happened. The publishing lifecycle makes those decisions a sequence in which each move needs one role, the risk tier decides how much review a change needs, and the RACI gives every activity, including incidents and emergency stops, exactly one accountable role. Only the service holds database credentials, and no protocol, however standard, earns trust on its own.
Each decision on this page is only as good as the evidence that it was followed. When audit asks who approved a grant, who called a tool and why a call was allowed, the answer has to come from records written at the moment of the call, with the caller, the decision, the policy version and the outcome. That is Observability and audit.