Economic safety for metered software

Put a hard spending limit on every costly task.

LimitFuse watches AI calls, cloud functions, queues, database work, and paid APIs—stopping runaway execution before it becomes a surprise bill while healthy work keeps moving.

Start guided setup Watch a runaway stop

Start with one workflow. Advanced controls stay out of the way until you need them.

A bright containment plane stopping one unsafe path while healthy paths continue

PROBLEM

Runaway work

ACTION

One task stops

REST OF APP

Keeps running

THE BILL SHOULD NEVER BE THE ALERT

Software can scale a mistake faster than billing can report it.

WHY THIS IS PERSONAL

$16,000

Years before LimitFuse, one of us received a $16k AWS bill after an Amplify bug. The code was accidental. The spend was real. An alert after the work ran was not protection.

CASE 01 / 10

AWS

$14,000

A few days · An event loop

WHAT HAPPENED

Two event-driven components triggered each other repeatedly. Every invocation looked valid in isolation, so the system kept scaling the mistake until the bill exposed it.

WHERE LIMITFUSE INTERVENES

Give the causal run one wallet, cap retries and fan-out, deny the next invocation, then reduce the affected Lambda concurrency or pause its queue—not the whole account.

THE SAME INCIDENT · WITH A FUSE

One event. One wallet. No endless echo.

The stable event ID joins both functions to one economic run. The next repeated attempt is refused before Lambda dispatch.

ILLUSTRATIVE SERVER-SIDE PATTERN
PAIR WITH PROVIDER LIMITS AND RECONCILIATION

AWS · PROTECTED PATHTYPESCRIPT

await limitfuse.executeExternalSafely({
  kind: "function",
  feature: "event-pipeline",
  logicalOperationId: event.id,
  attempt: event.deliveryAttempt,
  estimatedMaxCostUsd: 0.02
}, {
  timeoutMs: 20_000,
  execute: ({ signal, markStarted }) => {
    markStarted();
    return invokeLambda(event, { signal });
  }
});

Read the sourced account

Public accounts are summarized and identities are omitted; amounts and outcomes are those reported by the linked sources. Solution code is illustrative and runs server-side. LimitFuse enforces only protected execution paths. Uninstrumented traffic and already-running external work still require provider limits, runtime cancellation, and provider-log or egress reconciliation.

Stops runaway work before it runs up a bill

Keeps healthy work running

Shows what every workflow costs

Protects AI and ordinary metered software

Three simple steps

Safe from the first workflow.

You do not need to learn a new control plane. Connect one app, choose a limit, and let LimitFuse watch the dangerous edges.

Connect your app

Name the product you want to protect and copy its private connection key.

Pick a spending limit

Choose how much one task may spend—whether it is AI, serverless, storage, a queue, or a paid API.

Let the fuse work

A broken task stops at its limit. Unrelated customers, functions, and workflows stay live.

One task breaks. Everything else stays live.

LimitFuse follows the whole workflow, so it can stop the smallest unsafe piece instead of taking down your product.

YOUR APP STARTS A TASK

Create a weekly campaign

HEALTHY TASK

Continues normally

Useful work reaches the customer without interruption.

RETRY LOOP

Only this task stops

The limit is reached, the loop is contained, and the bill cannot keep climbing.

Internal guard or External Guard

Two paths. One hard limit.

We recommend the managed path whenever it supports the work. LimitFuse can then decide, dispatch, time out, and settle the operation inside one boundary. External Guard exists for the equally valid case where your credentials and content must never enter a LimitFuse-operated request path.

Start managed. Choose external when ownership or workload coverage requires it.

RECOMMENDED

MANAGED PATH · INTERNAL GUARD

LimitFuse owns the whole request lifetime.

Best for supported model calls and any path placed behind a LimitFuse-managed or customer-hosted gateway. The guard is authoritative because execution cannot start without passing it.

Admission, execution, timeout, and settlement share one controlled path
The next denied request cannot reach the supported provider
Provider usage is settled from the response instead of self-reported
The smallest unsafe run can stop while unrelated traffic stays live

Why it is safer

There is no gap between receiving permission and starting the billable work. LimitFuse can enforce the in-flight deadline and observe the final usage on the same path.

