AI Engineer · Published 2026-09-27

What It Actually Takes to Build a Software Factory — Tereza Tížková, Factory

Open on YouTube ↗

Summary

Overview

  • Speaker: Tereza Tížková
  • Channel: AI Engineer
  • Main topic: Building and operating autonomous software factories with AI agents
  • Purpose: To educate AI engineers on what it truly takes to build and operate a software factory, moving beyond simple code generation agents to autonomous, verifiable, and scalable development systems. Tereza Tížková from Factory discusses the concept, reality, and requirements of building a software factory—defined as the entire software development life cycle running autonomously. She outlines three core pillars: being model-agnostic, autonomous, and always improving, highlighting key challenges like routing, token optimization, context bloat, and validation.

Topic Map

Introduction to the Software Factory

  • Explanation: Defining what a software factory is and why the paradigm is shifting from autocomplete and code generation to full-cycle software development autonomy.
  • Key claims:
    • Software factory is the whole cycle of developing software that runs autonomously.
    • It includes signals, triage, planning, execution, validation, testing, and iteration.
    • Software factory wasn't possible two years ago due to LLM limitations, context lengths, and reasoning quality.
  • Examples:
    • Factory.com software factory dashboard tracking metrics.
  • Terminology:
    • Software Factory
    • Autonomous Lifecycle
  • Why it matters: Sets the baseline definition for autonomous software engineering organizations.

Pillar 1: Agnostic

  • Explanation: Being agnostic across interfaces and models, supporting multi-environment workflows and custom subscriptions.
  • Key claims:
    • Software factories must work across interfaces like Slack, CLI, desktop, and phone.
    • Portability beats lock-in by allowing bring-your-own-key, models, and machine routing.
    • Token optimization and routing win over just cost savings.
  • Examples:
    • Coinbase AI spend chart showing flat token spending via caching and model routing.
  • Terminology:
    • Model Agnostic
    • Automatic Model Routing
    • Token Optimization
    • Caching
  • Why it matters: Ensures organizations are not locked into single-vendor AI ecosystems and can optimize cost and speed.

Pillar 2: Autonomous

  • Explanation: Achieving long-running agent autonomy with proper permissions, governance, and reliable orchestration.
  • Key claims:
    • Autonomy requires earning trust through organizational and technical guardrails.
    • Agents need to run in the loop over long horizons without human intervention.
    • Loops in software engineering have leveled up from basic prompts to agentic missions.
  • Examples:
    • Factory Missions running 3D printing tasks and code refactoring over 16+ hours.
  • Terminology:
    • Autonomy
    • Orchestrator Agent
    • Worker Agents
    • Validator Agents
    • Validation Contract
    • Factory Missions
  • Why it matters: Enables scaling software development without requiring constant human intervention.

Pillar 3: Always Improving

  • Explanation: Continuous learning, context management, and agent readiness to prevent code degradation.
  • Key claims:
    • Without structure and good codebase hygiene, AI makes code worse.
    • Context bloat is the elephant in the room when agents use hundreds of tools.
    • Progressive disclosure defers tool context until needed, saving up to 50%+ on tokens.
  • Examples:
    • Deferred context engine charts showing token savings via tool pruning.
  • Terminology:
    • Context Bloat
    • Progressive Disclosure
    • Deferred Context Engine
    • Agent Readiness
  • Why it matters: Prevents technical debt accumulation and ensures codebase quality improves over time with AI.

Key Points

Software factory is not just writing code

  • Explanation: Generating code is only a small fraction of engineering time; triage, planning, validation, testing, and iteration comprise the rest.
  • Evidence: Eighty percent of engineering time is not writing code.
  • Practical implication: Engineering teams must build end-to-end autonomous loops rather than standalone code generation chatbots.

Agile and agnostic model routing

  • Explanation: Automatic routing between models improves reliability, speed, and cost efficiency.
  • Evidence: Automatic routing can save over 25% of cost easily while providing model fallbacks.
  • Practical implication: Implement classifiers that evaluate task difficulty and route to the most cost-effective and capable model.

