Tobi Lütke Made a 20-Year-Old Codebase 53% Faster Overnight. Here's How.

“Agents” aren’t one thing. In production, LLM systems that use tools and feedback loops tend to fall into four distinct “species,” and mixing them up leads to wasted effort, brittle systems, and quality failures. The practical takeaway: choose the agent type based on the goal—coding a task, coordinating a project, optimizing a metric, or routing workflow steps—rather than based on the model name powering the system.

The first species is the coding harness: an agent that effectively stands in for a developer to write and modify code inside a controlled environment. It can read and write files, run searches, and use the tools provided in its context. Variants differ in how safely they operate (for example, one approach prefers a virtual machine for isolation, while another tends to work directly on a local laptop), but the underlying pattern is the same: a human remains the quality gate while the agent executes coding work. Scale comes from decomposition—breaking a large project into well-defined chunks that can be handled by multiple single-threaded agents in parallel. The human’s job shifts toward planning and approving work, not doing the coding itself.

When projects get larger, coding harnesses evolve into project-level multi-agent systems like Cursor’s approach. Instead of one long-running agent holding the whole mental model, a planner agent manages a queue of tasks and spawns short-lived “execution” agents to solve specific subproblems. Success depends on the planner’s ability to track tasks, maintain context, and evaluate whether each execution agent delivered correct results. Cursor’s experience also highlights a design principle: keep the harness conceptually simple so it can scale—adding extra management layers can backfire.

The second species is the dark factory: an architecture that minimizes human involvement in the middle of the software pipeline. The system takes a specification, iterates automatically, and only proceeds when software passes evaluations. Humans typically focus on getting intent and requirements right at the start, and on accountability at the end (often reviewing code or monitoring production). The core idea is to remove bottlenecks: agents can push work forward quickly, and humans can’t always keep up during rapid iteration. Risk management matters—enterprise teams often require human review even when the middle is automated.

The third species is auto research, which is not about producing working software directly. It’s about optimizing a measurable metric via repeated experiments—essentially a hill-climbing loop. A metric is mandatory; without one, there’s no “research” to optimize. Examples include improving runtime performance in a codebase (as with Toby Lütke’s Liquid presentation framework) or tuning model settings, and the same approach can apply to business metrics like conversion rates if sufficient data exists.

The fourth species is orchestration frameworks, which coordinate handoffs between specialized agents—writer to editor, drafter to researcher, or ticket routing in customer success. Orchestration is essentially workflow routing (A to B), but it can feel heavy because it requires careful context and prompt management at every joint. It becomes worth the complexity when the scale is large enough—thousands or millions of routed items—so the coordination overhead pays off.

A final cheat sheet ties it together: use coding harnesses when judgment is the gate; use project-level multi-agent harnesses when humans still judge but work must be parallelized; use dark factories when evaluations and specifications are strong enough to automate the middle; use auto research when the target is a metric; and use orchestration when the problem is routing multi-step work. The warning is direct: don’t try to use auto research to build software, or force long-running coding harnesses into tasks that really require orchestration or human-driven creativity.