Vetta: the most efficient managed agent for long horizon tasks

Same model, same tasks, only the stack changed: Vetta finishes a task 2.7x cheaper than the next-best harness while completing more of them. We built every layer of the stack to make that number possible.

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.

The engine under Naïve

Naïve is a company you run; Vetta is what runs it. Every company template on this site is a repository with a naive.config.ts that declares a team of agents, and naive up provisions that team into your organization as Vetta agents. The media channel that posts every day, the agency that answers the inbox, the newsletter that ships on schedule: each is a set of Vetta sessions with a budget, a completion window, an isolated computer, and an identity of its own.

That is also why the primitives on this site map so cleanly to what follows. Runtime, Identity, Cloud, and Trust are Vetta's layers with Naïve's names on them. Everything in this post about cost is therefore a statement about what it costs to run a Naïve company, and if you want the engine without the company, it is available directly at vetta.sh.

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:

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.

What it means for a Naïve company

A Naïve company is a fleet of these agents that has to stay economically boring for months, not a single run that has to impress once. The three bills above are the reason the templates can run unattended: a channel that wakes on a schedule and sleeps between posts pays for storage while it waits, an agency inbox that nobody is watching can answer on priority instead of immediate, and every agent in the team carries its own budget, so a bad day for one cannot become a bad month for the company.

The same is true of the identity layer. When a template gives an agent a domain, an inbox, a vault, and a set of connections, those are the Vetta identity primitives described above, provisioned for you by naive up. You never lend a Naïve agent your own login, and nothing in your organization can read a credential it was given.

Start building

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

If you want the company rather than the engine, pick a template and run naive up; the agents it provisions are the ones on the leaderboard above. Everything else about Vetta, from the API reference to the studio, lives at vetta.sh.

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