Validation is critical in autonomous loops

  • Explanation: Loops without robust validation lead to cheating and unverified outputs.
  • Evidence: Factory Missions spend around 40% of their time on validation using scrutiny and user-testing validators.
  • Practical implication: Separate code creation from validation by using distinct non-authoring validator agents.

Codebase structure dictates AI success

  • Explanation: Adopting AI without a structured codebase and proper documentation leads to code degradation.
  • Evidence: Unprepared repositories experience significantly higher code degradation when using AI.
  • Practical implication: Run agent readiness checks (style, tests, docs, observability) before deploying autonomous agents.

Frameworks, Models & Processes

The Three Pillars of Software Factory

  • How it works: Builds software factories by treating them like high-performing human engineering teams.
  • Components:
    • Agnostic
    • Autonomous
    • Always Improving
  • When to use: When designing enterprise AI-native software development pipelines.

Factory Missions Architecture

  • How it works: Orchestrates long-running agentic workflows through specialized agent roles working in sequence.
  • Components:
    • Validation Contract
    • Orchestrator Agent
    • Worker Agents
    • Validator Agents (Scrutiny & User-Testing)
  • When to use: For complex, multi-step software engineering tasks lasting hours or days.

Agent Readiness Framework

  • How it works: Evaluates codebase hygiene and readiness for agentic workflows across 8 dimensions.
  • Components:
    • Style & validation
    • Build system
    • Testing
    • Documentation
    • Dev environment
    • Observability
    • Security
    • Task discovery
  • When to use: Before onboarding AI agents to an existing codebase.

Examples & Case Studies

An agent built a 760mm Factory rotor logo, wall-mounted, on a Bambu X1C 3D printer.

  • Illustrates: Open-ended task execution in physical-digital workflows using CAD tools.
  • Lesson: Autonomous loops can handle non-deterministic, open-ended tasks when paired with proper validation.

Coinbase reduced its AI cost growth while scaling token usage.

  • Illustrates: Token optimization through caching, prompt engineering, and model routing.
  • Lesson: Organizations can scale AI usage without exploding costs by implementing intelligent routing and caching.

Actionable Takeaways

  • Immediate:
    • Implement model routing and fallback mechanisms to optimize cost and reliability.
    • Audit your codebase for agent readiness using structured style, test, and documentation checks.
    • Adopt progressive disclosure for tool schemas to eliminate context bloat.
  • Strategic:
    • Rebuild organizational workflows from the ground up to support autonomous software factories.
    • Shift human developer focus from writing code ('how') to defining validation contracts and intent ('what').
    • Separate generation from validation by using dedicated scrutiny and testing validator agents.
  • Questions to investigate:
    • How do we prevent agent cheating and ensure rigorous validation in long-running loops?
    • What is the optimal threshold for model routing classifiers?
    • How can enterprises maintain codebase hygiene as autonomous agent output volume scales?

Claims Worth Verifying

  • Automatic routing can save over 25% of cost easily (metric)
  • Eighty percent of engineering time is not writing code (statistic)
  • Deferred context engine saves up to 50% of tokens at scale (metric)

Notable Quotes

"The software factory is the whole cycle of developing software that runs autonomously" "Without structure and good codebase hygiene, AI makes code worse" "We move up, towards deciding what to build, instead of how"

Compressed Summary

  • Software factories automate the complete software development lifecycle.
  • Success requires three pillars: Agnostic, Autonomous, and Always Improving.
  • Model routing and prompt caching optimize token costs and reliability.
  • Validation contracts and distinct validator agents prevent agent cheating.
  • Codebase structure and agent readiness prevent AI-induced code degradation.
  • Keywords: software factory, autonomous agents, model routing, context bloat, validation contracts
  • Core insight: Building a software factory requires moving beyond code generation agents to establish agnostic, autonomous, and verifiable development loops backed by rigorous codebase readiness.

Core insights

6
Architecturehigh noveltymoderate evidence

Validation is an architectural stage, not a post-hoc check: Factory Missions dedicate roughly 40% of their runtime to validation and use validator agents that did not author the code, implying the loop is designed with a separate authoring/verification boundary rather than self-review by the producing agent.

