Key facts
| Router model | plugsky-fusion escalates per request across tiers (live) |
| Agents | Memory, tools and orchestration are live |
| Strategies | cost_saver for workers, max_quality for planners and arbiters |
| Loop controls | Cap steps per agent and total calls per task in your orchestrator |
| Pricing | Flat monthly self-serve plans with no per-token charges on self-serve |
| Free tier | plugsky-micro and plugsky-lite on the free plan, no card required |
| Governance | Scoped keys, RBAC and audit logs per agent |
| Roadmap | Classifier routing (/v1/plugsky/route, model=auto) is coming soon |
TL;DR
- Every handoff resends context; compress messages between agents.
- Workers run cheap; planners, critics and arbiters run strong.
- Cap steps per agent and total calls per task.
- Budget the task end to end, not each call separately.
- Measure cost per completed task, including retries.
How it works, step by step
- Draw the agent graph and count the handoffs each task type requires.
- Assign tiers by role: retrieval and formatting cheap, planning and arbitration strong.
- Design compressed message formats so handoffs carry state, not transcripts.
- Cap steps per agent and total model calls per task; escalate on cap breach or fail cleanly.
- Share memory through a store instead of resending it in every message.
- Instrument per-agent usage and attribute it to task outcomes.
- Run a task suite and compare completion rate and cost per task before adding agents.
Try it yourself
Open the multi-agent workflow generator →
Fan-out multiplies every cost
A single agent sends one request per step. A multi-agent system sends one per step per agent, plus messages between them, plus retries when a worker misreads its task. Context compounds at every handoff because each agent wants the history, the instructions and the artifacts. The result is that cost grows with the square of the graph's connectivity rather than linearly with work done.
The remedy starts with topology discipline. Add an agent only when it has a distinct role that a prompt cannot serve, and count the handoffs each task type needs before building. Simpler graphs are cheaper, easier to debug and usually more reliable.
Roles deserve different tiers
Not every agent needs the strongest model. Roles divide cleanly:
- Retriever and extractor: cheap tiers with schemas and tight context.
- Formatter and summariser: cheap to mid tiers with capped output.
- Planner and decomposer: strong tier, small context, high leverage.
- Critic and arbiter: strong tier, used sparingly on disputed or high-risk work.
Fusion strategies set defaults per role key; custom rules pin compliance-sensitive roles. The planner is usually the best place to spend on capability and the easiest place to waste it through bloated context.
Handoffs, budgets and measurement
Design a compact message contract: objective, constraints, artifacts by reference, status. Do not forward transcripts. Store shared state in a memory store and pass identifiers instead, so agents pull what they need rather than receiving everything at every hop.
Budget each task end to end: a call ceiling across all agents, a step ceiling per agent, and a wall-clock timeout. When a budget is exhausted, fail into human review with the state preserved — an unbounded multi-agent loop is the most expensive failure mode available. Measure cost per completed task and completion rate; more agents should improve the second number without wrecking the first. Start on the free plan with plugsky-micro and plugsky-lite for workers, and use the 14-day full-access trial to calibrate stronger planners and critics; plans are on the live pricing page.
Honest comparison
| Multi-agent choice | Role-routed system on Plugsky | Frontier model for every agent | Single agent pipeline |
|---|---|---|---|
| Worker roles | Cheap tiers with schemas | Frontier price per step | One loop, fewer handoffs |
| Planner and arbiter | Strong tier, small context | Native strength | Often missing |
| Handoff context | Compressed state by reference | Full transcripts resent | Not applicable |
| Loop control | Per-agent and total budgets | Often unbounded | Single loop cap |
| Evidence | Cost per completed task | Token totals | Cost per task |
Frequently asked questions
Why are multi-agent systems so expensive?
Every handoff resends context and every agent runs its own loop, so cost grows faster than the work being done. Unbounded loops and verbose handoff messages are the usual culprits.
Do all agents need strong models?
No. Retrieval, extraction, formatting and summarisation run well on cheap tiers. Planning, decomposition, critique and arbitration deserve strong models and should receive compact context.
How do I reduce handoff cost?
Use a compact message contract with objectives, constraints and artifact references, and keep shared state in a store that agents read from instead of forwarding transcripts.
How do I stop runaway loops?
Set a call ceiling across the whole task, a step ceiling per agent and a timeout. On breach, stop and hand off to a human with state preserved rather than retrying.
Does adding agents improve quality?
Only when each agent has a distinct role. Measure completion rate and cost per task before and after each addition; more agents frequently lower reliability while raising cost.
Is there a classifier router for agents?
Classifier routing with model=auto is coming soon. Today, fusion strategies and per-key rules set tier policy per role.
How does flat pricing affect agent design?
Self-serve plans are flat monthly with no per-token charges, so retries and loops change latency and throughput rather than a variable bill. See the live pricing page for plans.
Can I prototype for free?
Yes. plugsky-micro and plugsky-lite are on the free plan with no card, and the 14-day full-access trial lets you calibrate strong planners and critics.