The problem

Most AI cost control happens too late.

A provider dashboard can tell you what happened after the API calls already executed.

That is useful.

But it does not stop a bad agent run while it is happening.

For basic LLM usage, this may be acceptable. You send one prompt, receive one response, and check the cost later.

Agents are different.

An AI agent is not one call.

It is a loop.

That loop may include:

model calls
tool calls
retries
fallback models
growing context
planning steps
validation steps
more retries

Each step may look reasonable by itself.

The failure appears across the whole run.

The expensive failure is usually boring

Many AI cost failures are not dramatic.

They are simple runtime failures:

the agent retries too many times
the prompt changes slightly but not meaningfully
the agent keeps calling tools without progress
the run exceeds a safe step count
the model price is unknown
the workflow crosses a budget limit

None of these require a complex theory.

They require boring runtime controls.

That is the point.

Production software already has limits everywhere.

Timeouts.

Memory limits.

Rate limits.

Retry limits.

Circuit breakers.

AI-agent runtimes need the same kind of thinking.

A dashboard is not a guardrail

A dashboard answers:

“What happened?”

A runtime guard answers:

“Should this next call happen?”

Those are different questions.

The second one is more important during execution.

Once the provider call is made, the cost is already real.

That is why AI-agent cost control should not only happen after the invoice.

It should happen before provider API calls execute.

Simple TypeScript-oriented thinking

Imagine an agent step before a provider call.

Before sending the request, the runtime can check a few things:

const decision = guard.beforeCall({
runId,
model,
prompt,
step,
estimatedCost,
});

if (!decision.allowed) {
throw decision.error;
}

const result = await provider.call({
model,
prompt,
});

The important idea is not the exact API.

The important idea is the position of the check.

It happens before the provider call.

That means the runtime can block dangerous behavior before money is spent.

Useful checks before the call

A practical guard layer can ask:

Is this model price known?

If not, fail closed.

Has this run exceeded its budget?

If yes, stop.

Has this agent exceeded max steps?

If yes, stop.

Is this prompt too similar to previous failed attempts?

If yes, block the loop.

Is the agent making no progress?

If yes, return a structured error.

These checks do not make the model smarter.

They make the runtime safer.

That matters.

Unknown model pricing should fail closed

Unknown pricing is easy to underestimate.

A typo in a model name can break assumptions.

A provider alias can change.

A fallback can route to something more expensive.

A dashboard may show this later.

A runtime guard can stop it before the call.

For production agent workflows, unknown pricing should be treated as a risk.

Failing closed is safer than guessing.

Max-step limits are production safety

A max-step limit sounds basic.

It is basic.

That is why it belongs in the runtime.

An agent that cannot finish in a reasonable number of steps may be confused.

Letting it continue forever is rarely useful.

A step limit gives the system a clear stopping point.

It also gives the developer a structured failure to inspect.

That is better than silent spending.

Where AI CostGuard fits

This is the layer I am building with AI CostGuard.

AI CostGuard is a local-first TypeScript / Node.js runtime safety layer for AI agents.

It is designed to catch cost and loop failures before provider API calls execute.

Current checks include:

retry storm detection
similar prompt loop detection
unknown model pricing blocks
max-step protection
budget guards
middleware and wrapper support
structured errors

It is not a billing ledger.

It is not a hard security boundary.

It is not an enterprise firewall.

It is a pre-call runtime kill switch for AI-agent cost and loop failures.

The takeaway

Cheaper tokens help normal runs.

Caching helps normal runs.

Routing helps normal runs.

But abnormal agent behavior needs runtime limits.

The key question is not only:

“How much did this model cost?”

The better question is:

“Should this next provider call be allowed?”

For AI agents, that question belongs before execution.