# What it takes to set intelligence free

Fabian Hedin, Lovable | AI Engineer CODE 2026 | 22:26

Source: https://www.youtube.com/watch?v=pZWPq_ZAmM4
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/what-it-takes-to-set-intelligence-free
Published: 2026-11-19
Tags: agents, coding-agents, harness-engineering, multi-agent

## TL;DR
- Lovable's first multi-agent framework failed because the models were not capable enough in 2023, so the company returned to a simpler single-agent system.
- Long-running agents need durable task histories, separate inboxes, stateless workers, checkpointed computers, and fast sandbox forks.
- Verification must happen inside each agent turn and through product and business feedback such as user behavior, experiments, payments, and conversions.

## Summary
Fabian Hedin explains how Lovable moved from a failed multi-agent framework to infrastructure for long-running coding agents. In 2023, the company used a main agent that spawned specialist agents, but the system made the product worse. Lovable later returned to a simpler design, then revisited agents as model capability improved. The current system separates an agent's durable task history from the processes that execute it. Git-inspired append-only histories allow agents to fork without copying shared history. Checkpointed computers let projects resume quickly, while copy-on-write memory makes sandbox forks inexpensive. Lovable also rewrote Vite in Rust to reduce startup time and memory use. Hedin argues that long-running agents need feedback loops at two levels: build, lint, runtime, and browser checks during a turn, then product data and business metrics between turns. The talk connects agent infrastructure to the outcome Lovable cares about, helping users create and operate products.

