Factory Raises $200 Million at $5 Billion Valuation to Scale Autonomous AI Coding Agents

Factory Secures $200 Million to Expand Droids, Its Model-Agnostic AI Software Engineering Platform

The latest example is Factory, an AI software-development company that has raised $200 million at a $5 billion valuation to expand its autonomous coding-agent platform for enterprise engineering teams.

Factory announced the funding on September 15, 2026, saying the new capital will be used to scale its approach to self-improving software development in the enterprise.

The company is best known for its Droids, AI coding agents designed to take software-development tasks from natural-language instructions through planning, implementation, testing and delivery.

Factory describes its broader platform as an “autonomy stack” for enterprise software teams, rather than simply another AI coding assistant.

The funding round comes as companies increasingly experiment with AI agents that can handle larger portions of the software-development lifecycle.

What Is Factory?

Factory is building an AI-native software-development platform around autonomous agents called Droids.

Instead of only suggesting individual lines of code, Droids can receive a task described in natural language and work through multiple stages of software development.

Factory says Droids can:

Plan software tasks
Search and understand codebases
Write code
Run tests
Make changes across repositories
Create pull requests
Work through developer tools
Operate with configurable levels of autonomy

The platform works across terminals, IDEs, browsers and communication tools such as Slack, according to Factory's product documentation.

This puts Factory closer to an autonomous software-engineering platform than a traditional code-completion product.

Factory's New Funding Round

Factory announced that it raised $200 million at a $5 billion valuation on September 15.

The company says the funding will help scale self-improving software development for enterprise customers.

Reuters also reported that the latest round increased Factory's valuation from less than $1.67 billion to approximately $5 billion.

The size of the round highlights the amount of investment currently flowing toward autonomous software-development systems.

Factory is competing in a market that includes products from large AI companies as well as specialized coding-agent startups.

Rather than focusing exclusively on the underlying AI model, Factory's approach centers on building a software-development system that can use different models and coordinate work across engineering environments.

Droids Are Designed to Work From One Natural-Language Task

The basic Factory workflow is deliberately simple.

A developer gives a Droid a task in natural language.

The agent then analyzes the repository, determines the required changes, modifies the relevant files, runs appropriate tests and prepares the resulting changes for review.

Factory describes this workflow as “one prompt to PR.”

The goal is to reduce the number of individual steps developers need to perform manually.

For example, instead of asking an AI assistant to generate a function and then manually integrating it, a developer can assign a larger task and allow the agent to work through the repository.

The developer can then review the resulting changes.

This distinction becomes more important as AI coding agents become capable of handling multi-file tasks.

Factory Supports Multiple AI Models

One of the company's notable design choices is its model-agnostic approach.

Factory says Droids can work with models from providers including Claude, GPT and Gemini.

That means an organization does not necessarily have to build its entire development workflow around one AI provider.

Different models can be selected for different tasks.

A team might use one model for code generation, another for reasoning-intensive tasks and another for specific types of repository analysis.

Factory's platform is designed to manage that model selection at the agent level.

This approach also gives enterprise teams an additional layer between their development workflow and individual model providers.

Codebase Understanding Is a Major Part of Factory's Approach

AI coding agents need more than the ability to generate code.

They need to understand the existing codebase.

Factory says its Droids use agentic search to understand entire repositories without requiring developers to manually select all the relevant context.

This is important for large software projects.

A small coding change can depend on files, interfaces, configuration settings and tests located across a repository.

An AI system that only sees the immediate file may generate code that appears correct but does not fit the larger application.

Factory's repository-understanding approach is designed to give its agents a broader view before making changes.

Droids Can Work Across Hundreds of Files

Factory's product documentation says Droids can coordinate changes across hundreds of files.

That capability targets a different class of software-development task from ordinary autocomplete.

Large changes often require modifications to multiple components at the same time.

An agent capable of navigating a repository and coordinating those changes can potentially handle work that would otherwise require a developer to manually locate and modify numerous files.

The challenge is maintaining correctness.

More autonomous actions also mean more opportunities for an agent to misunderstand requirements or introduce unexpected changes.

Factory therefore includes controls around how much autonomy an organization gives its agents.

Developers Can Control How Autonomous the Agents Are

Factory does not require every organization to give its Droids complete control.

The platform provides adjustable autonomy.

According to Factory, teams can configure agents from fully supervised operation through autonomous execution, controlling boundaries around edits, command execution and approvals.

That creates several possible operating modes.

A developer could use an agent primarily as an assistant and manually approve important operations.

Another team could allow greater autonomy for repetitive engineering tasks.

This type of configurable autonomy is becoming increasingly important as coding agents move toward production environments.

The appropriate level of independence can vary depending on the task, repository and security requirements.

Factory Is Building More Than a Coding Agent

The new funding is connected to Factory's broader vision of a software factory.

The company previously described Factory 2.0 as an agent-native, end-to-end software-development system in which autonomous agents operate across the software lifecycle.

The idea goes beyond asking AI to write code.

A software factory can potentially receive signals from:

Bug reports
Customer feedback
Internal conversations
Business requirements
Engineering requests

Those signals can then feed into AI agents that help plan and execute software work.

