RoboCo

An AI agentic company: 26 autonomous agents that plan, code, review, and ship real software as a governed team, now running on NVIDIA Nemotron 3 via Nebius Token Factory.

Comment

Inspiration

RoboCo started from a simple frustration: solo founders and solo developers don't have a team. Hiring one is expensive, and managing AI copilots one prompt at a time doesn't scale. So we built the thing we wished existed: an AI agentic company, a virtual organization of 26 autonomous agents plus one human CEO, structured like a real software company with a Board, Product Owner, Main PM, three delivery cells (developers, QA, documenters, PR reviewers), and formal governance: task hierarchies, acceptance criteria, PR-before-QA gates, review findings, and an org chart.

This hackathon was the push to make one big leap: take the entire company and run it on Nebius Token Factory, powered by NVIDIA's open Nemotron models, end to end.

What it does

RoboCo is a full autonomous software company you host yourself (Docker Compose, one command):

  • The CEO panel (Next.js): assign work, watch agents spawn live, approve board initiatives, read every journal entry, and control model routing for the whole fleet from one AI Routing card.
  • The agent gateway: 100+ MCP verbs (claim work, open PRs, fail reviews, request test databases) with collision guards, budgets, rate-limit parking, and evidence trails, so agents coordinate through state instead of chat chaos.
  • Real delivery: agents work in isolated git clones, commit with task IDs, open pull requests on GitHub/Gitea/GitLab, and every task passes QA review, PR review, and documentation gates before the CEO merges.
  • Nebius mode (built for this hackathon): flip one switch and all 26 agents spawn against Nebius Token Factory on NVIDIA Nemotron 3 Super. The default is structural, not a suggestion: apply_mode resolves every agent's model to nvidia/nemotron-3-super-120b-a12b even if the operator never opens the picker.
  • Token Factory Sandboxes: QA runs a task's test suite inside an ephemeral Token Factory Sandbox microVM (boot, execute, destroyed) instead of the agent container, with the result returning through the same evidence envelope every verb uses.

How we built it

  • Pluggable provider architecture (roboco/llm/providers/): each backend is a provider class plus a CLI config renderer. The Nebius integration clones the OpenRouter pattern end to end: Fernet-encrypted API key stored server-side, injected as NEBIUS_API_KEY/NEBIUS_BASE_URL at spawn; an opencode-CLI agent image whose config renders the Token Factory endpoint; a vendor-prefixed model ref (nebius/nvidia/...) so calls route through the Nebius provider block, never a built-in; and exit-code sniffing that parks rate-limited agents with backoff instead of killing them.
  • Nemotron by construction: the fleet default lives in settings (nebius_cli_model), so Nebius mode writes a GLOBAL routing assignment for Nemotron 3 Super that every agent inherits. Levels parity came next: the four live-verified Nemotron ids joined the static model catalog, so the Mix picker offers per-agent pins and the complexity-override validator accepts Nemotron tiers (Nano for LOW-complexity, Ultra available for heavy reasoning) exactly like Claude.
  • Token Factory Sandboxes: a QA/dev-scoped gateway verb archives the committed workspace HEAD server-side, uploads it to the Sandboxes API, spawns a disposable microVM that extracts the archive and runs the test command at the workspace root, then polls the operation until it reports exit code, stdout/stderr, and metered cost. Result lands in the agent's evidence envelope and the task journal.
  • Verification before vibes: every routing claim is pinned by tests against the real contract, and the integration defaults were verified against the live API with the hackathon key (which caught that our drafted model id didn't exist; the real catalog id is nemotron-3-super-120b-a12b).

Challenges

  • Ground truth vs. drafts: our drafted default model id looked plausible and passed every mock test, but the live catalog disagreed. Auditing against GET /v1/models caught it before it broke every spawn. Lesson recorded: settle every external contract against the live API.
  • Beta-access friction: Sandboxes spawn permissions aren't self-serve yet; we requested beta access and built the verb to degrade gracefully (a 403 becomes a retryable error envelope and agents keep their local shells) so nothing blocks while waiting.
  • Parallel provider workstreams: we merged a parallel Z.AI (GLM) provider branch mid-hackathon; two providers through the same routing seams meant a careful semantic merge, including renumbering our database migrations after the other branch took the same numbers.
  • Scale incidents as teachers: a production CPU-pinning incident during the window led to splitting the backend into api/dispatcher/indexer processes and shipping real observability (py-spy, pg_stat_statements), all released as v0.30.0 during the submission period.

What we learned

  • Ephemeral microVM sandboxes are the right primitive for agent verification: millisecond boot, full isolation, destroyed after the run.
  • Structural defaults beat documentation: routing Nemotron "by construction" meant nobody had to remember to select it.
  • An agentic company needs metering to be governable: per-agent token and cost attribution off Token Factory's metered usage turned spend into a first-class dashboard metric.

What's next

  • Sandboxes GA integration for every delivery role, Nebius Serverless Jobs for the fleet's background autonomy engines, and grounding the routing tier comparator with published per-model pricing.

Built With

Share this project:

Updates

Submission history