# ZERO to RUNNING Software Factory In 16 Minutes (LIQUID Software)

## Executive summary

This video introduces the Tiny Software Factory (TSF) architecture, positioning it as a form of 'liquid software' designed to adapt to specific problems. The core thesis is that engineers must shift from being 'in the loop' (the bottleneck) to 'near the loop,' where proactive AI agents operate autonomously and only require human input at critical decision points. The TSF enables this shift by providing a structured, three-step process (Initialize, Configure, Specialize) to rapidly deploy and customize agentic systems within any codebase.

## Key takeaways

- Shift from In-Loop to Near-Loop: The most significant meta-optimization for engineers is moving from 'in the loop' (where the engineer is the bottleneck) to 'near the loop.' In this state, proactive agents operate 24/7 and only stop when a decision point requires human attention. The TSF is designed to facilitate this transition.
- The Three-Step Deployment Process: The TSF is designed for rapid deployment using three steps: 1) Initialize (mounting the empty factory into a codebase), 2) Configure (passing a detailed plan/prompt to specialize the factory), and 3) Specialize (tailoring the factory for a specific problem set).
- Liquid Software Concept: TSF is defined as 'liquid software'—a new class of software that changes its shape and functionality based on the problem it is solving, adapting as the user learns more about the problem.

## Technical details

- Empty Factory Template: The TSF starts with an 'empty factory' template (Level Two), which contains generic agentic tooling that has no purpose until it is given a specific function. This allows for massive customization and redeployment against any problem.
- Tool Summary Feature: This feature allows a lightweight model to summarize the exact tool calls an agent makes, demystifying complex agentic actions. Users can configure the summary frequency (e.g., 'every three tool calls') and visible lines for better observability.
- Enhanced Sub-Agent Delegation: The factory supports granular sub-agents, allowing for specialized, constrained tasks. These sub-agents can be given dedicated model tiers, system prompts, tools, and specific budgets (time and spend budgets), enabling parallel processing of tasks (e.g., summarizing TSF server, client, and skill).
- Agentic Access Parody: This key feature allows the agent to perform equivalent commands to every button click or setting change a human could make within the system's UI. This enables the agent to operate at 'agentic speed' and dynamically adjust the software environment.

## Practical implications

- Implement a structured, modular approach to agent development, moving beyond single-prompt solutions to build systems that build systems.
- Utilize the TSF's empty factory template to create reusable, customizable tooling that can be adapted to solve recurring problems (brownfield/greenfield codebases).
- Focus on observability by implementing features like Tool Summary to manage the complexity of advanced agentic workflows.

## Topics

Agentic Engineering, Software Architecture, AI Agents, Build Systems, DevOps, Liquid Software, Agentic Engineer

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