Economic firewall for agents

An economic firewall
for AI agents.

Any agent. Any platform. Signed receipts anyone can check.

Keep your AI agents within budget on the paid services they use. Make external agents pay before they use yours. SatGate signs a receipt when it refuses an agent over a budget, a missing payment or a tool permission, and when an agent spends from a budget in Control.

Each time an agent uses a service, SatGate checks it first. (Developers call these services APIs.) Your own agents stop when their budget runs out. External agents pay on the routes you choose, so abusing your API gets expensive, and paying never gets them past your access rules.

Build with SatGate·See a signed receipt (Evidence Pack)

14 days free. No credit card.

Letting an AI agent trade in your brokerage account? Set limits for it. Works with Robinhood today. See how

Works with web APIs and AI tool servers Checks each request first
MCP · HTTP APIs · Lightning payments Open-source core gateway

The product shots come from the production recordings below.

See how it works

See SatGate in Action

Four recordings from production, with narration.

Your agents' API calls: a budget they can't overspend

Connect an API, set a route to Control, and mint a token with a 100-credit budget. Without the token the route returns 401; with it, 200. A demo agent spends the budget at 10 credits a call until SatGate blocks its next call. Then the open-source verifier checks the signed receipt for that refusal.

The agent in the recording is the dashboard's built-in demo agent.

Your agents' tool calls: only the tools you allow, within budget

Add an MCP server, mint a token with a 3-credit budget that can call one tool, and copy its config into Claude Code, Cursor, Hermes, OpenClaw or any other MCP client. A tool outside the list is refused before it runs. Once the budget is spent, the next call is refused too. The open-source verifier checks the receipts.

The agent in the recording is a scripted MCP client using the public satgate-mcp-bridge npm package.

Your agents on a real brokerage account: each with its own limits

Two agents trade one real brokerage account through SatGate, each with its own token. The trading agent can spend $200 a day, needs the owner's OK for any order over $4, and can only use its own account. It's refused on the owner's main account, buys $1 of Bitcoin, and is refused a $250 order the account could pay for. A $5 order waits until the owner approves it from the link in the email, then fills. The owner revokes the trading agent's token. Its next connection is refused, and the savings agent keeps trading. The refusals, the hold and each order get a signed receipt, and the open-source verifier checks them.

The agents in the recording are scripted MCP clients. The orders are real: three Bitcoin buys, $7 in total. Account numbers are masked.

External agents: pay before they get in

Set a route to Admit and choose how external agents pay: USDC on Base, sats over Lightning, or both, each with its own price. An agent with no wallet gets 402 Payment Required and never reaches your API. In the recording, a second agent sends one cent in USDC, the payment settles on Base, and the call goes through. Sending the same payment again is refused. With USDC, each payment buys one request. On Lightning you choose how many requests one payment buys, and on sat-priced routes the price can rise under load, up to a ceiling you set; unpaid 402s don't raise it. Paying never gets an agent past your access rules. SatGate signs a receipt when it refuses an agent for a missing payment.

The agents in the recording are scripted HTTP clients. The USDC payment is real: one cent, settled on Base.

Check the receipts from the video yourself. The paid call: live receipt or downloaded copy. A call refused for no payment: live receipt or downloaded copy. Then run the open-source verifier against SatGate's public key:

python3 tools/verify_evidence_pack.py https://api.satgate.io/v1/evidence/evid_e-suLq8DGymE6LvIJ2D1mTN95Oavy_4E --jwks-url https://api.satgate.io/.well-known/jwks.json --require-trusted-issuer

What the verifier checks

Budgets for your agents. Payment from external agents.

Control caps what your own agents can spend. Admit makes external agents pay before their request reaches you. Both leave signed receipts.

ON BY DEFAULT

Agents only get what you allow

Every route except the ones you mark PUBLIC

Before SatGate forwards a request, it checks what that agent is allowed to do. Paying doesn't change that: a paid request still can't go past its permissions, use an expired token or get around a revoke.

✓ Permissions per agent✓ Narrower tokens for sub-agents✓ Revoke works on the next request✓ Signed receipts

Your rules sit outside the model. Limits, receipts and the off switch live in SatGate, where no prompt or model provider can change them.

Zero trust for AI agents →

Your agents: budgets

Protected by default →

Observe (see usage)

See usage and cost without blocking requests.

Start here. Nothing is blocked while you see which agents call what, and what it costs.

  • ✓ Never blocks a request for being over budget; requests still need a valid token
  • ✓ Usage broken down by team
  • ✓ See which agents, tools and routes cost the most before you change anything
  • ✓ Built to add little overhead
Protected by default →

Control (budgets)

Enforce budgets and permissions before a request runs.

Then turn on limits. An agent that is out of budget or asks for something it isn't allowed is stopped before the request runs.

  • ✓ Budget checked on every priced request
  • ✓ Your agents spend from a budget you set; nobody pays per call
  • ✓ Per-agent spending caps

