Build agents that work within a budget
Give your agent a task and a budget. It can see which tools it may use, hand smaller budgets to sub-agents, and handle a refusal without working around your rules.
Your limits hold whatever the agent decides, because SatGate sits between the agent and the tools it calls.
# Public metadata. No account or install needed
curl -fsS https://satgate.io/.well-known/satgate
curl -fsS https://satgate.io/llms.txtSDK access
# Install today (public packages):
pip install satgate
npm install @satgate/sdkWhat you can try today
The public demo is a simulation that runs on your machine. It shows an agent finding the price, making allowed calls and running out of budget.
Start with the task
Real work, within limits you set.
SatGate protects the APIs and tools the task depends on. Observe shows usage without blocking. Control enforces your agents’ budgets and permissions. Admit charges external agents on paid routes, after checking they’re allowed in. Control and Admit sign receipts anyone can check, and Observe can too. A receipt is a record, not a compliance guarantee.
The task
Pick a task with a clear finish, like comparing prices or researching a topic. Judge the result on its own. The receipt only shows what was allowed.
Your limits
Set a budget and the tools the agent may use. Make sure the agent can’t reach the API directly and skip SatGate.
Receipts anyone can check
Check the receipts against SatGate’s published keys. A receipt shows what was allowed and what it cost, not whether the answer was right.
How it works today
Issue. Call. Check.
Mint a token with a budget in SatGate Cloud, send your agent's calls through SatGate, then check the receipt with the open-source verifier.
Issue a token
In the SatGate Cloud dashboard, mint a token for one agent with its budget, the tools or routes it may call and when it expires.
Make the call
Send the agent’s tool calls or API calls through SatGate. In Control, SatGate checks the budget and permissions before each call runs.
Check the receipt
Check a signed receipt with the open-source verifier against SatGate’s published keys. Keep it for audits, incident reviews or billing questions.
Developer details
Payments and internal budgets.
Fiat402 handles internal budgets: your agent spends from its budget and no money moves. Admit handles paid access for external agents: a Lightning (L402) or USDC on Base (x402) payment unlocks the route. Either way, SatGate still checks permissions. Paying never replaces them.
See /.well-known/satgate for published adapter status, meaning which payment methods are live.
{
"receipt_id": "rcpt_7J4xQf9",
"decision": "allowed",
"decision_reason": "budget_authorized",
"policy_version": "policy_2026_05_build_v1",
"route_or_tool": "api.example.com/search",
"capability_hash": "sha256:demo_redacted",
"attempted_amount_usd": "0.42",
"remaining_budget_usd": "4.20",
"evidence_pack_id": "ep_2026_05_12_001",
"signature": "ed25519:demo_redacted"
}{
"receipt_id": "rcpt_9Kp1vM2",
"decision": "denied",
"decision_reason": "budget_exhausted",
"policy_version": "policy_2026_05_build_v1",
"route_or_tool": "api.example.com/search",
"capability_hash": "sha256:demo_redacted",
"attempted_amount_usd": "4.20",
"remaining_budget_usd": "0.00",
"evidence_pack_id": "ep_2026_05_12_001",
"signature": "ed25519:demo_redacted"
}Agent integrations
Works with the framework you already use.
Whatever framework you use, the pattern is the same: the agent gets a token before it acts and a receipt after SatGate decides. The machine-readable details are at /.well-known/satgate.
Gateway quickstart
Run the open-source gateway on your own machine. Paid routes are optional; you can start with budgets only.
Capability schema
What a token holds: who issued it, who it’s for, allowed tools, budget, expiry, extra limits and how far it can be handed off.
Receipt schema
The signed record SatGate writes. 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.
Trust metadata
What SatGate publishes for machines: which tokens it accepts, how to verify receipts, and which payment methods are live.
Open verifier
Check a live receipt against the issuer’s published keys (JWKS). Uses RFC 8785 canonical JSON and Ed25519 signatures.
MCP integration
Put SatGate in front of MCP tools. On SatGate Cloud MCP, every action your agents take is recorded in a signed receipt. A self-hosted gateway signs with your own key.
OpenAI tools
Run OpenAI tool calls through SatGate and verify the receipts.
Anthropic tools
Enforce limits on Anthropic tool use in your own gateway, not inside the model provider.
LangChain
Keep LangChain for orchestration and add SatGate where the tools are called.
CrewAI
Give each CrewAI tool its own token, with signed receipts for budget spends and for refusals over a budget, a missing payment or a tool permission.
API overview
The gateway’s lower-level APIs.
Python SDK
Install and set up the Python SDK.
Node.js SDK
Install and set up the Node.js SDK.
Handoffs, refusals and retries
Give each sub-agent a smaller budget and fewer permissions, with enough set aside to finish its part. Try a request it isn’t allowed to make and one that runs past its budget, and check that both are refused. If a call times out and you don’t know whether it went through, check whether your setup can look up that same call before you retry. Treat an unknown result as unknown, not as a failure.
Try it on one real workflow.
To test a new agent with sub-agents, talk to us about a pilot. We’ll agree on the setup, the integrations and the limits before you start.