Vetta: the most efficient managed agent for long horizon tasks

Intelligence stopped being the bottleneck for autonomous work. Economics did not. A model that can finish a multi-hour task is useless in production if the run costs more than the work is worth, or if the machine hosting it bills for every hour the agent spends waiting.

Vetta is our answer: a managed agent built for long horizon tasks, where every layer of the stack is optimised for one number, the most intelligence per dollar spent.

Where the money goes

A long horizon task pays three bills from start to finish. It pays for every model call. It pays for the machine hosting the loop, including every hour the agent spends waiting on a schedule, a CI run, or a reply. And it pays a quieter third bill: the person who has to hand over credentials, approve access, and watch the run.

Most stacks only control one of those bills, because they only own one layer. We built all of them: the harness, the serverless runtime underneath it, the orchestration and self-improvement layers on top, and the surfaces you drive it from.

The model is a commodity: 20+ providers plug into the same routing layer, and every arm in the benchmarks below ran the same model. What decides the cost of a finished piece of work is everything wrapped around the model, and we own all of it. Vetta runs multiple harnesses out of the box today, and our own harness, tuned against this exact runtime, is next.

Each layer below exists to cut one of the three bills: the completion window prices the model call, the runtime and its sandboxes eliminate the idle machine, and identity removes the person from the loop. First, the proof that it adds up.

The proof

We publish results on the benchmarks page, computed from the same database our billing runs on. Two suites, two different axes.

Long Horizon Terminal Bench holds the model fixed (glm-5.2 in every arm) and swaps the harness across five contenders and three completion windows. This is the live efficiency leaderboard from that page, dollars per attempted task first:

All windowsimmediatepriorityloose

?Show all harness × window cells, or only one completion window.

Sorted by $ / task ↑

#	Harness	Window	$ / task↑	Resolve rate↓	$ / solve↓	Time / task↓	Output tok / task↓
1	Vetta	loose ◆	$0.1068	62.5%	$0.1709	45 min	16.2k
2	Hermes	loose	$0.1619	46.7%	$0.3469	56 min	10.7k
3	Vetta	priority ◆	$0.1895	81.3%	$0.2332	51 min	20.5k
4	Claude Code	loose	$0.2015	68.8%	$0.2931	58 min	21.8k
5	Vetta	immediate	$0.2232	75.0%	$0.2976	25 min	18.0k
6	Codex	loose	$0.2635	70.2%	$0.3753	54 min	48.2k
7	Hermes	priority	$0.3662	68.8%	$0.5327	56 min	15.4k
8	Claude Code	priority	$0.4293	75.0%	$0.5725	63 min	29.9k
9	Codex	priority	$0.5055	51.4%	$0.9835	57 min	44.7k
10	Claude Code	immediate	$0.5995	68.8%	$0.8720	26 min	21.7k
11	Pi	immediate	$0.6197	56.3%	$1.1016	30 min	23.0k
12	Hermes	immediate	$0.6844	62.5%	$1.0950	38 min	11.9k
13	Codex	immediate	$0.7647	57.7%	$1.3253	26 min	34.8k
14	Pi	priority	—	37.5%	—	33 min	18.6k
15	Pi	loose	—	37.5%	—	34 min	18.8k

◆ on the cost-efficiency frontier — no other configuration is both cheaper and higher-scoring. Dollars are what the vendor billed, not list price; cells without a verified invoice reading show no cost and are unranked on spend.

The result repeats off the terminal too: on SWE-Bench Pro, Vetta is cheapest per solved task on all three models it was run against.

One benchmark could be a lucky configuration. The same result on two suites, across two different axes, is a property of the stack. So where does the 2.7x come from? Take the three bills in order.

Bill one: the model call

Latency is a price you choose per request. The completion window is one field with three settings: immediate answers now, priority soon, loose eventually. Same model, same weights, different tariff. It defaults on the agent and overrides per session:

const session = await vetta.sessions.create({
  agent_id: agent.id,
  message: "Reconcile yesterday's refunds against the ledger",
  window: "priority", // immediate | priority | loose
});

Isolating the window in the benchmark data shows what it is worth. Dollars per completed task, Vetta against the cheapest competing harness in the same window:

