The agent era shifted gears. It's no longer one agent, one task, one API key. It's swarms — coordinator agents spawning specialist agents, each making their own API calls, each spending money. And the cost math changes dramatically when agents multiply.
The Multiplication Problem
A single agent making 100 API calls per task is manageable. A coordinator that spawns 5 sub-agents, each making 100 calls, each spawning 3 more specialists? That's 2,000+ calls from what started as one request.
# Agent delegation tree — real-world scenario
📋 Project Manager (budget: $500)
├── 🔍 Research Agent (delegated: $100)
│ ├── 🌐 Web Search Agent ($30)
│ └── 📊 Data Analysis Agent ($70)
├── 💻 Coding Agent (delegated: $200)
│ ├── 🧪 Test Agent ($50)
│ └── 📝 Docs Agent ($30)
└── 🎨 Design Agent (delegated: $100)
└── 🖼️ Image Gen Agent ($80)
# 8 agents, all spending concurrently
# Without governance: $500 budget becomes $???
The problem isn't that agents are expensive individually. It's that they compound. A coding agent that loops on a failing test, a research agent that broadens its search, an image gen agent that iterates on a design — each agent has its own optimization loop, and loops cost money.
Why Existing Solutions Fall Short
API keys per agent
You could give each agent its own API key with a spending limit at the provider level (e.g., OpenAI spend caps). But when a coordinator delegates to sub-agents, each sub-agent needs its own key. Key management becomes combinatorial. And there's no hierarchical budget — sub-agents' limits don't roll up to a parent ceiling.
Application-level tracking
You could build cost tracking into your agent framework. LangChain has callbacks, CrewAI tracks token usage. But this is per-framework — if your swarm uses agents from different frameworks (increasingly common), you need a unified layer. And application-level tracking happens after the call, not before.
Rate limiting
Rate limits don't understand delegation trees. If a coordinator is rate-limited to 100 req/min, but its sub-agents each get their own 100 req/min, the total swarm throughput is 800 req/min. More importantly, requests per minute ≠ dollars per minute.
The Solution: Hierarchical Economic Governance
What agent swarms need is economic governance at the infrastructure layer — a single enforcement point that understands delegation, budgets, and attribution regardless of which framework spawned the agent.
Hierarchical budgets
The coordinator gets a total budget. When it delegates to sub-agents, it carves out a portion. Sub-agents can never collectively exceed the parent's allocation. The math is enforced cryptographically.
Cascade revocation
If a coordinator goes rogue, revoke its token. Every agent in the delegation tree is instantly invalidated — no need to track down individual agents.
Scope attenuation
A research agent shouldn't call code execution tools. Delegation tokens carry scope restrictions — each level can only narrow the scope, never widen it.
Cross-framework enforcement
Because enforcement happens at the gateway (HTTP/MCP layer), it doesn't matter if agents are built with LangChain, AutoGen, CrewAI, or raw API calls. Same budget, same rules.
What This Looks Like in Practice
# 1. Mint a coordinator token satgate mint --agent "project-mgr" --budget 500 # 2. Coordinator delegates to sub-agents satgate delegate --from <pm-token> \ --to "research" --budget 100 --scope "/api/search*" satgate delegate --from <pm-token> \ --to "coder" --budget 200 --scope "/api/code*" # 3. Sub-agents delegate further satgate delegate --from <coder-token> \ --to "test-runner" --budget 50 --scope "/api/code/test*" # 4. Every agent hits the same gateway # Budget enforced at each level # Total spend across entire tree ≤ 500
The Enterprise Angle
For enterprises, agent swarms are a budget governance nightmare. Different departments run different agents on different APIs. Without centralized economic governance:
- Finance can't allocate AI budgets per department
- Security can't enforce least-privilege spending
- Engineering can't debug cost spikes across agent trees
- Compliance can't audit who authorized what spend
An economic firewall gives every stakeholder what they need: Finance gets budget enforcement, Security gets scope attenuation, Engineering gets attribution, Compliance gets an immutable audit trail.
Control your agent swarm's spend
SatGate is open source. Deploy in 5 minutes. See the delegation demo live.