Replit lets its agent's model pick subagents, effort and delegation itself

Why Replit scaffolds less

Replit's central claim is that a router, whether built on heuristics or a small model that reads each turn, will always be less capable than the model it chooses for. Replit Agent takes a different route. The main agent, called the core loop, picks the tier and effort of its subagents and adjusts its own effort as the task unfolds.

The company says every model release invalidates assumptions built into a harness, and that stronger models need less scaffolding for long-horizon tasks. It reports seeing models lean toward delegation on their own, using subagents for context management and parallelism. It also notes that the frontier is jagged: the strongest coding model is not necessarily the best at designing UIs or making slides. The harness therefore offers options and keeps guardrails, while the core loop decides at each step.

Four primitives for delegation

After experimenting with GPT-6 Astra, Replit says it found the model delegates well. It adds that the GPT-6 family is the first from OpenAI to support effort changes mid-turn without breaking the cache. Replit refined four harness primitives:

• Domain-aware subagents: read-only explorers, browser testers, reviewers and a design subagent for slides and UI, each with its own model and tooling. The harness still decides which specialists exist.
• Subagent tiers and effort: small, standard and large, each a step up in cost and capability, with an effort level inside the tier. A mechanical rename goes to small at low effort, while hypotheses for a stubborn bug go to large at high effort.
• Reusable subagents: the core loop can return to a subagent it has already briefed, and any number can stay warm across kinds and tiers.
• Dynamic effort tuning: Replit trained an escalation system that checks the trajectory at each step and matches effort to task difficulty, acting mid-turn rather than once on the request.

Replit also says the code quality of Astra and Fable 5.1 let it use its code-review subagent less, with no drop in eval scores.

How the models delegate in production

Replit says frontier models such as Astra and Fable cost more per token, yet it has observed them delegating to less costly subagents and keeping their own tokens for decisions that need them. Replit Agent never forces the core loop to spawn subagents. The company shared one week of production data per model, each at medium reasoning effort.

• Turns that dispatch a subagent: 32% for Fable 5, 21% for Fable 5.1, 36% for GPT-6 Astra.
• Turns that hand work to a general worker: 0.9%, 2.3% and 20%.
• Dispatches that return to an existing subagent: 17%, 29% and 42%.

According to Replit, the Fable models mostly send out read-only explorers and reviewers and keep implementation for themselves. Astra is described as the first model it has seen routinely delegate to general workers without being told to, and it tends to return to a worker once briefed.

Benchmark results

Replit evaluated Replit Agent in Max mode, its highest-quality setting, with Astra as the core loop. Its runs are means of four repetitions. Astra's figures come from published mini-swe-agent baselines. A second baseline is a sidekick architecture, the same configuration with the subagent primitives replaced by a single long-lived worker.

On DeepSWE v1.1, Replit Agent scores 72% at $2.11 per task. Astra alone scores 67% at $1.60 at low effort and 74% at $4.43 at xhigh effort. The sidekick scores 61% at $1.34.

On Terminal-Bench 4.0, with three GPU tasks excluded, Replit Agent reaches 49% at $2.53 per task. Astra alone gets 42% at $2.25 at low effort and 60% at $5.86 at xhigh. The sidekick manages 33% at $1.84.

Replit says its agent beats the sidekick architecture by 11 and 16 points, and that Astra's best settings sit 2 and 11 points above it at more than twice the cost. The company states that it ran Replit Agent exactly as it ships to users, with no changes to prompting or harness.

What it means

Replit frames the results as an instance of Sutton's bitter lesson: a rigid harness forces one way of working, while a composable one lets the model choose. Its conclusion is that the smarter models get, the less the harness should decide for them. For users, the claim is a better score-for-cost balance in Replit Agent, though the figures are Replit's own and the text notes that effort changes only preserve the cache on some models, such as the GPT-6 family and Fable 5.1.