Prime Agent’s Rust rewrite puts each coding session in its own worker process, allowing a session to fail without taking the others down. It also brings native Windows support in beta and simpler installation. These practical changes are separate from the announcement’s bigger claim about how the software was built.
In its October 9, 2026 Rust rewrite announcement, Prime Intellect says more than 2,000 agents worked across over 10,000 Prime Sandboxes, consuming more than 200 billion tokens to rebuild and optimize the tool.
The release is available as open-source software. The swarm totals, engineering timeline and performance findings are Prime Intellect’s own account, not independently verified results. The useful questions are what the shipped design changes and what the company’s documented workflow demonstrates about agent-written infrastructure.
Prime Agent’s worker processes provide crash isolation, not a security boundary. The repository explicitly warns that model-generated code runs with the user’s permissions.
Nine Rust Crates Replace the TypeScript Architecture
Prime Intellect describes the rewrite as an architectural reworking, not a direct language translation. The new code is split into nine Rust crates, with a one-way dependency graph and a shared types crate that defines messages used by clients, the daemon and workers.
That shared protocol definition addresses a common maintenance problem in multi-process software. If one component changes a message type, the compiler can flag incompatible uses elsewhere. It doesn't establish that a message’s meaning is correct, but it makes incompatible definitions harder to ship unnoticed.
The daemon coordinates attached clients, model streams, tool calls and messages between agents. Each session runs in a separate worker under a small supervisor. Prime Intellect says sessions persist on disk, letting clients reattach after a restart.
For long-running coding tasks, a terminal disconnect should not have to end the work, and one failed session should not disrupt unrelated sessions. The Prime Agent repository documents background execution, session attachment and service-management commands.
Platform-specific transport, process control and file locking now sit behind interfaces. According to Prime Intellect, that made Windows support a matter of implementing those interfaces instead of restructuring the daemon again.
The company attributes much of the memory and startup improvement to native code without a JavaScript runtime and garbage collector for each process. It also points to Rust’s compile-time checks for ownership, exhaustive enums and cross-thread data sharing.
The Rust harness still uses a persistent Python environment as its model-facing control surface. File operations, commands, tools and subagents are accessed programmatically through that environment, so the rewrite does not make Prime Agent Python-free.
The 2,000-Agent Claim Describes the Engineering Exercise
Prime Intellect says the rewrite exercise took two weeks. Its published breakdown lists 1,981 agents for the Rust implementation and 228 for performance optimization, totaling 2,209 agents and 228.70 billion tokens.
These vendor-reported totals are more specific than the rounded headline. They should not be read as evidence that more than 2,000 agents were running simultaneously.
The company says orchestrators and their agents ran on two eight-core CPU nodes, each supporting more than 100 concurrent subagents and their Python kernels. Compilation, type-checking and comparison work could be sent to Prime Sandboxes to avoid saturating the orchestration machines.
The exercise thus combined coordination on a small number of nodes with build and verification work distributed elsewhere. The sandbox count alone does not reveal peak concurrency, utilization or total compute cost.
The two-week rewrite figure also leaves out the rest of the path to release. Prime Intellect says follow-up work continued over subsequent weeks to finish feature ports, fix bugs, improve performance and polish the interface.
Humans remained involved in setting priorities, finding problems, directing changes and reviewing results. The announcement describes heavily automated engineering with human oversight; it does not establish an unattended migration from start to finish.
Separate Reviewers and Verifiers Controlled Merges
The more instructive part of the engineering account is its acceptance process. A root agent divided the migration into dependency-ordered tasks, monitored progress and merged completed work. Prime Intellect says that agent wrote no product code.
Each task then passed through four roles:
- Planner: specified the feature, the original TypeScript behavior and the parity check.
- Implementer: wrote Rust code in a dedicated worktree, allowing parallel development.
- Reviewer: examined the pull request adversarially, using a different model and a separate context.
- Verifier: compiled the implementation and ran its tests and parity checks in a fresh Prime Sandbox.
A failed review or verification returned the task to the implementer with the findings. Both had to pass before the pull request could merge.
Separating the reviewer from the author is a sensible attempt to reduce self-confirmation. Verification in a fresh environment makes acceptance less dependent on the implementer’s local state. Neither guarantees correctness, but both provide clearer checks than asking the code-writing agent whether its own work is finished.
Prime Intellect describes four kinds of parity checks. Terminal-interface tests compared frames rendered by the TypeScript and Rust versions under the same scripted model. Harness checks compared session transcripts and requests sent to model providers. Protocol checks covered daemon messages. Feature audits classified components as matching, partial or missing.
These checks gave agents measurable conditions for progress, though matching tested behavior is narrower than reproducing an entire product. The company acknowledges that limit: internal use uncovered bugs and missing behavior outside the differential tests’ coverage. Agents later reviewed logs and traces, while humans continued identifying problems and directing fixes.
For builders, the transferable lesson is the structure of the feedback loop. More agents can increase parallelism, but a migration needs explicit acceptance criteria, isolated verification and a route back to implementation when checks fail.
Performance Tests Exclude Model Inference
Prime Intellect says it built a benchmark harness to measure runtime behavior, then ran a three-day optimization loop aimed at improving results without breaking parity.
The disclosed setup used a fresh four-core, 8 GB Prime Sandbox for each benchmark. Agents ran in a terminal driven through a screen emulator against a scripted model. Results judged too noisy were withheld.
The timings excluded inference. They measure local harness overhead, including startup, rendering and other runtime operations, rather than how quickly an AI provider produces an answer or whether an agent writes better code.
The company says the Rust version is faster and uses fewer resources than most coding-agent harnesses. That remains a vendor comparison, not an independent finding. The available evidence supports discussing the architecture and testing method, but not declaring an independently established performance lead.
Sources
- Rust rewrite announcementprimeintellect.ai
- Prime Agent repositorygithub.com
