slash-agent: Hire the agent

Hire a coding agent with a budget. It quotes the job, books the right NVIDIA Nemotron model for each step, does the work, and hands you a receipt checked against Token Factory's usage.

Comment

Inspiration

Coding agents burn frontier-model tokens on steps a smaller model can do, and nobody sees the bill until it arrives. You wouldn't hire a contractor without a quote. We built the agent you can hire like one.

What it does

You give it a job and a budget. It works like this:

Step What happens Model
QUOTE prices the job before any call none
PLAN reads the project, writes a short plan Nemotron 3 Ultra, reasoning on
WRITE writes the change and a test that proves it the smallest Nemotron the job allows, reasoning off
TEST runs the project's own tests on a copy none
ITERATE sends failures back and writes again, up to 3 rounds, inside the budget as WRITE
RECEIPT what Token Factory billed, what the models asked for would have cost (estimated from the same tokens), what you saved none

TEST runs in the demo's container, not in Token Factory Sandboxes (beta access requested). PLAN and WRITE run on Token Factory.

Upgrade jobs look things up first. An upgrade needs today's release notes, not a model's memory. The Upgrade job (Zod 3 → Zod 4) runs one Tavily search and one extract of the official migration guide before it plans. PLAN and WRITE read the notes as data, and the plan cites them.

Try it live: pick one of four jobs on a small shop, set a budget of 1 to 5 cents, click Hire, and watch each step. Every run is a real job on Token Factory.

A live run (2026-10-21), the one in our video: Upgrade, 3¢ budget. SEARCH found the Zod migration guide. PLAN on Ultra: $0.010007 (2,682 tokens out, 2,455 of them reasoning). WRITE on Super: $0.002523. Tests passed in round 1. Billed $0.012530 against an estimated $0.018418 on the models asked for (the same tokens at their prices): $0.005888 saved. 1 Tavily credit. Nothing billed above its quote. That is one run, not a forecast: at 1,000 runs of the same shape the saving would be about $5.89 (arithmetic, not a measurement).

Who it's for

Anyone who runs coding agents on their own code: a solo developer with a handful of agents, or a whole team.

Agents spend frontier-model tokens on steps a smaller model can do. The bill arrives after the work.

Here, the agent quotes first and books the model per step:

  • PLAN needs reasoning, so it gets Nemotron 3 Ultra.
  • WRITE doesn't, so it gets the cheapest model at or above the floor. In our run that was Super: $0.002523, against an estimated $0.008411 on Ultra for the same step (30%).
  • The receipt shows what Token Factory billed, what the models asked for would have cost, and the difference.

The point is a number you can check against the invoice. At demo scale it is cents.

Design

One page, one job at a time. Pick a job, set a budget of 1 to 5 cents, click Hire. Each step appears as a card as it runs: HIRED, then SEARCH and EXTRACT on an upgrade, PLAN, WRITE, TEST. A retry shows as ↻ round 2.

The receipt is the last card. Billed, asked-for cost, saved. If a call was billed above its quote, the receipt says so.

It shows what the agent did, including the retry. When PLAN runs out of room, the card says ↻ reasoning off.

Jobs are presets. Four preset jobs on sample projects, and there is no free-text input.

How we built it

  • Nebius Token Factory with four NVIDIA Nemotron models (3 Ultra, 3 Super, 3 Nano, 3.5 Lightning) through the OpenAI-compatible API, a plain fetch client. The catalog has four; the demo's floors put PLAN on Ultra and WRITE on Super, so Nano and Lightning are available but not booked by these jobs.
  • Quality floor: each step has a floor, a tier from 1 to 3 (Ultra is 3, Super 2, Nano and Lightning 1). The engine books the cheapest model at or above it. PLAN's floor is 3 and WRITE's is 2.
  • slash-tokens, our open-source engine, quotes each step with NVIDIA's own tokenizer, books the cheapest model at or above the step's quality floor, caps output at the quote, and reconciles every call with the usage Token Factory returns.
  • Reasoning on or off per step (chat_template_kwargs.enable_thinking): on to plan, off to write, because reasoning is billed as output.
  • Tavily search and extract for the Upgrade job, with Tavily's own credit count on the receipt.
  • Safety: preset jobs only (no free text), the agent works on a copy, writes stay inside the project, installs run without scripts and can't add packages, one job at a time (others wait in a short queue), a $0.50 daily cap and 50 Upgrade runs a day.
  • Google Cloud Run hosts the demo, deployed from GitHub with no stored key (Workload Identity Federation). Both API keys live in Secret Manager, readable only by the app.

