Send the repo once.Get one patch back.
The other tiers answer one call at a time, and every file the model wants is a round trip to your machine. Smart+ uploads the repository once and runs the whole job on RouterLane's machine, where a file read takes microseconds and the tests run locally.
> add the missing validation and a test that covers it Smart+ is on, so this runs on RouterLane's machine. ● shell pack and upload the repository 45 files, 180 KB setup dependencies installed, tests found explore 18 calls plan written build 47 calls 2 files changed, +29 -1 test passed qa 14 calls diff reviewed deliver one patch ● shell download the patch and apply it applied cleanly, nothing staged Changed 2 files (+29 -1). Tests on the router: passed. Nothing is committed: read the diff and commit it. 2.3 min · 715K tokens · $0.75
Counts from the measured run on RouterLane's own 45-file repository, 2026-10-03.
Two commands on your machine. Everything else on ours.
Your agent runs exactly two shell commands: pack and upload, then download and apply. Between them is one assistant turn that streams its phases into your agent's own transcript.
your machine RouterLane's machine | | 1. pack and upload -----------> a copy of the repo under a fresh git baseline | one HTTPS request setup the project's own dependencies are installed | tracked + new files only explore a read-only agent reads the code and writes the plan | build a stronger model does the task with local tools | test the project's own test command runs on the copy | qa a fresh agent that never saw the build reviews the diff | failing tests or blocking issues go back to build | 2. one patch <----------------- deliver git diff against the baseline | git apply, nothing committed
Six steps.Three agents.
Each agent is a separate chain of model calls with its own instructions. The QA agent has not seen how the work was done: it gets the task and the diff, and is told to find what is wrong.
A cheap model reads and reviews while the strong one writes. Explore and QA run on DeepSeek 4.1 Flash at high effort; build runs on GLM 5.3 at high effort.
Pack and upload
git ls-files --cached --others --exclude-standardinto a tarball: everything git tracks plus anything new that is not ignored. It goes straight to RouterLane over HTTPS with a token good for that one job, so it never passes through the model and costs no tokens.Setup
The copy is put under a fresh git baseline and the project's own dependencies are installed, before any agent reads a line.
Explore
A read-only agent reads the code and writes the plan: the steps, the files that will change, the command that proves it works.
Build
The stronger model does the whole task with local tools: read, grep, write, edit and a shell. Dozens of tool calls inside one of your turns.
Test and QA, at the same time
The project's test command runs on the copy while a fresh agent reviews the diff. Failing tests or blocking issues go back to build for a repair round.
Deliver
One patch, applied with
git apply, with a three-way merge only if a plain apply would fail. Nothing is committed. If it does not apply, it is saved assmartplus-<job>.patch.
Two jobs, end to end.Measured on 2026-10-03.
Both run from a client that executed the tool calls for real.
| Repository | Upload | Explore | Build | QA | Result | Time | Tokens | Cost |
|---|---|---|---|---|---|---|---|---|
| A Python package, 5 files | 435 B | 4 calls | 5 calls | 3 calls | 2 files changed, +26 -1. Tests passed, QA pass, patch applied cleanly. | 24 s | 25K | $0.035 |
| RouterLane's own service, 45 files | 180 KB | 18 calls | 47 calls | 14 calls | 2 files changed, +29 -1. Tests passed, patch applied cleanly. | 2.3 min | 715K | $0.75 |
A long agent loop resends its conversation on every step, so a job's cost tracks the number of steps. The spend ceiling bounds it.
Limits
| Upload | 120 MB packed. Over it, the turn runs as plain Smart. |
|---|---|
| Spend per job | $1.50 by default. A job that reaches it stops, delivers what it has, and says so. |
| Commands | Each has a timeout and an output cap. |
| Repair | Failing tests or blocking QA issues go back to build for another round. |
| Workspace | Deleted after 48 hours. |
Falls back to Smart
A Smart+ turn becomes an ordinary Smart turn, with the reason recorded, when:
- the client declares no shell tool
- the repository packs to more than 120 MB
- the upload did not arrive
- too many jobs are already running
- Smart+ is switched off for the deployment
Your agent sees a normal answer.
Model-written commands.A fenced machine.
The agents run shell commands a model wrote. They run behind a boundary built for that.
A separate account
Jobs run as a unix account that owns nothing. It cannot read the service's code, its database or its credentials.
Bounded commands
Every command has a timeout and takes its process group down with it. Output is capped. Commands that reach outside the workspace are refused.
Fenced files
File tools refuse any path that resolves outside the repository copy. Installs are per job and thrown away with it.
Only what git would ship
Tracked files plus new files that are not ignored. No history, no ignored files, no node_modules.
One token, one job
The upload and the patch use a token good for that job only. The repository never passes through a model and costs no tokens.
Gone in 48 hours
Workspaces are deleted after 48 hours. The job record stays, so the work shows up in your usage.
Billed like Smart.Never billed twice.
Every token the job's agents spend is metered at Smart rates to the client that asked for it, on the request for the turn that started the job. The job tracks what has already been metered and only reports the difference.
Smart+ is on Enterprise plans, opt in per plan.
| Smart+ rates | per 1M tokens |
|---|---|
| Input | $1.00 |
| Output | $4.00 |
| Cached input | $0.20 |
| Default ceiling per job | $1.50 |
Your own lanes.Your own console.
Keys are issued on request. Tell us what you are building and which clients you use, and we will send a key by email.