Why it matters

It changes where responsibility for correctness lives. If validation is a distinct, budgeted stage with non-authoring validators, the harness must carry a formal contract of what 'done' means, allocate substantial runtime budget to verification, and treat validator agents as first-class components rather than prompts.

Generalization

Any autonomous loop that both produces and judges its own output will drift toward self-satisfying/cheating behavior; separating the judging role and budgeting verification time is a general reliability pattern for agentic systems.

Factory Missions spend around 40% of their time on validation using scrutiny and user-testing validators.
Open source video
Separate code creation from validation by using distinct non-authoring validator agents.
Open source video
Loops without robust validation lead to cheating and unverified outputs.
Open source video
Autonomous loops can handle non-deterministic, open-ended tasks when paired with proper validation.
Open source video
Mechanismhigh noveltymoderate evidence

Context is treated as a scarce resource with an explicit lazy-loading mechanism: a 'deferred context engine' applies progressive disclosure so tool context is only surfaced when needed, claimed to save 50%+ tokens when agents have access to hundreds of tools.

Why it matters

Tool proliferation is framed as the primary driver of context bloat, and the fix is a runtime retrieval/loading policy for tool definitions rather than a bigger context window. That makes tool metadata indexing and relevance selection part of the agent runtime, not the prompt.

Generalization

As tool count grows, static inclusion of all tool schemas scales context linearly with capability; deferring and retrieving tool context converts a fixed cost into a demand-driven one, a general pattern for tool-rich agents.

Context bloat is the elephant in the room when agents use hundreds of tools.
Open source video
Progressive disclosure defers tool context until needed, saving up to 50%+ on tokens.
Open source video
Deferred context engine charts showing token savings via tool pruning.
Open source video
Empirical Resultmedium noveltymoderate evidence

Codebase hygiene is a precondition, not a side effect: without structure and good codebase hygiene, AI makes code worse, and unprepared repositories experience significantly higher code degradation — motivating a structured 8-dimension 'agent readiness' audit (style & validation, build system, testing, documentation, dev environment, observability, security, task discovery).

Why it matters

It reframes AI adoption as gated on repo quality dimensions that are independently auditable. Engineering leaders can treat these eight dimensions as an adoption checklist with measurable pass/fail before granting agents write access.

Generalization

Agent output quality is bounded by the discoverability and machine-verifiability of the surrounding codebase; environments without machine-readable style, tests, and docs turn agent edits into unverifiable drift.

Without structure and good codebase hygiene, AI makes code worse.
Open source video
Unprepared repositories experience significantly higher code degradation when using AI.
Open source video
Run agent readiness checks (style, tests, docs, observability) before deploying autonomous agents.
Open source video
Mechanismmedium noveltymoderate evidence

A routing layer with task-difficulty classifiers sits between the agent and model providers, providing cost reduction (claimed >25%) and model fallbacks, and is presented as more valuable for reliability/speed than for cost alone.

Why it matters

It introduces a model-selection indirection point in the runtime that must be able to classify task difficulty and fail over between providers — a component that has its own evaluation surface (routing accuracy, fallback correctness) separate from the agent's task performance.

Generalization

Decoupling the agent logic from the model endpoint enables heterogeneous model use, graceful degradation on provider failure, and cost control without changing agent code.

Automatic routing can save over 25% of cost easily while providing model fallbacks.
Open source video
Implement classifiers that evaluate task difficulty and route to the most cost-effective and capable model.
Open source video
Token optimization and routing win over just cost savings.
Open source video
Portability beats lock-in by allowing bring-your-own-key, models, and machine routing.
Open source video
Architecturehigh noveltymoderate evidence

Long-horizon missions (16+ hours, including a physical 3D-printing task) are structured as orchestrator + worker + validator roles operating against a validation contract, positioning the unit of work as a mission rather than a prompt or a chat turn.

Why it matters

The 'validation contract' names the missing abstraction: an explicit, pre-declared success criterion that orchestration and validation agree on. Without it, long-running autonomy has no termination or correctness signal and must fall back on human review.

