Enterprise Autonomous Software Engineering with AI Droids

factory · Tech · 2025 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.6 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Enterprise autonomous software engineering

Factory targets enterprise software development tasks that are too large, old, and context-heavy for local code assistants, especially migrations, refactors, incident response, and multi-file delegated engineering work.

Constraints:

Enterprise codebases can be decades old, messy, and maintained by hundreds of thousands of developers.
Agents need the same contextual sources a human engineer receives, including Slack, Notion, project management, observability, and code.
Delegated work requires tests, pre-commit hooks, tool calls, PR creation, and review, not just code generation.
Large-context approaches can become cost-prohibitive.
Enterprise evaluation must consider deliverables, code churn, developer sentiment, timelines, and merged code.

Architecture

Factory provides enterprise software-engineering 'droids' for knowledge/technical writing, code, and reliability work. A user delegates a ticket or incident; the platform retrieves code and enterprise context from integrations such as Linear, Jira, Slack, GitHub, Sentry, PagerDuty, memory, and web search; the droid plans and edits across files, runs checks, creates pull requests, and exposes activity/context panels for review.

Diagram confidence: explicit (topology described by the source).

flowchart LR
  droid-dashboard["Droid dashboard"] --> code-droid["Code droid"]
  droid-dashboard --> reliability-droid["Reliability droid"]
  droid-dashboard --> knowledge-droid["Knowledge droid"]
  code-droid --> enterprise-integrations["Enterprise integrations"]
  reliability-droid --> enterprise-integrations
  knowledge-droid --> enterprise-integrations
  enterprise-integrations --> retrieval-layer["Retrieval layer"]
  retrieval-layer --> code-droid
  code-droid --> activity-and-context-panels["Activity and context panels"]
  activity-and-context-panels --> reviewer-workflow["Reviewer workflow"]

Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component	Role	Interacts with
`Droid dashboard`	Entry point for selecting knowledge, code, and reliability droids.	`Code droid`, `Reliability droid`, `Knowledge droid`
`Code droid`	Delegated coding agent that searches code, edits files, runs checks, and prepares pull requests.	`Enterprise integrations`, `Activity and context panels`
`Reliability droid`	Incident-response agent that compiles evidence and writes RCA material.	`Enterprise integrations`
`Knowledge droid`	Deep-research and technical-writing agent for documents or answers.	`Enterprise integrations`
`Enterprise integrations`	Connectors for code, project management, docs, incident, and communication systems.	`Retrieval layer`
`Retrieval layer`	Selects needed context efficiently instead of dumping whole repositories into prompts.	`Code droid`
`Activity and context panels`	Expose what the agent is doing and what context it is using for review.	`Reviewer workflow`
`Reviewer workflow`	Human review of code changes, CI, tests, PRs, and merge decisions.	—

Data flow

A user starts a droid session with a ticket or incident, references codebases through commands, the droid retrieves relevant context from code and enterprise integrations, plans and edits files, runs tests or hooks, creates a PR, and returns deliverables plus usage/quality metrics.

“I'm going to paste a ticket into our platform. We have integrations with a bunch of different stuff, linear, JIRA, Slack, GitHub, Century, PagerDuty, you name it.”article, stated

“It's running code. It's iterating on code. It's making edits to a bunch of different files. It's going to have to run pre-commit hooks and test all this stuff.”article, stated

Why this architecture

Factory argues that enterprise software work needs delegation rather than only collaboration: agents should receive the full context a human engineer would receive, execute in the cloud, and let humans review high-leverage deliverables.

“most enterprises, though, see that as the holy grail, not like going 15% or 20% faster.”article, stated

“They have all of these other information sources that they need to actually be a productive engineer.”article, stated

Models used: Droids · Sonnet 3.5 · Sonnet 3.7 · Codex · Gemini · LLMs · Retrieval

Scale

Factory focuses on enterprise codebases that are 30-plus years old.
“there are hundreds of thousands of developers who work on code bases that are 30 plus years old.”article, stated
The article contrasts a four-month migration with a three-and-a-half-day result.
“pulling in just a large migration task from taking four months to taking like three and a half days.”article, stated
The live demo edited or created roughly 12 files.
“It actually finished these changes. I think it's like roughly 12 files that it edited, created.”article, stated
The demo used 43% of context size on Factory's large monorepo.
“like a little 43% of context size use.”article, stated
The company reports Fortune 500 enterprise deployments exploding over the prior 90 days.
“over the last 90 days, the deployments that we've had with like the large enterprise and fortune 500 has been exploding.”article, stated

Alternatives considered (roads not taken)

Optimize for solo-developer zero-to-one coding assistants.

Rejected because: Factory sees enterprise legacy-code work as underserved and more valuable.

“the relatively underserved enterprise perspective, which is there are hundreds of thousands of developers who work on code bases that are 30 plus years old.”article, stated

Keep agents only inside the IDE.

Rejected because: Factory says engineers need Slack, Notion, Linear, Datadog, Sentry, PagerDuty, and other context sources.