## Key ideas
### Lovable's first multi-agent system made the product worse
[00:40](https://www.youtube.com/watch?v=pZWPq_ZAmM4&t=40s)
In 2023, Lovable believed agents were the future and built a sophisticated framework around GPT-4-era models. One main agent could spawn specialists such as implementation, front-end, and back-end agents, which exchanged messages. Hedin says the system did not work and made the product worse. Before the company ran out of money, it returned to a simpler design in late 2024: smaller models handled knowledge retrieval while one main model wrote to the user and produced code. That version was responsive and reliable. Hedin says Lovable is now using agents again because model intelligence has reached a level that supports more complicated systems.

### Lovable measures its platform by the product users create
[03:52](https://www.youtube.com/watch?v=pZWPq_ZAmM4&t=232s)
Hedin describes Lovable as a chat interface connected to a preview of the result. Users can ask the agent to build software, while the platform provides hosting primitives such as databases, authentication, storage, compute, security scanners, backups, and logs. The agent can inspect these resources and connect code to GitHub. Lovable also includes business capabilities for payments, email, SEO, advertising, analytics, and conversion analysis. Hedin's point is that the output is a product or business, not only source code. The agent therefore needs to work across the software and business parts of the platform.

### An inbox lets agents receive work from humans, other agents, and systems
[07:48](https://www.youtube.com/watch?v=pZWPq_ZAmM4&t=468s)
Lovable previously limited agents to about 30 minutes because longer runs were considered unreliable. Its new runtime removes that time limit, allowing an agent to work for 10 hours or more. Each agent has a separate inbox. Human prompts, messages from other agents, and scheduled system events can all arrive there. When the agent is ready, it copies a message into its trajectory, which is the task history used to continue the work. This design gives an always-on agent a way to receive new instructions without tying its lifetime to one interactive request.

### Git-inspired histories make agent work forkable
[10:06](https://www.youtube.com/watch?v=pZWPq_ZAmM4&t=606s)
An agent trajectory is an append-only event log. Each event points to its parent, the preceding event, so multiple events can point to the same parent and create a fork. Lovable can start parallel agents from any point without duplicating their shared history. These agent branches can communicate, although Hedin says Lovable cannot merge agent directories in the same way Git merges code. The history also records tool calls, failures, successes, and other platform events. A debug view can render the interface at any point in the history, giving Lovable control over what happened at each stage.

### Separating task history from prompts lets Lovable adapt context to each model
[11:10](https://www.youtube.com/watch?v=pZWPq_ZAmM4&t=670s)
The full trajectory contains more information than every prompt needs. Lovable keeps that complete append-only history, then builds a prompt from it for the language model. This allows the system to compact or summarize older events differently depending on the model's context length and the task. The prompt is therefore a rendered view of the task history rather than the history itself. Hedin presents this separation as a way to support different models and prompting strategies without losing the underlying record of what the agent has done.

### Stateless workers let deployments continue without interrupting agents
[13:03](https://www.youtube.com/watch?v=pZWPq_ZAmM4&t=783s)
The processes that execute agents are separate from the task histories. Between tool calls and turns, the system persists the work to the history, so the process can come and go. Hedin says Lovable deploys its system 700 times per day, about once every two minutes. A long-running agent should keep working while the platform moves to a new deployment, including a deployment needed for a security fix. The durable task history allows different processes to take over the same work. The task can continue for 10 hours or longer while the compute process changes underneath it.

### Checkpointed computers make project startup and resume fast
[14:30](https://www.youtube.com/watch?v=pZWPq_ZAmM4&t=870s)
Lovable uses checkpoints for the computers where agents run development servers and verify their work. A shared golden checkpoint contains the operating system, system services, common tools, and a ready-to-start development server. It includes disk contents, memory, and running processes, and Hedin says a new project can copy it in about 230 milliseconds. Project-specific code and dependencies are checkpointed as the agent works. Lovable can stop an idle computer and restore it in under a second, without dropping requests in transit. The same mechanism lets the system fork a computer for separate draft environments.

### Copy-on-write memory makes many sandbox forks practical
[16:16](https://www.youtube.com/watch?v=pZWPq_ZAmM4&t=976s)
Lovable can create several computer environments from one checkpoint. Its copy-on-write approach avoids allocating a separate copy of all RAM for each fork. A memory page is copied only when a process writes to it, at which point the fork receives its own version. Lovable also streams memory into a sandbox so the machine can boot before every page has arrived. The operating system and early processes become usable first, while the remaining memory loads. These choices reduce startup work and allow agents to explore different fixes or performance changes in parallel.

### A Rust rewrite of Vite reduced preview startup and memory use
[18:02](https://www.youtube.com/watch?v=pZWPq_ZAmM4&t=1082s)
To make the development computers faster, Lovable forked Vite and rewrote it in Rust. Hedin says this made code start twice as fast and reduced the time to show a preview from 40 seconds to three seconds. Removing the Node.js dependency reduced the memory footprint of these machines by 6.5 times. Controlling the application also gave Lovable more control over how memory is written, which works with the copy-on-write design used for draft computers. The result is a system that can run many agents in parallel while giving each one a usable development environment.

## Notable quotes
- "We almost failed as a company because we thought back in 2023 that these agents are the future, so let's build for them now." (00:40)
- "In the end what matters is actually not the code. What matters is the outcomes." (05:18)
- "By separating the prompt from the actual task history, we're able to render prompts for any type of model or any type of task." (12:11)
- "We deploy to it 700 times per day. That's about once every two minutes." (13:36)
- "The agent needs to get information. It took an action. Was this a good action or was it a bad action?" (19:33)

## Tools & references mentioned
- Lovable
- Fabian Hedin
- GPT-4
- GPT Engineer
- GitHub
- Git
- Vite
- Rust
- Node.js
- Linux kernel

## Who should watch
- You are building coding agents that need to run for hours rather than one request at a time.
- Your agent workers are difficult to deploy, resume, or fork without losing task state.
- You want to connect code-generation feedback to user behavior, experiments, payments, or conversion data.

## Editor's note

Fabian Hedin says Lovable's first multi-agent system made the product worse. Kitaru records an agent run, including its model calls and tool results, so the failed behavior can be replayed after a change to the model, prompt, or code without touching real systems.

Written by the AIE Talks editors (the Kitaru team), not by the speaker.

## Related talks

- [Build Agents That Run for Hours](https://aietalks.com/talks/build-agents-that-run-for-hours) (Ash Prabaker & Andrew Wilson, Anthropic, 1:15:40)
- [Your agent is blindfolded](https://aietalks.com/talks/your-agent-is-blindfolded) (Johan Lajili, Poolside, 09:58)
- [We Kept Rebuilding Our AI Agent. Here's What Survived](https://aietalks.com/talks/we-kept-rebuilding-our-ai-agent-heres-what-survived) (Fuad Ali, Arize AI, 20:06)
- [The Multi-Agent Architecture That Actually Ships](https://aietalks.com/talks/the-multi-agent-architecture-that-actually-ships) (Luke Alvoeiro, Factory, 18:31)
- [Agents Made Code Free. Maintaining It Didn't Get Cheaper.](https://aietalks.com/talks/agents-made-code-free-maintaining-it-didnt-get-cheaper) (Dmitry Buykin, Maersk, 18:04)