Generalization

Horizon length is bounded by the strength of the machine-checkable completion signal; extending agent runtime requires a contract that can be evaluated without the authoring agent.

Loops in software engineering have leveled up from basic prompts to agentic missions.
Open source video
Factory Missions running 3D printing tasks and code refactoring over 16+ hours.
Open source video
Agents need to run in the loop over long horizons without human intervention.
Open source video
Mental Modelmedium noveltyweak evidence

Autonomy is framed as something an organization grants incrementally through organizational and technical guardrails (permissions, governance) rather than something a model capability unlocks — trust is earned, then scope is expanded.

Why it matters

It makes permissions and governance first-class runtime concerns alongside model quality, and suggests autonomy level should be a configurable policy that ratchets as reliability evidence accumulates.

Generalization

Agent autonomy is a graded permission surface; the engineering work is in the guardrails and evidence trail that justify each expansion, not only in prompt or model improvement.

Autonomy requires earning trust through organizational and technical guardrails.
Open source video
Software factory wasn't possible two years ago due to LLM limitations, context lengths, and reasoning quality.
Open source video

Deep dives

5

Machine-checkable validation contracts for long-horizon missions

Research question

What representation makes a validation contract independently evaluable by a non-authoring validator agent before the mission starts, and does pre-declaring it reduce rework and validator-originated cheating?

Why

The validation contract is named as the interface between orchestration and verification but has no described format, authoring process, or evaluation semantics. Without a machine-checkable representation, 'done' collapses back into human review, which caps mission horizon length and negates the ~40% validation budget spent on validator agents.

Separate code creation from validation by using distinct non-authoring validator agents.
Open source video
Loops without robust validation lead to cheating and unverified outputs.
Open source video
Factory Missions spend around 40% of their time on validation using scrutiny and user-testing validators.
Open source video
Source video

Deferred tool context vs. tool-selection accuracy

Research question

Does progressive disclosure of tool schemas reduce task success or increase wrong-tool invocation rates, and at what tool count does the tradeoff flip against the 50%+ token savings?

Why

The token savings of a deferred context engine are reported without any accuracy, latency, or task-success impact. If deferral costs correctness, the mitigation becomes a new failure mode rather than a free optimization, and the tool-metadata index and retrieval policy become the real subject of tuning.

Context bloat is the elephant in the room when agents use hundreds of tools.
Open source video
Progressive disclosure defers tool context until needed, saving up to 50%+ on tokens.
Open source video
Deferred context engine charts showing token savings via tool pruning.
Open source video
Source video

Failure and recovery semantics of the model routing layer

Research question

Under injected difficulty-classification errors, what fallback and escalation policies bound the cost of misrouting a hard task to a weak model, and how much of the claimed >25% savings survives routing mistakes?

Why

Routing introduces a classifier whose accuracy is asserted but unmeasured. A misclassification either wastes budget on over-provisioned models or silently degrades task quality, so routing needs its own evaluation surface separate from the agent's task performance — otherwise cost savings are booked against unobserved quality loss.

Automatic routing can save over 25% of cost easily while providing model fallbacks.
Open source video
Implement classifiers that evaluate task difficulty and route to the most cost-effective and capable model.
Open source video
Token optimization and routing win over just cost savings.
Open source video
Source video

Task-conditioned validation budgets

Research question

Does the validation share of mission runtime vary systematically by task class and risk, and does a task-conditioned validation budget outperform a fixed ~40% allocation on escaped-defect rate per unit time?

Why

A single aggregate 40% figure across 3D printing and refactoring hides whether validation cost is a stable property of autonomy or a domain-specific artifact. If it varies, a fixed allocation is either over-spending on low-risk tasks or under-verifying high-risk ones, which directly governs throughput policy.

Factory Missions spend around 40% of their time on validation using scrutiny and user-testing validators.
Open source video
Factory Missions running 3D printing tasks and code refactoring over 16+ hours.
Open source video
Source video

Which agent-readiness dimensions actually predict code degradation

