Summary

Factory’s core bet is that enterprise software development will move from in-IDE collaboration to cloud-based delegation across the full SDLC. It targets hundreds of thousands of developers maintaining 30-plus-year-old codebases, where the prize is not working “15% or 20% faster” but handing complete tasks to parallel cloud agents. As human-authored code declines, planning and coordination will remain human-driven while code and documentation execution will probably become fully delegated “very soon”; testing and verification are expected to take more human attention.
The product’s differentiation is orchestration rather than a single coding model: specialized “droids,” enterprise-wide context, selective retrieval, and asynchronous execution. Knowledge, code, and reliability droids connect to systems including Linear, Jira, Slack, GitHub, Sentry, and PagerDuty; the agent asks clarifying questions instead of requiring prompt engineering. In the demonstration, it modified or created roughly 12 files using 43% of its context and could then be instructed to open a pull request, while exposing an “X-ray into its brain.”
Legacy modernization is the clearest enterprise ROI wedge offered in the episode. The founders cite one large public company whose migration reportedly fell from four months to roughly three and a half days, with no downtime. Their representative workflow turns codebase analysis, documentation, dependency mapping, Jira tickets, and parallel implementation into agent sessions, condensing a process bottlenecked by “bureaucracy and technical complexity and understanding.”
Usage-based pricing makes retrieval efficiency a commercial requirement, not merely a technical preference. Customers pay small fixed access and per-user fees, but most spending flows through “standard tokens”; Factory therefore retrieves only relevant code and organizational context rather than dropping an entire monorepo into a growing context window. Enterprise quality is partly tracked through code churn: mature codebases may run at 3%-4%, while poorly maintained or rapidly changing ones can reach 10%-20%.
The founders see the harness and evaluation stack as the higher-leverage layer while frontier models keep changing underneath it. They combine task-based code evals with behavioral specifications for questions, planning, and tool use, while the host cited estimates that a SWE-bench run can cost $8,000-$15,000 and Matan noted that benchmark charts can function as “big bar versus little bar” marketing. Their probably biggest model request is post-training on goal-directed trajectories lasting one to three hours, without the provider-specific CLI habits that currently make models favor Grep or Glob over better tools.
By the founders’ account, commercialization is now constrained more by adoption and top-of-funnel than by initial product pull. After spending roughly the first year and a half of a little over two years refining the enterprise interaction model, they say Fortune 500 deployments accelerated sharply over the preceding 90 days, largely through word of mouth. One January user reportedly said that even if he were the only person at his company using Factory, he would still tell the company to let him use it instead of hiring “three engineers for myself”; Factory is now hiring deeply technical customer-facing operators described internally as “a junior Eno.”

Deep dive

1. Code’s verifiability helped turn a hackathon meeting into a company in eight days

Matan recalled that he and Eno attended Princeton and shared roughly 150 friends without ever having a one-on-one conversation. At a 2023 LangChain hackathon, a chance encounter became a discussion about code generation and then “intellectual love at first sight”; they spent the following 72 hours awake and building together.
Eno arrived from Hugging Face, where customers repeatedly wanted fine-tuned models for their own codebases. He had also explored a loop that wrote and executed Python for finance: it felt “not very helpful” for that domain but “incredibly interesting” for software.
Matan had spent about 10 years pursuing string theory before shifting his Berkeley PhD work toward AI. Code “nerd sniped” him because model performance in code appeared fundamental to performance even on downstream tasks such as poetry—and, unusually, code could be executed and validated against ground truth.
The available GPT-3.5 model was clearly insufficient for autonomous engineering, but chain-of-thought, self-reflection, scaling, larger context, and improving capability-price frontiers pointed in one direction. They incorporated two days after meeting; eight days after meeting, Matan left his PhD and Eno quit his job.

2. Factory chose unglamorous enterprise code as its wedge

