Your AI Agent Has Permissions — and a Wallet: Why Cost Control Is Also Security

AI agents do not only need limits on what they are allowed to do. They also need limits on how much they can spend, how long they can operate and when they must ask for approval.

On October 21, 2026, The Register reported a striking figure: Peter Steinberger, creator of OpenClaw and a member of OpenAI’s technical staff, estimated that he had consumed around $10 million worth of tokens during the previous month.

The number is eye-catching, but another part of his comment is more important: Steinberger acknowledged that not all of that consumption was useful.

During the same conversation, when trust and agent access were discussed, he raised another issue: we may not want to give an agent every permission available. He even suggested using another agent to authorize the first one.

One caveat matters here. The $10 million figure is a public estimate made by Steinberger, not an audited bill with a published breakdown of models, tokens and workloads. But the exact number is not the real lesson. The architecture behind it is.

When we give an agent autonomy, we delegate both technical authority and spending capacity.

We have traditionally treated those as separate problems. IAM manages permissions. FinOps manages cost. With autonomous agents, that separation is becoming increasingly artificial.

An agent is not just a smarter chatbot

In a conventional generative AI interaction, the user still retains much of the operational control:

User → prompt → model → response

There are exceptions, but the number of calls is usually bounded and the interaction tends to stop once the response is returned.

An agent changes that model. We give it a goal and allow it to decide how to achieve it:

Goal
  ↓
Agent
  ├── calls the model
  ├── queries an API
  ├── invokes an MCP tool
  ├── reasons again
  ├── spawns a sub-agent
  ├── retries an operation
  ├── validates the result
  └── continues until the task is complete

This autonomy is useful, but it breaks an important assumption: one user request no longer means one operation.

A single task may trigger dozens or hundreds of model calls, API requests, searches, database queries, internal tools and other agents. If the loop is poorly bounded, the system may keep working long after it has stopped producing useful value.

OWASP explicitly addresses this risk in its AI Agent Security Cheat Sheet. One of the risks is Denial of Wallet (DoW): excessive API or compute costs caused by unbounded agent loops. Recommended controls include limits on tokens, cost, retries and tool chains.

Least privilege should no longer mean permissions alone

Cloud security has relied on the principle of least privilege for years:

An identity should receive only the permissions required to perform its function.

With agents, we need to extend that principle.

Consider an agent that investigates security alerts. It may need read access to a SIEM, CloudTrail logs and threat intelligence. That does not mean it should be able to delete resources, modify IAM policies or execute arbitrary shell commands.

So far, this is familiar territory.

Now add a second dimension:

Technical permissions
---------------------
Read logs:          YES
Query SIEM:         YES
Modify IAM:         NO
Delete resources:   NO

Economic permissions
--------------------
Cost per task:        unlimited?
Model calls:          unlimited?
Retries:              unlimited?
Sub-agents:           unlimited?
Execution time:       unlimited?

An agent can comply perfectly with its IAM policy and still create a serious financial incident.

That leads to a useful additional principle: economic least privilege.

An agent should receive not only the minimum technical authority required, but also the minimum operational budget required to perform its task.

A budget is also a security boundary

Imagine that an agent receives one alert and develops ten hypotheses. It spawns one sub-agent for each hypothesis. Every sub-agent performs twenty searches, multiple tool calls and several model invocations to review its conclusions.

The execution tree grows quickly:

1 investigation
   ↓
10 hypotheses
   ↓
10 sub-agents
   ↓
20 searches per sub-agent
   ↓
LLM + tools + validation + retries
   ↓
Hundreds or thousands of operations

None of this has to be malicious. The cause may simply be inefficient planning, weak stopping criteria and missing limits.

Cost controls should therefore become part of the agent policy, just like access controls:

agent: vulnerability-researcher

permissions:
  github:
    read: true
    write: false

  cloud_logs:
    read: true

economic_policy:
  max_cost_per_task: 2.00
  max_cost_per_day: 20.00
  max_model_calls: 50
  max_tool_calls: 100
  max_subagents: 3
  max_execution_time: 15m

approval_required:
  cost_above: 2.00
  destructive_action: true
  external_write: true

The syntax is illustrative. The design principle is what matters: autonomy should have an explicit budget.

Agent identity: a new form of workload identity

The issue is not purely economic. It also goes directly to IAM.

Agents are becoming a new category of non-human identity. They are not exactly users, and they are more than simple service accounts. An agent can receive a goal, select tools dynamically, delegate tasks and act on behalf of a person or an application.

NIST is actively examining this problem. In 2026 it published a concept paper on the identity and authority of software agents, focused on applying identity standards and best practices to agentic AI applications. The starting point is straightforward: if an agent can access datasets, tools and applications, we need appropriate identification and authorization controls.

A simplified evolution looks like this:

User
  ↓
Service account
  ↓
Workload identity
  ↓
AI agent identity

But agents introduce an important difference. They do not merely use a credential. They make dynamic decisions about when and how to use it.

Reachability is not authorization

