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

Summary of business-specific content (Software Factory / Factory.com)

What a “software factory” is (definition + scope)

• A full software development cycle with autonomy, not just code generation.
• Includes an ongoing loop of:
  • collecting signals (user feedback, logs)
  • prioritizing what matters
  • orchestrating execution + validation + production quality testing
  • iterating and continuously improving the process/knowledge
• Core emphasis: code writing is the easiest part; the hard parts are around:
  • organization
  • validation
  • context
  • reliability

Should you build it or outsource it?

• The speaker argues you can’t simply “install” a middle-of-organization consulting solution.
• To become a software factory, you must rebuild/reshape the organization from the ground up, similar to building a real team—but with many agents.

---

Key operating principles / playbook (3 must-haves)

• Agnostic
  • Independent of a specific LLM vendor/model.
  • Independent of how you currently operate.
  • Must integrate across common enterprise systems (e.g., Slack, GitHub, plus existing subscriptions/workflows).
• Autonomous
  • Agents must have trust + permissions + management.
  • Agents are expected to run for long durations (weeks or even ~a year) without human intervention.
• Continuous improvement
  • Treat the system like an organization:
    • onboarding
    • shared understanding of a codebase
    • documentation
    • process optimization over time

---

Framework/process architecture: the “factory control loop”

(Orchestrator → Executors → Validators)

Agent roles and flow

• Orchestrator
  • Defines the “completion contract” before code is written.
  • Prescribes what “done” means and distributes work.
• Executors (performers)
  • Run work as a sequence, not a parallel swarm, to keep context fresh and reduce divergence.
  • Each executor can have sub-agents for smaller tasks.
• Validators (reviewers)
  • Evaluate outcomes produced by agents who did not write the evaluated code.
  • Send feedback back toward the start of the loop.

Validation types (explicit)

• Verification validator
  • Strict code review using linters, types, tests, and codebase quality checks.
• User testing validator
  • Performs real interaction in a virtual computer/arena:
    • clicks through UI and workflows to confirm functionality
    • catches “looks-good-but-doesn’t-function” issues common in code-output-only automation

Example mission results / operational metrics mentioned

• A client mission lasted 16 hours.
• Validation can consume up to ~40% of the overall process.

---

Continuous improvement challenge: context management in enterprises

The problem

• Enterprises use hundreds of tools (examples: Figma, Notion, Gmail, Drive, Slack).
• Risks include:
  • agents selecting wrong tools due to similar names
  • context window overflow → compression → lost/incorrect information
  • choosing the wrong tool/context leading to quality failures

Concrete mechanism: deferred context

• A deferred context mechanism:
  • agents initially see a short list of tools + brief descriptions
  • full tool details are loaded only when needed
  • nothing is deleted; details are hidden until required
• Business impact:
  • substantial token savings at scale
  • stated outcome: ~50% token savings or more (speaker’s claim)

---

Cost + reliability optimization: model agnosticism via routing

Why routing matters

• A Coinbase CEO example (tweet referenced) suggests token spend can be reduced without reducing token usage/growth, via optimizations like:
  • caching
  • allowing model choice defaults
  • routing models to optimize tokens
• In Factory, “automatic model routing” chooses models dynamically.

Router framework (described as 4 parts)

1. Task assignment / permissions
   • Different roles (e.g., marketing, sales, engineering) can have different default models and permissions.
2. Classification
   • Analyze task complexity using signals such as:
     • query structure
     • codebase/task complexity
     • tools involved
3. Thresholding for “sufficient competence”
   • Determine the minimum model level likely to complete the task reliably.
4. Routing + fallback
   • Use the cheapest model predicted to succeed.
   • Switch models if completion fails (speaker notes this is rare).

Reported targets / KPIs

• Conservative benchmark: ~25% savings or more (token/cost-related).
• Additional benefits:
  • improved speed/reliability
  • open-model speed advantages
  • provider failure fallback

Caching stance (business/pricing view)

• Caching benefits aren’t inherently proprietary:
  • open models can be hosted on dedicated compute and benefit from similar caching
• Final user pricing depends on:
  • pricing strategy
  • agreements with API providers
• Framed as “platform independence” rather than pure technical novelty.

---

“Agent readiness” hygiene framework (readiness of the codebase)

• The speaker references a performance gap:
  • organizations that only “implement AI”
  • vs. those that prepare deeper
• Stanford University data is mentioned: without structured codebase preparation, training, and quality documentation, AI can degrade the code.
• Factory-developed “agent readiness” framework (hygiene checks) includes:
  • reproducible development environments
  • quality tests
  • documentation quality
  • code style
  • linters / maintainable code practices
• Outcome: customers run checks and receive recommendations to fix issues before deploying agentic work.

---

Actionable recommendations implied by the talk

• Rebuild organizational processes end-to-end (not just add an “AI code agent”).
• Implement the agent loop with strong governance:
  • define completion criteria up front
  • separate verification and user-testing validation
• Avoid “swarm chaos”:
  • prefer sequential executor execution to keep context fresh
• Address enterprise context reality:
  • deploy deferred context patterns to reduce token waste and tool confusion
• Reduce cost and increase reliability:
  • use model routing + caching strategies rather than forcing one “best” model everywhere
• Invest in codebase hygiene:
  • run “agent readiness” checks to prevent AI-driven deterioration

---

Presenter / sources mentioned

• Presenter: Tereza Tížková (Factory)
• Company/source referenced: Coinbase CEO tweet (token spend optimization example)
• Research referenced: Stanford University data
• Client examples mentioned: EY, Adobe (and other unspecified clients, including a mission lasting 16 hours)