
Who Controls Trust? Governing Trust Across APIs and AI

Mike Goerlich
· 9 min readKey Takeaways
Authorization must remain consistent across systems. As tasks move between AI agents, APIs, and other digital services, the same business rules must apply without permissions expanding along the way.
Authorization needs to be enforced where actions take place.
Having the right policies isn't enough. Organizations must ensure that systems can prevent unauthorized actions before they have consequences.
Organizations need to be able to verify what happened.
Records of authorization decisions and actions taken are essential for accountability, particularly when AI agents operate across multiple systems.
On this page
How Explicit Authority Becomes Runtime Control
An organization may have well-defined authorization policies and still find that an AI agent can perform actions it was never supposed to take. The problem is not necessarily the policy itself. It is whether the limits it establishes remain effective as a task moves between systems. A task may be limited to one customer, one claim, or one approved amount, but those limits are of little use if they disappear when another service takes over or if they never reach the system carrying out the action. The previous article examined how authority becomes explicit. This article asks what the architecture must do to keep it effective once execution begins. In this series, Security Sovereignty means retaining control over identity, authorization, and policy even when providers, infrastructure, or operating conditions change.
Access to a capability is not authority to use it
A 2025 incident involving OpenAI's Operator makes the distinction concrete. Washington Post technology columnist Geoffrey A. Fowler asked Operator to find cheap eggs in his neighborhood and gave it access to his grocery accounts so it could search. Those accounts already contained a saved payment method, and Operator went on to buy a dozen eggs and arrange delivery. What began as a request to find a purchase option became a completed transaction. (The Washington Post; free to read via Anchorage Daily News)
OpenAI's published safeguards said Operator should ask for approval before finalizing significant actions, including submitting an order. But in this case, the agent went from researching a purchase to actually making one. If it already had access to checkout, what was supposed to stop it from completing the purchase without approval?
And this is not just a problem with browser agents. A service account may be able to modify thousands of customer records, or an integration may have access to initiate payments across an entire business. But just because a system has the technical ability to do something does not mean it is authorized to do it for a particular task.Â
Keep the meaning of authority consistent
Consider a claims handler authorized to approve a payout of up to €10,000 on one specific claim. That authority has to mean more than "access to the claims system". It needs to identify which claim is in scope, which action is permitted, what amount has been approved, who is exercising the authority, and under which conditions.
Defining those limits is only part of the challenge. They also need to mean the same thing wherever they are evaluated. That becomes difficult when one interpretation lives in an identity-provider role, another in a gateway policy, and a third in application code. There is nothing inherently wrong with implementing checks in different places. Problems arise when each system starts interpreting the same business rule differently, until nobody can say which version is the real one.
The organization also needs to define how those constraints are evaluated, who may grant an exception, and how authority may be delegated. Otherwise, changing a gateway or moving an application can become an unplanned change to the organization's authorization model.
This does not mean every authorization decision needs to happen in one place. Different systems can make the decisions relevant to their responsibilities while remaining accountable to the same authority model. The organization controls what the authority means; each system applies those rules where it has the context and responsibility to do so.
Authorization belongs to the business, not the platform. The technology should support that ownership without requiring every service to reconstruct the rules for itself.
Preserve the task's limits across delegation
Now consider what happens as that approval moves between systems. The claims handler uses an agent to submit it through an API to the claims service, and the approved payout then passes to a payment service. That service has standing credentials allowing it to release much larger sums across many claims. It may need those credentials to perform its job, but their broader reach must not become the effective authority for this transaction.
If those standing privileges replace the €10,000 approval during the handoff, a bounded authorization has effectively become a blank check.
The distinction between approving a payout and executing the payment matters here. The claims handler's authority determines which approval they may grant. The payment service performs a different action and needs to establish that the proposed payment is supported by that approval. Neither the handoff nor the service's greater technical privileges should change the claim, amount, or conditions attached to it.
Each system involved needs a reliable way to establish the limits of the task: which claim is in scope, what has been approved, who granted that approval, and on whose behalf the next action is being performed. A request cannot simply assert wider authority and expect the next system to accept it. This reflects a basic principle of backend design: no component should take another's word for what it is allowed to do. Authority has to arrive as something the receiving system can verify, typically a token issued by an authorization server the organization controls, so that each component can check what has been granted rather than trusting whoever passed the request on.
The implementation may use delegated credentials, a reference to an authorization record, Token Exchange, or another mechanism suited to the environment. What matters is that changing the executing component does not silently expand the task. A downstream service may use its own identity to connect to another system without making all of its standing privileges available to the operation.
Circumstances can also change while a task is underway. An approval may be withdrawn, the level of risk may change, or an agent's delegated authority may expire. Continuous authorization means identifying where those changes require a fresh decision and ensuring that current context can influence it before the action takes effect. It does not mean every API call needs to pass through a central policy engine; it means distinguishing authority granted earlier from authority that still applies now. The agent may choose its path, but it must not redefine the authority governing that path.
Enforce authority where the consequence occurs
Preserving authority through a series of handoffs only helps if a system can act on it before the consequence occurs. For a claims payout, the approval has to constrain the payment that is actually released, not merely the request that first entered the workflow.
A gateway may be well placed to validate a token, check its audience, and decide whether a request should reach the claims service. It may not have enough information to determine whether the claims handler may approve this particular payout. That decision could depend on responsibility for the claim, the applicable approval limit, fraud indicators, or other business state held by the claims system.
The payment service has a related but different responsibility. It needs to establish that the payment it is about to release is backed by a valid approval for that claim and amount, issued by an actor authorized to grant it. Access to the payments API is not a substitute for that relationship. To enforce this, the payment service needs a say in what the tokens it receives must contain, such as the claim, the approved amount, and who approved it, so that it can check each payment against those attributes and its own business state rather than against the caller's general access to the API.
Different systems can play different roles in this process. An authorization service may evaluate policy, the claims system may provide business context, and the payment service may enforce the decision. What matters is that the decision applies to the proposed action and reaches a system that can still stop it. If the payment has already gone through, or the decision applies to a different transaction, the authorization check has not constrained the outcome.
The same issue arises when an agent interacts with an external system. If that system cannot recognize task-specific limits, the integration may need to provide a restricted way to submit actions so that the required authorization applies before submission. Giving the agent broad access through an existing user session does not create that restriction.
For any action with real consequences, the organization should know which component can refuse it and whether that component has enough information and control to enforce the relevant limit. That is how different systems can share responsibility for authorization without forcing every decision into the same place.
Establish what happened independently of the agent
Organizations also need to be able to show what actually happened and whether it stayed within the authority granted. For a claims payout, a successful API response says little about whether the payment remained within those limits. The organization should be able to identify who initiated the task, who approved the payout, which component released the money, what authority applied to each action, and what amount was ultimately paid against which claim. Because the attributes in a token describe who is acting, on whose behalf, and with what authority, they also give each component something concrete to record. If the claims and payment services log those attributes alongside their own decisions, rather than storing the tokens themselves, the organization can answer these questions after the event instead of reconstructing them from scattered system logs.
This information does not have to live in one system or one log. It does need to remain connected well enough to determine whether a payment was actually authorized rather than merely processed successfully. The agent's own explanation can provide useful context, but the systems involved need to provide independent evidence of what they received, decided, allowed, and executed.
In Controlling the Chain, I examine how to inspect and test these relationships in practice. The architectural responsibility here is to make that examination possible. Decisions, enforcement, and business results should be traceable without relying on the agent to reconstruct what happened or explain why its actions were permissible.
Security Sovereignty at runtime
This brings us back to the question at the heart of this series: who controls trust? It is not enough to define what an agent or service is allowed to do. Those limits need to remain meaningful as tasks move between systems, and they need to be enforced before an unauthorized action produces a consequence.
Security Sovereignty means retaining that control even as technology changes. An organization may move its claims service to another cloud, replace a gateway, or introduce a different agent platform. None of those changes should alter who may approve a payout, how much they may approve, or what the payment service is authorized to execute.
This is why sovereignty goes beyond the ability to move workloads. If the meaning of authorization is inseparable from one particular platform, an organization may be able to move its software while leaving control of the rules behind.
Governing trust across APIs and AI is not about controlling every step an agent takes. It is about allowing the path to vary without allowing the authority governing that path to vary with it. The organization should be able to explain where that authority came from, preserve its limits as execution moves, enforce those limits wherever consequential actions occur, and change the implementation without surrendering control of the rules.
That is where Security Sovereignty becomes real: not in trusting an agent to behave as intended, but in the organization's ability to keep consequential actions within the limits it has set.