RunHalt

Stop agent spend mid-run.

Hard budget before tokens are generated. Kill a runaway run in flight — not after the invoice.

Get started How it works
RunHalt · control plane live
Run agent-1
Ceiling 5 calls
Status running
Budget hold $0.00 / $0.50
Call HTTP Result
  1. 01200ok · streamed
  2. 02200ok · streamed
  3. 03200ok · streamed
  4. 04200ok · streamed
  5. 05200ok · streamed
  6. 06409run_killed

Product

A hard stop for agent spend — not another chart.

Agents retry, call tools, spawn sub-agents, grow context. Cost is non-linear. Most tools show you the bill after. RunHalt is an OpenAI-compatible gateway: virtual keys, hard ceilings before tokens generate, and mid-run kill when a task loops or overruns.

How it works

Your agent talks to RunHalt. RunHalt talks to the model.

Same chat-completions API — only base URL and key change. RunHalt decides whether the request reaches the provider.

your agent RunHalt OpenAI / Anthropic

  1. 01

    Authenticate with a virtual key

    Agent sends Authorization: Bearer sk-rh-…. That is not your OpenAI key. RunHalt loads the budget attached to it.

  2. 02

    Reserve worst-case cost

    Before tokens generate, RunHalt holds estimated max cost. Too little budget left → HTTP 402. Zero spend at the provider.

  3. 03

    Forward the stream

    On success, RunHalt injects your real provider key and streams through — no full buffering.

  4. 04

    Settle actual usage

    When the response finishes, real tokens are charged and unused reservation returns to the budget.

  5. 05

    Halt a runaway run

    Same X-Run-Id across one agent task. Breach call/cost/loop ceilings → HTTP 409 run_killed. Abort — don’t retry.

Integration

Point your agent at RunHalt. Keep calling OpenAI as usual.

Paste your provider key once. Get an endpoint and virtual key. Set them as base URL and API key — never put the real key in the agent.

# 1) In RunHalt: paste your OpenAI key, create a virtual key
# 2) In the agent / SDK:

export OPENAI_BASE_URL="https://runhalt.com/v1"
export OPENAI_API_KEY="sk-rh-…"

# Optional — protect one agent task:
#   X-Run-Id: my-agent-task-42
#   X-Fuse-Run-Max-Calls: 20

Works with the OpenAI Python SDK, LangChain, curl, or anything OpenAI-compatible. Budget exhausted → 402. Run over limit → 409.

Pricing

Free to prove the kill. Pro for production.

BYOK only — we never mark up your OpenAI tokens. You pay for the control plane.

Free

$0

  • 2 virtual keys
  • 1 000 gateway calls / month
  • Hard budget (402) + base run kill
  • Lab included
  • Analytics up to 72 hours
Start free

Pro

$9.99/mo

  • 20 virtual keys
  • Unlimited platform calls
  • Duration + spend-velocity kill
  • Halt / spend webhooks
  • 30-day analytics retention
Upgrade in app

FAQ

Trust questions, straight answers.

What we store, where keys live, and how you leave.

What do you log?

Usage metadata only: model, token counts, estimated and actual cost, virtual key id, optional run id, and halt events (budget / kill). Prompt and completion text are streamed through and not stored. Provider keys and passwords are never written to application logs.

Where does my provider key go?

Only into RunHalt — never into the agent. It is encrypted at rest with AES-GCM under a server master key and kept in Postgres. At request time it is decrypted in memory solely to call the upstream provider. Agents authenticate with a virtual key (sk-rh-…), not your real OpenAI key. The operator who holds the master key can decrypt every tenant credential — that is inherent to a proxy that must inject the key.

What happens if RunHalt is down?

If the service is unreachable, your agent cannot call through the gateway — no spend via RunHalt. If the budget store is unavailable, hosted mode fails closed: requests are rejected instead of silently forwarding to the provider.

How do I leave?

In the dashboard: remove the stored provider key, disable or delete virtual keys, sign out everywhere, or delete the workspace (password required). Also point OPENAI_BASE_URL back at the provider.

Get started

Hosted in minutes.

Create an account, paste a provider key, get an endpoint and virtual key. Point the agent at RunHalt and set a low call ceiling to prove a runaway gets halted.

Open dashboard Read the docs