Authority Architecture for Agentic Banking: A Governance Layer on Gemini Enterprise Agent Platform

By NATARAJA Team

Banks are moving agentic AI into the places that matter: credit decisions, payment release, fraud holds, KYC and AML screening, limit changes, and treasury operations. In agentic banking, an AI agent does not just score a risk. It acts on it. That shift is exactly where infrastructure governance ends and decision governance begins.

Google's Gemini Enterprise Agent Platform gives banks a strong governance foundation for the agents themselves: identity, access, alignment checks, and audit. Sitting naturally on top of that foundation is a second layer, decision authority: which agent may make which banking decision, within what limits, under whose delegation, and accountable to whom. That layer is the subject of the Executive Authority Brief on Authority Architecture, and pairing it with the platform is what turns a fleet of capable banking agents into a governed system.

This article does three things. It compares Gemini Enterprise Agent Govern with NATARAJA's agentic AI framework and the 5 Laws of Sovereign Decision Making. It sets out what an Authority Architecture for agentic banking looks like. And it shows a sample implementation that runs an Authority Architecture on Gemini Enterprise Agent Govern.

What Gemini Enterprise Agent Govern Provides

Google's platform governs agents across four pillars, and they are genuinely useful:

  • Agent Registry. A central directory of the approved agents, tools, Model Context Protocol servers and endpoints across the organisation.
  • Agent Identity and Agent Gateway. Every agent gets an identity, a SPIFFE ID used for authentication, access control and audit. All agent traffic passes through the gateway, where policy is enforced, and the gateway can delegate authorisation to Identity-Aware Proxy, Model Armor, the Semantic Governance policy engine, or a custom authorisation service.
  • IAM Unified Access Policies and Semantic Governance policies. Access is denied by default unless an IAM policy grants it. Semantic Governance policies, still in preview, check each proposed tool call against constraints written in plain English and against the user's intent, and allow it or deny it.
  • Model Armor, observability and audit. Content inspection on inputs and outputs, gateway telemetry with Cloud Trace, anomaly detection, and logs for audit and monitoring.

In short: the platform answers a precise and important question, can this agent reach and call this service, safely and observably? The Authority Architecture answers the complementary one this article is about, which decisions may it make? What the platform does not do is ask a person. Every check it runs returns allow or deny. None of them holds a decision while a named human approves it.

From Access to Decision Authority

IAM grants an agent permission to call an API. Authority Architecture grants the authority to make a banking decision. They are complementary layers, and keeping them distinct is what keeps accountability clear.

A credit agent may have IAM permission to call approveCredit. The governance question a bank actually has to answer is: under whose delegated authority may it approve, up to what amount, for which customer-risk tiers, with what escalation when it nears the boundary, and which named human owns the outcome if it goes wrong? None of that lives in an IAM binding. It lives in an Authority Architecture.

This is the central argument of the agentic AI framework: governance has to be designed into the decision, not just the access path. And it maps cleanly onto the 5 Laws of Sovereign Decision Making:

  • Structured Decision Design defines explicit, machine-readable authority boundaries. The platform enforces them with IAM Unified Access Policies and gateway authorisation; the decision tiers, delegation chains, and escalation thresholds are the bank's to design.
  • Integrated Data & Context governs the inputs a decision runs on. The platform supplies grounding and context; the framework decides which context is authoritative for a given decision.
  • Traceable Reasoning requires an inspectable trail of inputs, reasoning, and alternatives. Request-response logs are the substrate. Decision-level reasoning traceability sits on top.
  • Aligned Action keeps execution consistent with intent and risk appetite. Semantic Governance policies are a strong primitive here; the framework defines what "aligned" means for each banking mandate.
  • Auditable Impact ties outcomes back to accountable owners. Audit trails feed it; the accountability mapping is the bank's to design.

The pattern is consistent: Gemini Enterprise Agent Govern is the enforcement and observability plane. The Authority Architecture is the decision-governance plane that tells the enforcement plane what to enforce.

What an Authority Architecture for Agentic Banking Looks Like

An Authority Architecture is the explicit, governed map of who may decide what. For agentic banking, build it around decisions, not applications. Every consequential decision gets four things: an authority tier, a delegation source, machine-readable limits, and an escalation path with a named accountable owner. Together they make up the decision's Authority Envelope, the first of the four practices of Decision Accounting.

A workable tiering for a bank:

  • Tier A: autonomous. Low-consequence, reversible, high-volume. Duplicate-transaction detection, statement generation, low-value fraud flags. The agent acts; humans review in aggregate.
  • Tier B: bounded autonomy. The agent acts within hard limits, and any exception escalates. Credit-limit changes up to a threshold, payment release below an amount, KYC re-screening, standard dispute resolution.
  • Tier C: recommend only. High-consequence or irreversible. Loan approvals above a threshold, customer offboarding, AML suspicious-activity filing, large treasury moves. The agent prepares a traceable recommendation; an accountable human decides.

