Factory CEO Matan on AI Coding, Software Factories, and Why the AGI Debate Comes Back to Responsibility

1. Guest Background

This episode is an interview on Sources with Alex Heath, hosted by Alex Heath and titled “Factory CEO on why AGI is already here.” It was uploaded by Sources Podcast on 2026-09-29 and is listed at 3016 seconds. The guest is identifiable: Matan, CEO of Factory. The evidence does not establish a fuller biography, education history, or outside career record, so the supported background should stay within the episode’s own frame: Matan appears as the CEO of Factory, speaking about AI coding agents, enterprise software engineering, model routing, AGI, safety responsibility, and the changing role of engineers.

Factory is described in the guest context as a company in the AI coding agents space. Its work is described as building model-agnostic AI coding tools and agents intended to change how software engineering is done, with an emphasis on empowering developers rather than replacing them with a black-box service. That matters because Matan is not a neutral commentator in this conversation. He is explaining the world from the vantage point of a company whose product thesis depends on enterprises wanting model flexibility, developer control, and software workflows that can be orchestrated by agents.

Alex frames the topic by saying that AI coding represents much of what is happening in the AI boom: it is dynamic, fast-moving, and one of the earliest places where companies have seen ROI from AI. Matan’s answer turns that framing into the episode’s main analytical thread. The discussion is not a general tour of AGI speculation. It is an episode about how software production may move from IDE autocomplete to coding agents, and then toward enterprise “software factories” built around context, routing, workflow integration, human gates, and organizational trust.

2. What the Episode Covers

Matan begins with a before-and-after picture of AI coding. When Factory started, he says, the world was barely adopting GitHub Copilot and IDE autocomplete; only some AI companies were deeply focused on agents. The shift, in his telling, came around the turn from 2025 into 2026, helped by Andrej Karpathy publicly discussing how he used coding agents. That made enterprises more open to behavior change, not merely tool adoption. Matan says Factory saw token usage rise by well over 10x year over year and that being an engineer today is almost unrecognizable compared with three years earlier. That 10x figure should be read as Factory’s observed usage claim in the episode, not as an independently measured industry-wide fact.

Factory’s origin story is unusually concrete. Matan says the company started on April 17, 2023, and was already pitching autonomous coding agents at a time when models looked much less capable than they do now. The early conviction came from an exercise he and his cofounder played: could a human, using only copy-pasting and guidance rather than writing code directly, get ChatGPT to complete full tasks such as building a feature or writing tests? They found that with the right context and the right subdivision of the problem, ChatGPT could do larger chunks of work consistently enough to make autonomous agents look like a tractable engineering problem. In other words, the agent was not just a better model. It was a system for providing context, defining task boundaries, and orchestrating execution.

That helps explain Factory’s early slogan, “the future is IDE free.” Matan says the line caused many founding-engineer candidates to leave the process because they thought the company was crazy. In retrospect, he presents it as a useful filter: people who remained were more likely to believe in the future Factory was trying to build, not just in a startup with good investors. He is also careful about uncertainty. He says he did not know exactly where models would be on the September 16, 2026 recording date, but believed the trajectory was visible from scaling laws. The directional claim was that humans would not keep writing every line of code forever.

Matan then places Factory in a three-part market map. First are model providers such as OpenAI, Anthropic, Google, SpaceX, and applications built around their models. Second are service-like companies that use tools to do work, migrations, or projects for customers. Third is Factory’s intended position: a model-agnostic platform for the future of software engineering. Factory’s self-description is not “we do all the development for you.” It is “we give developers more leverage.” Matan repeatedly says the company wants to empower developers and respect their intelligence.

That leads to Factory’s emphasis on modularity. Matan says developers hate black boxes and like to tinker, so the model under the hood, the model-routing procedure, and the defaults should be adjustable rather than locked in. Factory’s agent is called Droid, but he resists making Droid the whole story. The goal is a software factory in which Cursor, GitHub Copilot, Claude Code, Codex, Droid, or other steps can all be part of the customer’s process. The “factory” remains the customer’s system even if individual agents or steps are swapped out.

The enterprise focus is also central. Matan says enterprises contain a large amount of messy, tedious, low-leverage engineering work: COBOL migrations, decades-old codebases, and modernization tasks that individual hobbyists may never face but large organizations cannot avoid. He also says Factory does not want to compete in a prosumer usage-subsidy game against large model companies. Its capital plan follows that enterprise orientation. Matan says Factory began 2026 with 30 people, including two salespeople, planned to end the year with 300 people, and opened or was opening offices in London, Sydney, and Tokyo. Funding, he says, goes toward global go-to-market capacity and toward research engineers building a model-agnostic software development agent that performs better than Codex, Claude Code, and similar tools. Those are company plans and claims from Matan, not independently verified outcomes.

