Factory 2.0: From coding agents to software factories

In 2023, we launched Factory with the mission to bring autonomy to software engineering. While others were using models to speed up coding, we set out to deploy autonomous Droids across the enterprise software development lifecycle. Today we are announcing the next phase in the future of software engineering.

Improving the productivity of individual engineers is no longer enough. Unlocking organization-wide productivity requires an interconnected, agent-native, end-to-end system. This system must improve over time by observing itself. The incremental units of this system are AI agents. This system will be built by engineers, and in turn will build their software.

This system is the software factory.

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. These changes are built, tested, reviewed, secured, shipped, and monitored. Monitoring that deployed software generates more signals. The entire system is a continuous feedback loop. Almost no one has meaningfully instrumented this loop to be fully AI-driven. We are still early, but the proliferation of software factories is going to happen very quickly.

A robust software factory must have:

Model Independence.
Every model has a different trade-off of cost, performance, and speed. No one model fits every need within an enterprise. Your software factory must allow your organization to deliberately choose different models, or rely on a Router to automatically (or rule-based) select the best* model for any given task. As models commoditize, costs decrease while speed and performance increase.

Sovereign Intelligence.
You must be the sovereign of your software factory. Whether fully hosted in the cloud, bring-your-own-key, self-hosted data plane, EU-specific, or completely air-gapped with no external network access. Sovereignty means more than choosing where the system runs. It means owning a system that learns from itself, feeding every agent session, code review, and resolved incident back into the loop. The more you invest in your software factory, the more capable it becomes, and that capability stays with you, inside your walls, under your control.

Continual Learning and Self-Improvement.
Every stage of the software development lifecycle must be instrumented. When code review, security analysis, documentation, QA, and incident response all run on the same platform, they share the same agent core, the same model router, the same organizational context. A security finding informs the code review. A deployment triggers a documentation update. An incident correlates with the PR that caused it. Every additional automation, integration, or customization flows to the entire organization at once. The router itself learns to optimizes resources. The assembly line should span the full floor of the software factory.

We have been building software factories with our customers for the last few months. Software factories are already in production across the world’s largest organizations including NVIDIA, EY, Adobe, Palo Alto Networks, Adyen, Blackstone, Wipro, Comarch and more.

No organization starts with a fully autonomous software factory. Autonomy is a maturation process that is gradual and specific to every organization’s readiness and comfort level. Deploying autonomy across the organization happens through deliberate engineering effort to codify workflows and standardize processes.

Factory enables a spectrum of autonomy over time, because not every process should use long-horizon autonomous tasks. Well-defined, measurable tasks run with simple Droid agents or skills. Automations coordinate recurring workflows with a shared objective and memory. Remote and persistent execution leverages Droid Computers for long running or local agents. Multi-agent autonomous execution called Missions solve complex tasks over hours or days by decomposing work into parallel tracks to handle. Different autonomous processes are used for varying requirements based on the level of human guidance required, the information sensitivity, and the level of Agent Readiness.

Organizations that invest in their autonomous software development will see engineering outcomes surge, while owning decisions around cost, quality and context. The role of engineers is all the more important in this new era. No longer will they be the sole custodians of building the software. Instead, they will be responsible for building the factories that build the software. With this comes the responsibility of governance, safety, and the ownership of business outcomes. The next era of software development will be engineering-led and will see engineering responsibilities grow to span across the business itself.

Software factories are not built in a day. But the best day to start building your factory is today. Today we expand this functionality with visibility to manage your software factory directly in the Factory desktop app.

If your organization is ready to build your software factory, reach out: https://factory.ai/contact.

* Best can be set according to cost, performance, speed, or some combination.