From one goal to a working team.
Type a goal. The system researches, decomposes, builds, and delivers — autonomously.
One prompt. No config, no YAML, no agent definitions.
Root agent auto-researches the codebase and invents the right team.
Each agent runs a tight RLM loop — search, read, think, execute, verify — repeating until solved.
Agents coordinate via A2A protocol — no shared memory or context window.
Single agents break on real codebases.
Teams have tried everything: single coding agents, prompt-stuffed RAG pipelines, hand-wired MCP tools, elaborate harnesses. They all hit the same wall. Real codebases are too large for one context window, too complex for one agent, and too dynamic for static tool configs. Nobody stopped to ask: what if the agents invented their own team?
- ✗Entire codebase stuffed into context
- ✗Context rot beyond ~50K tokens
- ✗Sequential: one task at a time
- ✗One failure halts everything
- ✗Static tool lists, no emergent roles
- ✓Context lives in sandboxes, not prompts
- ✓Agents explore via grep, find, cat
- ✓Specialists run in parallel
- ✓Agents catch and fix each other's errors
- ✓Roles invented per goal, never hardcoded
- ✗Try different coding agent harnesses
- ✗Hand-wire MCP tools and hope they compose
- ✗Build RAG pipelines to stuff context
- ✗Tune prompts and pray context holds
- ✗Never break the problem down RLM-style
Built for developers who move fast.
Not another AI coding assistant.
Agentnetes is not autocomplete. It is not a chatbot. It is a swarm that investigates, builds, tests, and delivers.
One goal. A recursive agent swarm.
The root agent decomposes your goal, invents the right team of specialists, and orchestrates them across isolated sandboxes. Roles are fully emergent. Nothing is hardcoded.
Five ideas. One system.
Agentnetes combines five research-backed patterns that individually improve agent performance and together create something qualitatively different.
RLM Pattern: Context lives in sandboxes
Recursive Language Model runtime. Instead of stuffing files into an agent's context window, context is externalized into a filesystem that agents explore programmatically.
Agents write small shell scripts to grep, find, and read exactly what they need. This keeps token footprints tiny regardless of codebase size and has been shown to outperform naive context-stuffing by 2x on software engineering benchmarks.
AutoResearch Loop: Try, measure, keep
Agents do not write code and hope for the best. They write code, run tests, measure the result, and either keep the change or discard it and try again.
The Test Engineer runs vitest after every change. Type errors trigger re-implementation. Test failures trigger targeted patches. The loop runs until everything passes or the agent escalates to root.
Two-Tool MCP: search() and execute()
Each agent has exactly two tools exposed via MCP: search() for finding things in the codebase, and execute() for running shell commands in its sandbox.
This keeps the agent's tool surface to roughly 1,000 tokens regardless of task complexity. The agent writes arbitrary code against these two primitives. No tool proliferation. Just two powerful primitives that compose into anything.
A2A-Ready: Every agent is a publishable service
Every agent Agentnetes spawns generates a standard A2A Agent Card describing its capabilities, skills, and endpoints.
Today these cards are internal. Tomorrow any specialist agent can be published as an independent, discoverable service. A Provider Engineer becomes a reusable service any other system can call.
Load Balancing: Work distributed across the swarm
All specialist agents run concurrently via Promise.allSettled. Work is load-balanced across the agent pool automatically. One agent failing never blocks the others.
maxWorkers caps concurrency like Kubernetes resource limits on a node. Promise.allSettled provides fault-tolerant dispatch: a failing Engineer never kills the Scout or Tester. The swarm delivers what it can regardless of individual failures.
Built on the bleeding edge
Every layer is the latest available. No legacy versions. No compatibility shims.
One sentence. Dynamic team. Real results.
From goal to dynamic team formation to delivered artifacts in isolated sandboxes.
You give a goal
Type what you want built. Not instructions on how. Just what. Agentnetes figures out the rest. The goal can reference a GitHub repo or an uploaded codebase.
Root agent explores
The Tech Lead spawns a Firecracker sandbox pre-warmed with the target repo. It uses grep, find, and cat to map the architecture. Context lives in the filesystem, not the prompt.
Team self-assembles
Based on what it finds, the root agent invents the team. Roles, goals, and dependencies are all emergent. A provider task gets different specialists than a security audit.
Agents work in parallel
Each specialist runs concurrently in its own Firecracker microVM. They explore, write code, run tests, and fix failures. No sequential bottlenecks.
Agents collaborate
Test failures and findings route back to the right specialist automatically. The vRLM runtime handles inter-agent communication. No human needed to relay.
Synthesis and delivery
The root agent collects all artifacts, verifies completeness, and streams a structured summary to the UI with every generated file. Each agent publishes an A2A card.
vRLM: The Orchestration Runtime
Virtual Recursive Language Model Runtime. The engine between your goal and the agents. Inspired by the RLM pattern from MIT CSAIL.
Root agent explores the repo with grep and find, then calls the Gemini planner to invent a specialist team. Roles are fully emergent. Nothing is hardcoded.
Workers run in parallel. Each gets an isolated Docker container with the repo pre-cloned, and two tools: search() to grep the codebase and execute() to run any shell command.
When all workers complete, the root agent reads their findings and artifacts, then produces a structured summary. Every generated file is collected and streamed to the UI.
Every phase emits typed events over Server-Sent Events. The UI subscribes and renders agent activity in real time with no polling.
Three ways to run
From instant browser demo to full local execution with Docker sandboxes
Watch the full agent lifecycle in your browser. No API key, no Docker, no install. Pre-scripted scenarios replay real event sequences.
Clone the repo and run locally. Both simulation and real agent execution available. Configure your Google API key and target repo directly in the UI. No .env file needed.
Install the npm package globally and run against any local git repo. Requires Docker running locally and a Google API key.
Any model. Same swarm.
Bring your own Google API key and swap models from the UI. No config file needed. Separate planner and worker models let you balance quality vs cost.
apiKey: process.env.GOOGLE_API_KEY
});
See it in action
One goal in, a swarm of self-discovering agents out. Watch the full pipeline from goal to delivered code.
See the swarm execute
Give it a goal. Watch specialist agents spawn, explore, implement, test, and deliver inside isolated sandboxes. Under 90 seconds.