Most teams hit this pattern eventually.

You add Stripe metered billing to your agent. You set a monthly cap. You feel good about it.

Then one customer sends a query that kicks off a recursive research loop. The agent runs for 40 minutes. By the time your cap triggers, you've already burned $80 of compute for a customer on a $10 plan.

Stripe didn't fail you. You asked it to track spend. It tracked spend. The problem is that tracking is a receipt. You needed a pre-authorization.

The actual fix: check before the run, not after.

from agentbill import meter

u/meter(
    event="research_run",
    customer_id_from="customer_id",
    ceiling=5.00,
    preflight=True
)
async def run_agent(customer_id: str, query: str) -> str:
    return await your_agent(query)

If the customer is over budget, CeilingExceededError is raised before a single token is consumed. The function never runs. No charges. No surprise invoice.

The mental model shift:

Monthly caps answer: "Did this customer spend too much this month?"

Per-request ceilings answer: "Should I even start this run?"

Those are different questions. The second one is the one that saves you money.

What this looks like in practice:

• Customer A has 83 units left. Query comes in estimated at 5 units. Run starts.
• Customer B has 3 units left. Same query. Blocked before execution. Returns a clean error your frontend can handle.
• Customer C is on pay-as-you-go. No limit. Run starts. Event recorded after completion.

All three cases, one decorator.

What about outcome-based billing?

One more pattern worth knowing. If you're building something like a support agent, you probably don't want to charge for failed attempts.

@meter(
    event="support_ticket",
    customer_id_from="customer_id",
    units=lambda result: 5 if result.get("resolved") else 0
)
async def handle_ticket(customer_id: str, ticket: dict) -> dict:
    ...

Charge 5 credits if the ticket got resolved. Charge 0 if it didn't. Your customers pay for results, not attempts.

Been building AgentBill to solve exactly this — preflight governance for AI agents. Happy to answer questions or talk architecture in the comments.

What billing patterns are you using right now for your agents?

The pattern I kept seeing: monthly caps are useless for agents. One misconfigured loop can exhaust a monthly budget in hours. A per-request ceiling that blocks BEFORE compute starts is the actual fix.

Comment "Repo" to get a free access.

Curious what others are using for agent spend control.

My AI agent racked up $340 in one night while I slept.

No bug. No attack. Just a loop that retried 400 times because the success condition was slightly off.

Monthly caps didn't save me - they reset on the 1st and this happened on the 3rd. Rate limiting didn't help either - the calls were spaced out enough to pass.

The fix I ended up building: a preflight check. Before the agent runs, it asks "does this customer have budget for this?" If not, it blocks the run entirely. Not after the damage is done - before.

Sounds obvious in hindsight. But I couldn't find a single library that did this cleanly, so I built one.

Open source, 3-line integration. Curious if others hit this problem or if I just have unusually expensive taste in debugging sessions.

Been building AI agents for clients and kept rewriting the same boilerplate. Finally packaged it: preflight budget check before any tokens are consumed, per-customer billing, Docker deploy config. Works out of the box.

Comment here and I'll DM you the GitHub link.

LangGraph loops are the hardest case for cost control. The decorator wraps the entry point fine, but conditional edges mean cost can spiral between node transitions and you only see it post-mortem.

We added client.checkpoint() for exactly this — drop it inside any node:

def my_node(state):
    check = client.checkpoint(agent_id="researcher", units_so_far=state['units_used'])
    if not check.approved:
        raise Exception(f"Mid-run blocked: {check.reason}")
    return do_work(state)

Read-only check, no double-billing, remaining_units comes back so you can decide whether to abort or degrade gracefully.

v0.3 also ships per-step anomaly detection — if a node suddenly costs 3x its historical baseline you get anomaly: true with the deviation %.

Repo in comments.

Been burned by a research agent that kept retrying on failed web fetches. Every retry called the LLM. No kill switch. Woke up to a $498 bill.

Built a simple preflight pattern to block runs before they start:

from agentbill import AgentBillClient

client = AgentBillClient(api_key="agb_your_key")

def run_agent(task: str, customer_id: str):
    check = client.preflight(
        agent_id="researcher",
        budget=2.00,
        customer_id=customer_id
    )
    if not check.approved:
        raise RuntimeError(f"Blocked: {check.reason}")

    result = your_agent(task)

    client.record(
        agent_id="researcher",
        cost=check.estimated_cost,
        customer_id=customer_id
    )
    return result

Check runs before the first token. If budget is gone, nothing executes.

Two things I'm still unsure about:

