# The 3 Pillars of Autonomy

Michele Catasta, Replit | AI Engineer CODE 2025 | 24:42

Source: https://www.youtube.com/watch?v=MLhAA9yguwM
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/the-3-pillars-of-autonomy
Published: 2025-12-22
Tags: agents, coding-agents, context-engineering, multi-agent, testing

## TL;DR
- Fully autonomous coding agents must make technical decisions without requiring nontechnical users to supervise their work.
- Verification through autonomous testing prevents small implementation errors from accumulating into broken applications.
- Parallelism can reduce waiting time, but the agent must handle task decomposition and merge conflicts instead of pushing that work onto the user.

## Summary
Michele Catasta argues that autonomy is the main target for Replit's coding agent because nontechnical users cannot supervise software creation or make technical decisions. He separates autonomy from long runtimes. An agent can run autonomously on a narrow task and still respond quickly, while a broad task may require a long gap between interactions. He presents three pillars: model capability, verification, and context management. Verification requires testing at every step, with browser-based testing used to find broken buttons, mock data, and other incomplete features. Context management uses files, plans, documentation, memories, and subagents instead of putting every piece of state into one context window. The final pillar is parallelism, which trades extra compute for a faster user experience. Catasta says Replit's next direction is for the core agent loop to decompose tasks and coordinate parallel work, so users do not have to plan subtasks or resolve merge conflicts themselves.

