Key facts
| Router model | plugsky-fusion escalates per request across tiers (live) |
| Coder tiers | plugsky-coder and plugsky-coder-fast are live for agent building blocks |
| Agents | Memory, tools and orchestration are live |
| Loop controls | Cap steps and tool calls 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 |
| Usage controls | Scoped keys and usage analytics per agent |
| Deployment | Cloud, VPC, on-prem and air-gapped options |
TL;DR
- Route agent roles: reads and edits cheap, planning and recovery strong.
- Trim repo context per step; do not resend the whole tree.
- Cap iterations and tool calls, and fail into human review.
- Cache file reads and test output within a run.
- Judge agents on task completion and steps, not tokens alone.
How it works, step by step
- Define agent roles: planner, editor, test runner, reviewer, recovery.
- Assign a model tier per role and keep the mapping in versioned configuration.
- Give the planner a compact repo map instead of full file contents.
- Implement step and tool-call caps with a clean failure path into human review.
- Cache file reads and test results inside a run so repeated steps are free.
- Run a task evaluation set and record completion rate, steps per task and review edits.
- Move one role at a time to a cheaper tier only when completion holds.
Try it yourself
Open the AI agent cost calculator →
Where coding-agent spend goes
A coding agent is a loop, and loops inflate everything: each step carries the task, the repo state and the history; each tool call returns output that joins the context; each failure adds another attempt. The dominant costs are usually context accumulated across steps, strong models used for mechanical edits, and retries that repeat identical work.
That suggests three levers in order: shrink what each step carries, match the model to the step's difficulty, and make repeated steps unnecessary through caching and better planning. All three are within your orchestrator; none require a different API.
Roles, tiers and loop budgets
Give the agent explicit roles and pin a tier to each. Planning, ambiguity resolution and failure recovery deserve strong models; file reads, mechanical edits, formatting and test execution are cheap-tier work. The reviewer can be a mid-tier model with your test suite as evidence.
- Planner: strong tier, small context, produces a task list.
- Editor: fast coder tier, one file or hunk at a time.
- Runner: cheap tier for interpreting deterministic tool output.
- Recovery: strong tier only after a failed attempt, with the failure log attached.
Cap total steps and tool calls per task, and hand off to a human when the cap is reached. An agent that loops forever is the most expensive failure mode in software.
Context discipline and evidence
Send the smallest context that lets a step succeed: the task description, a repo map, the target file and its direct dependencies. Cache file reads and test results within a run, and never resend an unchanged diff. Log which tier handled each step, how many steps completed the task and where human review edited output.
Evaluate on real tasks: completion rate, steps per task, review edit rate and wall-clock time. Optimise those before bragging about token savings, because a cheaper agent that takes three times as many steps is a worse deal. Flat self-serve plans keep experimentation affordable — check the live pricing page for plans — and the free plan with plugsky-micro and plugsky-lite is enough to build the harness.
Honest comparison
| Agent choice | Role-routed coding agent | Strongest model every step | Single cheap model |
|---|---|---|---|
| Planning | Strong tier, compact context | Strong tier, bloated context | Weak plans, more retries |
| Mechanical edits | Fast coder tier | Strong tier for trivia | Usually adequate |
| Failure recovery | Escalated with logs | Native strength | Loops without progress |
| Loop control | Step and tool caps | Often uncapped | Often uncapped |
| Evidence | Completion and step metrics | Token totals only | Token totals only |
Frequently asked questions
Why are coding agents so expensive?
They are loops: every step resends context and every failure adds another attempt. Cost grows with steps, context size and model tier, so all three need explicit control.
Should every agent step use the strongest model?
No. Planning, ambiguity resolution and recovery benefit most. File reads, mechanical edits and formatting run reliably on fast coder tiers, and that is where most of the step count lives.
How do I trim repo context?
Send a repo map plus the target file and direct dependencies, not the whole tree. Cache reads within a run and drop stale diff content once it has been applied.
What stops an agent from looping forever?
Step and tool-call caps enforced in your orchestrator, with a clean handoff to human review when the cap is reached. Retries should also be budgeted per task, not per step.
How do I evaluate a cheaper agent?
Measure task completion, steps per task, human review edits and time to completion on a fixed task set. A cheaper tier that needs more steps is not cheaper.
Which Plugsky models fit coding agents?
plugsky-coder and plugsky-coder-fast cover coding work, with 30+ general models available for planning and review behind the same endpoint.
Can agents run in our network?
Yes. Plugsky deploys in our cloud, your VPC, on-prem or air-gapped, and scoped keys keep agent credentials isolated per workspace.
Can I build the first agent for free?
Yes. plugsky-micro and plugsky-lite are on the free plan with no card, and the 14-day full-access trial covers stronger tiers for evaluation.