Cost model

Two bills get mixed up all the time. Keep them separate:

For typical Harbor / Agent jobs the model invoice dwarfs platform compute. Desktop VMs and external Mac sessions bill differently (EC2 / Mac cloud) — see Desktop operations.

For how requests move through the system, see Architecture.

Compute planning numbers below are us-central1 list prices (July 2026), not an invoice. Discounts and Spot change them — see Levers.

---

Model spend (cost_usd)

What cost_usd is

Harbor records model (LLM provider) spend in USD on each finished run:

result.harbor.stats.cost_usd

alongside n_input_tokens, n_output_tokens, and n_cache_tokens. That number comes from Harbor’s usage stats for the agent/model — not from Autopilot CPU/RAM pricing.

Prometheus mirrors the same model spend as sandbox_worker_job_cost_usd_total (labelled by model) and sandbox_worker_job_cost_usd_by_provider_total.

Per job vs per trial

Prefer per-trial cost for credits when present. If a platform-fault trial has no per-trial cost yet, the platform falls back to apportioning job-level cost_usd by trial count.

---

Billing attribution and credits

n_errored_trials only counts failures. Credits need whose fault each failure was. Classification is owned by sandbox_core.jobs.platform_trial and copied to API, SSE, BigQuery, Langfuse, and Prometheus.

A provider 429 wrapped in a Temporal ActivityError stays provider, not platform — otherwise a vendor outage becomes our refund.

Unbillable model spend (Prometheus sandbox_platform_unbillable_cost_usd_total, BigQuery views unbillable_platform_spend / daily_platform_fault_cost):

1. Sum cost_usd on trials with platform_failure=true when every such trial has a cost, plus
2. Any prior_platform_attempt_cost_usd (recovered slots that still burned tokens on a discarded platform attempt),
3. Else fall back to job_cost_usd × n_platform_errored_trials / n_trials.

Operator detail (sinks, migrations, GMP scrape): repo runbook temporal-passn.md — Billing attribution.

---

Platform compute

Managed hosts (Daytona, E2B, …) usually have little or no fixed bill and a higher per-hour rate. We are the opposite: cheaper per hour, higher base. That is why low volume favours them and high volume favours us — see Where the models cross over.

Variable: one sandbox-hour

Autopilot bills what the pod requests, not how busy the CPU is. Default trial shape: 1 vCPU, 2 GiB RAM, 10 GiB ephemeral disk.

Billed per second. A measured Harbor trial on dev (~36s with warm image cache) is about $0.00056 of compute — roughly 1,800 trials per $1 of platform compute (before model spend).

Same shape at other providers

We win on the hourly rate. We lose on the monthly base until volume is high — next section.

Notes:

• E2B production rates usually need their ~$150/mo Pro plan (fixed cost).
• Daytona gives the first 5 GiB storage free.
• Vercel Sandbox bills active CPU, not wall time — not in this table.

Vs Daytona we are about 33% cheaper per sandbox-hour, mostly because their memory rate is much higher.

Fixed: what you pay when the queue is quiet

Approximate idle control plane on dev (pod requests × list rates + cluster fee). Burst workers and claimable pool are called out separately.

BuildKit is a large idle slice. It exists so Dockerfiles become cached images instead of rebuilding every trial.

Two different “warm” costs (easy to confuse)

Agent/Harbor trial pods are not on Spot. Spot reclaim mid-agent wastes model money and can break an eval. Spot is for idle disposable CodeEdit pool pods only.

Harbor workers are pay-for-use: floor 2 when idle on dev (so one long job does not block prompt-turn traffic on the shared queue), up to 8 when the queue is busy. See Architecture.

Where the models cross over

You earn back our fixed base from the cheaper hourly rate:

Plain English: at low volume, managed hosts are cheaper on compute alone. We win on scale, plus tenancy, VPC, and running trials in your boundary — not on the fixed bill being small.

Speed: cold create vs claim

Creating a new gVisor pod on the request path is still ~5–6s (median measured on cold CodeEdit). That sits inside Daytona’s published cold path (5–120s). Their <90ms number is a warm-pool claim, not a fresh create.

Node warm placeholders only help scheduling; they do not turn 6s into 200ms. The claimable pool does that for CodeEdit — and it is on for dev/preprod. Long-lived sessions (RFC 0001) amortise create across many execs into one sandbox.

For Agent/Harbor, accept is already fast (202); most wall time is the model and verifier, not pod start.

For the full boundary—provider prompt cache, reusable sessions, and why pass@k answers stay fresh—see Caching and reuse.

Levers (biggest first)

1. Right-size task.toml / labels.memory_mb — you pay for the request, not CPU %. Undersizing wastes model money on OOM retries.
2. Committed-use discounts — large cut on vCPU (and the fixed base).
3. Keep task images cached — miss rebuilds cost BuildKit time and latency.
4. Node warm placeholders — turn down if you do not care about first-request after idle (~$10/replica/mo).
5. Claimable CodeEdit pool — Spot depth is latency bought with idle money; shrink depth or disable if CodeEdit is unused.
6. Spot on trials? — No for Agent/Harbor. Yes for idle CodeEdit pool pods (already the default on dev).

Not on this page

• Network egress to model APIs
• GPUs (not offered)
• gVisor tax (already inside the pod request you are billed for)