FILED FROM LISBON — The most useful thing Replit has done for the autonomy-layer category over the last year is not the agent itself; it is the pricing model the company put around the agent. Replit Agent — by mid-2026, on the v3 release — is priced by effort. The unit of billing is not a seat, not a prompt, not even a successful completion. It is the work the agent does, measured in checkpoints and effort credits.

This is the part of Replit's product story the Bulletin has spent the most editorial time on. The pricing model is not just a commercial decision. It is a category-shaping move. The seat-based pricing of the SaaS era was, structurally, a price for access to a system. The usage-based pricing of the API era was a price for individual operations. Effort-based pricing is, in our reading, the first real commercial pattern that prices the autonomy itself — and the math behind it is more honest than the trade-press coverage has yet acknowledged.

The product, briefly

Replit Agent is, by the v3 release, a near-end-to-end build agent. The user describes the application they want. The agent scaffolds it, configures the database, writes the code, deploys to Replit's infrastructure, and circles back when the result needs to be revised. The product is positioned somewhere between Lovable's vibe-coding posture and Cognition's long-horizon engineering one — closer to vibe-coding in target user, closer to long-horizon in capability.

The product's reported revenue trajectory is steep but not at Lovable's pace. Replit was reportedly past $100M ARR by mid-2025, with the Agent business driving most of the year-over-year growth. The customer base is heavier on independent builders and small teams than on enterprises, which is the part of the autonomy-layer market that has historically been hardest to commercialize.

Effort credits, in plain language

Replit's Agent pricing is denominated in "effort credits." A credit covers a unit of agent work. The unit is not a token, not a prompt, not a function call. It is a higher-level abstraction the company has defined as roughly the amount of work an average user would attribute to a single "step" the agent takes.

In practice, this looks like:

• Scaffolding a new app — roughly 50 to 150 credits.
• Adding a database table with migrations — roughly 15 to 40 credits.
• Fixing a failing test — roughly 5 to 20 credits.
• A long-horizon refactor that touches multiple files — roughly 80 to 300 credits.

The variation within each band is the part of the pricing model that does the most interesting work. The agent's actual effort on a given task depends on the size of the codebase, the quality of the user's prompt, the number of revisions needed, and the model behind the agent. Replit publishes the post-hoc effort cost for each completed task. The user sees what they paid for.

This is the part of the pricing model the Bulletin treats as load-bearing. The autonomy-layer products that will survive are the ones where the buyer can reconcile what they paid for against what they got. Per-seat pricing breaks that reconciliation. Per-token pricing breaks it in a different way. Effort-based pricing is the first commercial pattern in the category that lets the buyer evaluate the actual unit economics.

The math, worked

A representative small-team build, from the Replit Agent v3 documentation and our own working sample:

A two-person team building an internal tool — a customer-portal frontend with auth, a basic admin dashboard, three API endpoints, and a small Postgres schema. End-to-end, from blank Replit project to production deploy: roughly 1,200 to 1,800 effort credits. At the current pricing tier of roughly $0.10 per credit, that is $120 to $180 of agent cost.

The same work, done by a junior engineer in a small team, would take three to five days. The fully-loaded cost — salary, benefits, opportunity cost — is conservatively $1,500 to $3,000 for a US-based team, less for a distributed one. The agent is between 10x and 20x cheaper, depending on the comparison point. The agent is also faster: the same work that takes three to five days for a junior engineer takes the agent something like four to eight hours of wall-clock time.

The agent is not a substitute for the engineer in every case. The Bulletin's working position is that the right way to think about it is as a force-multiplier for the engineer, not a replacement. The team that uses the agent well does more work; the team that uses the agent badly produces the same work at a lower cost but with a higher rate of revisions. The autonomy-per-dollar number is real but it is not the only number that matters.

What this means for the category

Replit's pricing model is, in the Bulletin's view, the working template the rest of the autonomy layer will end up adopting. Lovable is already there in everything but vocabulary. Cognition's Devin pricing is moving in the same direction. The vibe-coding category is consolidating around effort-based commercial models because the seat-based and prompt-based models do not survive the unit-economics conversation.

The structural reason is the one the Bulletin has been arguing for two years. The autonomy layer is not a SaaS layer. The unit of value is not a user; it is the work. The commercial models that price the work directly are the ones that align the buyer's economics with the product's economics. The ones that price something else — access, capacity, prompts — will get displaced.

What we are watching

The autonomy-per-dollar number is the metric the field will be evaluated on for the next eighteen months. Replit's published number is, by our reading, defensible. The next companies to publish will set the field's expectation; if the published numbers are consistently 10x-20x cheaper than the equivalent human work, the autonomy layer's commercial story consolidates fast. If the published numbers are closer to 3x-5x, the commercial story is slower and more contested.

We will report on the public numbers as they emerge.