External agents: access and payment

Protected by default →

Admit (external access)

Give external agents limited access, and charge them where you want to.

On a paid route, payment comes first, before the request reaches your API, so abusing it gets expensive. Paying never gets an agent past your access rules.

  • ✓ No shared API keys to hand out
  • ✓ Payment only on the routes you choose
  • ✓ You set the price and how many requests one payment buys
  • ✓ You decide what each agent can reach
RECEIPTS FOR BOTH

Receipts anyone can check

Control, Admit and Observe all sign receipts.

SatGate signs a receipt when it refuses an agent over a budget, a missing payment or a tool permission, and when an agent spends from a budget in Control. On SatGate Cloud MCP, every action your agents take is recorded in a signed receipt. Each receipt comes in an Evidence Pack you can export. Your auditor can check the signatures with the open-source verifier and SatGate's published keys, with no need to trust the AI company. A receipt shows what SatGate decided. It is not a compliance certificate.

✓ Your agents and external agents✓ Refusals too✓ Any edit breaks the signature✓ Open-source verifier

Charging for access makes abuse more expensive. It doesn't replace rate limits or access controls, and it only covers traffic that goes through SatGate.

Why API keys don't work when agents hand off work

An API key gives full access or none. A SatGate token carries its own budget, permissions and expiry. An agent can hand a sub-agent a narrower token, never a broader one.

Mark a route PUBLIC to leave it open, for health checks (/healthz), docs and webhooks. Every other route is protected by default.

How a request gets checked

Get a token once. SatGate checks each request.

An agent gets a token when it starts, like putting an E-ZPass on the windshield. After that, SatGate checks and meters each request as it passes.

Agent startsIn your cloud
→
Gets a tokenOnce
→
SatGate checksEach request
→
Your serviceYour API

SatGate checks the token itself, so it doesn't call your identity provider on every request.

THE RESEARCH

Built for agents that hand work to other agents

A 2026 paper on AI delegation (Tomasev et al.) describes a problem we see in practice: when agents hand work to other agents, each one needs clear limits on what it can do and spend. One approach it proposes is tokens that can only be narrowed as they are passed down, such as macaroons.

SatGate's tokens are macaroons.

Limited permissions

Each agent gets only the permissions it needs, and each handoff can only narrow them.

Budget caps

Set budgets per agent and per route. SatGate checks them before forwarding.

Stops on the next request

Once an agent hits a limit, SatGate refuses its next request.

We built SatGate because standing API keys and after-the-fact alerts are a bad fit for autonomous systems. The paper put words to a problem we were already seeing in agent deployments.

Where it fits

Three ways to set it up. Start with one route or one tool.

STANDARD

CDN / WAF
↓
SatGate
↓
Your API

REST, GraphQL, any HTTP endpoint

SIDECAR

Existing Gateway
↓
Legacy traffic
↓
SatGate
↓
↓
Your APIs

Route only agent traffic through SatGate

MCP PROXY

AI Agents
↓
SatGate MCP Proxy
↓
MCP Servers / Tools

Budgets per tool, including for sub-agents

How it works

Most teams start by pointing one endpoint or one MCP tool at SatGate.

1

Pick a policy

Set a policy per route: public for health checks and docs, protected for everything else.

routes:
  - match: { pathExact: /healthz }
    policy: { kind: public }
  - match: { pathPrefix: /v1/ }
    policy: { kind: observe }
  - match: { pathPrefix: /premium/ }
    policy: { kind: charge, priceSats: 10 }
2

Apply it

Apply it when you are ready. Every version is kept with an audit entry for who changed what, and on Pro and Enterprise you can roll back.

v3 (applied) ← current
v2 (available)
v1 (available)

Audit entry: who, when, diff
3

Point your agents

Send agent traffic to api.satgate.io with your tenant header, so every request goes through SatGate.

# Agent requests
GET https://api.satgate.io/v1/...
X-SatGate-Tenant: your-tenant

# MCP clients
npx satgate-mcp-bridge
4

Check what happened

Signed receipts for budget spends and for refusals over a budget, a missing payment or a tool permission, ready to export as Evidence Packs.

Example only
Allowed: 1,203
Refused: 12,847
Paid:    $847

→ Export Evidence Pack

FAQ

Questions

What is SatGate?

SatGate is a gateway that sits in front of your APIs and MCP tools. It keeps your own agents within the budgets and permissions you set and charges external agents on the routes you choose.

How does SatGate control what agents do?

Before a request reaches your API or MCP tool, SatGate checks the agent’s permissions, its remaining budget and whether its token was revoked. If a check fails, the request stops at SatGate.

How do I give an agent a budget?

You set the budget, the permissions and how many times it can hand work to a sub-agent. The agent gets a token with those limits built in.