The fact that an agent can technically reach a resource does not mean it is authorized to use it.

This distinction becomes especially important when we expose capabilities through APIs, plugins or MCP servers. An integration may provide many more functions than a particular use case actually needs.

OWASP uses the term Excessive Agency for risks caused by excessive functionality, permissions or autonomy. The problem does not require a successful attack against the model. A hallucination, ambiguous instruction or poor agent decision may be enough.

OpenClaw applies the same principle in its own security guidance, recommending sandboxing, strict allowlists, per-agent access profiles and tight restrictions around high-risk tools such as execution, browser access and credentials.

The secure default should therefore be the reverse of “give it access now and restrict it later”:

Default: no access
        ↓
Add only required tools
        ↓
Scope each tool
        ↓
Separate read from write
        ↓
Require approval for sensitive actions

Should one agent authorize another agent?

Steinberger’s suggestion to use an agent to authorize another agent is interesting. A second model can add context and recognize that a requested action is unnecessary, disproportionately risky or too expensive.

But there is an important boundary.

We should not make one probabilistic model the only authorization boundary for another probabilistic model.

An authorization agent may assist the decision, but critical actions should remain subject to independent, deterministic controls.

For example:

Agent
  ↓ requests action
Control layer
  ├── IAM / policy engine
  ├── budget
  ├── rate limit
  ├── risk classification
  └── human approval when required
  ↓
Tool / API

If the agent asks to delete two hundred cloud resources and the “authorization agent” believes the request looks reasonable, an IAM policy or approval gate should still be able to answer DENIED.

This separation between decision and execution is also reflected in OWASP guidance: do not rely solely on model output for authorization decisions, and independently validate high-impact operations.

The agent control plane

As agents become more autonomous, we need to think in terms of a control layer around them. Securing the model alone is not enough.

                 AI Agent
                    │
       ┌────────────┼────────────┐
       │            │            │
    Identity     Budget       Tool policy
       │            │            │
       ├────────────┼────────────┤
       │            │            │
      IAM       Rate limits   Approval gates
       │            │            │
       └────────────┼────────────┘
                    │
             Audit / Observability
                    │
                 Kill switch

At a minimum, that control plane should answer these questions:

  • What identity does the agent use?
  • On whose behalf is it acting?
  • Which data can it access?
  • Which tools can it invoke?
  • Which operations are read-only and which change state?
  • How much can it spend per task and per time period?
  • How many times may it retry?
  • Can it spawn sub-agents?
  • Which actions require human approval?
  • Can we reconstruct exactly what it did afterwards?
  • Is there a mechanism to stop execution and revoke its credentials?

Observability also changes. Logging the initial request and final answer is no longer enough. We need to correlate model calls, decisions, tools, identities, costs and resulting changes across systems.

FinOps is becoming part of agentic AI security

Cloud Security and FinOps were already connected. A compromised resource can be abused for cryptomining, exfiltration or fraudulent consumption. Agentic AI makes that relationship even more direct.

Unwanted spending may come from an attacker, but it may also come from an agent doing exactly what it was designed to do — only too aggressively.

That means budget should be treated as an execution policy, not merely as a financial alert reviewed at the end of the month.

A budget alert that arrives after the money has been spent is useful for FinOps. A control that stops execution before the budget is exceeded is also a security control.

Autonomy needs controls that are independent of the model

The $10 million OpenClaw figure is spectacular, but it is not the main lesson.

The real question is what happens when the agents we currently use for coding, research or summarization start operating continuously across email, cloud environments, repositories, corporate tools and business processes.

At that point, it will no longer be enough to ask whether the model is capable or whether the prompt is well written.

We will need to ask:

Who is this agent?
What can it do?
Which credentials does it use?
On whose behalf is it acting?
For how long?
How many actions may it execute?
How much may it spend?
What requires approval?
Who can stop it?
Can we audit everything it did?

Agent security cannot depend exclusively on the model making “good decisions”. It must be built on controls the agent itself cannot bypass or rewrite.

Autonomy without limits is not intelligence. It is uncontrolled technical and financial exposure.

References

¿Te interesa la seguridad en Cloud?

Comparto análisis técnicos, laboratorios prácticos y experiencias reales sobre Cloud Security.

Análisis de ciberseguridad cloud, sin ruido

Casos reales de ataques, defensas y arquitectura cloud explicados sin relleno. Para arquitectos, DevOps y responsables de seguridad que no tienen tiempo que perder.

Política de privacidad

Francisco Sepúlveda

Francisco Sepúlveda

Instructor de Cloud Computing y Ciberseguridad, Diseñador de Experiencias Formativas

Instructor y consultor en Cloud Computing, Ciberseguridad e IA, con más de 25 años de experiencia en entornos empresariales reales. Diseño e imparto programas de formación técnica combinando experiencia profunda en la materia con diseño de experiencias formativas, para que los conceptos complejos de seguridad realmente se queden. Comparto análisis técnico aplicado en Cloud Security in Practice.

Conoce más →