Factory

What is Factory?

Factory is agent-native software development software that uses “Droids” to delegate complete engineering tasks—such as refactors, incident response, and migrations—across the development lifecycle. The stated goal is to let teams run AI coding agents wherever they already work without requiring a change to their existing tools, models, or workflow.

From the page, Factory positions Droids as workflow-embedded agents that can operate in an IDE, a browser UI, a command-line interface, Slack/Teams, and a project/backlog context. The emphasis is on delegating tasks end-to-end (including producing outputs like pull requests) while keeping traceability from ticket to code.

Key Features

• Workflow-embedded “Droids” across multiple interfaces: Delegate tasks in an IDE/terminal, web UI, CLI, Slack/Teams, and project manager context.
• Task delegation without forcing a tool switch: Use the same development workflow and tooling rather than moving to a separate system.
• Supports common IDE/terminal contexts: The page specifically calls out VS Code, JetBrains, Vim, and terminal usage on macOS/Linux and Windows.
• Web-based agent execution: Run Droids directly from the browser for complex coding tasks such as refactors or debugging without additional setup described on the page.
• Agent-driven automation for CI/CD and maintenance: The CLI path is described for scripting and parallelizing agents for phases like CI/CD, migrations, and automated code review.
• Project/backlog-triggered execution with PR creation: Factory can trigger agents from issue assignment or mentions, pull context, implement solutions, and create PRs while maintaining traceability from ticket to code.
• Shared support/engineering channel in Slack/Teams: Delegate incident triage and small fixes via plain English to get code-level solutions.

How to Use Factory

1. Get started via the provided quickstart: Use the “Quickstart Guide” referenced on the page to begin running Droids from your chosen interface (IDE or terminal first is explicitly emphasized).
2. Delegate a task from your existing workflow: In your IDE or terminal, assign a task to the Droid (the page references examples like refactors, debugging, and migrations) while keeping your existing tools and shortcuts.
3. Use additional interfaces as needed:
   • Run Droids in the browser for immediate agent-driven work.
   • Use the command line to script/parallelize agent runs for CI/CD, migrations, or maintenance.
   • In Slack/Teams, delegate support or incident triage items in plain English.
4. For backlog-driven work, trigger from issues: Use the project manager/backlog experience where Factory triggers agents from issue assignment or mentions, generates code changes, and creates PRs with traceability.

Use Cases

• IDE-based refactors and debugging: A developer can delegate a refactor or troubleshooting task from their editor (e.g., VS Code, JetBrains, Vim) without changing their workflow.
• Web UI for fast agent experiments: A team member can run coding tasks from a browser UI when they want to delegate refactors or debugging immediately.
• Command-line automation for CI/CD: A build/release engineer can script and parallelize Droids to support CI/CD-related activities such as automated code review and other maintenance tasks.
• Incident triage and quick fixes via Slack/Teams: Support and engineering teams can send tasks in plain English during incidents, receiving code-level solutions through a shared channel.
• Backlog-to-PR engineering workflow: A team can trigger agents from issue assignment or mentions, letting Factory pull context, implement changes, and create PRs while keeping the connection between the ticket and the resulting code.

FAQ

• Where can I run Factory’s Droids? The page lists IDE/terminal, desktop/web, command line, Slack/Teams, and a project manager/backlog interface.

• Do I need to change my existing tools or workflow? Factory’s positioning states that Droids work “everywhere you do” without requiring you to change your tools, models, or workflow.

• Which IDEs are mentioned? The page specifically calls out VS Code, JetBrains, and Vim, plus terminal usage.

• Can Factory create pull requests from tickets? The project manager/backlog flow described on the page says Factory can create PRs while maintaining traceability from ticket to code.

• Is Factory designed for enterprise use? The page includes an “Enterprise” section describing it as secure, scalable, and ready to integrate with existing engineering tools, and mentions industry-grade security and compliance, but it does not list specific standards or certifications.

Alternatives

• General-purpose LLM coding assistants: Tools focused on chat-based coding help may assist with snippets or guidance, but they typically don’t embed the same end-to-end agent workflow across IDE, CI/CD, Slack/Teams, and backlog-to-PR execution as described for Factory.
• CI/CD automation platforms and internal dev automation: Teams can build scripts or agent-like workflows around their pipelines, but this differs from Factory’s emphasis on agent-native delegation across multiple interfaces.
• Workflow/issue automation tools with custom integrations: Automating actions based on ticket events is possible with generic automation platforms, but you’d need to connect coding execution, context handling, and PR creation yourself.
• IDE task automation extensions: Editor plugins can streamline repetitive tasks inside the IDE, but they may not provide the same cross-interface delegation (web/CLI/Slack/Teams/project manager) described on the Factory page.