Research question

After instrumenting repositories with per-dimension readiness scores, which of the eight dimensions correlate with measured code-quality drift following agent contributions, and with what weights?

Why

The readiness framework lists dimensions and asserts that unprepared repositories degrade faster, but without per-dimension metrics the audit functions as an unordered checklist. Identifying the load-bearing dimensions would convert a qualitative gate into a prioritized, measurable pre-adoption investment.

Without structure and good codebase hygiene, AI makes code worse.
Open source video
Unprepared repositories experience significantly higher code degradation when using AI.
Open source video
Run agent readiness checks (style, tests, docs, observability) before deploying autonomous agents.
Open source video
Source video

Article ideas

4

Validation Is a Stage, Not a Step: Budgeting Verification in Autonomous Loops

Any agentic system that authors and judges its own output will drift toward self-satisfying verification, so correctness must be purchased explicitly — as a separate stage staffed by non-authoring validators and governed by a pre-declared contract — and the resulting ~40% runtime tax is the actual price of long-horizon autonomy, not overhead to be optimized away.

Angle

Reframe validation from a quality gate applied after generation into a budgeted architectural stage with its own costing model, failure modes, and org implications for throughput planning.

Source video

Your Repository Is the Prompt: Agent Readiness as a Precondition for Autonomy

Agent output quality is bounded by the machine-readability of the surrounding codebase, so granting agents write access before style, tests, docs, and observability are machine-discoverable does not accelerate development — it manufactures unverifiable drift, making the readiness audit an adoption prerequisite rather than a refactoring afterthought.

Angle

Argue that codebase hygiene is an audit gate with pass/fail dimensions that must be cleared before autonomy is granted, inverting the common sequence of adopting AI tooling first and cleaning up later.

Source video

Context Is a Budget, Not a Window: Why Tool Proliferation Broke Static Prompting

Treating all tool schemas as fixed prompt cost makes context scale linearly with capability, so tool metadata indexing and demand-driven retrieval must move into the agent runtime — but deferral trades token savings for a new class of surfacing failures that the 50%+ savings figures do not account for.

Angle

Frame context bloat as a runtime resource-management problem with a named mitigation and a named new failure mode, rather than a window-size problem to be solved by larger models.

Source video

Autonomy Is Earned in Permissions, Not Unlocked by Models

Autonomy scope is a graded permission surface ratcheted by accumulated reliability evidence, not a capability that arrives with a better model — which means the engineering artifact worth building is the guardrail-and-evidence trail that justifies each scope expansion, and the primary failure mode is granting scope faster than trust is established.

Angle

Argue against capability-determinism in agent adoption and for treating permissions and governance as first-class runtime concerns alongside model selection.

Source video

Project ideas

4

Contract-First Mission Harness

beyond-evals

Missions whose success criteria are expressed as a pre-declared, machine-checkable contract before authoring begins will show lower validator-agent cheating rates and lower rework-per-mission than missions where completion is judged post-hoc by the validator.

Proof of concept

A spec format covering preconditions, required tests, and acceptance checks; an orchestrator that refuses to start authoring without a valid contract; and a non-authoring validator that evaluates only against the contract — run on a fixed repository refactoring and artifact-generation task set.

Measurement

Cheating/self-satisfaction rate (validator passing outputs that fail an independent held-out check), rework cycles per mission, and validation-to-execution time ratio, contract-first vs. post-hoc, across matched task classes.

Source video

Routing Fault-Injection Rig

gatehouse

Injected task-difficulty misclassifications will reduce realized cost savings below 25% and degrade task success non-uniformly, and a fallback policy triggered by runtime difficulty signals will recover most of the loss at a bounded extra-cost threshold.

Proof of concept

A routing layer with a difficulty classifier, provider fallbacks, and caching, plus a fault injector that deliberately routes hard tasks to weak models and easy tasks to expensive models; compare fixed-policy vs. signal-triggered escalation policies.

Measurement

Routing accuracy, realized cost vs. baseline single-model binding, task success rate under injected error, recovery cost per misroute, and the error rate at which the savings claim no longer holds.

