Cursor 2.0 Background Agents: How Freelance Devs Should Bill in 2026
Cursor 2.0 shipped October 29, 2025 with the Composer model and a multi-agent interface — and Background Agents now run async tasks in cloud VMs while the developer keeps coding. Background Agents always run in Max mode, and a 50-step task costs roughly $0.30 to $0.60 in usage. The question for a freelance developer is no longer whether to use Background Agents; it is how to bill the hours an agent does instead of you.
The Delivvo team· May 19, 2026 8 min read
Cursor 2.0 shipped on October 29, 2025 with two structural changes that matter more for freelance economics than any prior Cursor release. First, Composer — Cursor's first proprietary model, a mixture-of-experts trained on the full Cursor agent tooling harness, finishing most agentic turns in under 30 seconds and roughly four times faster than comparably intelligent alternatives (Introducing Cursor 2.0 and Composer, October 29 2025). Second, a multi-agent interface that lets a developer run up to eight agents in parallel across isolated git worktrees or remote machines (InfoQ, Cursor 2.0 Expands Composer Capabilities, November 2025).
Background Agents — Cursor's async cloud-VM agents that work on a dedicated branch and open a PR when done — sit at the intersection of these two changes. They are the surface where "I write code with AI help" becomes "the agent writes the code; I review it."
For a freelance developer billing hourly, this is a billing problem.
What Background Agents actually do in 2026
The mechanics, briefly. A Background Agent in Cursor 2.0:
Receives a task from you in natural language ("implement the password-reset flow following the spec in docs/auth.md").
Spawns an isolated Ubuntu VM in Cursor's infrastructure.
Clones your repo, checks out a dedicated agent branch.
Runs through the task end-to-end — reading the spec, writing code, running tests, iterating on failures — using the full Cursor agent tooling harness.
Keep reading
Pushes the branch and opens a PR for your review when done.
You do not need to keep Cursor open while this runs. You can fire two or three Background Agents in parallel and switch to other work — review them when they ping you.
The cost surface is where 2026 freelance economics get awkward: Background Agents always run in Max mode, and a 50-step task costs roughly $0.30 to $0.60 at Claude Sonnet rates per several public estimates of the new pricing tier. Cursor's own pricing page lists the consumer tiers (Cursor Pricing) at Hobby $0, Pro $20/month, Pro+ at the agent-power-user tier, Ultra at $200/month for heavy users, with Teams at $40/user/month. Background Agents draw against the included usage credits up to a quota and then bill on usage.
The freelance billing problem, stated cleanly
Until late 2025, the freelance developer's billing structure was uncontroversial: hourly or project. Hourly works because the freelancer's hour and the work output are roughly proportional — a senior dev produces N units of working code per hour, the client pays for the hours.
Background Agents break the proportionality.
A senior freelance dev using Background Agents in 2026 can ship the equivalent of 6-10 hours of pre-Cursor-2 work in 2 hours of actual focused review. The agent did the implementation; the dev did the review, the integration calls, and the spec authoring up front. The dev's hour is now leveraged against ~3-5x the output it used to produce.
If you bill hourly at the same rate, you are now charging the client for 2 hours of work that produced what 6-10 hours used to. If you bill hourly at a marked-up rate to capture the productivity gain, you have to explain the rate increase. If you bill for the wall-clock time including Background Agent runs, you are charging the client for hours you spent watching an agent work — defensible only up to the point the client notices.
The structural problem: hourly billing was a proxy for value because hour and value were proportional. In 2026 they are not.
The four billing models that actually work in 2026
Four credible patterns have emerged among freelance developers using Background Agents and similar async tools (Devin, Codex Cloud, Claude Code background runs). All four work; the right pick depends on the client and the project type.
Pattern 1 — Fixed-price scope-locked work
The cleanest model. Quote a fixed price per scoped feature ("password reset flow with all five edge cases handled and tests, $3,200"). The Background Agent productivity gain is yours; the client pays for the deliverable, not the hours. Works best for well-scoped greenfield features where the spec is clear and edge cases are enumerable.
The catch: requires actually writing the scope. Vague briefs blow up fixed-price work whether or not there's an agent in the loop. Writing crisp scope is the freelancer skill that compounds in 2026.
Pattern 2 — Outcome-based retainer
Monthly retainer pegged to outcomes, not hours. "$12,000/month for: shipped features per the roadmap, 2-hour weekly review call, on-call response within 4 hours during business hours." The client buys access to the freelancer's judgment and shipped output; how many hours you spent (and how much of the work an agent did) is your problem.
This is where senior freelance devs are converging in 2026 — high-trust client relationships, clear outcome contract, no hourly bookkeeping. The model is closest to a "fractional engineering lead" structure. See the fractional-roles-eating-freelance-services post for the broader trend.
Pattern 3 — Hourly at a higher rate, transparent about leverage
If the relationship is hourly and you can't or don't want to restructure it, the honest move is to raise the rate and tell the client why. "My rate is now $220/hour because I'm shipping 2-3x what $140/hour bought you in 2024 — happy to walk you through how, and you'll see it in throughput." Clients who care about throughput will accept this without friction. Clients who care about the hourly number itself will not — and those clients are the ones whose billing relationship doesn't survive the next 18 months anyway.
Pattern 4 — Per-output micro-pricing
Less common but increasingly viable for specific work types. Quote per PR, per bug fix, per migration, per feature. "$450 per shipped feature, average 3-5 features per week." Works where the units are clean and roughly comparable in size. Doesn't work where work units vary by 10x in scope.
The choice between these four is mostly a function of how productised your existing work already is. A freelancer running custom one-off projects will find fixed-price scoping the cleanest first move. A freelancer with a stable book of two or three clients will graduate to outcome-based retainer faster. A freelancer running bug-fix or migration work where the units are clean and comparable can move to per-output micro-pricing directly. None of the four are wrong in isolation; the wrong move is to keep billing hourly while quietly absorbing the agent-driven productivity gain — that pattern trains the freelancer to under-price their work indefinitely.
What goes wrong when you keep billing hourly
The two failure modes worth naming so they don't sneak up on you.
Failure mode 1 — quiet under-pricing compounds. Each hour you bill at the legacy rate is an hour where the agent did 2-3x the work and the client paid for one. Multiply across a year of invoices and the gap is real money — usually in the $30,000 to $80,000 range for a full-time freelance dev with an active book. The client is not the villain here; they're paying what you charge. The fix is on the freelancer's side.
Failure mode 2 — the client notices before you do. A sophisticated client who knows what their internal devs ship per week with similar tools will recognise the throughput-versus-bill gap. The conversation that follows is awkward — the client either asks for a rate cut ("if Background Agents are doing the work, why is my bill what it is?") or shifts the work in-house. The freelancer who restructured billing in 2026 doesn't have this conversation; the one who kept billing hourly does.
Both failure modes are avoidable. They require restructuring before the relationship reaches them, not after.
A laptop with code on screen beside a notebook — the review surface that Background Agents make the dominant freelance dev workflow in 2026
What freelance devs should actually do in 2026
Three concrete moves for a freelance developer who hasn't yet adapted their billing:
1. If you're hourly, do the audit. Pick three projects from the last quarter. For each, estimate what those projects would have taken in pre-Cursor-2 hours vs. what they actually took. If the gap is bigger than 2x, your hourly rate is leaking value to clients and you are training yourself to under-price your work.
2. Pick a primary billing model and move new clients onto it. Don't try to migrate existing relationships mid-stream. New clients sign on the new model; existing clients stay on the legacy structure until renewal. The two-track approach is cleaner than negotiating a rate change on a live project.
3. Get good at scope authoring. Fixed-price and outcome-based contracts both depend on the same skill: writing a clear, testable scope up front. In 2026 the implementation half of freelance dev work is increasingly the agent's; the spec half is increasingly the freelancer's competitive moat. Time spent improving how you write scope returns multiples in 2026.
The freelance developers who do well in the Cursor 2.0 era are not the ones who type faster. They are the ones who scope better, review faster, and charge for outcomes rather than hours.
Delivvo gives freelance developers a branded client portal for proposals, contracts, file delivery, and milestone-based invoices on their own connected gateway — and zero platform take. Productised pricing and outcome-based retainers map cleanly to milestone deliverables; agent-augmented hourly invoices do not. The portal is built for the billing model the work is moving toward, not the one it is moving away from. See how it works →
The takeaway
Cursor 2.0 and Background Agents did not break freelance development. They broke the proportionality between hours billed and value delivered, which is what hourly billing was a proxy for. The freelance developers who keep billing hourly in 2026 will either under-charge for their actual output or have an awkward rate-increase conversation. The ones who shift to fixed-price scoped work, outcome-based retainers, or transparently-leveraged hourly will compound forward.
Pick a model. Move new clients onto it. Get good at scope. The technology already changed; the billing structure is catching up.
