Nimbus

Autonomous agents you can actually trust: see every step they take, what it costs, and approve the rest.

Comment

Quick Links: 9-Clip Visual Tour (/welcome) · Live App on Railway · 2:40 Video (YouTube) · GitHub Repo (MIT)

Inspiration

Every weekday starts the same way: inbox, calendar, GitHub notifications, half an hour of reading, and then writing the same kinds of replies as yesterday. Plenty of agents in 2026 can read an inbox or run on a schedule, so that chore alone is not the hard part anymore.

The hard part is what happens once you actually leave personal agents running every day. While building with the tools in this track, I kept hitting three walls:

  1. One big model for every step burns through your credits. If a scheduled agent routes every file read, retry loop, verification check, and memory update through a single frontier model, a week of background jobs costs more than the chore is worth.
  2. Chat windows hide the work, while hosted clouds lock you in. Tools like OpenClaw and Hermes Agent are great for talking to an agent from Telegram or Slack, and NemoClaw and OpenShell give an agent a sandbox. But when a run makes 20 tool calls across multiple roles, a single chat thread cannot show you which agent read which file, why a step retried, or what each hop cost. Hosted SaaS assistants go the other way and lock your data, memories, and learned rules inside a black box you do not own.
  3. Approvals rarely turn into rules you can read and revoke. Most assistants either act without asking or ask you for the exact same permission every single morning because yesterday's approval never updates the agent's skill file.

The core idea of the Nebius and NVIDIA Global AI Hackathon and the Nebius AI Builder Program is to build on open infrastructure you own end to end, reach for Nemotron 3 Ultra only where serious reasoning matters, and let Super and Nano handle the fast everyday calls so your credits stretch further. I built Nimbus to be the operations room for that kind of agent crew.

What it does

Nimbus is a self-hosted personal operations room that runs your standing jobs with a crew of NVIDIA Nemotron 3 agents on Nebius Token Factory, shows you every step and its live token cost on a timeline, waits for your yes before anything leaves the app, and rewrites its own SKILL.md file after every run.

1. Plan and price before anything runs

When you give Nimbus a standing job like "Every weekday at 8, read my inbox, calendar, and GitHub, tell me what needs me, and draft the replies," an Orchestrator on Nemotron 3 Ultra 550B plans the run first. It shows you who does what, which tools are allowed, and the estimated cost before anything executes. You can edit, reorder, or add steps to the draft plan, then click Approve plan.

2. Watch the crew on a live timeline

As the run executes, the crew works in parallel on a live timeline with one row per agent, a model badge on every hop, and the price ticking in cents in the header. Nemotron 3 Super 120B runs the Researcher, the Analyst, and the Writer; Nemotron 3 Nano 30B runs the Checker and the Learner. Every step is open: click any bar on the timeline to inspect the exact email, calendar invite, file, or command output that agent read.

3. Approvals that turn into revocable rules

Nothing with an outside side effect leaves without you. When the Writer wants to send a reply or open a pull request, the cloud mascot turns orange and the action lands in your tray as an approval card. You can approve it once, reject it with a note, or click Approve & always allow, which writes a plain-text allow: rule into that workstream's SKILL.md file (for example, allow: send_message to [email protected]) that you can read or revoke anytime.

4. Learning you can read and revert

After the run finishes, a Learner agent on Nemotron 3 Nano 30B extracts vector memories and rewrites the workstream's SKILL.md file with a side-by-side diff and a one-click Revert button. When the job runs again the next morning, it starts with what it learned, sends the pre-approved reply automatically under your rule without interrupting you, and costs less.

5. Same crew in your chat app (/v1/chat/completions)

Nimbus exposes an OpenAI-compatible /v1/chat/completions endpoint, so OpenClaw, Hermes Agent, or NemoClaw can point at it with ten lines of config. You can ask "what needs me?", start a run, and approve pending cards straight from your phone while every step records into the exact same web timeline.

Standing workstreams included

  • Morning Brief: Reads your inbox export, calendar, and GitHub notifications at 08:00 into a ranked one-page brief and holds three drafted replies in the approval tray.
  • Ship Nimbus (Self-Maintaining Repo Crew): Runs pnpm eval and pnpm typecheck on its own repository, reproduces a failing router test in a sandbox, asks you inline whether to fix the router or the test golden, drafts a unified diff patch, and waits for approval before opening a GitHub PR.
  • Token Factory Cost Audit & Watch: Audits Nimbus's own SQLite call log, runs A/B trajectory evaluations (pnpm eval:ab), and proposes router-rules.json changes that cut run spend by an additional 15.3%.
  • Hackathon Radar: Scheduled research using Tavily web search that compares updates against yesterday's memories and queues a three-bullet digest for approval.