The point is not to slow banking down. It is to make the boundary between autonomous and human authority explicit, enforced, and auditable, so that when an agent acts, the chain back to a delegating authority and an accountable owner stays intact. This is precisely what the Executive Authority Brief Control Note translates into board-level, enforceable controls. The tiers above are really a path: for the cross-industry view of how an Executive Decision Platform moves a decision from assisted to governed autonomous mode, see our guide on the journey to autonomous decisions.

Sample Implementation on Gemini Enterprise Agent Govern

Here is how the Authority Architecture maps onto the platform. The architecture is the design; the platform is the enforcement.

1. Register agents with an authority profile. In the Agent Registry, register each banking agent with metadata that records its authority tier, the decision types it may make, its value limits, the customer-risk conditions it operates under, the delegating role, and its escalation target. The registry becomes the bank's authority inventory, not just an agent catalogue.

2. Set the access boundary with Agent Identity and IAM. Give each agent an Agent Identity, then use IAM Unified Access Policies to fix the coarse authority boundary: which tools and services that identity may call at all. Access is denied unless a policy grants it, so the limit-change agent can invoke the limit-change tool and nothing else, and conditions can narrow that further, down to individual tools. IAM answers which actions are reachable. It is the outer ring of Structured Decision Design.

3. Check decision limits at the Agent Gateway, and hand the exception to a person. IAM governs which actions are reachable, while the business limits, such as a transaction's value, live one layer up. Route every action through the Agent Gateway to a custom authorisation service that reads the request itself. A credit approval of £50,000 to a low-risk customer passes. The same agent attempting £500,000, or any Tier C decision, is blocked, and the agent is told why. The platform's part ends there: it can allow or block, but it has no step that holds a decision for a named person to approve. That step belongs to the decision layer. The blocked decision goes to a gate where a credit officer approves, amends or rejects it, and signs. The signed decision is then handed to the bank's own systems to carry out under the officer's authority, not the agent's. In Decision Accounting this is The Seal: the agent prepared the decision, a named person made it, and the record shows both.

4. Bind actions to intent with Semantic Governance. Use Semantic Governance policies to check that the agent's action aligns with the lending mandate, risk appetite, and customer-treatment rules, catching the case where an action is permitted by IAM but misaligned with intent. This is Aligned Action made operational, and it is the layer where the three authority tiers come to life. The tier-by-tier policies, with sample configurations, are below.

5. Inspect and record. Use Model Armor for content guardrails on inputs and outputs, and the platform's logs and traces as the raw record. Then add the decision itself on top: for every Tier B and Tier C action, a Decision Record of the inputs, the reasoning, the alternatives considered, the authority under which it was taken and who approved it, written by the runtime rather than the agent, so the decision is defensible to a regulator, not just observable to an SRE.

6. Close the loop to accountability. Feed the logs into an accountability matrix that maps every decision to a named human owner and an escalation path. That is Auditable Impact, and it is the difference between "we have logs" and "we can show who was accountable when the agent was wrong."

Read together, the platform gives you identity, access, alignment checks, guardrails, and logs. The Authority Architecture gives you the decision tiers, delegation chains, escalation thresholds, and accountability mapping that tell those primitives what to enforce. The two are complementary: the platform enforces and records, the Authority Architecture decides what is enforced and recorded.

Semantic Governance Policies for Each Authority Tier

A Semantic Governance policy is a natural-language rule that the platform's policy engine evaluates with an LLM judge before a tool call runs. The feature is in preview. It returns one of two verdicts, ALLOW or DENY, and a denied call goes back to the agent with a rationale, or with a fixed message you set for the customer. Two verdicts are enough for three tiers, as long as the human step lives in the decision layer: ALLOW is the agent's own authority, DENY is the boundary, and the denial is where escalation starts. Writing the mandate in plain English also means a risk officer can read it.

A policy is scoped to a specific agent or to specific tools. Here is how that looks for a handful of agentic-banking agents, tier by tier.

Tier A: Autonomous Agents

Example agent: Statement and Notifications Agent. It generates statements and low-value alerts. Its mandate is broad but its blast radius is near zero, so the policy keeps it firmly in that lane.

"Allow statement generation, balance summaries, and transaction notifications for any account in good standing. Deny any action that moves money, changes a credit limit, opens or closes an account, or alters a customer's risk classification."

gcloud beta ai semantic-governance-policies create stmt-agent-scope \
  --agent=statement-notifications-agent \
  --natural-language-constraint="Allow statement generation, balance summaries, and transaction notifications for any account in good standing. Deny any action that moves money, changes a credit limit, opens or closes an account, or alters a customer's risk classification."