## Key ideas
### Autonomy for nontechnical users requires removing technical supervision
[00:00](https://www.youtube.com/watch?v=MLhAA9yguwM&t=0s)
Catasta frames Replit's problem as different from coding agents built for expert developers. Technical users can stay in the loop, inspect changes, and decide whether to accept them. Nontechnical users cannot do that, so the agent must make the technical decisions on its own. He compares this with Tesla's Full Self-Driving experience, where the driver still needs a license and must handle unusual events. Replit wants the equivalent of a passenger experience: users should care about what they are building, while the agent handles how it is built. The goal is to let every knowledge worker create software without understanding the implementation choices.

### Autonomy is the amount of work users can delegate without technical decisions
[04:16](https://www.youtube.com/watch?v=MLhAA9yguwM&t=256s)
Catasta says autonomy should not be measured simply by how long an agent runs. A long runtime can result from a broad task, while a narrow task can be completed autonomously and quickly. Tasks have a natural amount of work, and agents repeatedly plan, implement, and test. Replit wants to maximize the time during which users do not need to make technical decisions and the agent can complete the task independently. Users still control what they want to build. They should not have to monitor the agent's technical choices or treat hours of uninterrupted execution as a vanity metric.

### Verification prevents small coding errors from becoming application-wide failures
[07:17](https://www.youtube.com/watch?v=MLhAA9yguwM&t=437s)
Catasta says agents often create 'painted doors', such as a button whose handler is missing or data displayed from a mock source instead of a database. Replit's internal evaluations found that more than 30% of individual features were broken the first time the agent wrote them, and almost every application had at least one broken feature. Nontechnical users will not test every button and field, so they cannot reliably discover these failures themselves. Autonomous testing supplies feedback from the application, prevents errors from compounding, and checks whether the agent's claim that a task is complete is true.

### Browser testing gives agents feedback beyond unit and API correctness
[11:14](https://www.youtube.com/watch?v=MLhAA9yguwM&t=674s)
Catasta describes a progression from static code analysis and debugging to unit tests, API tests, and browser-based testing. Unit tests mainly cover functional correctness and do not provide full integration coverage. API tests can check endpoints but cannot show whether a web application works or looks right. Computer-use testing directly operates the interface through screenshots, but it is expensive and slow. Browser-use testing interacts with the browser through abstractions over the DOM. Replit combines programmatic interactions, database access, logs, API calls, clicks, and screenshots as a fallback, so the testing agent can gather enough information to fix incomplete features.

### Generated Playwright tests become reusable regression tests
[13:32](https://www.youtube.com/watch?v=MLhAA9yguwM&t=812s)
Catasta contrasts generic browser tools with writing Playwright code directly. Generic tools expose actions such as creating a tab, clicking, and filling forms, but they cannot easily cover every unusual interaction a web application may require. Playwright code is manageable for language models and more expressive. It can also be rerun after it is created, so each generated test contributes to a regression suite. Catasta says this approach was roughly an order of magnitude cheaper and faster than computer-use testing. The tests therefore provide repeated feedback without asking the user to manually walk through the application.

### Long context windows are not required for long autonomous tasks
[15:22](https://www.youtube.com/watch?v=MLhAA9yguwM&t=922s)
Catasta says Replit has found that most tasks, including ambitious ones, can be completed within 200,000 tokens. The agent does not need to place all state into a context window. It can write documentation in the codebase, persist plans and task lists on the file system, and store memories there for later retrieval. Subagents help by starting with a fresh context and receiving only the part of the task they need. They run to completion, return their results, and pass those results back to the main loop. This separation of concerns reduces context pollution and lets the main agent remain focused.

### Subagents keep browser observations from confusing the main coding loop
[18:37](https://www.youtube.com/watch?v=MLhAA9yguwM&t=1117s)
Replit found that testing inside the main loop creates too much noisy state. When the same loop writes code, performs browser actions, and receives browser observations, the coding process becomes confused by the extra interaction history. The architecture therefore moves testing into a subagent. The main loop decides when verification is needed, the testing subagent runs the Playwright and browser work, and only its final observation returns to the main loop. Catasta presents this as a practical reason to use subagents: they isolate a task that has different actions and different context needs from the agent that is writing the application.

### Parallelism improves the waiting experience while adding compute and coordination costs
[19:31](https://www.youtube.com/watch?v=MLhAA9yguwM&t=1171s)
Catasta introduces parallelism mainly as a user-experience concern. A long autonomous run can leave a user waiting after writing one large prompt and receiving a task list. Parallel agents trade extra compute for less elapsed time, but they also duplicate much of the context across multiple windows. Their outputs can create merge conflicts, which expert developers may handle but Replit's nontechnical users do not understand. Parallel testing can run while code is being created, and multiple sampled trajectories can improve performance when enough compute is available. The benefit is real, but the coordination work cannot be handed to the user.

### The core loop should decompose and coordinate parallel tasks
[22:17](https://www.youtube.com/watch?v=MLhAA9yguwM&t=1337s)
Current parallel-agent systems often rely on the user to decide which tasks to run, dispatch each one, and reconcile the results. Catasta says Replit is working on an architecture where the core loop becomes the orchestrator. It would determine subtasks and choose parallel execution on the fly. This removes the user's need to understand task decomposition. The agent can also apply software-engineering techniques that reduce the chance of agents editing the same areas and creating conflicts. Catasta does not claim that merge conflicts will disappear, since corner cases remain. The core loop's orchestration is Replit's main direction for the next version.

## Notable quotes
- "Autonomy should not be basically conflated with long run times." (05:07)
- "The first one is of course the capabilities of frontier models like the baseline IQ that we inject in the main agentic loop." (06:57)
- "So we had to find a complete orthogonal solution to that which is autonomous testing." (10:20)
- "The high level message here is that long context models are not needed to work on long trajectories." (15:22)
- "The core loop as an orchestrator is going to be our main bet for the next few months." (23:30)

## Tools & references mentioned
- Replit Agent
- Replit
- Tesla Full Self-Driving
- Playwright
- Anthropic
- Claude Sonnet

## Who should watch
- You are building coding agents for people who cannot inspect code, test every feature, or resolve implementation decisions themselves.
- Your agent can run for long periods, but users spend too much time waiting or lose context while it works.
- You are designing browser testing, subagent orchestration, or parallel execution and need to think through cost, latency, context pollution, and merge conflicts.

## Related talks

- [In the Land of AI Agents, the Verifiers Are King](https://aietalks.com/talks/in-the-land-of-ai-agents-the-verifiers-are-king) (Tariq Shaukat, Sonar, 18:53)
- [Self Coding Agents](https://aietalks.com/talks/self-coding-agents) (Colin Flaherty, Augment Code, 17:23)
- [Your agent is blindfolded](https://aietalks.com/talks/your-agent-is-blindfolded) (Johan Lajili, Poolside AI, 09:58)
- [Bounded Autonomy: Between Free Will and Determinism](https://aietalks.com/talks/bounded-autonomy-between-free-will-and-determinism) (Angus J. McLean, Oliver, 16:52)
- [Agents Need More Than a Chat](https://aietalks.com/talks/agents-need-more-than-a-chat) (Jacob Lauritzen, Legora, 14:21)