An agent a person is watching should be on immediate. An agent that starts at midnight and delivers at nine has no reason to be, and pays materially less for the same model.

That settles what a model call costs. But a long horizon agent spends most of its wall-clock time not calling the model at all, which is the second bill.

Bill two: the idle machine

The Vetta Runtime is where most of the cost behaviour on long horizon work comes from, and it is serverless from the ground up: the agent loop runs on durable objects, not on a machine you rent by the hour.

The loop is an alarm, not a call stack. Each cycle: wake on a trigger, take one bounded turn, commit the transcript and cursor to durable storage, sleep. Between turns there is no process to pay for. A session waiting on a nightly schedule or a human reply costs only what its stored state occupies, and a crash loses at most one turn, never the run.

That shape is what changes the hosting bill at fleet scale. From Naïve Lab, the modelled cost of hosting one million agents for a month, over published rate cards:

Every call is priced before it is made. Budgets are structural, not a report you read the next morning. An agent cannot be created without one; a call that would breach the cap is refused before it runs.

const agent = await vetta.agents.create({
  name: "nightly-triage",
  model: "glm-5.2",
  budget: { cap_micro_usd: 50_000_000, max_task_micro_usd: 5_000_000, period: "month" },
});

Cost-efficient sandboxes. Each session gets an isolated computer: a paused micro-VM meters its stored disk and no vCPU at all, so an agent that works for twenty minutes across an eight hour window pays for twenty minutes of compute.

const computer = await vetta.computers.create({ vcpu: 2, memory_mb: 2048, browser: true });
await vetta.computers.exec(computer.id, "pnpm test");
 
await vetta.computers.pause(computer.id); // no vCPU metered until resume

V8-isolate sandboxes (coming soon). The next runtime tier drops the machine entirely: an in-isolate shell plus a WASM registry runs roughly 95% of typical ops commands inside a V8 isolate, no real computer needed. On our isolated-vm backend a sandbox goes from create to first execution in about 2.79 ms and holds resident state in about 1.2 MB of RAM per agent, which is what makes fleets of mostly-idle agents economically boring. This is ongoing research at Naïve Lab.

With the model call priced and the idle machine gone, one cost is left, and it is the one nobody meters: the human who has to stay in the loop.

Bill three: the person in the loop

An agent that needs a person to lend it their logins, share a bot token, or approve every credential is not unattended, it is supervised. Vetta removes that dependency by giving the agent someone to be. An identity is a named persona with real endpoints: verified domains, inboxes, phone numbers, and two pieces built for unattended operation.

Passport. Third-party apps the identity has authorized over OAuth. The agent connects to real services as its persona, not as a shared bot token.

Vault. A write-only credential store. Values are injected at the network boundary; the agent uses secrets it can never read, and no route ever returns a credential value.

One persona, real endpoints, sealed credentials

Identity

A persona with its own domain, inbox, and phone number.

Passport

Apps authorized over OAuth.

GitHubGmailSlackNotionLinearStripe

Vault

Secrets the agent uses but can never read.

const ava = await vetta.identities.create({
  name: "Ava Sales",
  description: "Outbound SDR persona for the growth team",
});
await vetta.identities.attach(agent.id, ava.id);
 
// Passport: the persona authorizes a real service over hosted OAuth
await vetta.connections.connect({ auth_config_id: crmAuth.id, identity: ava.id });
 
const vault = await vetta.vaults.create({ display_name: "ava-vault", identity_id: ava.id });
await vetta.vaults.credentials.create(vault.id, {
  kind: "env_var",
  key: "STRIPE_KEY",
  value: stripeKey, // travels once, sealed server-side; no route ever returns it
});

Every identity action is gated by policy, so what a persona may do is declared, not hoped. Access is set up once, then the agent runs for months without anyone lending it a login.

That is the whole argument. Model calls priced per request, idle time metered at storage, and no standing human cost: three bills, each cut structurally. The 2.7x on the leaderboard is what they add up to.

Start building

Vetta is in early access. Create an agent with a budget, pick a window, give it work.

The models will keep getting better. The bill for running them is ours to fix.