Replit Launches Missions: Set a Goal and a Budget, and a Swarm of Agents Plans, Builds, and Tests
On 17 November 2026 Replit launched Missions: you set a goal, a budget, and approval rules, and a swarm of agents plans, builds, tests, and iterates until an independent AI judge confirms the goal is met. Its self-test built DataCat, a monitoring platform, in two days for $3,000 — and Replit open-sourced DataCat the same day.

In short: people set the goal and the budget; a swarm of agents does the planning, building, and testing
On 17 November 2026, Replit launched Replit Missions: you define an outcome, set a spending limit and a few boundaries, and a swarm of agents plans, builds, tests, and iterates until the goal is reached. In Replit's words, this is built for the complex work teams never have time or capacity for: winning more enterprise customers, improving product performance, or replacing legacy software. The entry point is in Replit's sidebar: click "New", select "Mission", and describe your most ambitious goal.
The biggest difference from Replit Agent is not "it can write code" but "it can take a goal". What you used to say to an agent was "change this code" or "add me a login page"; now you say "win our first 10 paying enterprise customers". You do not need to decide upfront which industries to target, which buyers to reach, or which customer problem to solve first — finding and evaluating those approaches is part of the work you hand over. During setup, Missions asks questions to define success: what counts as an enterprise customer for your business? Do paid pilots count toward the first 10, or does success mean signed annual contracts above a minimum value? Your answers shape which accounts the mission prioritizes and how it measures results.
Three things stay in human hands: the budget, the boundaries, and acceptance. Your Missions agreement sets the spending limit, which actions require your permission, and which tradeoffs are acceptable — such as offering paid pilots or discounts on annual contracts. For example, you can cap the mission's spending at $1,000 and require approval before the Agent contacts prospects, shares a proposal, changes customer-facing sales materials, or makes product commitments. These limits and approval requirements remain in place as the approach evolves; they do not lapse because the agents changed tactics.
On the execution side, a swarm of agents works in parallel rather than one agent grinding through from start to finish. For an enterprise sales mission, one agent might research target accounts while another develops a demo and a third prepares outreach for your approval. After approved outreach is sent, the mission returns to review which accounts and messages are generating qualified conversations, then decides where to push next: put more effort into an industry showing stronger interest, refine a demo around a recurring buyer question, or revise messaging that gets few responses. You can close your laptop and let the cloud agents work, receiving progress updates on your terms — blockers immediately, a daily digest, or weekly — and it reaches out when it needs your input.
Acceptance is handled by an independent AI judge: it checks results against your agreed success criteria, and agents use its feedback to refine their work. A mission is marked complete when those criteria are met. If the budget runs out first, work stops with the outcome still unresolved. Whenever you want a closer look, you can see completed work, active tasks, and next steps, including anything awaiting your approval. The most important sentence in this design is "work stops when the budget runs out": it turns agents from "unlimited trial and error" into "trial and error within a budget you set", and the budget and the acceptance criteria are both defined by a person in advance.
Why a swarm of agents rather than one stronger agent? Replit's answer is parallel exploration. For a problem like performance optimization, agents test different implementations in parallel, use shared findings to refine their approaches, and work together to validate correctness as they identify faster solutions. Replit tested this across 13 representative benchmark tasks using NumPy: with Auto (Max), a single agent achieved speedups of up to 4x, a 16-agent swarm reached 17x, and a 32-agent swarm reached 19x. Auto (Power) showed the same pattern: 2x, 7x, and 9x. Replit's conclusion is that the swarms got further because exploring more approaches in parallel helped them find substantially faster implementations.
The self-test: two days and three thousand dollars to build a monitoring platform
Replit used itself as the first example. The team wanted to bring application monitoring in-house to reduce costs and gain more control, so it gave Missions the goal of building DataCat, a platform it could customize and run on its own infrastructure. The result: in two days, within a $3,000 budget, a swarm of agents built a working platform with dashboards, alerts, and application tracing, then tested it against measurable performance and reliability goals. Beyond the platform, the mission also built DataCat's own agent, which collects monitoring data from each server, and its tracing libraries. DataCat can run independently of the original platform's agent and libraries.
These self-test numbers are worth reading one by one. To test whether DataCat could help diagnose a failure, the team deliberately introduced a database bug. DataCat raised an alert in 38 seconds, beating the 60-second target, and traced the failure to the exact database query and its logs. Then came a three-hour load test: the mission built sample applications, and DataCat stored 26 million records of application activity and 4.4 million log entries with no data lost, while searches and alerts kept running. All 36 data-correctness checks and 15 alert-reliability checks passed — 51 of 51.
The comparison with the original platform is more interesting still. In matched Node.js tests, the application handled 39% more requests with 51% less monitoring-related processor overhead under DataCat; DataCat's agent also used less memory and made logs searchable sooner. On API compatibility, each DataCat storage engine passed 51 of 56 checks, versus 45 of 56 for a comparison build made with Claude Code's /goal feature using the same initial prompt. On application trace intake, DataCat with Postgres took in 49,000 traces per second, versus 9,800 for the Claude Code build — 5x faster. Metric intake was 405,100 metric points per second versus 224,600, nearly twice as fast. Agent memory under load was 82–108 MB for DataCat's agent, versus 319 MB for the original platform's agent (240-second average). Time until logs are searchable was 0.5 seconds with DataCat's agent, versus 4.2 seconds with the original platform's agent (median).
These numbers have to be read together with the caveats Replit wrote into the announcement itself: controlled tests do not establish performance against the original platform's hosted service or on Replit's production systems; the Node.js comparison used matched workloads and monitoring work; the build comparison used one run per setup on identical cloud machines, scored only shared product areas, and used the original platform's agent version 7.56.2 to send data; API compatibility was a separate test suite from data correctness and alert reliability; the agent comparison used repeated runs of the same workload, one agent at a time, both sending to the same Radar server. Replit printing these limits deserves credit — but it also means the DataCat report card currently has only one witness, Replit itself, with no independent third-party verification yet.
The head-to-head with Claude Code deserves a second look in particular. Replit's account: DataCat accepted all data types from the original platform's agent (logs, metrics, host data, and traces), while the Claude Code build accepted logs only; DataCat passed more API compatibility checks and took in traces and metrics faster; the Claude Code build covered more product areas and took in logs faster. On storage engines, DataCat has two (Postgres and ClickHouse) versus one (SQLite) for the Claude Code build. The sample size here is small — one run per setup — and it is Replit's own arena with Replit as its own referee. Its value is in showing the tradeoff between two approaches, not in declaring Claude Code the loser: parallel swarm exploration has an edge at "doing one thing deep and fast", but that does not mean a single agent loses on every task.
DataCat also matters beyond the launch itself: Replit open-sourced it today at github.com/replit/datacat under the Apache 2.0 license, as a self-hostable version. According to the repository, DataCat puts metrics, logs, distributed traces, dashboards, infrastructure, and alerts in one place, runs on your infrastructure, stores data in PostgreSQL (telemetry optionally in ClickHouse), and accepts OpenTelemetry and Datadog-compatible agent traffic, with no hosted account or external service required. The repository was created on 17 November 2026 and had only 6 commits and 4 stars on launch day — this is a newborn open-source project, not a mature product. Anyone who wants to use it should follow its own README: Docker Compose to start, local email/password accounts, single-use invite links to add members.
Another number: a hundred thousand yen of starting capital, grown to 4.82 million in a year
Besides DataCat, Replit offered a second example: E-Commerce Bench. In this simulated benchmark, an agent starts with ¥100,000 and runs online stores for a simulated year, choosing suppliers, avoiding scams, and setting prices. In a single run, Missions grew that to ¥4.82 million, roughly 48 times the starting money — a state-of-the-art result more than three times the best on the public leaderboard. Replit presents it as further evidence for the "Self-Driving Company": people set direction, make consequential decisions, and remain accountable while agents carry the execution and coordination.
The number hits hard, but it has to be read carefully. One run, a simulated environment, three times the leaderboard best — none of those qualifiers can be dropped. The suppliers, scams, and pricing rules in the simulation are all set by the benchmark's designers; the 48x was produced inside that sandbox, not in a real market. Treating it as a signal that "an agent swarm can handle long-horizon, multi-step work with feedback" is reasonable; treating it as a promise that "give an agent ¥100,000 and it will earn ¥4.82 million" is a misreading. Replit's own text says "in a single run" — that qualifier matters.
Put the two examples together and the product logic of Missions becomes clear: it is not "a better coding Agent" but "an Agent that manages projects". Agents used to take tasks — write a piece of code, fix a bug; Missions takes goals — win customers, build a platform, run a store for a year. The difference between a task and a goal is that a task comes with a clear definition of done, while a goal requires you to define what done means. Missions builds "defining done" into the product: it questions you during setup, writes the budget and boundaries into the agreement, and has an independent judge check against the standard at acceptance. Without those three pieces, "taking on goals" would be just a slogan.
How Missions differs from Agent — and from other "multi-agent" products
To understand Missions, separate it from Replit's own Agent and from other "multi-agent" products on the market. Replit Agent takes tasks: you describe a change, it edits code in a cloud sandbox, runs it for you to preview, and opens a draft pull request for your review. The task has clear boundaries — what to change, to what extent, and when it counts as done are all stated by you in advance. Missions takes goals: the goal has no ready-made definition of done; the standard is something you define together with it, and the path is something it finds, tests, and changes itself. Agent is an "executor"; Missions is an "executor plus project manager" — responsible for breaking work down, running it in parallel, checking it, and reviewing it, not just writing the code.
Compared with always-on agents such as OpenAI's Dots and Anthropic's Duet, Missions differs in that it grew out of a coding agent rather than a general-purpose assistant. Dots and Duet are general-purpose agents that happen to handle code; Missions coordinates swarms of Replit Agents doing engineering work — building apps, optimizing performance, running benchmarks. Cognition's Devin Bots, launched the same day, is a similar idea — a persistent agent that manages teams of Devin instances — but Devin Bots manages Devin instances while Missions manages Replit Agents, each growing inside its own ecosystem. For users, that means the choice is not about the concept but about the toolchain you already use: where your code, your projects, and your deployments live is where Missions lives.
Another difference sits in the acceptance mechanism. Many multi-agent products talk about "parallelism" and "speed"; Missions talks about "budget" and "acceptance" — work stops when the budget runs out, a judge checks against a standard, and the standard is one you set in advance. Together, those three answer a question every agent product eventually faces: when agents work on their own, who guarantees they have not drifted off course or burned money recklessly? Missions' answer is: the budget caps the money, the judge caps the quality, and you cap the standard. If any of the three is missing, the whole design falls over. If your team has ever been scared by an agent's bill, or burned by an agent "confidently doing the wrong thing", those three are the parts to watch most closely.
This design has its limits too. Missions is good at work where "the goal is clear but the path is not": winning customers, improving performance, replacing an old system — you know what you want, just not exactly how to get there. When the goal itself is vague — "make our product a bit better", "think about what else we could do" — Missions cannot help, because it needs you to first answer "what counts as better". The questions it asks during setup are there to force you to translate a fuzzy goal into a checkable standard. If you cannot do that translation, the mission cannot start. That is not a product flaw but an honest design: it does not pretend it can make decisions for you; it only promises to run the execution once you have decided.
Budget and approvals: what control actually looks like
Unpack the phrase "budget and boundaries" and control turns out to be made of concrete things. First is the spending cap: you can write a hard number into the mission agreement — say, $1,000 — and the agents stop when they hit it, whether or not the goal is reached. Second is the approval list: which actions must go through you first — contacting prospects, sharing a proposal, changing customer-facing sales materials, making product commitments. Replit's examples are exactly these four, all actions that are hard to undo once done. Third is the acceptable tradeoffs: whether paid pilots are okay, whether annual contracts can be discounted — things the agents may only use in negotiation if you have said yes in advance; what you have not approved, they may not decide on their own.
Combined, the practical effect is "agents working inside a cage": you set the size of the cage, the approval list is its bars, and the freedom inside is the agents' ability to choose their own path, switch tactics, and try things in parallel. A cage too small leaves the agents no room and the goal unfinished; a cage too big loses control of budget and risk. The most common mistake for first-time Missions users is setting the cage too wide — a big goal, a generous budget, only the minimum approvals — and then discovering the agents spent most of the budget in the wrong direction. The steadier approach is the reverse: start with a small goal, a small budget, and many approvals; run it once, see what it is like on your own tasks, and only then widen the cage step by step.
Progress reporting is also part of control. Missions lets you choose during planning what you want to hear about (blockers, progress updates, general status) and how often (immediately, in a daily digest, or weekly). That choice is itself a form of management: choose "immediately" and you will be interrupted often but catch drift early; choose "weekly" and you save time but only learn on the weekend that it went the wrong way. For most teams, "daily digest plus blockers immediately" is a sensible starting point — not drowned in messages, but not letting a mistake run for a whole week either. Once you learn how it behaves, adjust to your own rhythm.
Our judgment: try it on a small goal first; don't bet a big budget on day one
For people doing vibe coding, the most interesting thing about Missions is not DataCat or the 48x — it is that it changes what counts as a task. You used to break a big goal into a dozen small tasks and feed them to an Agent one by one; now you can hand over the whole big goal and let the swarm break it down, run it in parallel, and check it itself. That is especially attractive for small teams: the product launch that keeps being postponed, the refactor that would take ten senior engineers a quarter, the off-the-shelf software you want to build in-house but have no bandwidth for — all of them now have a "try it" entry point. Replit's announcement lists exactly those three kinds: the postponed launch, the labor-heavy refactor, the in-house replacement.
But before trying, three things need to be thought through. First, the budget is a guardrail, not a suggestion. Missions is designed so that work stops when the budget is spent, with the result left unresolved — better than burning money without limit, but it also means you should decide before starting what the goal is worth. A $1,000 cap and a $3,000 cap decide how many approaches the agents get to try. Second, the acceptance criteria are written by you, not guessed by it. The questions during setup — what counts as an enterprise customer, do paid pilots count — the more precisely you answer them, the more meaningful the judge's checks are; answer vaguely and acceptance becomes a formality. Third, every report card so far comes from Replit itself: a one-run comparison, its own arena, itself as referee. Before independent users produce their own DataCat and their own 48x, try one small goal on a small budget and see what it is like on your own tasks.
One more practical reminder: Missions currently lives inside Replit's own product — the goal, the budget, the boundaries, and the judge all run in its system. If you want to use it in your team's core workflow, first ask about ownership of the data and code, whether mission records can be exported, and in what form unfinished work is handed back to you when the budget runs out. Replit's announcement does not answer these questions — it answers "what it can do", not "who owns the result and how it is handed over". For a small team, those two questions matter as much as a 17x speedup. Run one small goal first, get your own numbers, and only then decide whether to hand over a big one.
Comments (0)
Sources
Related articles
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.