Measured numbers on live Nebius Token Factory runs

All numbers below come from real NVIDIA Nemotron 3 runs on Nebius Token Factory (release notes):

Run Cost Tokens Calls (Model / Tool) Ceiling Baseline Router Saving Outcome
Morning Brief Run 1 (run_724b8d9d) $0.0216 58,950 23 / 21 $0.0283 24% 1 plan, 1 brief page, 3 replies approved; saved 1 allow: rule
Morning Brief Run 2 (run_915dfc1d) $0.0209 57,015 20 / 18 $0.0287 27% 3% cheaper than Run 1; reviewer reply sent under rule with no card; 16 memories held
Live Chat API Run (run_6b393ab6) $0.0282 76,827 24 / 21 N/A N/A Triggered and approved end to end via /v1/chat/completions; 8 memories saved
Unapproved sends $0.0000 0 0 / 0 N/A N/A Every outgoing action waited for human approval or matched an active rule

How I built it

I built Nimbus solo in three days starting Oct 27, 2026 using Next.js 15, React 19, TypeScript, Tailwind v4, React Bits Pro (Sorbet), dithercn for the Bayer-dithered shaders and charts, and SQLite (libsql with Drizzle ORM) for all local state, including SSE run events, versioned artifacts, vector embeddings, SKILL.md revisions, and an LLM response cache.

Model routing on Nebius Token Factory

The entire model layer is a single Vercel AI SDK provider (src/lib/tokenfactory.ts) pointed at Nebius Token Factory's OpenAI-compatible API (https://api.tokenfactory.nebius.com/v1). Role system prompts keep a stable prefix so Token Factory's cached-input pricing applies automatically, and all structured outputs are enforced through Zod tool schemas.

Tier Token Factory Model ID Assigned Roles Price ($ / 1M in / out) Why this size
Ultra nvidia/Nemotron-3-Ultra-550b-a55b Orchestrator $1.00 / $3.00 1 to 2 calls per run where planning, routing, and approval framing matter
Super nvidia/nemotron-3-super-120b-a12b Researcher, Analyst, Writer $0.30 / $0.90 256K context fits a full morning's inputs for search, code, and drafting
Nano nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B Checker, Learner, Router Classifier $0.06 / $0.24 1/16th of Ultra's input cost for high-frequency verification and memory extraction

Those role assignments act as ceilings rather than fixed tiers. Before each hop, the cost router (src/runtime/router.ts) checks deterministic rules and a cached Nano classifier to pick the cheapest tier that can handle the step. If a call hits a 429 rate limit, 5xx, or timeout, the router falls one tier down (Ultra to Super to Nano) and never up, protecting both reliability and the hard per-run and per-day spend caps (NIMBUS_RUN_CAP_USD and NIMBUS_DAY_CAP_USD).

Zero-key judge mode and evaluation suite

So judges can test the entire app in two minutes without API keys, pnpm dev runs out of the box against a deterministic scripted mock model whenever NEBIUS_API_KEY is unset, and switches to live Nebius Token Factory models as soon as a key is added. Every change is gated by 19 trajectory evaluation goldens (145 per-hop assertions) and 27 end-to-end checks (pnpm eval, pnpm check:cases, pnpm check:rules, pnpm check:learning, pnpm check:budget).

Challenges I ran into

