Inspiration
Single coding-agent CLIs hold one sequential conversation. Real engineering work wants parallel workers, enforced budgets, an audit trail, and a guard that is faster than the thing it guards. Nebius Token Factory serves five NVIDIA Nemotron tiers behind one key — a complete software engineering org chart, if an orchestrator routes each role to the right tier.
What it does
uta is a single-binary agent orchestrator and shell (brew install unleashtheagents/tap/uta). With --worker nebius, the engine routes by role automatically:
- Nemotron 3 Ultra (
nvidia/Nemotron-3-Ultra-550b-a55b) plans, synthesizes, and judges (~10% of tokens). - Nemotron 3 Super (
nvidia/nemotron-3-super-120b-a12b) executes parallel coding subtasks (~90% of tokens) with nine native tools (read_file,write_file,edit_file,list_dir,search_files,glob,run_command,tavily_search,tavily_extract). - Nemotron 3 Nano (
nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B) compacts oversized worker outputs (--compact-over) and long conversation histories (/direct). - Nemotron 3.5 Lightning (
nvidia/Nemotron-3_5-Lightning) returns a ~200 ms PASS/FAIL verdict before any state-changing tool call (blocking piped-shell installs in 208 ms). - Nemotron 3.5 Super-VL (
nvidia/Nemotron-3.5-Super-VL) inspects UI screenshots and architecture diagrams (uta nebius see,/image).
A workflow file turns a goal into a verified DAG: uta run -f examples/workflows/wordlab.yaml -y has two Nemotron Super workers build two Go packages in parallel, each behind a go test gate that re-runs the worker on failure, then a third worker that needs: both wires up the CLI — delivering a 1.72x parallel speedup and 68.2% cost saving vs all-Ultra, while uta perf and uta nebius cost print the full audit trail. A permissions gate (.uta/permissions.yaml, allow/ask/deny with interactive [y] once / [s] session / [a] always prompts and pre/post hooks) decides what runs; every write is checkpointed so uta undo reverts a whole run; and any .mcp.json server becomes a native Nemotron tool (mcp__<server>__<tool>).
How we built it
Pure Go (CGO_ENABLED=0), stdlib + a few focused packages, with embedded SQLite recording every prompt, SSE token chunk, reasoning trace, tool call, file diff, and sentinel verdict. The Nebius provider is a native OpenAI-compatible client featuring SSE streaming with coalesced tool-call deltas, per-tier reasoning_effort (Ultra high, Super medium, Nano low, Lightning none), automatic retry with Retry-After backoff, prompt-cache accounting, and built-in Nemotron list prices so dollar budgets (--budget-usd, uta limits, and steer linear budgets) enforce accurately.
Challenges we ran into
- Reasoning token exhaustion on small tiers: Small tiers with default reasoning occasionally spent their entire token budget inside
<think>blocks and returned empty answers — solved with per-tierreasoning_effortpolicy plus automatic retry-with-reasoning-off. - Sub-250ms sentinel determinism: Making Nemotron 3.5 Lightning return consistent PASS/FAIL verdicts without false positives on normal
go test/ file edits required prompt tuning measured across a 21-case live matrix and blast-radius tiering (hard-blockingrun_command, warning + checkpointing onwrite_file/edit_file). - Making parallel workers camera-reliable: two of our first three DAG rehearsals failed — workers wrote debug scratch files inside packages (breaking the
go testgates), the sentinel then blocked their own cleanup, and the DAG stuck after retries. The cures became product: exact worked examples and file whitelists in subtask prompts, gateretry_producer, and (v0.17.2) rendering routine non-zero tool exits dim so iteration doesn't read as failure. Ultra's synthesis once reported a CLI flag that didn't exist; constraining the goal to "describe only verified behavior" fixed it. - Interleaved SSE tool-call deltas & real dollar caps: Reassembling streamed multi-tool JSON arguments by index and building a client-side per-call pricing ledger (
uta nebius cost,uta limits) since Token Factory does not yet expose a server-side spend-cap endpoint.
Accomplishments that we're proud of
Every claim is live, reproducible, and measured on Nebius Token Factory: 1.72x parallel DAG speedup, 54.7%–68.2% cost savings vs all-Ultra, 208 ms live block of a piped-download install by Nemotron Lightning, native Tavily search + extract grounding, a 70-second uta nebius demo any judge can run with one key, and a full cross-platform CI/release matrix (Linux/macOS/Windows, Homebrew tap, Docker image).
What we learned
Latency budgets decide agent architecture: a ~200 ms Lightning check is fast and cheap enough to run inline before every state-changing tool call. Engine-level role-tier routing beats manual model-per-prompt tags, and smaller MoE models perform best when reasoning is selectively disabled for classification and compaction turns.
What's next
Nebius Token Factory Sandboxes as a remote isolated run_command backend, policy-as-code sentinel rules, and mixed-fleet profiles that coordinate cloud Nemotron swarms alongside local claude and agy CLIs on the same DAG.
