← All speakers

Eno Reyes is the co-founder and chief technology officer of Factory, where he builds autonomous software engineering systems that carry work from planning through implementation, validation, and deployment. His central insight is that reliable autonomy depends as much on organizational context and verifiable engineering environments as on model capability.

Raised in Atlanta, Reyes graduated from Princeton University in 2021 and worked at Microsoft and Hugging Face before founding Factory with fellow Princeton alumnus Matan Grinberg in 2023. The pair connected at a San Francisco hackathon, built an early autonomous coding demonstration, and attracted backing from Sequoia Capital. They were subsequently named to the 2025 Forbes 30 Under 30 list in artificial intelligence. Reyes has described his experience with fragmented tools, technical debt, and scattered institutional knowledge as formative to his approach.

  • Factory Droids: Reyes helped build agents for code review, documentation, testing, migrations, and feature development. Their architecture combines planning, explicit decision criteria, and environmental grounding: custom interfaces translate developer tools and noisy continuous-integration results into usable feedback. His approach to agent reliability weighs finer-grained planning against error propagation, additional inference against cost, and autonomy against human oversight.
  • Agent-ready codebases: Reyes argues that organizations should prioritize deterministic validation loops over marginal differences between coding-model benchmarks. Opinionated linters, reliable tests, documented interfaces, and OpenAPI specifications make generated changes mechanically verifiable, enabling specification-driven development, parallel agents, and larger modernization projects. His account of agent readiness describes a reinforcing cycle: stronger validation improves agents, which can then improve the engineering environment.
  • Organizational context: Effective agents need access to product requirements, design documents, customer feedback, incident histories, and runbooks—not only source code. Reyes envisions systems that clarify requirements, prepare validated pull requests, support planning, and investigate incidents using tools including Notion, Confluence, Jira, and Linear.
  • Software factories: In Factory’s next-stage strategy, co-written with Grinberg, Reyes connects customer signals to implementation, review, security checks, deployment, and operational feedback. His model requires enterprise governance, model independence, and organizational control over data. He positions forward-deployed engineering as a bridge between enterprise conditions and reusable product improvements, while engineers increasingly design, supervise, and refine the systems that build software.

Read the topics behind these talks

4 conference talks

Key ideas

Scroll to read ↓

Reliable software agents need plans that stay coherent, decisions that can be evaluated, and interfaces that turn environmental feedback into useful next actions.

  • Different software tasks need different agent architectures
    0:25 ↗
  • Keep long plans coherent without preserving every mistake
    2:49 ↗
  • Choose task granularity, then replan against reality
    4:05 ↗
  • Make successful plans recognizable
    6:02 ↗
  • Sample decisions and make their criteria explicit
    7:50 ↗
  • Specialize difficult decisions and simulate candidate paths
    9:24 ↗
  • Turn repeated workflows into usable tools
    11:36 ↗
  • Process feedback before asking the agent to use it
    14:00 ↗
  • Gather enough context, then begin solving
    15:44 ↗
  • Choose where human guidance belongs
    17:06 ↗

Key ideas

Scroll to read ↓

Factory’s deployed engineers turn customer workflows into product improvements, with deterministic validation providing the foundation for increasingly autonomous software development.

  • What should an engineer embedded with a customer actually do?
    0:16 ↗
  • The modernization request Factory does not want to sell
    3:14 ↗
  • From an incoming signal to a monitored deployment
    5:06 ↗
  • A software factory is built, not bought
    6:57 ↗
  • Make deployment repeatable and the business case explicit
    8:32 ↗
  • Validation makes longer autonomous work possible
    12:05 ↗
  • Define completion before spending inference
    13:57 ↗
  • Build an exemplar that other teams can recognize
    16:16 ↗
  • Legal workflows can close the loop; terminal flicker cannot yet
    18:15 ↗
  • Builder, teacher, and systems thinker
    19:42 ↗

Key ideas

Scroll to read ↓

Reliable coding agents need more than a good model: they need an environment that makes engineering standards explicit, executable, and easy to verify.

  • What can you verify?
    0:21 ↗
  • Turn engineering standards into executable checks
    3:09 ↗
  • The gaps humans tolerate become agent constraints
    4:40 ↗
  • Specify, generate, verify, iterate
    6:05 ↗
  • Reliable single tasks come before parallel agents
    7:35 ↗
  • Make implicit engineering knowledge available
    8:53 ↗
  • Use agents to strengthen their own working environment
    11:14 ↗
  • From available checks to approved production changes
    12:53 ↗

Key ideas

Scroll to read ↓

Delegating production work takes more than a coding agent: it requires shared context, collaborative planning, reliable validation, and clear responsibility for what agents do.

  • What changes when agents do the work?
    0:15 ↗
  • Production software still needs engineering judgment
    2:51 ↗
  • From a delegated task to a pull request
    3:43 ↗
  • Failure often begins with missing context
    4:51 ↗
  • Research what to build before asking for code
    6:30 ↗
  • Build the PRD from evidence and constraints
    8:19 ↗
  • Turn the plan into coordinated work
    9:26 ↗
  • Connect incident evidence before proposing a mitigation
    10:49 ↗
  • Make incident response a learning cycle
    12:32 ↗
  • The work moves outward, and responsibility remains
    13:51 ↗

References