1. Is a decorator cleaner than wrapping the call directly?
2. Anyone handling this differently for self-hosted models where cost isn't per-token?

One pattern I kept seeing in this sub: people using Stripe metered

billing as a safety net for runaway agents.

scarlett1908 said it best a while back: "the moment you're using it

as your safety net you've already lost the run."

The problem: Stripe tells you what happened. It doesn't stop the bad run.

AgentBill does preflight. Before your agent runs, check if the

customer has budget. Block if not.

pip install agentbill-sdk

from agentbill import AgentBillClient

client = AgentBillClient(api_key="...", ceiling=50)

client.preflight("research_agent", estimated_units=10)

# raises CeilingExceededError if 10 > 50

Also published as an MCP server (agentbill-mcp on PyPI) so Claude

Code and Cursor can use it natively.

Built for single-call atomic functions. Multi-step workflow support

is on the roadmap.

agentbill.fly.dev if you want to try it.

Every time our agent hit an edge case, it would loop. By the time we noticed, the bill was already there.

So we built AgentBill! a preflight check that runs before each agent call. Before the LLM fires, it checks:

• Is this customer over their budget?
• Does the estimated cost exceed the ceiling I set?
• Has the free tier been exhausted?

If any of those are true, the run gets blocked before it touches the API.

3-line integration:

from agentbill import AgentBillClient
client = AgentBillClient(api_key="...")
client.preflight(agent_id="my-agent", customer_id="user-123")

Open source. Free tier included. Happy to share the repo in the comments if there's interest.

Been building AgentBill - a preflight billing layer for AI agents.

The problem we kept hearing: monthly caps don't catch the bad single run. One 3-hour research loop can blow your budget before the monthly cap even triggers.

So we shipped per-request ceilings. You set a max cost per invocation at init time. If the estimated cost exceeds it, the run is blocked before any compute starts.

from agentbill import AgentBillClient, CeilingExceededError

client = AgentBillClient(api_key="agb_...", ceiling=50)

try:

result = client.preflight("researcher", estimated_units=100)

# run your agent

except CeilingExceededError:

# blocked before compute starts — nothing wasted

Free tier: 1,000 preflight calls/month, no credit card.

Happy to answer questions about the architecture. What ceiling values are people actually using in production? DM me for the repo.

Happy to answer questions about the architecture. What ceiling values are people actually using in production?

I built an AI research agent. Charged $99/month, same as every other SaaS tool I'd ever built.

Three months in, I looked at my OpenAI invoices.

Some customers were costing me $4/month. Others were costing me $180. I was charging everyone the same $99.

The problem isn't unique to me. Every founder I talk to who's building an AI agent product hits the same wall: your costs are variable, but your pricing is fixed.

The obvious answer is usage-based pricing. But when I tried to implement it with Stripe's metered billing — 6 API objects, 47 pages of documentation, and two weeks later I still had a broken implementation that didn't stop expensive runs before they started.

The core issue: existing billing tools record usage after the fact. They can't stop a $43 agent run when your customer has $2 left in their balance.

So I built a small layer that does three things:

1. Checks the customer's credit balance before the LLM runs
2. Blocks the call immediately if they're out — no API call made, no cost incurred
3. Records usage after success only

It's been running in production for a week. No more surprise invoices.

Happy to share what I learned about pricing AI agent products if anyone's working through the same problem.

Are you charging flat fees for variable-cost AI products? How are you handling the cost variance?

Hey everyone.

I’ve been building B2B SaaS products for a while, but as I’m shifting more towards autonomous AI features and agents, my unit economics are completely breaking down.

Here is my dilemma: If I charge a standard flat subscription (say, $49/mo), one user might run a simple task that costs me $0.50 in LLM API calls and compute. But another "power user" might trigger a deep, multi-step agent workflow that burns through $30 of API costs in a few days.

I know the logical answer is to move to Usage-Based Billing (Metered Billing), but after spending a few hours reading Stripe’s metered billing documentation, I wanted to pull my hair out. It feels incredibly bloated and completely disconnected from the reality of tracking "Agent runs" or "Tokens used".

For those of you building AI tools or agents in production: How are you actually handling this right now?

1. Are you just charging a super high flat monthly fee and hoping the power users are subsidized by the casual ones?
2. Did you waste weeks building a custom internal "Credit/Token" system from scratch?
3. Are you using Stripe Metered Billing and I just need to suck it up and read the 47 pages of docs?
4. Is there some obvious developer tool for AI billing that I'm completely missing?

Would love to hear how you are practically solving this in your apps.