Platforms now carry the standards

Platform engineering has taken on a governance job. The Cloud Native Computing Foundation (CNCF) Platforms White Paper puts it in one sentence: "In a nutshell, platforms bridge from underlying capability providers to platform users like application developers; and in the process implement and enforce desired practices for security, performance, cost governance and consistent experience." Under "Secure by default" it adds: "A platform should be secure by default and offer capabilities to ensure compliance and validation based on rules and standards defined by the organization."

The CNCF Platform Engineering Maturity Model says the same thing as a maturity step. At its third operations level, "New services must adhere to standard practices such as standard interfaces, documentation, and governance." Team Topologies defines the platform team as "a grouping of other team types that provide a compelling internal product to accelerate delivery by Stream-aligned teams." Stream-aligned teams are the teams aligned to a flow of work, usually from one part of the business.

Read together, the three split the work. The platform team runs the controls. Someone else defines the rules and standards the controls apply. Where an organization has an enterprise architecture function, that someone is the architects, whether they sit on a review board, in a principal engineer group or in an advice forum.

The CNCF paper's phrase "defined by the organization" is where the handoff lives, and it is where the handoff usually goes unrecorded.

One decision, three groups

Take the example from When Kubernetes Works but the Application Still Fails. The orders service must reach PostgreSQL only through its data adapter (the one module that opens database connections and owns the connection pool), and the deployment must stay inside a database connection budget. That article works through the arithmetic. The database accepts 100 connections, 3 of them reserved connections (slots PostgreSQL holds back for superusers), which leaves 97. Each pod opens a pool of 12, so 8 pods fit (96 connections).

A rolling update adds surge pods, the extra pods a Deployment runs above its desired count during the update, and the default 25% surge turns 6 pods into 8. So the Horizontal Pod Autoscaler (HPA) for the service must not scale past 6 replicas: 6 plus 2 surge pods is 8, and 8 × 12 = 96.

Count who touches that one decision:

  • Architecture accepts it, because it binds a shared database and more than one team.
  • The platform team encodes the replica cap in an admission policy (a rule the cluster checks before it accepts an object such as an HPA), adds the budget arithmetic to the pipeline and sets an alert on connections in use.
  • The service team owns the adapter and the pool size in application config.

The architects hold the reason. The platform team holds three of the five artifacts that carry it: the admission policy, the pipeline check and the alert. The service team holds the other two, the adapter code and the pool setting. Each group can do its job well while the link between the decision and the controls goes missing.

Where the handoff breaks

Policy as Code Enforces Rules. Who Governs the Decisions Behind Them? covers one break: a policy that keeps evaluating after its decision was superseded. Three more come from the handoff between architecture and platform.

Nobody wrote down who may change what. During an incident, a platform engineer raises the HPA maximum from 6 to 9 and files an exception against the admission policy. Was that a waiver within the platform team's authority, or a revision of an architecture decision? The policy engine records that an exception happened. Nobody recorded whether the engineer was allowed to grant it.

Delegation happened by accident. The architecture record says "stay within the connection budget." The number 6 appears only in the policy. The platform engineer who picked it made an architectural choice, and architects reviewing the decision later will not find it in their record. If the pool size changes, the record gives them nothing to recompute.

The reported number measures the control. An architect asks whether teams comply. The platform team reports that the admission policy passed every HPA in the orders namespace (the Kubernetes namespace that holds the service) last quarter. That figure says the policy ran. It does not say whether the policy still matches the budget, whether the alert fires, or whether any handler bypasses the adapter. A rule with zero failures can be correct, or it can be checking nothing that matters.

Engineering decision governance already lists authority and exceptions among the properties of a governed decision. Across the architecture and platform boundary, those two properties need concrete answers per decision. Three actions cover most of it:

ActionWho holds it (connection budget example)What it changes
AcceptArchitecture, with the database ownerThe decision enters force: the budget exists, and the adapter is the only path to the database.
ReviseArchitectureThe decision itself: a new budget, a connection pooler such as PgBouncer in front of the database, a different database limit. A new version, with every control that cites it listed for review.
WaivePlatform team, within stated boundsOne case, for a stated period: for example, an HPA maximum above the cap for seven days during a launch, with the reason recorded against the decision.

Decentralised models do not remove the question. In the advice process Andrew Harmel-Law describes in Scaling the Practice of Architecture, Conversationally, "anyone can make an architectural decision", provided they first consult everyone meaningfully affected and people with expertise in the area. The person deciding does not have to follow the advice, but has to seek it out, listen to it and record it. That settles who may accept. The platform team still needs to know which accepted decisions its controls enforce, and who may waive them.

Then write down what the architects delegated. For this decision, a reasonable split gives the platform team the enforcement points and their parameters, as long as the arithmetic holds: which admission policy, which pipeline step, which alert threshold. It gives the service team the pool size and adapter code within the same budget. It keeps the budget formula, the reserved connections and the adapter boundary with architecture. A platform change that breaks the formula becomes a revision request, not a policy edit.

The last piece is a reference in each direction. Every control cites the decision identifier and version it enforces. The decision record lists the controls that enforce it, with an owner for each. When architecture revises the decision, the list tells the platform team what to change. When the platform team waives a control, the waiver lands against the decision the architects own.

Measure the decision, not the control