Factory argues that this kind of interconnected system is necessary to move from individual developer productivity toward organization-wide software automation.

Factory Recently Expanded Its Enterprise Distribution

The September funding round follows another important development for Factory.

On September 9, the company announced that Factory became available through the Claude Marketplace, allowing eligible enterprise customers to apply Anthropic spending commitments toward Factory.

This gives enterprise customers another purchasing route for adopting Factory.

The move also places Factory closer to the broader ecosystem of enterprise AI infrastructure rather than treating it purely as an independent developer application.

For organizations already using Claude across engineering teams, the marketplace integration can simplify the procurement process.

Factory's Platform Works Across Developer Environments

Factory's Droids are designed to operate where developers already work.

The company's product documentation lists support for:

VS Code
JetBrains
Vim
Browser-based workflows
Slack
Terminal environments

The platform also includes desktop and command-line interfaces.

This approach is important because forcing developers to move into a separate AI interface can create friction.

Instead, Factory is attempting to make autonomous agents available across existing development surfaces.

An engineering team can therefore interact with an agent from the environment most appropriate for the task.

Factory Also Supports Background and Cloud Agents

The company's platform includes cloud and local execution options.

Factory's current plans include cloud and local background agents, while higher-tier plans provide access to Factory-managed cloud computers for remote Droids.

Background execution is particularly relevant for autonomous coding.

An agent can work on a task without requiring the developer to remain actively involved in every step.

That can change how engineering teams allocate work.

Instead of waiting for an engineer to complete a repetitive task manually, a team could assign the work to an agent and review the resulting changes later.

Why Model-Agnostic Coding Agents Matter

The AI model market is changing rapidly.

New models can improve coding, reasoning, context handling and tool use at different speeds.

Building an engineering workflow that depends completely on one model can therefore create a technology dependency.

Factory's model-routing approach is designed to provide flexibility.

Its documentation says users can choose Claude, GPT, Gemini or another supported model depending on the task.

This can also make it easier for organizations to evaluate new models without completely rebuilding their engineering workflow.

The agent platform remains the interface while the underlying model can change.

Factory's Enterprise Focus

Factory is explicitly targeting enterprise software engineering teams.

Its product positioning emphasizes large codebases, multi-file changes, adjustable autonomy and integrations across existing development environments.

That focus distinguishes it from coding assistants primarily designed for individual developers.

Enterprise software development introduces additional requirements around:

Access controls
Code review
Security
Auditability
Repository permissions
Deployment policies
Model selection
Human approval

Autonomous coding systems therefore need to function within organizational processes rather than simply generate code.

Factory's platform is designed around that environment.

What the $5 Billion Valuation Says About AI Coding Agents

Factory's new valuation reflects investor interest in autonomous software development, but the valuation itself does not establish how the technology will perform across enterprises.

The more concrete signal is the amount of capital being directed toward building AI systems that can perform increasingly large portions of engineering workflows.

Reuters reported that Factory's latest funding comes as autonomous coding becomes one of the major applications of generative AI.

The technology is moving from code suggestions toward agents capable of planning, implementation, testing and delivery.

That creates a much larger potential market than conventional autocomplete tools.

Challenges for Autonomous Coding Agents

Greater autonomy also introduces new challenges.

An AI coding agent can make changes much faster than a human developer, but speed does not guarantee correctness.

Organizations still need to consider:

Code quality
Security vulnerabilities
Dependency changes
Incorrect assumptions
Test coverage
Repository permissions
Human review
Deployment safeguards

Factory's adjustable-autonomy system is one way to address some of these concerns, allowing organizations to define how independently agents operate.

For production environments, human review and automated testing remain important safeguards.

The role of the developer may therefore shift from writing every line of code toward specifying requirements, reviewing changes and managing agent workflows.

What Factory's Expansion Means for Developers

The latest funding and product expansion point toward a broader change in software development.

AI coding tools are no longer limited to helping developers type faster.

The emerging model is closer to delegating software tasks to AI agents.

A developer might describe a feature, bug fix or engineering task and let an agent investigate the repository, make changes, run tests and prepare a pull request.

That does not eliminate the need for developers.

Instead, it changes where developers spend their time.

Less time may be spent on repetitive implementation, while more attention can move toward architecture, requirements, code review, security and system-level decisions.

Factory's $200 million funding round and $5 billion valuation underline the growing investment in autonomous software engineering.

Its Droids are designed to handle much larger software-development tasks than traditional code-completion tools, including repository analysis, multi-file changes, testing and pull-request preparation.

The company's model-agnostic strategy is also notable.

By supporting models from providers such as Anthropic, OpenAI and Google, Factory is attempting to build a durable software-development layer that can adapt as the underlying AI model market changes.

The September 2026 funding round gives Factory additional resources to expand that approach across enterprise engineering teams.

The bigger story is not simply Factory's valuation.

It is the continuing shift from AI that helps developers write code to AI agents that can be assigned software-development work and execute it with increasing independence.

As these systems mature, the central challenge for engineering organizations will be balancing that autonomy with testing, security, permissions and human oversight.

Frequently Asked Questions

What is Factory AI?

Factory is an AI software-development platform built around autonomous coding agents called Droids. The agents can plan, write and test code and prepare changes for delivery.