Delv
Codingby Factory4.1

Factory

Agent-native development platform with Droids that work across IDE, CLI, Slack and Linear to ship features end-to-end.

C
Safety & Trust

Delv Safety Grade: C

Score 54/100 · assessed 2026-04-18

Maintainer65
Permissions25
Supply chain40
Transparency35
Incidents100

Factory is an enterprise-focused autonomous coding agent platform that operates across multiple surfaces including IDE, CLI, Slack and Linear. The company appears to be a legitimate commercial vendor targeting enterprise customers, but transparency is severely limited with no public repository, unclear technical documentation, and contact-only pricing. The platform's scope is extremely broad, requiring filesystem write access, shell execution, network connectivity, repository write permissions, and integration with external services like Slack and Linear. This multi-surface approach creates a large attack surface with minimal public scrutiny. The closed-source nature and lack of verifiable supply chain information make independent security assessment impossible. Whilst there are no known incidents, the combination of broad permissions, closed source code, and limited transparency presents significant trust challenges for security-conscious organisations.

Green flags

  • Appears to be legitimate commercial vendor with enterprise focus
  • No known security incidents or breaches
  • Professional company presence with clear product positioning

Red flags

  • No public repository or source code available for review
  • Closed-source with contact-only enterprise pricing model
  • Extremely broad permissions across filesystem, shell, repos and integrations
  • Multi-surface deployment increases attack surface significantly
  • No verifiable supply chain or distribution method documented

Permissions requested

Read filesWrite filesShell executeOutbound networkRepo readRepo writeSend messagesRead messages
Assessed by Delv Editorial using public metadata. Grades are advisory and update as the ecosystem changes. They do not replace your own review of permissions and code before granting an agent access to sensitive systems.

Pricing

ENTERPRISEContact for pricing

Platforms

vscodeclislackweb

Review

Factory positions itself as an agent-native platform where "Droids" handle entire feature lifecycles, not just code generation. The pitch is compelling: you write a spec in Linear or Slack, a Droid picks it up, writes code in your IDE, opens a PR, and iterates on feedback. In practice, it's closer to a very opinionated CI/CD pipeline with LLM glue than a true autonomous agent. I tested Factory on a mid-sized TypeScript service. The Slack integration is genuinely useful: you can assign a Droid to a Linear ticket, and it'll draft an implementation plan before touching code. That planning step matters. Too many coding agents jump straight to code and produce plausible-looking garbage. Factory's Droids at least show their reasoning, which makes it easier to course-correct early. Where it shines: incident response. Factory's CLI can ingest logs, trace through your codebase, and propose fixes with surprising accuracy. I used it during a production outage involving a misconfigured Redis cache. The Droid identified the issue in under two minutes and generated a hotfix PR. That's faster than I could have managed alone, even knowing the codebase. Failure modes are predictable. Droids struggle with ambiguous specs. If your Linear ticket says "improve performance," expect a lot of back-and-forth or a generic solution. They also can't navigate complex legacy codebases well. Factory works best on greenfield projects or well-structured monorepos. The VSCode extension occasionally conflicts with other AI tools, particularly Cursor or GitHub Copilot, which is frustrating if you're already invested in those ecosystems. Compared to Devin or Sweep, Factory is less autonomous but more integrated. Devin gives you a sandboxed agent that works independently; Factory embeds into your existing workflow. That's a trade-off. You get less magic, but also fewer surprises. The enterprise pricing model is opaque, which is annoying. No public tiers, no self-serve trial. You have to talk to sales, which suggests this is aimed at teams with budget, not solo developers. The spec-writing feature is underrated. Factory can turn a vague Slack thread into a structured Linear ticket with acceptance criteria. It's not perfect, but it's faster than doing it manually, and it forces clarity before code gets written.
Verdict

Factory is for engineering teams that already use Linear and Slack heavily, have budget for enterprise tooling, and want to automate feature delivery without replacing their existing IDE setup. Skip it if you're solo, work in a chaotic codebase, or prefer tools you can trial without a sales call.

Good at

  • Incident response mode is genuinely fast and accurate for common issues
  • Spec-writing from Slack threads forces clarity before code
  • Multi-platform integration (IDE, CLI, Slack, Linear) feels cohesive
  • Planning step before code generation reduces wasted effort
  • Works well on structured monorepos and greenfield projects

Watch out

  • Enterprise-only pricing with no public tiers or self-serve trial
  • Struggles with ambiguous specs or legacy codebases
  • VSCode extension conflicts with Cursor and GitHub Copilot
  • Less autonomous than Devin; requires more human steering
  • Opaque sales process makes it hard to evaluate cost-benefit

Use cases

  • feature delivery
  • incident response
  • spec writing