Factory’s scope is the full end-to-end software-development lifecycle, especially inside enterprises. The underserved opportunity is not a viral zero-to-one demo but “really ugly,” “hairy,” 30-plus-year-old codebases maintained by hundreds of thousands of developers, where an unsexy migration can create far more value.
The founders argue that the IDE embeds constraints from a tool refined over 20-plus years for humans writing every line. Latency matters inside it, while free or $20 plans constrain inference quality and volume; a cloud platform can instead optimize for delegation, which enterprises view as the “holy grail.”
Their labor boundary is explicit: the outer loop—planning, speaking with colleagues, deciding what should exist—will remain highly human-driven. The inner loop of writing code or documentation is likely to be delegated soon, which is why they object to presenting agents as replacements for whole human beings.

3. “Droids” evolved from deterministic workflows into goal-directed agents

The company was first incorporated as the San Francisco Droid Company, until counsel warned that Lucasfilm was “particularly litigious.” “Factory” emerged partly from an actor-critic equation—putting “actor” into a function produced “f-actor-y”—and partly from the software factory-method association.
“Droid” survived because “agent” originally implied an unreliable endless while loop taking actions without guidance. Early droids were closer to workflows: asynchronous, event-triggered, and guided by deterministic or semi-deterministic behavior.
As models and guardrails improved, droids became relatively unbounded in how they pursue a task. Planning, decision-making, and environmental grounding keep them loosely goal-oriented over long durations, so the founders concede that “agent” is now technically the proper description.
Three recurring jobs shape the platform: knowledge and technical writing, code, and reliability. The code droid is the daily driver; the reliability droid compiles incident evidence, produces root-cause analysis, and handles SRE-style investigation that humans otherwise face on call at 3:00 a.m.

4. Enterprise context is treated as part of the worker, not optional retrieval

Factory’s interface emphasizes an activity log and context panel while work is underway, reserving detailed code review for completion. The goal is visibility into what the droid is doing—an “X-ray into its brain”—rather than forcing the user to watch each line appear.
Factory has integrations with Linear, Jira, Slack, GitHub, Sentry, and PagerDuty, among others. Matan compared this with the broader enterprise sources a human engineer needs, including Notion and Datadog: dropping an agent into code alone resembles onboarding an engineer without Slack, tickets, documentation, or production telemetry.
Rather than demand a perfect template, the droid searched, proposed a plan, and asked targeted questions about mockups, button behavior, fields, and missing implementation. Matan’s management analogy: good delegation grants autonomy where appropriate but states hard constraints before hidden assumptions produce an unsatisfactory result.
Factory proactively synthesizes “synthetic insights” about environment setup, repository structure, and module relationships. A droid.yaml can add guidance, while rules from other providers are ingested selectively because those files often contain extra instructions needed by weaker tools; Factory keeps only what it does not already know.

5. Delegation requires a different interface—and makes testing more valuable

During the conversation, the droid edited or created roughly 12 files, ran code, and could then be instructed to create a GitHub pull request. A built-in browser could view HTML and SVG, and the task consumed 43% of context despite operating on Factory’s large monorepo.
The key demonstration was temporal: the founders held a podcast conversation while the agent worked. Their intended workflow is to launch another task, then another, rather than browse a phone while waiting; cloud-native parallelism lets a developer begin the day by setting multiple pieces of work in motion.
Matan compared evolving the IDE into this interface with turning a horse into a car through incremental modification. If humans write a steadily smaller percentage of code, the optimal interface is unlikely to descend directly from the tool optimized for writing 100% of it.
Human time should therefore shift toward understanding, planning, and testing. The founders expect agents finally to deliver test-driven development’s promise: a droid is not finished until it passes tests the human trusts. The hosts’ useful caveat was that changed functionality sometimes requires changing tests too; the founders conceded that difficult verification problems remain.

6. Model upgrades create behavioral shocks that Factory must absorb

Moving from Sonnet 3.5 to 3.7 caused enterprise users to notice that familiar prompts suddenly produced more or less of particular behaviors; Gemini may be selected for longer context. Factory is deciding when to act as a “shock absorber” and when a genuinely different reasoning model requires teaching users a new interaction pattern.
Its evaluation stack combines task-based benchmarks—built partly on Aider-style code-editing and file-generation work—with a behavioral specification. High-level principles become tasks, rubrics, and graders covering such distinctions as asking questions under ambiguity while following detailed instructions without unnecessary interruption.
The host cited estimates of $8,000-$15,000 for a SWE-bench run, yet Matan said “big bar versus little bar” genuinely wins customers. Matan also agreed that Factory does not prioritize competing there because enterprise work differs, while daily internal sentiment often reveals behavioral changes faster.
Heavy post-training now gives models provider-specific tool preferences: Sonnet 3.7 “smells like” Claude Code, while Codex shows similar CLI-oriented fingerprints. A model may insist on Grep or Glob over a superior search tool. Factory currently considers external scaffolding higher leverage than freezing a model through fine-tuning, but is building benchmarks compatible with possible future post-training and wants one-to-three-hour goal-directed trajectories.

