The thing that stops a runaway agent is not a better prompt.

02 — How it works

One call, and the limits are in place.

No proxy, no sidecar, no changes to the code that calls the model. The transport is injected in-process, so requests still go straight to the provider.

from openai import OpenAI
from backstop import Backstop, BackstopConfig

client = Backstop.wrap(
    OpenAI(),
    budget=50_000,     # token ceiling
    config=BackstopConfig(
        initial_concurrency=4,
    ),
)

client = Backstop.wrap(
    OpenAI(),
    # tokens, and dollars on top
    budget=50_000,
    budget_usd=Decimal("5.00"),
    config=BackstopConfig(
        initial_concurrency=4,  # in flight
    ),
)

from backstop.exceptions import BudgetExceededError

try:
    response = client.chat.completions.create(...)
except BudgetExceededError as exc:
    # A subclass of openai.OpenAIError, so the
    # handlers you already have still catch it.
    log.warning("Budget reached", extra={"used": exc.tokens_used})

04 — In plain words

Four hard ideas, said simply.

Budget

A number you promise. The agent may spend it however it likes — and when it is gone, the next request never leaves your machine. It fails in your code, where you can handle it.

Circuit breaker

The electrical kind. When a server keeps failing, the switch flips and stops sending it traffic for a while, then lets one request through to see if it recovered.

Concurrency

How many things are allowed to be in flight at once. Past that number, work waits in a queue rather than being thrown away — and a critical request waits less than a background one.

Shadow mode

Watch what would happen without letting it happen yet. The same budget, the same thresholds, every decision recorded — and nothing blocked.

06 — Proof

Check it yourself, in thirty seconds, with no API key.

backstop verify runs a real wrap against a local mock transport, blocks a runaway, and prints what it measured. If it cannot prove the limits work, it says so and exits non-zero.

# Backstop Verify — 30-Second Keyless Proof

Mode: offline (local mock transport, zero network, zero keys)
Provider: openai (gpt-4o-mini simulation)

| Metric             | Result              |
|--------------------|---------------------|
| Allowed calls      | 2                   |
| Blocked calls      | 8                   |
| Tokens reserved    | 500                 |
| Tokens saved       | 2,000               |
| Exception surfaced | BudgetExceededError |
| Wall-clock overhead| 0.08 ms             |

## Mechanism Checks
- [PASS] config valid: BackstopConfig() built with sane bounds.
- [PASS] wrap pipeline: served a mock request end-to-end.
- [PASS] budget block: 8/10 runaway calls blocked at 500 tokens.
- [PASS] overhead: control-path p99 = 0.080 ms (direct 0.261 ms).
- [PASS] cache hit: the second identical request came from cache.
- [PASS] per-agent isolation: agent A blocked 5/5 at its own cap
        while agent B kept serving.

Summary: 8 passed, 0 warn, 0 failed, 0 skipped
Status: VERIFIED (real wrap enforcement active)

08 — Questions

The ones worth asking.