# Engineers… Your Software Factory NEEDS Agent Sandboxes to SCALE (exe.dev)

## Executive summary

The video argues that traditional methods of running AI agents—such as allocating a small corner of a local machine or relying solely on containers/CI/CD—create bottlenecks. To achieve true scale and autonomy in an 'AI developer workflow' (ADW), the entire software factory must be moved into dedicated, isolated agent sandboxes (e.g., using exe.dev). This architecture enables complex workflows like running 'Best of N' comparisons across multiple model configurations while maintaining zero blast radius via disposable keys.

## Key takeaways

- The Bottleneck Problem: If an engineer is 'in the loop,' they are the bottleneck. True scaling requires moving beyond local compute limitations by giving every agent its own isolated computer, achieving isolation, scale, and autonomy.
- Three-Tier Architecture for Scale: The recommended architecture involves an Out-loop orchestrator (on the engineer's machine), an In-sandbox orchestrator (on each VM), and the core Software Factory/ADW agents running inside the sandbox. This allows the top-level agent to kick off work and then go quiet, only requiring human intervention at planning and reviewing stages.
- Best of N Pattern: Sandboxes enable running 'Best of N' patterns by simultaneously executing the same prompt/workflow across multiple agent configurations (e.g., Default, Frontier, Deepest, Open Weights), allowing for comparison and selection of the optimal outcome.
- Security and Isolation: Sandboxes provide critical security by ensuring a 'bounded blast radius.' Agents use ephemeral resources, such as OpenRouter provisioning keys with hard spend caps, which are revoked upon teardown, preventing unauthorized access to production systems (e.g., AWS).

## Technical details

- Agent Sandboxes vs. Containers: Sandboxes offer three key advantages over containers: true isolation, insane scale, and autonomy. They provide agents with an entire dedicated computer environment rather than a limited corner of the host machine.
- Software Factory Workflow: The system implements the full Software Developer Life Cycle (ADW) within the sandbox, including plan, build, test, review, and document. This is a composition of agents plus deterministic code.
- Model Stacking and Compute: Engineers should focus on the 'model stack' (combining compute) rather than selecting a single model. The goal is to leverage abundant compute by combining various models (e.g., Gemini 3.6 Flash, DeepSeek V4 Flash, GLM5.2, GPT-4o Luna) for optimal performance/cost trade-offs.
- Agentic Access (Meta Layer): To move at 'light speed,' an agent layer must wrap the entire process. This meta-layer allows the orchestrator to interact with agents running inside multiple sandboxes simultaneously, enabling advanced observability and control.

## Practical implications

- Shift focus from single, powerful agents to building specialized 'Software Factories' that compose multiple models and deterministic code.
- Implement a three-tier orchestration system (Out-loop -> In-sandbox -> ADW) to achieve maximum scale and minimal human intervention.
- Use sandboxes for all agentic work to guarantee isolation and prevent resource conflicts or security breaches on the host machine.

## Topics

Agentic Engineering, Software Development Life Cycle (SDLC), Distributed Computing, AI Workflow Orchestration, Sandboxing, Model Stacking, Build Automation, Factory In A Box Codebase, Super Simple Software Factory Video, Agent Sandboxes on Exe.dev, OpenRouter provisioning keys API

Source: https://www.youtube.com/watch?v=SEI_qIW4o2c