7. Token pricing aligns Factory with useful output—but metrics remain slippery

Factory charges small fixed amounts for team access and additional users, then bills usage directly in “standard tokens,” benchmarked against standard models. The founders reject opaque credits: users who understand tokens can judge efficiency, while Factory has tried to reduce the inference required for each outcome.
Reporting extends past accepted completions or successful chat sessions to pull requests, merged code, and deliverables. Even billion-token context would not eliminate retrieval’s role: dumping everything into the prompt stays expensive, while precise selection from a large monorepo lowers cost without relying on “throw the whole repo in and pray.”
The founders use a roughly three-week window as an example for code churn: if a merged line is changed within a shorter period, it may count as churn rather than longer-term refactoring. Mature large codebases may sit near 3%-4%; poorly maintained or rapidly changing ones can reach 10%-20%, and 10% at a company such as Atlassian would represent substantial waste. Still, the founders found that satisfied buyers rarely needed elaborate ROI dashboards: developer sentiment and unmistakably accelerated deliverables mattered more.

8. Legacy migrations compress when bureaucracy becomes machine-executable

The strongest reported result was a large public company’s migration dropping from four months to around three and a half days, with no downtime. For the founders, that timeline is more persuasive to a VP of engineering than commits, lines of code, or a constructed productivity score.
Their concrete model was a national hospital system running a 20-year-old Java codebase and moving to Java 21. Conventionally, four to 10 consultants and a project manager analyze dependencies, author documents, define a strategy, create epics and tickets, assign sequenced work, and absorb delays whenever one dependency slips.
In Factory, one person can request codebase analysis and module documentation, ask for a migration plan, generate Jira or Linear tickets, identify dependencies, and open parallel droid sessions. The human reviews changes and CI results, then merges, shifting the rate limiter from implementation staffing to “how fast can a human being delegate the tasks appropriately.”
Factory does use a forward-deployed approach for large customers because this behavior is unfamiliar. In one migration, its team worked beside two customer engineers until they “saw the light”; those engineers then became internal advocates, helping Factory earn trust without assuming a strong product alone will undo 20 years of developer habits.

9. Adoption, semantic observability, and technical go-to-market are the next constraints

The hosts raised a 5,000-token-per-second target discussed with Together AI. Factory’s answer was conditional: faster output would make delegation feel magical and ease adoption, but would not materially change enterprise migrations constrained by organizational work. Faster inference paired with lower cost would matter more, enabling parallel generation techniques whose current quality gain does not justify their expense.
Conventional traces are not the hardest observability problem; LangSmith was called “fantastic.” The unresolved need is semantic observability when customer code is invisible and dissatisfaction is subjective: what did the user intend, and did the result feel right? The host suggested Amplitude or Statsig as conceptually closer, while Matan said he would like to see that direction and that LLMs may be needed inside the observability layer itself.
By their account, Factory spent roughly its first year and a half refining the enterprise interaction pattern, then saw Fortune 500 deployments “exploding” over the previous 90 days through referrals and CEO conversations. Scaling that pull requires technical customer-facing hires who can address a CIO and then sit beside developers—the internal archetype is “a junior Eno.”
Design is treated as operating infrastructure, not decoration. Matan’s older brother Cal established the logo and brand, giving an engineering-heavy team a non-engineering perspective that droids can themselves consume and imitate. The closing signal of broader market expansion: some individuals who were not previously developers reportedly use Factory more than a 100-person enterprise.

Xi Jinping’s paranoid approach to AGI, debt crisis, & Politburo politics — Victor Shih After Interviewing AI Founders, Here's What You Really Need to Know | EP #175