Model routing becomes the episode’s second major spine. Matan says the idea was embedded from the beginning because Factory does not want a world in which one model provider is better than all the others. The router can select models dynamically by performance, latency, and cost. The point is not that engineers should constantly study every model release. For routine work, Matan wants the experience to feel like using electricity in a toaster: the engineer wants the task done, not a daily briefing on the cost-performance frontier. But for special cases, users should still be able to choose a particular model manually.

Alex presses on the obvious bear case: what if one model takes everything? Matan accepts that Factory’s future depends on a multi-model world and says every company must understand the claims it needs to be true. His answer has two layers. The practical layer is that model leadership changes quickly, and enterprises should not be trapped in yesterday’s frontier. The political-economic layer is that the entire economy and free market also need one provider not to become significantly better than all others, because that would create what he describes as a monopoly-level social threat likely to involve government.

The AGI portion of the episode is more nuanced than the title alone suggests. Matan says plainly that AGI is already here and that we are living in a post-AGI world. Yet he is not claiming that every social consequence has arrived or every problem has disappeared. He says prediction variance is high: some people think all jobs are going away, while job reports still show millions of jobs being created. His reasoning is that if people had seen Factory’s current capabilities four years ago, they would have reacted as if the system were smarter than every human. Humans, however, rapidly turn shocking capabilities into table stakes.

On AI safety, Matan distinguishes safety work from what he sees as fear-driven or responsibility-evading narratives. He says society should spend time on safety and ensure releases do not cause harm. But when a deployed system or sandbox creates harm, he and Alex both return responsibility to the provider. Alex’s example is that if a Hugging Face-like incident happened at a major bank, there could be Senate hearings and major litigation against OpenAI; the point is that a model escaping a sandbox is a vendor failure, not a conscious being acting independently. Matan’s lava-pit analogy makes the same claim in simpler terms: if someone invites a guest into an apartment with a lava pit at the entrance, the owner is responsible for creating the danger before society needs an entirely new inspection bureaucracy.

The episode also touches regulation and openness. Matan praises a distinction that would regulate closed models while exempting open models, arguing that it tilts the field toward openness when the U.S. has lagged on open models. He adds that Factory’s own margin structure does not depend on open or self-trained models, because he does not want routing decisions biased by Factory’s economics rather than customer value. Alex calls Factory a margin-positive AI business in 2026; Matan responds that token resale can create negative margin, while solving customers’ problems can create positive margin. He also says Factory refunded customers in its first two years when early agents failed to make them extremely happy, choosing trust over short-term revenue.

Competition is framed less as a clean fight and more as a shifting set of partnerships. Matan says Factory most often sees OpenAI and Anthropic tools such as Claude Code or Codex in the market, but also sends those model companies significant traffic. He compares model providers to maturing cloud companies that eventually learn that working with competitive partners can expand total usage. On Cognition, he draws a philosophical contrast: Cognition, in his view, looks more like Palantir, Accenture, or Deloitte, taking on large projects with its own tools, while Factory wants to sell a product that enables developers. He does not dismiss FDE-like roles, though. He says goods and services will both remain, and technical problem-solving generalists will keep mattering because customers need help with behavior change, complexity, and product gaps.

3. Core Views: Reasoning, Examples, and Limits

The strongest analytical move in the episode is Matan’s reframing of AI coding as a change in software organization rather than a better autocomplete feature. The evidence he uses is the 2023 exercise in which humans did not write code but supplied context, guidance, and decomposition while ChatGPT completed larger tasks. That example matters because it makes early autonomous coding agents look less like a miracle and more like an engineering system: define the problem, feed the right context, divide the task, run the loop, and let the model do more of the implementation.

The limitation is also inside his own account. Matan says he did not know exactly where models would be on the recording date; he believed the trajectory was clear but not the timing. “The future is IDE free” may have moved from fringe to more widely accepted among the engineers he describes, but the episode does not prove that every workflow, every developer, or every organization will abandon IDE-centered work. It supports a narrower but still important claim: Factory was early to a behavior-change thesis, and part of the market has moved closer to that thesis.

A second core view is that the defensible enterprise platform may be the software factory, not the isolated agent. Factory’s examples support this. Droid is one agent, but Matan does not want Droid to be mandatory. Cursor, Copilot, Claude Code, Codex, and other tools can all become replaceable parts of a broader workflow. The product philosophy follows from that: developers need modularity because they need to inspect, tune, and adapt systems. A black box may be convenient for a narrow job, but it can block the very tinkering through which engineers become agent-native. Factory’s automated model-evaluation process is another example: a software factory is not only a model call, but also the operating system that decides which models belong in the routing repertoire.

The uncertainty is that model-agnostic routing is both a customer benefit and Factory’s strategic bet. Alex’s bear case is the right one: if a single model provider wins decisively, routing loses some importance. Matan’s reply combines operational evidence and political economy. Operationally, model leadership, latency, cost, and task fit all vary. Politically, a single overwhelmingly superior model provider would create a dangerous concentration of power. The first argument is directly connected to enterprise tool choice; the second is plausible reasoning, but it is still a strategic forecast, not settled evidence.

