# reyes-factory-building-machine-software-2026-09-22

## Veille

Talk by **Eno Reyes** (co-founder and CTO of **Factory**, whose "droids" agents are described in the introduction as used by hundreds of thousands of developers and companies such as **Nvidia** and **MongoDB**, right after a **$150 million Series C**), published on **September 22, 2026** on the **FirstMark Capital** channel (25 min 51 s video, transcript of about 5,300 words). He presents the "software factory" as an agent-driven feedback loop, and the role of humans as stewards of this factory.

## Titre Article

Building the Machine That Builds the Software | Eno Reyes, Co-Founder & CTO of Factory

## Date

2026-09-22

## URL

https://www.youtube.com/watch?v=NLsiZtleLe4

## Keywords

software factory, software factory, Factory, Droid, coding agents, feedback loop, SDLC, model independence, routeur de modèles, sovereignty, air gap, traces, governance, agent identity, audit, harness, agent readiness, deterministic validation, guardrails, Google metric, inference allocation, Missions, role of developers

## Authors

Eno Reyes — cofondateur et CTO de Factory ; conférence vidéo (FirstMark Capital).

## Ton

Profile: a technical executive talk from a coding-agent vendor, addressed to engineering leaders and CIOs at large enterprises, in a spoken, demonstrative register. It opens with a retrospective (2023: autocompletion "from lines to paragraphs, files, repositories"), then works through the questions organizations are asking (token costs, ROI, dependence on a single model, the role of developers) before proposing his framework. Positions are stated as principles ("you should…") and illustrated with Factory's internal practices. The speaker presents certain choices as his own opinions ("our take would be"), notably on agent identity, and acknowledges trade-offs: full sovereignty requires a lot of effort and is not suited to every organization.

## Pense-betes

- **From coding to the loop**: the "coding agent" era keeps the mental model of "I press, I get the code." Reyes notes that developers spend most of their time outside the code: review (in the broad sense, not just the pull request), manual testing and QA, debugging, planning.
- **Signal loop**: signals (customers, bugs, telemetry, competitors) → triage by humans (PM, EM) → plan → code → validation (test, QA, security) → deployment → monitoring → new signals. The question is not feasibility but **measurement, analytics, and governance**: *"the problem is not technical. The problem is organizational"*.
- **Principle 1, model-agnostic**: a CIO should not have to bet on a single model; dependence exposes you to the vendor's pricing. Factory describes a router that allocates the model by task and by role (e.g., product managers and developers don't access the same range), to arbitrate cost and quality centrally.
- **Principle 2, sovereignty**: choice of deployment, from SaaS to air gap ("on a submarine"). The most valuable data is the **traces**: to correct a bad prioritization decision, you need to know why the factory made it. Reyes qualifies this: it is flexibility to have available, not necessarily to exercise.
- **Principle 3, the entire SDLC, one single agent**: code review, continuous security, black-box QA (web, CLI, API), synchronized documentation, incident response, progressive deployment. A single agent avoids multiplying routers, cost policies, and trace exports. Building a CLI agent in-house is considered feasible; multi-surface (SDK, sandboxes) much less so.
- **Governance**: hierarchical agent identity (organization, team, project, user, machine); the user's identity is inherited for synchronous activity, a service account for sandboxed code review. Controls: allow lists, risk classification, spending caps, and audit capable of tracing, in **a single query**, from table access back to the person, the prompt, and the reasoning traces. Indexing code in a third-party cloud is considered non-essential.
- **Bottleneck shifted**: *"it hasn't been the LLM for a little bit"*; the harness is becoming good, the new constraint is the organization (tools accessible to agents, deterministic validation: lint, tests, typing, file conventions enforced at commit).
- **Humans and the metric**: humans shift from building the software to building the factory, in regular code rather than natural-language specifications. Every company must find its "Google metric" to make token allocation steerable by ROI (example: Missions, a 50 ms latency target with 2 billion tokens allocated).
- ⚠️ **Scope**: talk given by a vendor describing its own products; no measured customer data is provided, and the Q&A session did not take place due to time constraints. The figures cited (150+ signals, 140 people in San Francisco, Series C) are self-reported.

## RésuméDe400mots