A Tier A policy is mostly ALLOW with a hard DENY fence around anything consequential. The agent never needs to escalate, because it can never reach a decision that would warrant escalation.

Tier B: Bounded-Autonomy Agents

Example agent: Card Limit Agent. It adjusts credit-card limits within policy. The agent acts on its own inside hard bounds. At the edge the call is denied, and the denial starts the escalation instead of ending the request.

"Allow credit-limit increases up to 20 percent of the current limit for customers in risk tier low or medium with no arrears in the last 12 months. Deny any increase above 20 percent, any increase for customers in risk tier high, and any change where the new limit would exceed £25,000: these need a credit officer's approval. Deny any limit change on accounts flagged for fraud, in collections, or under a hardship arrangement."

gcloud beta ai semantic-governance-policies create card-limit-bounds \
  --agent=card-limit-agent \
  --natural-language-constraint="Allow credit-limit increases up to 20 percent of the current limit for customers in risk tier low or medium with no arrears in the last 12 months. Deny any increase above 20 percent, any increase for customers in risk tier high, and any change where the new limit would exceed GBP 25000: these need a credit officer approval. Deny any limit change on accounts flagged for fraud, in collections, or under a hardship arrangement." \
  --agent-response-denial-message="This limit change needs approval from a credit officer."

Example agent: Payment Release Agent. Same shape, different decision: ALLOW within a value band, DENY above it with dual approval as the next step, and DENY always for sanctioned counterparties.

"Allow release of outbound payments up to £50,000 to previously verified beneficiaries. Deny payments above £50,000 and payments to any beneficiary added in the last 24 hours: these need dual approval. Deny any payment to a sanctioned entity or to a country on the bank's restricted list."

The denial at the boundary is where the Authority Architecture's escalation path begins. The platform stops the call and says why. The decision layer takes it from there: it routes the decision to the named approver, records the approval, and hands the signed decision to the bank's systems to carry out. The agent's own authority never grows. It does the routine work, and the human is pulled in exactly at the boundary, not for everything.

Tier C: Recommend-Only Agents

Example agent: Credit Decision Agent. It prepares loan recommendations. The whole point of Tier C is that the agent must not commit the decision, so the policy denies the commit action outright and confines the agent to drafting.

"Allow this agent to assemble the credit file, run affordability checks, and prepare a written recommendation. Deny any action that approves, declines, or disburses a loan. Every credit decision must be committed by a named human credit officer."

gcloud beta ai semantic-governance-policies create credit-recommend-only \
  --agent=credit-decision-agent \
  --natural-language-constraint="Allow this agent to assemble the credit file, run affordability checks, and prepare a written recommendation. Deny any action that approves, declines, or disburses a loan. Every credit decision must be committed by a named human credit officer."

Example agent: AML Investigation Agent. It drafts suspicious-activity reports. The regulatory filing is a human act, so the agent may prepare and queue, never file.

"Allow this agent to investigate alerts, gather evidence, and draft a suspicious-activity report into the compliance review queue. Deny any action that files a report with a regulator or closes an alert. Filing and disposition are reserved for a named compliance officer."

A Tier C policy inverts the Tier A default: the autonomous surface is preparation only, and every consequential action is deny-by-default with a human commit step on top. That is what keeps the operator-error-or-design-failure question answerable, because the record shows the agent recommended and a named human decided.

Why This Belongs in Semantic Governance, Not Only in IAM

IAM and the gateway enforce whether an action is reachable and within what numeric limit. Semantic Governance adds the layer that reads like a mandate, catching the action that is technically permitted but misaligned with intent, such as a payment that sits under the limit yet is headed to a beneficiary that does not fit the customer's pattern. Writing the mandate in plain English also means the people accountable for the decision, the credit officer, the compliance officer, and the risk committee, can read and sign off on the exact words the engine enforces. That is Aligned Action made legible, not just operational.

Why This Matters More in Banking Than Anywhere Else

Banking is where the gaps bite hardest. A misaligned agent does not just produce a bad output; it can extend credit, release a payment, or file a regulatory report.

When an agentic banking decision causes a loss, the first question a regulator, a board, and a court will ask is the one the Executive Authority Brief on AI Incidents poses: operator error, or design failure? Without an Authority Architecture a bank cannot answer it. The agent acted, but under whose authority, within what limit, and inside its mandate or outside it? With one, the answer is already on the record: a defined agent, under a delegated authority, inside or outside an enforced boundary. That single distinction is what decides where accountability lands.

The pressure only grows. Competitive Acceleration and Systemic Exposure describes the trap: every bank feels it must scale agentic AI faster than its rivals, and that race quietly accumulates systemic exposure as ungoverned authority spreads across the estate. Authority Architecture is the discipline that lets a bank move at competitive speed without scaling systemic risk in lockstep, because every new agent inherits an explicit, enforced boundary rather than an implicit, unbounded one.

