Factory Launches Factory 2.0 to Replace Human-Managed Software Teams

Factory just drew a hard line between the first wave of AI coding tools and what it believes comes next. The company launched Factory 2.0, rebranding its platform from a collection of coding agents into what it calls a software factory -- an autonomous, end-to-end system that ingests signals from the real world and turns them into production software, continuously and without human hand-holding at every step.

Improving the productivity of individual engineers is no longer enough. Unlocking organization-wide productivity requires an interconnected, agent-native, end-to-end system. That is the core thesis behind Factory 2.0, and it marks a deliberate pivot in how the company positions itself against tools like Cursor and GitHub Copilot.

The assembly line metaphor is literal

The software factory starts with signals from the outside world -- bug reports, internal conversations, customer feedback, business requirements. These signals get triaged and turned into planned changes. Those changes are built, tested, reviewed, secured, shipped, and monitored. Monitoring that deployed software generates more signals. The entire system is a continuous feedback loop.

The agents doing the work are called Droids -- Factory's term for specialized AI agents that handle specific stages of the software development lifecycle (SDLC). Unlike GitHub Copilot or Cursor, which focus heavily on in-editor code completion, Droids are designed to execute longer-horizon tasks: generating new features across multiple repositories, writing and running tests, performing code review, producing documentation, and deploying to production.

Factory also introduced a capability called Missions for the most complex work. Missions allow a user to describe a business outcome in natural language -- like migrating a billing service off legacy Python 2 -- and watch multiple Droids plan, execute, and verify the work over hours or days.

Three pillars the platform is built on

Factory's architecture rests on three design principles that distinguish it from single-model, single-IDE tools:

• Model Independence: Every model has a different trade-off of cost, performance, and speed. No single model fits every need within an enterprise. The software factory must allow organizations to deliberately choose different models, or rely on a Router to automatically select the best model for any given task. Each Droid is model-agnostic, meaning it can route its reasoning through Anthropic's Claude, DeepSeek, or other frontier models depending on the task.
• Sovereign Intelligence: Deployment options range from fully managed SaaS to hybrid, on-prem, and completely air-gapped with no external network access, across AWS, Azure, and GCP. The organization owns the context, the learning, and the agent capabilities -- nothing leaks to a shared model.
• Continual Learning: Every stage of the SDLC feeds back into the same agent core. A security finding informs the next code review. A deployment triggers a documentation update. An incident correlates with the PR that caused it. The system gets smarter the more it runs.

Already in production at household names

NVIDIA, EY, Adobe, Palo Alto Networks, Adyen, Blackstone, Wipro, and Comarch run the platform today. Factory has been quietly building these deployments with enterprise customers for months before making the 2.0 announcement public.

Factory posted 200% quarter-over-quarter growth in 2025 and doubled revenue month-over-month for six months. Hundreds of thousands of developers now use Factory's platform. The company also achieved 58.8% task success on Terminal Bench versus competitors like Claude Code and Cursor -- a benchmark that tests agents on real command-line tasks in live shell environments rather than synthetic puzzles.

The new desktop visibility layer

With Factory 2.0, the company expands functionality with visibility to manage the software factory directly in the Factory desktop app. The desktop app itself launched a couple of months ago. It is built for running multiple Droids at once, with each session living in the sidebar with its own context, progress, and history -- so you can start a Droid on a feature build, kick off another on a migration, and check in on either without losing your place.

The new software factory view inside the desktop app gives engineering leaders a live operational dashboard: signal throughput, deployment rate, tickets triaged, PRs validated, and incidents processed -- all in one place. This is the management layer that turns a collection of agents into something you can actually govern at scale.

Who built this, and why now

Theoretical physics PhD Matan Grinberg and Eno Reyes, previously a data scientist at Hugging Face and Microsoft, built a platform that could autonomously solve coding problems during a San Francisco hackathon, then expanded it and founded Factory. Grinberg and Reyes were named to the Forbes 2025 30 Under 30 class for AI.

The timing of Factory 2.0 is deliberate. Almost no one has meaningfully instrumented the full SDLC loop to be fully AI-driven. The company believes the proliferation of software factories is going to happen very quickly. The competitive landscape is shifting: GitHub Copilot has 4.7 million paid subscribers and reaches 90% of the Fortune 100, while Cursor hit a $50 billion valuation with $2 billion in annual revenue. Factory is betting that neither of those tools is actually competing for the same thing it is building.

Enterprise-focused platforms like Factory, Cognition's Devin, and Anthropic's Claude Code for enterprises focus on autonomous, long-horizon tasks that span multiple repositories, systems, and days of wall-clock time. The distinction matters for buyers: a developer-seat tool and an autonomous agent are not substitutes, and most large enterprises are now buying both.

What this means for engineering teams

Factory 2.0 is not a drop-in replacement for your IDE plugin. It is a platform play aimed at engineering leadership -- the people responsible for how an entire organization ships software, not just how fast one engineer can write a function. The software factory dashboard is the clearest signal of that: it surfaces org-level throughput metrics, not individual autocomplete stats.

Autonomy in Factory's model is a spectrum, not a switch. The platform supports simple Droid agents for well-defined tasks, automations for recurring workflows, and full multi-agent Missions for complex, multi-day work. Organizations can start small and expand as their comfort with agent autonomy grows. The software factory is currently available in beta preview, and existing Factory customers can request access through their account team. New organizations can fill out a contact form to get in line.