The maturity model treats measurement as its own aspect and ties it to outcomes. At its third measurement level, "Desired results and outcomes are identified followed by standard metrics chosen to indicate progress towards those outcomes." At its second operations level: "Migration and upgrade work is tracked against a burndown chart enabling the organization to track rate of compliance and time until completion." That line is about platform migrations, and the same instrument fits a revised decision: the platform team can burn down the controls still enforcing the old version. Apply the same thinking to decisions. Three measures belong to each one:

  • Coverage. Which parts of the decision have a running control, and which still depend on someone reading a document. For the budget: the adapter rule, the pipeline arithmetic, the admission policy and the alert, each present or absent.
  • Exceptions. How many waivers exist against the decision, how old they are, and who granted them. One seven-day launch waiver is routine. A dozen open waivers is evidence the decision no longer fits the system.
  • Intervention cost. The human time the decision consumes: blocked builds someone had to override, exception requests, manual reviews of changes the controls could not judge. A decision that costs a team hours every week deserves a review, whatever its pass rate says.

These measures give architects something to act on. High exception counts and high intervention cost are a request to revise. Low coverage is a request to the platform team for another control, or a sign that part of the decision should stay as guidance.

Agents raise the rate of change

Coding agents now edit HPA objects, pool settings and policy exceptions in the same pull request as application code. An agent asked to unblock a deployment can produce a well-formed exception in seconds. Whether that exception falls within anyone's delegated authority is a question the policy repository cannot answer, because the delegation lives nowhere in it. A team can hold the link together by hand when the numbers change twice a year. That gets harder once an agent can propose a new replica cap or exception in any pull request.

Where Mneme fits

Mneme, an open-source decision and control layer for agentic software development, covers the repository side of this link today, in mneme-hq 0.10.0, Mneme's open-source package at its current release. It does not enforce infrastructure policy, provision cloud resources or manage identity and access, as the platforms page states. Admission policies, pipeline arithmetic and alerts stay with the platform team's own tools.

What ships:

  • The Decision Index, Mneme's persisted, versioned record of decisions, stores each decision's immutable versions, its lifecycle status (such as active or superseded) and its source, for example the architecture decision record (ADR) file and its content hash.
  • Agents can propose decisions through Mneme's Model Context Protocol (MCP) server, but that server cannot accept, reject or activate them. Acceptance is a separate command-line step, mneme decision accept or reject, which the decision proposals docs reserve for a person. Accepting a decision does not switch on enforcement; protection is a separate step with mneme protect activate, described under protection activation.
  • A decision with an active typed rule (a machine-checkable constraint, such as exact text that must not appear in certain paths) is enforced in continuous integration, in warn mode (report the violation, pass the job) or strict mode (fail the job). It is also checked before a change reaches disk when Claude Code, Codex CLI (command-line interface) or Kiro CLI 3.0 writes through its own file-editing tools. Changes made through shell commands reach disk first; Claude Code and Codex CLI check them at the end of the agent's turn, and for other agents CI checks the change when it reaches a pull request. A violation names the decision behind it. For the budget example, that is the adapter rule.
  • mneme audit classifies every active decision as Protected (the audit observes an installed typed rule in the decision's record, the artifact that mneme check and the agent hooks enforce), Mneme-ready (a safe rule is identified but not installed), Requires modelling (the decision needs more structure before a rule can express it) or Guidance (not suited to deterministic enforcement). That is a coverage measure for the repository side.

What does not ship: the Decision Index records no approver identity. Mneme keeps acceptance out of the agent's MCP tools, but it does not record or verify who ran the command, so who accepted or revised a decision belongs where identities are verified, such as pull request review on the ADR files. Mneme has no waiver record and does not measure intervention cost. Linking a decision version to platform controls across layers is conceptual; teams do it today by citing the ADR identifier in each policy.

What to do now

  • Name the three actions per decision. For each decision a platform control enforces, record who may accept, revise and waive it.
  • Write the delegation down. State which parameters the platform team may set and which belong to architecture. Put the derived numbers, such as the replica cap, in the decision record, not only in the policy.
  • Cite in both directions. Each control names the decision and version it enforces. Each decision lists its controls and their owners.
  • Report per decision. Coverage, open waivers and intervention cost, reviewed by the people who own the decision.

Frequently asked questions

How do platform engineering and enterprise architecture divide governance work?+
Enterprise architecture sets direction and accepts the decisions that bind more than one team. Platform teams run the controls: templates, policies, pipeline checks and alerts. The CNCF Platforms White Paper describes platforms that ensure compliance "based on rules and standards defined by the organization." The weak point is the link between an accepted decision and the controls that enforce it.
Who should be allowed to waive an architecture decision?+
Whoever the decision's owners delegate that authority to, within stated bounds and for a stated period. One workable split lets the platform team waive a control for one case, such as a launch, while revisions to the decision itself stay with architecture. Record each waiver against the decision, so a growing pile of waivers reads as a reason to revise it.
How do you measure compliance with an architecture decision?+
Measure the decision, not one control's pass rate. Track coverage (which parts have a running control), exceptions (how many open waivers, how old, granted by whom) and intervention cost (human time spent on overrides, exception requests and manual reviews). A policy that never fails tells you it ran, not that the decision holds.
Does Mneme enforce platform or infrastructure policy?+
No. Mneme does not enforce infrastructure policy, provision cloud resources or manage identity and access. It records decisions in a versioned Decision Index and enforces decisions that have an active typed rule on repository code, in Claude Code, Codex CLI and Kiro CLI 3.0, and in continuous integration. Admission control and runtime alerts belong to the platform team's own tools.