That is also why the Executive Authority Brief on Authority Architecture treats authority as a board-level domain in its own right, alongside strategy, financial performance, and risk, rather than a technical detail delegated to the platform team.

What Banking Supervisors Asked For in October 2026

Two supervisors moved in the same month, and both describe this architecture. On October 7 the Monetary Authority of Singapore issued its final Guidelines on AI Risk Management. They apply to every financial institution and every form of AI it uses, including systems that act autonomously and use tools. The board owns the AI risk appetite. The institution keeps an inventory of its AI use and assesses the materiality of each use case. And it stays accountable for AI that a third party supplies, which is what a bank's agents on Gemini Enterprise Agent Platform are: the platform is Google's, the accountability is the bank's. The Guidelines take effect on October 7, 2027.

On October 19 the FCA published its review of good and poor practice in AI. Firms with agentic use cases were registering their agents in a central inventory that shows who owns each agent and what systems and data it can reach, which is the authority inventory in step 1 above. The same day the FCA said it will build a trusted framework for agentic finance covering "agent identity, delegated authority, accountability and execution". Identity is what the platform provides. Delegated authority and accountability are what this article is about.

In the EU, the AI Act treats AI used to assess the creditworthiness of individuals as high-risk, with the obligations applying from December 2, 2027. The Tier C Credit Decision Agent above is that kind of system, and its recommend-only design, with a named human making the final call, is the kind of human oversight the Act requires such systems to have.

When the Agent Belongs to the Customer

The tiers above govern a bank's own agents. In October the same question arrived from the other side. Customers had started handing their login details to AI agents that act on their accounts, and CBS News reported that JPMorgan will not let just any outside agent in, while Schwab said it has been blocking unauthorised agents. A customer's agent raises the same question as the bank's own: under whose delegation is it acting, within what limits, and who answers if it moves money the customer never meant to move. Blocking answers that for now. The lasting answer is the same Authority Architecture applied to agents coming in from outside: a delegation the customer grants explicitly, limits the bank can check, and a record of every decision made under it.

Frequently Asked Questions

What Is Decision Authority in Agentic Banking?

Decision authority is the governed right of an AI agent to make a specific banking decision: which decision it may make, up to what limit, under whose delegation, and accountable to whom. It is distinct from access. Infrastructure governance (identity, IAM, audit) controls whether an agent can reach a service; decision authority controls which decisions it may make once it can. In agentic banking, where an agent acts on a risk rather than only scoring it, that authority has to be explicit, enforced in the runtime, and traceable back to an accountable human.

What Is the Difference Between IAM Permission and Decision Authority?

IAM grants an agent permission to call an API; decision authority grants it the right to make a business decision. A credit agent may have IAM permission to call approveCredit, but the governance questions (up to what amount, for which customer-risk tiers, with what escalation, and which named human owns the outcome) live in an Authority Architecture, not an IAM binding. They are complementary layers, and keeping them distinct is what keeps accountability clear.

Which AI Agent May Make Which Banking Decision?

That is set by an authority tier assigned to each decision, not to each application. A workable tiering: Tier A (autonomous) for low-consequence, reversible, high-volume decisions; Tier B (bounded autonomy) where the agent acts within hard limits and escalates exceptions; and Tier C (recommend only) where the agent prepares a traceable recommendation and a named human commits the decision.

What Is an Authority Architecture for Agentic Banking?

It is the explicit, governed map of who may decide what: every consequential decision gets an authority tier, a delegation source, machine-readable limits, and an escalation path with a named accountable owner. It sits on top of a platform like Gemini Enterprise Agent Govern, telling the platform's enforcement primitives what to enforce.

What Controls Should a Bank Have Before Deploying Autonomous AI Agents?

Five, in this order. An inventory of every agent, with its owner and what it can reach. An authority tier for every decision each agent makes, with a delegation source and machine-readable limits. An access boundary that denies by default, so an agent can call only the tools its tier needs. A named human gate for every decision above the agent's limits, where the approval is signed and then carried out under that person's authority. And a Decision Record, written by the runtime rather than the agent, that a supervisor can read. Platforms such as Gemini Enterprise Agent Platform supply the identity, access and logging. The tiers, the limits and the human gate are the bank's to design.

The Bottom Line

Gemini Enterprise Agent Govern is a strong foundation, and banks should build on it. A platform governs agents; an Authority Architecture governs the decisions those agents make. Together they turn identity, access, and audit into something a board, a regulator, and a customer can trust: explicit authority, enforced limits, real escalation, and accountability that never leaves a human hand.

If you want to map your own agentic banking estate against an Authority Architecture, and see which AI investments are actually improving decisions, start with an AI Value Realisation Review or request a governed pilot. For the full argument, the Executive Authority Brief series is where this began.