Eno Reyes, co-founder and CTO of Factory, presents how to build a "software factory" — an organization where agents take on the full software development loop. He starts from a retrospective: in 2023, code AI was expected to progress from line autocompletion to file autocompletion, then to repositories. Coding agents arrived, but most usage remains "I ask, I get." According to him, this era is running out of steam: organizations are now asking questions about cost overruns, return on investment, dependence on a single model, and the role of developers, who spend little time on coding alone.

He describes development as a feedback loop. Signals coming from customers, bugs, telemetry, or competitors are triaged, then turned into a plan, code, validation, and deployment, which in turn produces new signals. Each step can be handed to agents. For Reyes, the real difficulties are measurement, analytics, and governance: the problem is organizational rather than technical.

Three principles structure his framework. First, model independence: an IT leader should not have to tie themselves to a single vendor, nor be subject to its pricing. A routeur de modèles allocates compute by task and by role. Second, sovereignty: choosing one's deployment, from SaaS to air gap, and retaining control of traces, since correcting a bad decision made by the factory requires understanding why it was made. Third, coverage of the entire lifecycle, with the same agent across all surfaces, to avoid scattering policies, routers, and trace exports.

Governance remains difficult: agent identity (inherited from the user for interactive activity, service account for sandboxed review), model controls, allow lists, risk classification, spending caps, and audit capable of tracing, in a single query, from table access back to the person, the prompt, and the traces. He considers indexing code in a cloud unnecessary.

The bottleneck, he says, is no longer the model, nor now the harness, but the organization's preparation: tools usable by agents and deterministic validation (lint, tests, typing, conventions). Factory offers an *agent readiness* product measuring more than 150 signals.

Humans become the stewards of the factory: they watch for drift, correct the system, and durably prevent errors, in regular code rather than natural-language specifications. Reyes concludes that companies will need to find their "Google metric," a link between an engineering indicator and a business outcome, to allocate inference according to ROI, for example by giving an agent a performance target with a token budget.

## GrapheDeConnaissance

- Eno Reyes —travaille_chez→ Factory (ORGANISATION, 0.97)
- Eno Reyes —a_créé→ Factory (ORGANISATION, 0.9)
- Factory —publie→ Droid (TECHNOLOGIE, 0.95)
- Factory —publie→ Agent Readiness (TECHNOLOGIE, 0.93)
- Factory —publie→ Missions (TECHNOLOGIE, 0.9)
- Factory —mesure→ série C de 150 millions de dollars (MESURE, 0.88)
- Eno Reyes —recommande→ construire la software factory indépendante du modèle (AFFIRMATION, 0.93)
- Eno Reyes —recommande→ rester souverain sur le déploiement et les traces de la software factory (AFFIRMATION, 0.92)
- Eno Reyes —recommande→ un même agent sur toutes les surfaces du SDLC (AFFIRMATION, 0.92)
- Eno Reyes —affirme_que→ le goulot est désormais l'état de préparation de l'organisation plutôt que le modèle (AFFIRMATION, 0.9)
- Eno Reyes —affirme_que→ le problème de la software factory est organisationnel et non technique (AFFIRMATION, 0.9)
- Software factory —utilise→ boucle de rétroaction (CONCEPT, 0.92)
- Droid —utilise→ routeur de modèles (TECHNOLOGIE, 0.88)
- routeur de modèles —réduit→ dépendance à un fournisseur de modèle (CONCEPT, 0.85)
- Agent Readiness —mesure→ plus de 150 signaux de la base de code (MESURE, 0.9)
- validation déterministe —améliore→ fiabilité des agents (CONCEPT, 0.88)
- Eno Reyes —prédit→ les meilleures entreprises seront celles qui trouvent leur Google metric (AFFIRMATION, 0.85)
- Google metric —permet→ allocation d'inférence guidée par le ROI (CONCEPT, 0.85)
- Missions —s_applique_à→ objectifs de performance de long terme (CONCEPT, 0.82)
- Eno Reyes —affirme_que→ les humains deviennent les stewards de l'usine logicielle (AFFIRMATION, 0.88)

---
Canonical: https://www.thekb.eu/en/fiches/reyes-factory-building-machine-software-2026-09-22/