Source video

Deferred Context Engine A/B Bench

new

Progressive disclosure of tool context preserves task success at tool counts up to a threshold, beyond which wrong-tool and missing-context invocation rates rise enough to erase the token savings' practical value.

Proof of concept

Two matched agents over the same task suite with an identical tool catalog of hundreds of tools: one with all schemas statically injected, one using a tool-metadata index with demand-driven retrieval; instrument every invocation for which tools were surfaced and when.

Measurement

Token cost per task, task success rate, wrong-tool invocation rate, late-surfacing failures (correct tool needed but never retrieved), and the tool-count crossover point where success diverges.

Source video

Agent Readiness Scorecard

movement-lab

Per-dimension readiness scores (style & validation, build, testing, documentation, dev environment, observability, security, task discovery) will predict subsequent code-quality drift after agent contributions, and a small subset of dimensions will carry most of the predictive weight.

Proof of concept

An instrument that computes each of the eight dimension scores from repository artifacts, paired with a drift measure (lint/type/coverage deltas, review rework, revert rate) recorded on every agent-authored change across a set of onboarded repositories.

Measurement

Correlation and relative weight of each dimension against measured degradation per repository, plus whether a composite readiness threshold separates net-improving from net-degrading repositories.

Source video

Architectural implications

4

Factory Missions split work across orchestrator, worker, and validator agents with a validation contract, rather than one agent producing and self-reviewing.

Before

A single code-generation agent whose output is reviewed by a human or by the same agent.

After

Role-separated pipeline: orchestrator plans, workers author, non-authoring validators check against a pre-declared contract.

Consequence

Validation becomes a budgeted runtime stage (~40% of mission time) and correctness becomes a distinct component with its own evaluation, not a property of the generator.

Source video

Progressive disclosure via a deferred context engine replaces loading all tool definitions up front.

Before

All tool schemas and context injected into the prompt regardless of task.

After

Tool context is retrieved/deferred on demand from a tool index, pruning unused tools.

Consequence

Context becomes a managed runtime resource; the system now needs tool metadata, relevance selection, and a policy for when to surface a tool — and a new failure mode of surfacing the wrong or too-late context.

Source video

Model routing and fallbacks sit between agent logic and model providers.

Before

Agent bound directly to one model/vendor.

After

Routing classifier dispatches tasks to cost/capability-appropriate models with fallbacks and caching.

Consequence

Model choice becomes a policy layer that must itself be evaluated (routing accuracy, failover behavior), and cost/latency/reliability can be tuned without changing agent code.

Source video

Agent readiness is an audit gate across eight dimensions before agents are granted repository access.

Before

AI tooling adopted into any repository regardless of hygiene.

After

Repos are scored on style/validation, build, testing, docs, dev environment, observability, security, and task discovery before autonomous onboarding.

Consequence

Codebase hygiene becomes an explicit, measurable infrastructure investment and a prerequisite to autonomy rather than a refactoring afterthought.

Source video

Tradeoffs and failure modes

4

Validation budget vs. throughput

Benefit

Non-authoring validators catch cheating and unverified outputs, enabling genuine long-horizon autonomy.

Cost or risk

Roughly 40% of mission runtime is spent on validation, materially reducing effective throughput per mission.

Factory Missions spend around 40% of their time on validation using scrutiny and user-testing validators.
Open source video
Source video

Progressive disclosure vs. context sufficiency

Benefit

Deferring tool context until needed saves up to 50%+ tokens when agents have hundreds of tools.

Cost or risk

Deferring context introduces a risk that a required tool or fact is not surfaced at the moment of need; the summary does not describe how that risk is mitigated.

Progressive disclosure defers tool context until needed, saving up to 50%+ on tokens.
Open source video
Source video

Model routing vs. routing correctness

Benefit

Over 25% cost savings plus fallbacks for reliability and speed.

Cost or risk

Introduces a classifier whose misclassification can send hard tasks to weak models or waste budget; routing accuracy is an unverified assumption.

Automatic routing can save over 25% of cost easily while providing model fallbacks.
Open source video
Source video