CUSTOMER PATH · EXTERNAL GUARD

Your call stays yours.

LimitFuse reserves economic authority before your function runs; your system executes it and settles afterward. This is the lowest-trust integration and the broadest workload surface.

Provider credentials, prompts, payloads, and responses stay in your infrastructure
Protect functions, queues, databases, storage, jobs, browsers, and paid APIs
Use your own provider, runtime, region, network, and cancellation mechanism
Reconcile uncertain work from provider logs or cloud egress

The honest limitation

A remote authorization cannot kill code it does not operate. Enforce the signed deadline locally, pass cancellation through every layer, cap provider work, install a durable watchdog for jobs, and reconcile uncertain outcomes.

Managed flow

YOUR APP → LIMITFUSE DECIDES + RUNS → PROVIDER → EXACT SETTLEMENT

External flow

YOUR APP → AUTHORIZE → YOUR PROVIDER → SETTLE OR RECONCILE

Compare every safety boundary

TWENTY PROTECTED PATHS

One small guard. Almost anywhere.

Choose a workload. Every example uses the same server-side contract: reserve authority, run with a deadline, then settle measured cost. Your provider key and payload stay with you.

SDK optional Raw HTTPS supported Provider credentials stay outside

CHOOSE A WORKLOAD · 01 / 20

Managed gatewayAI

AI completion

Cap tokens, retries, calls, and cost before a model request leaves LimitFuse.

Open full API docs

AI COMPLETION · SERVER ONLYTYPESCRIPT

const response = await limitfuse.chatCompletions({
  model: "limitfuse-default",
  messages,
  max_completion_tokens: 400
}, {
  metadata: {
    feature: "support-reply",
    operation_id: crypto.randomUUID(),
    max_cost_usd: 0.04
  }
});

Examples are intentionally small. Named provider adapters return the LimitFuse execution shape with the value and measured cost. Production integrations must also enforce provider-native token, byte, duration, concurrency, and cancellation limits. Client-side apps call your backend; never ship a LimitFuse project key in a browser, mobile binary, or desktop bundle.

AGENT-ASSISTED SETUP

Tell your agent what to protect. Review the fuse.

Give the portable LimitFuse skill to Claude, GPT/Codex, or another repository-capable coding agent. It can trace the costly path, choose the correct boundary, implement the guard, add tests, and prepare a canary. You keep approval over secrets, deployment, billing, and enforcement.

CLAUDEGPT / CODEXOTHER CODING AGENTS

Inspect

Find the costly model calls, functions, queues, jobs, and paid APIs in your repository.

Choose

Recommend the managed path where LimitFuse can own execution, or External Guard where your key and payload must stay local.

Implement

Write the SDK or raw HTTPS integration, policy, deadlines, cancellation adapter, and deterministic tests.

Prove

Run shadow checks and a low-cost canary, then present the evidence before enforcement changes.

USE TODAY · PORTABLE SKILL

A complete integration playbook for your coding agent.

The skill teaches the agent to preserve server-only keys, prefer the managed safety boundary, harden External Guard when required, write tests, and stop for human approval before consequential actions.

Download LimitFuse skill Agent setup guide

MCP · APPROVAL-GATED CONTROL PLANE

Tools, not unchecked authority.

Connect compatible agents to https://mcp.limitfuse.com/mcp with a project-scoped MCP key. They can inspect the project, compare safety boundaries, prepare integrations and canaries, and dry-run an operation against the active policy. The endpoint exposes no mutation tools: enforcement, containment, key rotation, deployment, and billing stay in the signed-in console.

Read policies, runs, incidents, and evidence

Propose a policy or integration diff

Simulate and prepare a bounded canary

Require a person for consequential changes

OpenAPI 3.1 llms.txt MCP setup Raw API

Agent support does not make a deployment self-authorizing. The agent may inspect, implement, test, and prepare evidence; a project owner must still supply secrets securely and approve production enforcement, destructive containment, credential rotation, and payment changes.

Protect your first workflow.

Guided setup shows one decision at a time. When you want deeper controls, Advanced mode is always one click away.

Start guided setup