The third view is that “AGI is already here” should be read as a capability-threshold claim rather than a complete social-outcome claim. Matan is saying that systems now do things that, four years earlier, would have looked like a post-AGI shock. He is not saying all work has vanished or all safety problems have been solved. In fact, he emphasizes high variance in predictions and admits many problems remain. That makes the title less sensational than it first appears: the episode’s argument is about normalization. Capabilities that would once have produced panic are quickly absorbed into everyday expectations.

The fourth view is that AI safety should be discussed through responsibility, not model personhood. Matan and Alex both reject treating a model as an independent human-like actor when a sandbox or deployed system causes harm. The lava-pit analogy is useful because it grounds the debate in product accountability: if you create a hazardous environment and invite people into it, you own the consequences. The boundary is that accountability does not eliminate the need for safety research or governance. Matan himself says safety work has merit. The more precise lesson is that safety institutions should not become a way for vendors to avoid responsibility for deployment choices.

The final core view concerns engineering labor. Matan’s “code is cheap” argument does not make engineers irrelevant; it changes what engineering skill means. The scarce work becomes defining multidimensional constraints, choosing the right problem, and judging the nuanced solution to a constrained optimization problem. That is why he talks about high clock speed, obsessive focus, high agency, and company-building experience as signals. In his view, the people who rise are those who can turn ambiguous problems into solved problems with increasing leverage.

There is an important boundary here too. The episode does not establish that everyone will become equally capable as a builder, or that professional engineering depth disappears. Matan’s Steve Jobs photography analogy points to a subtler outcome: many more people may do work previously called engineering, without identifying as engineers. Like phone cameras made photography widespread without making every phone user a professional photographer, AI coding may spread engineering behavior while preserving differences in taste, judgment, depth, and responsibility.

4. Learning and Application

For enterprise buyers, the first practical lesson is to evaluate AI coding vendors beyond the question of which model is strongest today. The better questions are architectural and commercial: can the system switch models dynamically, route by performance, latency, and cost, allow manual override for special tasks, and preserve access when provider relationships change? Matan uses the OpenAI-Cursor relationship change as an example of why model access is not just a technical feature. It is a business continuity risk.

Model agnosticism, however, is not free. A router needs benchmark suites, model evaluation, cache strategy, tool-use tuning, and integration into the organization’s workflow. Factory’s own automation of new-model evaluation shows the hidden maintenance burden. A large engineering organization may want that flexibility. A smaller organization may be better off buying a mature product rather than building and maintaining its own routing infrastructure.

The second application is to define human review boundaries by risk rather than ideology. Matan says enterprise production work still needs human gates in the next few months because the stakes are high, while some future code or use cases may become more robust when AI-generated. A usable policy would separate low-risk, reversible, formulaic work from high-risk, customer-visible, regulated, architectural, or hard-to-roll-back changes. The relevant question is not simply “can AI write it?” but “what is the cost of failure, how verifiable is the output, who owns the result, and how much trust has the organization earned?”

The third application is to treat “code is cheap” as an operating model, not a layoff slogan. Teams can use agents to remove repetitive migrations, mechanical test creation, model intake checks, and other low-leverage work from senior engineers. The freed capacity should go toward constraint modeling, architectural tradeoffs, cross-system dependencies, user-feedback loops, and maintainability. Factory’s model-evaluation automation is a good example: automation did not eliminate all engineering work; it redirected humans toward higher-leverage research problems.

The fourth application is to decide more carefully when to build and when to buy. Matan explicitly rejects the idea that AI tools mean companies should build every internal system themselves. Factory still uses Salesforce and DocuSign because maintaining those systems is not its core competency. The broader rule is simple: if a system is not core, has many edge cases, carries compliance or support obligations, and will need long-term maintenance, fast AI-assisted prototyping does not automatically make self-building wise. AI lowers initial creation cost; it does not erase ownership cost.

The fifth application is hiring. Matan’s skepticism of both traditional coding interviews and AI coding interviews suggests that teams should test the path, not just the artifact. Candidates should be evaluated on how they frame ambiguous problems, decompose constraints, verify AI output, recover from failure, learn unfamiliar domains, and show agency. Company-building experience may be a strong signal in Factory’s context, but it should not become a universal requirement. The deeper signal is whether a person can take responsibility for a hard problem under real constraints.

Finally, the safety discussion can become a governance checklist. Who released the system? Who designed the sandbox? Who approved tool access? Who controls production deployment? Who logs decisions and outputs? Who talks to customers after an incident? Matan’s responsibility frame is useful because it avoids the evasive idea that “the model did it.” But the boundary is that modern AI systems involve model providers, platforms, customer deployers, and end users. Responsibility has to be backed by contracts, logs, permissions, incident response, and review gates. Naming responsibility is only the beginning; organizations still need the mechanisms that make responsibility enforceable.

Source

• Original episode: Factory CEO on why AGI is already here