Autonomy vs. guardrails

Benefit

Long-running agents can operate without constant human intervention, scaling development.

Cost or risk

Autonomy must be earned via organizational and technical guardrails; granting scope faster than trust is established is the implied failure mode.

Autonomy requires earning trust through organizational and technical guardrails.
Open source video
Source video

Open questions

5

How is a 'validation contract' actually expressed and made machine-checkable before a mission starts?

Why unresolved

The summary names the validation contract as a component but gives no representation, format, or authoring process.

Research direction

Prototype a contract specification (preconditions, required tests, acceptance checks) and measure whether pre-declared contracts reduce validator-agent cheating and mission rework.

Source video

Does deferring tool context cause tool-selection failures, and how often?

Why unresolved

The 50%+ token savings are reported but no accuracy or task-success impact of progressive disclosure is given.

Research direction

A/B benchmark a tool-rich agent with full schemas vs. deferred retrieval, measuring token cost alongside task success and wrong-tool invocation rates.

Source video

Which of the eight agent-readiness dimensions actually predict code degradation, and how are they measured?

Why unresolved

The framework lists dimensions and claims unprepared repos degrade faster, but no per-dimension weighting or metric definition is provided.

Research direction

Instrument repositories with per-dimension scores and correlate each against measured code-quality drift after agent contributions.

Source video

Is the ~40% validation share stable across task types, or does it vary by domain and risk?

Why unresolved

Only a single aggregate figure is reported across the described missions (e.g., 3D printing, refactoring).

Research direction

Log validation-to-execution time ratios per task class to derive a task-conditioned validation budget policy.

Source video

How does the routing layer recover from misrouting, and what escalation path returns work to a stronger model?

Why unresolved

Fallbacks are mentioned but the trigger conditions and escalation logic are not described.

Research direction

Build a routing harness that injects difficulty-classification errors and measures recovery cost and success rate under fallback policies.

Source video

Key claims

7
factualVerification needed

Eighty percent of engineering time is spent on activities other than writing code, so code generation alone does not constitute a software factory.

Evidence

Eighty percent of engineering time is not writing code.

Question

What is the empirical source and population for the 80% figure, and does it hold across team types?

Source video
comparativeVerification needed

Progressive disclosure of tool context saves up to 50%+ tokens when agents use hundreds of tools.

Evidence

Progressive disclosure defers tool context until needed, saving up to 50%+ on tokens.

Question

What is the baseline context configuration and task mix behind the 50%+ savings figure, and does task success hold constant?

Source video
comparativeVerification needed

Automatic model routing can save over 25% of cost while providing model fallbacks.

Evidence

Automatic routing can save over 25% of cost easily while providing model fallbacks.

Question

Over what workload and baseline is the 25% savings measured, and what is the effect on task quality?

Source video
causalVerification needed

Unprepared repositories experience significantly higher code degradation when AI is used.

Evidence

Unprepared repositories experience significantly higher code degradation when using AI.

Question

How is code degradation quantified, and is the effect from AI use, repository maturity, or a confounder?

Source video
factualVerification needed

Factory Missions allocate roughly 40% of their runtime to validation using non-authoring validators.

Evidence

Factory Missions spend around 40% of their time on validation using scrutiny and user-testing validators.

Question

Is the 40% figure consistent across mission types and does higher validation share correlate with fewer escaped defects?

Source video
factualVerification needed

Autonomous loops can handle non-deterministic, open-ended physical tasks such as a 3D-printed wall-mounted rotor logo when paired with proper validation.

Evidence

Autonomous loops can handle non-deterministic, open-ended tasks when paired with proper validation.

Question

How much human intervention occurred during the 16+ hour mission, and how many attempts were needed?

Source video
causalVerification needed

Software factories were not feasible two years ago due to LLM limitations in context length and reasoning quality.

Evidence

Software factory wasn't possible two years ago due to LLM limitations, context lengths, and reasoning quality.

Question

Which specific capability thresholds (context length, reasoning benchmarks) were the binding constraint?

Source video

Connections

5