Challenges we ran into

  • Hidden request framing. Our first quotes counted message content only and came in under the bill. We measured the framing on real bills (16 tokens a request plus about 7 per extra message) and built it into every quote.
  • Scope creep. An "add free shipping" job also fixed an unrelated coupon bug, because the project's rules said coupons should never discount shipping. We taught the planner to plan only what the job asks and note anything else.
  • Release notes without code. The first Upgrade runs failed because the extracted notes lost a key line. Extracting the start of the guide, where breaking changes are listed by impact, fixed it.
  • A search that came back empty. Tavily sometimes answers a good query with nothing, and still charges the credit. A visitor's first Upgrade run hit it on Oct 21 and stopped before any model call. The agent now asks once more.
  • Planning that ran out of room. Our first live Upgrade run on Oct 16 did not finish. PLAN spent its whole 4,000-token output cap on reasoning (4000 out, 4000 reasoning), so there was no plan to write from. Token Factory confirmed it: finish_reason: length. After 3 rounds the run billed $0.024614 and stopped, with nothing billed above its quote. The fix (PR #11): if a reasoning plan reaches its cap, plan once more with reasoning off. The next run passed in round 1.

Accomplishments that we're proud of

  • The receipt reconciles to Token Factory's usage. No call was billed above its quote in our test runs.
  • Smaller models do real work. Nemotron 3 Super wrote the change and a test that passed the project's tests in round 1, at about 30% of Ultra's estimated cost for that step.
  • Five Upgrade runs on Oct 26 saved 15% to 38% a run, 24% overall, billed by Token Factory against the same tokens priced on Nemotron 3 Ultra (estimated). All five passed in round 1.
  • A live run found a real bug, and we fixed it in the open. The failed run is in the repo history (PR #11), not hidden.
  • Two Tavily calls on every Upgrade run, shown on the receipt.
  • A public demo anyone can run, for a few cents a job, capped at $0.50 a day.

What we learned

  • The cheapest model that passes the tests is the right model. You only know which one that is if you quote before the call and reconcile after it.
  • Reasoning is billed as output. Turn it on to plan and off to write.
  • Run it for real. The planning cap showed up in a live run.
  • Quote the framing. Our first quotes counted message content only and came in under the bill. We measured the framing on real bills (16 tokens a request plus about 7 per extra message).

Honest limits

  • Preset jobs on sample projects. Four jobs: three on a small shop, one Zod 3 → 4 upgrade. No free text.
  • TEST runs on an isolated copy inside the demo's container, not in Token Factory Sandboxes. Beta access is requested.
  • One job at a time, with a short queue (3 waiting, up to 2 minutes), capped at $0.50 a day and 50 Upgrade runs a day.
  • Upgrade is not always a pass. On Oct 14 it passed 4 of 5 runs. On Oct 16 the first run failed until the planning fix. On Oct 21 a visitor's run ended early because Tavily returned an empty search, so the agent now asks once more. On Oct 26, 5 of 5 Upgrade runs passed in round 1 (3¢ budget each). The WRITE step sometimes needs a retry, or fails; the page shows it either way.
  • Tavily: the receipt shows 1 credit a run, from the search. The extract response reports 0. Tavily's team confirmed that is expected for /extract, and account usage shows on their /usage endpoint, after a short delay. The receipt counts what the responses report.

How it meets the hackathon requirements

  • Runtime calls to Token Factory with NVIDIA open models: every job calls Nemotron 3 Ultra (PLAN) and the smallest Nemotron at or above the floor (WRITE), live on the demo.
  • Where Token Factory accelerated our workflow: one OpenAI-compatible API for four Nemotron models: choosing a different model for a step is a change of the model ID, not a new integration, which is what lets each step book the cheapest model its quality floor allows. The usage on every reply lets us check each call against its quote and show what Token Factory billed, with no separate billing export. A whole job fits a budget of 1 to 5 cents, so we could build and test it with live runs instead of mock data.
  • Tavily: two runtime calls on every Upgrade run (search, then extract), shown on the receipt.
  • Significantly updated. slash-agent is new: its first commit is Oct 10, inside the submission period. Before the period (it opened Aug 26) the engine was slash-tokens 1.6.5 (Aug 25), a library with no agent loop and no Nemotron support. Since, six releases (1.6.6 to 1.8.1):
    • slash-tokens 1.6.6 → 1.8.1 (Oct 7–11): quote(), decide(), reconcile(), hire().run(), the four Nemotron models, request framing measured on real bills.
    • slash-agent (from Oct 10): the Token Factory client and the full loop; the live demo on Cloud Run (Oct 14).
    • The Upgrade job with Tavily (PR #9).
    • Files sent back unchanged are no longer counted as changes (PR #10).
    • Planning again with reasoning off when PLAN runs out of room (PR #11, Oct 16), found by a live run.
    • From the Oct 20 live review (PRs #14 to #18, Oct 20–21): the first screen explains itself and a ? button opens the basics; a live progress line and bar; a baseline on the receipt and a ROUTING view; a short queue; a Stop button.
    • Upgrade job fixes (PRs #19 and #21, Oct 20–21): ask Tavily for the relevant parts of the changelog, and ask the search once more when it answers with nothing.
  • Feedback: the README section "Feedback on Nebius Token Factory and NVIDIA Nemotron".

What's next

  • Token Factory Sandboxes for every TEST (beta access requested): isolated microVMs, with checkpoint and branch to try fixes in parallel.
  • Jobs on your own repositories, opened from issues.
  • Budgets and model policies per project or team; receipts exported to BigQuery.
  • Feedback shapes it: five changes here came from the judges' live review, recorded in the repo. This is a foundation, so tell us what to build next.

Built With

  • bun
  • github-actions
  • google-cloud-run
  • nebius-token-factory
  • nvidia-nemotron
  • secret-manager
  • slash-tokens
  • tavily
  • typescript
  • workload-identity-federation
  • zod
Share this project:

Updates

Submission history