Building against a scripted mock model let me ship the UI and state machine fast, but it hid how real models behave in a multi-agent loop. When I pointed Nimbus at live Nemotron 3 models on Nebius Token Factory across six recording attempts (spending about $0.49 across 198 real model calls), seven real issues surfaced that the mock never hit:

  1. Missing source paths in the brief: On the first live run, the Researcher immediately stopped and asked where my inbox lived because its prompt did not name the local file paths. I updated SKILL.md to declare exact sources (fixtures/inbox/*.eml, fixtures/calendar.ics, and fixtures/github-notifications.json) upfront.
  2. Burning all turns reading without reporting: The Researcher read one file per turn, used up all 8 of its turns, and exited without writing a report. I fixed that by raising child agent budgets to 12 turns and making the final turn a tool-free synthesis step so every agent is guaranteed to return a report.
  3. Dropped reports during handoffs: The Orchestrator literally wrote "Researcher's report: … (include the report)" instead of pasting the text, forcing the Writer to re-read every raw file from scratch. I changed the runtime bus so handoffs automatically attach prior crew reports.
  4. Drafting replies without calling the send tool: The Writer drafted all three email replies inside a markdown document without ever calling send_message, because its system prompt focused on writing documents rather than taking actions. I updated the Writer prompt to call send_message once per reply and explained that send_message itself raises the approval gate.
  5. Ungrounded status claims: In one live run, a drafted reply told a reviewer that a login fix "has shipped" when the GitHub notification only said the pull request was in review. I tightened both the Writer and Checker prompts to ground every status claim strictly in the latest source text.
  6. Thinking tokens starving tool calls on Nano 30B: The Learner agent on Nemotron 3 Nano 30B spent its entire 600 to 1,500 token output budget inside <think> blocks and got cut off before calling save_learning. Turning thinking mode off (chat_template_kwargs.enable_thinking = false) and requiring the tool call dropped the Learner's output from over 690 tokens down to 102 tokens, saving memories and rewriting SKILL.md cleanly on every run after.
  7. Mismatched tool parameter keys in Run 2: In Run 2, the Orchestrator sometimes raised send actions itself using { to, body } instead of the Writer's { channel, text }, which prevented the saved allow: rule from matching until I normalized tool arguments across roles.

Every one of these fixes is committed with a regression test and documented with run IDs in docs/video/RELEASE.md.

Accomplishments that I'm proud of

I am proud that the product, the live deployment, and the 2:40 video are backed by real, verifiable runs on Nebius Token Factory rather than slides or mocked screenshots. You can open /welcome and watch nine video loops cut directly from the recorded real-model take, where Run 1 costs $0.0216, the router saves 24%, the approval gate writes a real rule into SKILL.md, and Run 2 finishes cheaper at $0.0209 while sending the ruled reply automatically with no card.

I am also proud of the human control model: every external action waits as a card, every saved rule is a plain-text line you can revoke, every SKILL.md rewrite has a diff and a Revert button, and the entire repository still runs locally in two minutes with pnpm dev and zero API keys so anyone can inspect it.

What I learned

First, I learned that Nemotron 3 tool calling is reliable across all three model tiers on Nebius Token Factory. Ultra, Super, and Nano all handled structured Zod tool schemas cleanly through the OpenAI-compatible API. Whenever a multi-agent run failed in practice, the culprit was almost always dropped context between agent handoffs, unnormalized tool parameters, or missing file paths in the brief rather than model tool syntax.

Second, I learned that small reasoning models need explicit thinking budgets. Nemotron 3 Nano 30B is fast and cheap at $0.06 per 1M input tokens, but leaving reasoning enabled on single-shot structured extraction tasks will eat through max_tokens before the tool call is emitted. Turning thinking off (chat_template_kwargs.enable_thinking = false) for the Learner made its output six times smaller (102 tokens instead of 690+) and completely reliable.

Finally, I learned that live per-token pricing from the API is a product feature in its own right. Once the runtime knows the exact price of Ultra, Super, and Nano on every hop, cost stops being a surprise bill at the end of the month. The app can estimate the price before a run starts, display cent-by-cent spend on the timeline, stop automatically at a daily cap, and audit its own Token Factory bill.

What's next for Nimbus

Next, I plan to move the Analyst's run_code step from a restricted local subprocess into isolated Nebius Token Factory Sandboxes and NVIDIA OpenShell containers right next to the models (beta access requested). I also want to fine-tune Nemotron 3 Nano 30B on our trajectory evaluation dataset as a dedicated, ultra-cheap Checker, deploy the container image directly on a Nebius Serverless Endpoint alongside scheduled Nebius Serverless Jobs, and bring Nemotron 3.5 Super VL into the Researcher and Analyst lanes so workstreams can inspect screenshots, invoices, and PDFs on the same Token Factory endpoint.

Built With

  • dithercn
  • drizzle-orm
  • hermes-agent
  • libsql
  • nebius
  • nebius-token-factory
  • node.js
  • nvidia-nemotron
  • openclaw
  • playwright
  • react
  • remotion
  • shadcn-ui
  • sqlite
  • tailwindcss
  • tavily
  • typescript
  • vercel-ai-sdk
  • zod
Share this project:

Updates

Submission history