“that's like the equivalent of onboarding a human engineer, just like throwing them into your code base and being like, all right, like, go.”article, stated

Throw the whole codebase into a huge context window.

Rejected because: Factory argues retrieval remains important for cost efficiency even as context windows grow.

“if you do have billion token context window model, you throw it all in there, it's still going to be more expensive.”article, stated

Freeze or fine-tune models for behavior control.

Rejected because: Factory sees more leverage in iterating external systems around changing models.

“freezing the model at a specific quality level and freezing the model at a specific data set just feels like it's lower leverage than continuing to iterate on all these external systems.”article, stated

Patterns

`tool-use-orchestration` (orchestration)

Droids call project-management, code, memory, web, and incident tools while executing delegated engineering work.

“the system has access to a bunch of different tools. Here, memory, project management tools, GitHub, web search.”article, stated

`rag-retrieval` (retrieval)

Factory emphasizes retrieval to select precise repository and enterprise context rather than stuffing everything into long context.

“The reason why retrieval is so important for us is because even if there is a model that's going to have these larger context windows”article, stated

`eval-driven-development` (evaluation)

Factory uses task-based evals, internal benchmarks, tool-use quality, code edits, PRs, and code churn to hill-climb agent behavior.

“those task-based evals tend to be the ones where it's most critical that we hill climb continuously on versus the, the top level evals.”article, stated

`human-in-the-loop-gate` (governance)

Humans delegate tasks and review generated code, CI, tests, and PRs before merging.

“you as a human being just review the code changes, right? This looks good. Merge. Did it pass CI? Okay, great.”article, stated

Tradeoffs

Build a delegation workflow instead of only collaborative IDE assistance.

Chose Cloud-native droids that work while the human delegates and reviews. over Local-first autocomplete or chat tied to the IDE..

Rationale: Factory believes enterprise value comes from delegated tasks rather than only 15-20% faster local coding.

“shift from a very collaborative workflow, which is what I think we see with most tools today, and a more delegative workflow”article, stated

Expose activity and context rather than only final code.

Chose Activity log and context panel. over A code-only editing view while the agent works..

Rationale: The team says reviewers need an X-ray into what the agent is doing during execution.

“What matters most is seeing what the agent is doing and having a bit of like an X-ray into its brain.”article, stated

Keep pricing usage-based and token-transparent.

Chose Standard-token direct billing plus usage tracking. over Opaque credits..

Rationale: The team wants enterprise users to understand token usage and deliverables.

“We're fully usage based. So the tokens, I think for us, it's really important to like, respect the users and their ability to understand what what this stuff means.”article, stated

Gotchas (what bit them)

Agents without enterprise context perform like under-onboarded engineers.

Root cause: Code alone lacks the surrounding Slack, Notion, ticket, incident, and project context humans receive.

Resolution: Integrate enterprise information sources and retrieval into the agent platform.

“when you onboard a human engineer, what do you actually onboard them to? Slack, Notion, Linear, like Datadog, Sentry, PageReduce.”article, stated

Model upgrades change agent behavior.

Root cause: New models have different interaction patterns, personalities, and tool-use preferences.

Resolution: Use the product layer as a shock absorber while selectively teaching users new interaction patterns.

“when we upgraded from Sonnet 3.5 to 3.7, we suddenly had a lot of developers being like, hey, wait, it now does this less or does this more.”article, stated

Better context windows can increase cost.

Root cause: Large context can make each call more expensive even if it improves capability.

Resolution: Invest in retrieval and token efficiency.

“you still want to be very cost efficient. And this is something that our customers care a lot about.”article, stated

Enterprise observability is semantic and subjective.

Root cause: Vendors cannot see customer code data, but quality includes subjective code-style and experience judgments.

Resolution: Track deliverables, merged code, code churn, sentiment, and semantic observability signals.

“you can't see their code data at all, but you're trying to build a product where you can do it. You can improve the experience.”article, stated

Evaluation

Factory evaluates through internal task benchmarks, tool-use behavior, task deliverables, PRs, merged code, code churn, developer sentiment, and timeline compression.

Metrics: Task-based evals · Fast, accurate, high-quality code edits · Tool calls with correct parameters · Pull requests created · Merged code · Code churn · Developer sentiment · Migration time reduction

“is it fast, accurate, and high quality code edits? Does it call tools with the right parameters?”article, stated

“Here are the pull requests created. Here's merged code. We help enterprise users look at things like code churn”article, stated

Outcomes

Factory reports a large migration compressed from four months to about three and a half days.
The platform supports parallel delegated tasks and PR creation.
Factory reports accelerating Fortune 500 and large-enterprise deployments over the last 90 days.

The case discusses 30-plus-year-old codebases, hundreds of thousands of enterprise developers, a 12-file demo edit, 43% context use, and Fortune 500 deployments.

“we had something that was going to be delivered in the next quarter and we could get done this week with no downtime.”article, stated

“being cloud native, being able to parallelize these, like I'm only sharing one tab, but if I just open another one and started right now, we support that natively.”article, stated