Cursor Scales AI Agents for Weeks and Builds a Rust Web Browser: What It Means for Coding

What happens when you give hundreds of AI agents weeks of time, billions of tokens, and the freedom to build real software? Cursor decided to find out and the results are honestly wild.

In its official blog post titled Scaling long-running autonomous coding, Cursor shared how it scaled autonomous coding agents from chaotic early attempts into a reliable system. The headline moment: those agents built a web browser from scratch in Rust called FastRender running for almost a full week and generating more than 1 million lines of code across 1,000 files.

Let’s break down what Cursor did, why it worked, what FastRender includes, and what it signals for the future of AI-powered software development.

Why did Cursor run hundreds of AI agents?

Cursor’s goal wasn’t just to make a demo app. They wanted to stress-test a real idea: can AI agents build complex software autonomously for long periods without constant human steering?

Most current AI coding workflows focus on short tasks: you prompt, it generates, you fix, you move on. Cursor aimed bigger. They tested what happens if AI can operate like a long-term engineering team.

What went wrong at first?

Cursor openly admits the first approach failed. The early system had what they call flat coordination. It sounds reasonable: many agents coordinate together on the same codebase and share tasks freely.

But in practice, flat coordination created predictable problems:

• Lock conflicts and clashing edits on shared branches
• Agents avoiding hard work and creating more low-value tasks
• Workflow bottlenecks and stalled progress
• Higher chance of drift over long runtime

In short: more agents didn’t mean more progress. It just meant more chaos.

How Cursor fixed it: The hierarchical pipeline

The turning point was switching from messy distributed teamwork into a clean pipeline. Cursor moved to a hierarchical multi-agent setup with clear roles.

Instead of everyone coordinating with everyone, the system became structured around three core roles:

1) Planners

Planners explore the codebase and break down work recursively. Their job is to figure out what needs to be done and turn it into actionable tasks.

2) Workers

Workers execute tasks. They grind through implementation work without trying to manage the global plan. This reduces coordination conflicts and keeps throughput high.

3) Judge

The judge evaluates output, approves progress, and helps the system decide the next cycle. Think of it as a quality and direction layer.

Key idea: simplifying agent roles worked better than complex distributed coordination models.

This structure made it possible for Cursor to run hundreds of concurrent agents working on shared branches while keeping collisions low.

What models powered the system?

Cursor says its agents ran for weeks using GPT-5.2 models. The big takeaway here is less about raw intelligence and more about consistency.

According to Cursor, GPT-5.2 performed better at:

• staying focused over long periods
• avoiding drift compared to other options
• maintaining a useful working context while iterating

Cursor also mentions something that will interest anyone building AI automation: prompts mattered more than complicated harnesses. That is, strong prompts and clear constraints reduced drift better than extra orchestration layers.

FastRender: Cursor’s AI-built Rust web browser

The most attention-grabbing part of the blog is FastRender.

Cursor set a challenge: build a full web browser in Rust. Not a toy renderer. Not a "hello world" DOM demo. A browser-style engine with real components.

How big is FastRender?

Cursor reports the project ran nearly a week and produced:

• Over 1 million lines of code
• 1,000+ files

Some sources cite it may be even larger (up to ~3 million lines), but Cursor’s post highlights the 1M+ scale directly.

What does it include?

FastRender contains major browser building blocks such as:

• HTML parsing
• CSS layout
• Text shaping
• Painting and rendering pipeline
• A custom JavaScript VM

Screenshots in Cursor’s post show the engine rendering simple web pages, including Google (described as "kind of" correct). It’s not comparable to WebKit or Chromium yet but that’s not the point.

The point is: autonomous agents built a real browser-like system with meaningful architecture.

Quick comparison table

Aspect	FastRender	Mainstream browsers
Language	Rust	C, C++, Rust (parts)
Maturity	Early and experimental	Production-grade
Development style	Autonomous multi-agent coding	Human engineering teams
Goal	Prove long-running agent scaling	Reliable real-world browsing

Other long-running AI projects Cursor shared

FastRender is the flashy story, but Cursor also listed other projects that prove this system isn’t just a one-off experiment.

1) Solid-to-React migration (Cursor’s own code)

Cursor ran agents for more than 3 weeks to migrate parts of its codebase from Solid to React.

Reported diff impact:

• +266K lines
• -193K lines

Cursor suggests the result is potentially mergeable, which matters because production code migrations are usually painful and slow.

2) Video rendering optimization

Cursor highlights a big performance win: a Rust rewrite of a rendering component used for zoom and pan effects.

Result: around 25x faster performance, and this one reportedly shipped into production.

3) Ongoing experiments

Cursor also mentioned longer projects currently underway, including:

• Java LSP (~550K LoC)
• Windows 7 emulator (~1.2M LoC)
• Excel clone (~1.6M LoC)

These aren’t simple scripts. They’re heavy engineering domains: compilers, emulation, and productivity software.

So what did Cursor learn?

Cursor’s conclusions are surprisingly practical, and they apply beyond Cursor itself.

Lesson 1: simpler agent roles beat complex orchestration

The hierarchical pipeline worked because it reduced fragile coordination. Planners plan, workers build, judge evaluates. That’s it.

Lesson 2: prompts are a major scaling lever

Cursor claims that prompt design mattered more than elaborate harness logic for preventing drift. This is a big reminder that structure in language can act as structure in engineering.

Lesson 3: long-running autonomy is now realistic

Cursor’s experiments used billions of tokens, proving that with enough throughput and the right coordination design, AI can push toward month-scale projects.

What does this mean for the future of coding?

Cursor isn’t saying AI replaces developers tomorrow. What they’re showing is something more interesting: a new development style.

If multi-agent systems can reliably deliver large engineering outputs, we may soon see workflows like:

• AI agents handling migrations and refactors continuously
• AI teams building internal tools while humans focus on product decisions
• AI-driven prototyping that produces real codebases, not throwaway demos

In that world, developers won’t stop coding. But they might start managing agent teams the same way engineering managers guide human teams today.

FAQs

What is Cursor’s multi-agent coding system?

It’s a framework Cursor used to run many AI agents at once. They use a hierarchical structure: planners create tasks, workers implement, and a judge evaluates and repeats the cycle.

Did Cursor really build a browser with AI?

Yes. Cursor’s agents built FastRender, a Rust-based browser project with HTML parsing, CSS layout, rendering logic, and even a custom JavaScript VM. It’s experimental but impressive.

Can I view the FastRender code?

Yes. The FastRender project is open source and hosted on GitHub. You can inspect the codebase and structure yourself.

References

• Cursor Blog: Scaling long-running autonomous coding
• GitHub: wilsonzlin/fastrender
• CEO announcement on X (search Michael Truell, Jan 14 2026)

// Mini takeaway snippet
// The lesson isn’t that AI can write code.
// The lesson is that AI can coordinate and sustain weeks of engineering.