Flywheel

1. Preface: The Airplane Analogy

Building “faster horses” (focusing purely on execution velocity) misses the point of technological shifts. Airplanes don’t just go faster than horses; they change what’s possible—e.g., attending a meeting in Europe and being home the same day.

Likewise, agentic systems don’t just speed up coding or data analysis; they reconfigure the feasible set of how organizations plan, learn, and execute. When the cost of execution approaches zero, the bottlenecks shift entirely.

2. Introduction: The Execution Bottleneck Dissolves

AI systems are now capable of performing meaningful, executable tasks for economically valuable work. While base models can handle 15-minute tasks, multi-agent systems scale this capability by decomposing complex problems (divide and conquer) and executing the resulting "leaf nodes."

This introduces a critical metric: the $A/H$ ratio (Agent-to-Human capacity).

When $A/H > 1$, organizational output capacity scales faster than human attention can manage it. When $A/H > 10$, the dynamics change radically. The traditional bottleneck (task execution) dissolves. The new bottlenecks become:

1. Context: Reliably understanding the environment, the codebase, and the problem space.

1. Alignment: Clearly defining the desired outcome (Reward Functions).

Organizations must redesign their architecture and culture around these new constraints.

3. The Foundations of Scalable Agentic Systems

3.1. Systems of Context

Mission: Deliver the right slice of context to the right actor (human or agent) at the right time, within attention/token budgets.

A. Hierarchical Decomposition: Breaking Problems into Leaf Nodes

Scalability requires more than just executing tasks; it requires creating them from abstract goals.

• Planners and Graphs: "Planner" agents must recursively decompose goals into a dependency graph (often a Directed Acyclic Graph, or DAG) of executable leaf nodes.

• Parallelization and State Management: The goal of decomposition is to maximize parallel execution while managing state, understanding execution order, and handling failures (retries and compensation logic).

B. Context Boundaries and Contracts

Naive Retrieval Augmented Generation (RAG) fails when the corpus is large or complex. Context is not flat.

• Structured Retrieval: Systems must shift from generic dense retrieval to hierarchical or graph-aware indexing that understands domain boundaries and relationships.

• Contracts and Ontologies (The "APIs" of Context): Boundaries must be explicit to manage complexity. A "contract" (e.g., standardized folder structure, API schema, domain ontology) defines how different areas (code modules, teams) communicate. This allows agents to navigate reliably without needing the full context of the adjacent domain, encapsulating complexity and preventing regressions from silent changes.

• The Indexer Agent: Specialized agents are required to continuously organize, summarize, map dependencies, and create pathways through the knowledge base.

3.2. Systems of Learning

$\mathrm{Rewards} > \mathrm{Backlogs}$

When execution is cheap, managing inputs (endless backlogs) is inefficient. Organizations must shift to managing outputs via reward functions and counter-metrics.

B. The Alignment Challenge and Goodhart’s Law

Designing rewards that agents cannot game is the core alignment challenge. When a measure becomes a target, it ceases to be a good measure (Goodhart's Law). Robust counter-metrics (guardrails) are non-negotiable to prevent perverse incentives and gaming.

C. The Human Role: Explanation and Constraint

Agents optimize rewards; humans design the optimization space. The human role shifts to explaining/justifying the goals (the "why") and constraining behavior (defining safety, ethics, and strategic trade-offs).

4. The New Value Landscape (Organizational Impact)

4.1. The Shift from OPEX to R&D

• Before: High manual OPEX dedicated to repetitive execution.

• Now: Agents cover repeatable OPEX. Human value and organizational returns concentrate in R&D focused on improving the system itself:

• Developing better retrievers (graph-aware).

• Defining clearer contracts/ontologies.

• Designing and validating well-shaped reward functions.

• Promoting stabilized LLM prototypes → deterministic automations.

4.2. Force Multipliers and the A/H Ratio

Force multipliers grow in value with a larger “army.” The quality of the infrastructure determines organizational velocity.

• With $A/H = 1$, individual productivity still matters significantly.

• With $A/H = 10$, architecture, context indexing, and testing frameworks matter more than individual output.

• With $A/H = 100$, the quality of the infrastructure is decisive.

Investment Strategy: As the $A/H$ ratio rises, organizational investment must shift proportionally toward R&D on multipliers (retrievers, contracts, testing infrastructure, and reward validation).

4.3. Cultural Shifts: Inverted Happiness and the Frontier

Organizations should celebrate the moment AI “does everything” for a specific slice of work. This frees human capital to operate at the frontier—the edge of what isn’t automated yet. Value shifts from "busyness" to leverage, system design, reframing problems, and inventing new tools.

5. The Architecture (Building Blocks)

5.1. The Agent Platform (An Elastic Workforce)

• Interface (Events + RPC): TaskRequested → ContextBuilt → ActionProposed → ActionApplied → ObservationRecorded.

• Models: Multi-LLM routing by cost/latency/quality trade-offs.

• Tools and Execution Security: Ephemeral, sandboxed “computers” (secure execution environments) are essential. Tools include FS/CLI, HTTP, read-only DB access, codegen, linters, test runners.

• Agent Templates: Specialized roles: Planner, Implementer, Reviewer, Indexer, Doc-Scaffolder.

• Engine & Infra: Queues, idempotency guarantees, retries with jitter, compensation logic, policy enforcement, audit trails, cost/latency budgets.

5.2. Workflows and the Deterministic Promotion Path

• Builder: Declarative steps (YAML/JSON) bound to Python (for deterministic parts) + LLM steps gated by checklists.

• The Promotion Rule: Whenever an LLM-driven pattern stabilizes, it must be promoted to deterministic code. This is crucial for cost control, predictability, reliability, and auditability. It is how the system "learns" and hardens over time.

5.3. Monitoring, Signals, and Rewards

• Internal Metrics: Latency, errors, retries, token/\$ cost, context-fit score, contract compliance.

• External Metrics: Activation, conversion, TTR, NPS/CSAT, revenue.

• The Join: Internal + external metrics must be joined to compute actual reward impact (did the work matter?).

6. The Goal: Self-Improving Systems (The Meta-Loop)

The culmination of these foundations is a system that improves itself. This occurs when the Systems of Context and Systems of Learning are linked in a meta-loop:

1. Agents execute tasks to optimize rewards.

1. Insights from this optimization are analyzed (by humans and meta-agents).

1. These insights are used to refine context boundaries, improve tools, and adjust reward functions.

The proportion of time invested in working on the system drastically increases relative to time spent working in the system.

7. Conclusion and Testable Predictions

When brute execution becomes cheap (high $A/H$), improving the system beats tightening your own screws. Context is the feedstock; rewards close the learning loop; force multipliers scale with the size of your “army.” The airplane metaphor holds: it’s not just getting there faster—it’s making new routes possible.

7.1. Testable Predictions

1. Teams that optimize rewards (not task volume) will run 2–5× faster learning cycles.

1. Manual OPEX will fall below 40% in teams with $A/H > 3$.

1. Adopting the folder contract + hierarchical retrieval halves onboarding time ($>50\%$ reduction).

1. Most severe regressions will stem from silent contract changes; linters + versioned interfaces will cut incidents by 10×.