Every major lab shipped a coding agent this week — Meta, AWS, and the usual suspects all crowding the same 72-hour window — and in the noise it would be easy to miss that Factory AI Droids quietly shipped the platform update that actually changes how you’d deploy an agent inside a real engineering org. Factory is the rare non-headline-lab player whose pitch isn’t “another chat window with a terminal.” It’s a fleet of specialized droids — one for code, one for reliability, one for knowledge, one for tickets — that run against your own infrastructure and your own repos. We put it through a week of real work on a mid-sized TypeScript monorepo and a legacy Python service, and the results are more interesting than the benchmark numbers suggest.
What’s new in Factory AI Droids
The headline change is specialization plus placement. Factory’s platform now treats a “droid” as a configured worker with a defined role, a scoped toolset, and its own memory of your codebase, rather than a general assistant you re-brief on every task. The Code Droid writes and reviews changes. The Reliability Droid works incidents — reading logs, correlating deploys, drafting the postmortem. The Knowledge Droid answers “why is this like this” from the accumulated sediment of PRs, docs, and Slack threads. The Tutorial and Migration droids handle onboarding and the long-tail refactors nobody volunteers for. Each one is a separate execution context with its own permissions, which matters enormously once you stop demoing and start letting agents touch production repos.
The second change is the deployment story. Factory now runs meaningfully self-hosted: point droids at a bring-your-own-cloud execution environment, keep source code inside your VPC, and route model calls through your own provider keys — including Anthropic, OpenAI, or Bedrock endpoints you already have contracts for. Factory AI self-hosted is the feature that gets the platform past security review at companies where “we upload your repo to a vendor sandbox” is a non-starter. Combined with the local CLI (droid), you get the same agent whether you’re in the browser, in your terminal, or triggered by CI.
Third: the CLI itself has grown up. Factory’s terminal agent runs headless, accepts piped input, emits structured output, and can be invoked from a GitHub Action or a cron job. That turns an interactive tool into infrastructure. The most useful thing we did all week wasn’t chatting with a droid — it was wiring one into a nightly job that opened three dependency-upgrade PRs with passing tests before anyone logged on.
Why it matters
- Specialization beats one big loop for long tasks. A droid scoped to migrations, with migration-specific context and tools, drifts less over a 40-file refactor than a general agent that has to rediscover the task shape every session. Our TypeScript strict-mode migration finished with 91% of files needing no human touch; the same prompt to a general-purpose agent stalled around file 12.
- Self-hosting is the real moat right now. Regulated orgs, defense-adjacent shops, and anyone with source-code-egress rules can’t use most of this week’s launches at all. An AI software engineering agent that runs in your VPC with your model keys clears a procurement bar the hyperscaler-hosted tools don’t.
- Model portability protects you from the weekly launch cycle. Because Factory brokers to whatever frontier model you point it at, a better model next month is a config change, not a migration. Tools welded to one lab’s model inherit that lab’s roadmap.
- Per-seat pricing is under pressure. When every lab bundles a coding agent into an existing subscription, independent startups have to justify a standalone line item. Autonomous coding agent pricing is shifting from seats to task-based or compute-based billing, and Factory’s usage component is early evidence.
- The bottleneck moves to review. Three droids producing PRs in parallel outruns a two-person review queue fast. Teams adopting this need a review policy before they need more agent seats.
- Benchmarks are becoming marketing. Every vendor now cites a SWE-bench Verified number in the 70s. SWE agent benchmarks no longer discriminate between tools; deployment model, context handling, and failure behavior do.
How to use Factory AI Droids today
-
Install the CLI. It’s a single binary and works on macOS, Linux, and WSL.
curl -fsSL https://app.factory.ai/cli | sh droid --version -
Authenticate and confirm which model you’re brokering to. On a bring-your-own-key plan, set the provider key in your environment first so nothing routes through a vendor-hosted default.
export ANTHROPIC_API_KEY="sk-ant-..." droid auth login droid config set model claude-opus-5 droid config list -
Give the droid a repo-level brief. Factory reads a config file at the repo root — this is where specialization actually happens, so spend real time on it. Ours looked roughly like this:
# .factory/config.yaml project: name: billing-api language: typescript package_manager: pnpm commands: install: pnpm install --frozen-lockfile test: pnpm vitest run --reporter=dot lint: pnpm eslint . --max-warnings=0 build: pnpm tsc --noEmit conventions: - "No default exports outside of route modules." - "All DB access goes through src/db/repositories — never raw SQL in handlers." - "Every behavior change needs a test in the same PR." boundaries: never_touch: - "infra/terraform/**" - "src/legacy/pricing-v1/**" -
Run your first scoped task headlessly rather than interactively. Headless mode is where the tool earns its keep, and it forces you to write a brief good enough to survive without follow-up questions.
droid exec --auto medium "Add idempotency-key support to POST /v1/charges. Store keys in the existing Redis client (src/cache/redis.ts), TTL 24h. Return the cached response on replay with the original status code. Add tests covering: first call, exact replay, and same-key-different-body (must 422)." -
Tighten the autonomy dial deliberately. Factory exposes graded autonomy — low asks before edits, medium executes reads and edits but pauses on destructive commands, high runs the loop end to end. Start at medium on any repo you care about.
droid exec --auto low "..." # approve every file write droid exec --auto medium "..." # edits freely, pauses on shell side effects droid exec --auto high "..." # full loop, use in disposable branches only -
Wire it into CI once you trust the output shape. Most teams skip this step, and it’s the one that produces compounding value.
name: nightly-droid on: schedule: - cron: "0 7 * * 1-5" jobs: upgrade: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - run: curl -fsSL https://app.factory.ai/cli | sh - name: Dependency sweep env: FACTORY_API_KEY: ${{ secrets.FACTORY_API_KEY }} ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }} run: | droid exec --auto medium --output-format json \ "Upgrade all minor and patch dependencies. Run the test suite. If any test fails, revert that single package and note it in the summary. Open one PR per package group." | tee droid-run.json -
Feed the Knowledge Droid before you need it. Point it at your ADRs, runbooks, and closed PRs on day one; its answers are only as good as what it has indexed. In our test, questions about a two-year-old caching decision were answered correctly only after the droid ingested the original RFC.
How it compares
The obvious matchup is Droids vs Devin — Cognition’s agent is the category’s reference point and now absorbs Windsurf’s IDE surface. But the honest comparison set is wider, because this week’s launches put hyperscaler agents in the same buying conversation.
| Capability | Factory Droids | Cognition Devin | Hyperscaler agents (AWS / Meta class) | Terminal agents (Claude Code / Codex CLI) |
|---|---|---|---|---|
| Execution location | Vendor cloud, BYOC, or self-hosted in your VPC | Vendor-hosted cloud workspaces | Provider cloud, tied to that cloud’s IAM | Your machine or your CI runner |
| Model choice | Broker to multiple frontier providers with your keys | Vendor-selected | Locked to the provider’s own models | Single-lab model |
| Task model | Multiple role-specialized droids with scoped tools | One general agent per session | One general agent, cloud-service aware | One general agent, highly steerable |
| Beyond writing code | Incident response, knowledge Q&A, ticket triage, docs | Primarily code and code review | Code plus that cloud’s ops surface | Whatever you script around it |
| Headless / CI use | First-class, JSON output | Supported via API | Native to the cloud’s pipeline product | Excellent, scriptable |
| Pricing shape | Seat plus usage; enterprise tier for self-hosted | Seat plus compute credits | Often bundled into existing cloud spend | Bundled into an existing subscription |
| Best fit | Mid-to-large teams with compliance constraints | Teams wanting the most autonomous single agent | Shops already all-in on one cloud | Individual engineers and small teams |
Our practical read after a week: for a single engineer, a terminal agent is still the best value, and it isn’t close — the bundled ones cost nothing extra. Factory starts winning at the point where you have more than one agent running at once, more than one person reviewing, and a security team with opinions about where your source code lives. That’s a real segment, and it’s exactly the segment the hyperscaler launches are least equipped to serve without cloud lock-in.
What’s next
The near-term roadmap signal to watch is fleet orchestration: multiple droids working the same ticket with a supervising droid arbitrating conflicts. Factory has the architectural head start here because its droids are already separate scoped contexts rather than threads in one loop. If they land clean handoffs — Code Droid opens the PR, a review droid critiques it, the Reliability Droid watches the canary — that’s a genuinely different product from a chat agent, and the hardest thing for a competitor to bolt on.
The second thing to watch is pricing. Every Factory AI review 2026 that treats this as a pure capability comparison misses the actual competitive dynamic: when a coding agent ships free inside a subscription your team already pays for, independents survive by selling what bundles can’t include — self-hosting, model neutrality, and cross-cloud portability. Expect Factory’s enterprise tier to lean harder into those, and expect the entry tier to get squeezed. If you’re evaluating now, negotiate on the usage component, not the seat count.
Finally, watch how these tools report failure. In our testing the most valuable behavior wasn’t a clean 200-line PR — it was the run where the droid attempted a change, saw three tests break, reverted itself, and wrote an honest summary explaining which assumption was wrong. Agents that quietly deliver broken confidence cost more than they save. As benchmark scores converge, that’s the axis we’d evaluate on, and the one nobody puts on a launch slide.
Frequently Asked Questions
Can Factory AI Droids really run entirely on our own infrastructure?
Substantially, yes — that’s the differentiator. Enterprise deployments support bring-your-own-cloud execution so repository contents and build environments stay in your VPC, and you can route inference through your own provider keys or a Bedrock-style endpoint. Verify the specifics of the control plane with their team during procurement; “self-hosted” means different things at different vendors, and the question to ask is precisely what metadata leaves your network.
How does Factory pricing compare to Devin?
Both use a seat-plus-consumption shape rather than flat per-user pricing, and both have enterprise tiers where the list price stops being meaningful. The practical difference is that Factory’s usage cost can partly land on your own model contract if you bring your keys, which changes the math for teams with existing committed spend. Budget by expected task volume, not headcount.
Do the benchmark scores actually tell me which agent is better?
Not anymore. Leading agents cluster tightly on SWE-bench Verified, and the benchmark rewards self-contained Python bug fixes that look nothing like a multi-service TypeScript refactor. Run a two-week pilot on three real tickets from your own backlog — one bug, one feature, one migration — and compare human review time. That number decides the purchase.
Is this a replacement for a terminal agent like Claude Code?
No, and treating it that way leads to overspending. Terminal agents are for the loop you’re personally in; Factory’s droids are for work that runs without you — nightly upgrades, migrations, incident triage, onboarding questions. Most teams we’d advise end up running both, with the terminal agent as the default and droids handling delegated background work.
What’s the biggest failure mode in practice?
Review capacity. Autonomy set to high across several droids will generate more pull requests than a small team can meaningfully evaluate, and rubber-stamped agent PRs are how you get a codebase nobody understands. Cap concurrent droid tasks at roughly half your reviewer count until you have data on merge quality.
How much context setup does it need before it’s useful?
Plan on a half-day. The config file, the command definitions, and explicit boundaries around directories the agent must never touch are what separate a useful droid from a plausible-sounding one. Our first-day results were mediocre; results after writing a proper conventions block were dramatically better, and that ratio held on both codebases we tested.
Go deeper than this article
This article covers the essentials. Our premium eguide library gives you the full step-by-step playbooks — prompts, workflows, and copy-paste recipes you can put to work today.
