Understanding Factory: An AI‑Powered Agent Army for Scalable Software Development

Recent AI coding tools have become much more capable, yet integrating them into a development team often feels incomplete. Factory addresses this gap by treating AI as a full development team composed of specialized agents, or "Droids," each responsible for a distinct aspect of software engineering.

Core Concept: Droid Design Philosophy

Different development tasks require different expert agents, just as a mature team assigns front‑end, back‑end, and operations work to appropriate members.

Five Core Droids

Code Droid – the primary programmer that writes, refactors, and fixes code. It offers progressive refactoring, pre‑optimised system hints, a dedicated toolset, model adaptation, and task‑specific design.

Knowledge Droid – the research and documentation specialist. It follows a four‑step workflow: (1) research latest articles and papers, (2) analyse applicability, (3) tailor suggestions to the project, and (4) generate complete technical documents. The author notes a serverless cost‑optimisation report that was more thorough than a week‑long manual effort.

Reliability Droid – the monitoring and incident‑response guardian. It handles production alerts, performs root‑cause analysis, conducts fault isolation, and documents solutions. Its root‑cause analysis once traced a bug back three days to a code change that had been overlooked.

Product Droid – the product‑management expert. It translates business requirements into technical tasks, tracks progress, allocates resources, and assesses risk, effectively merging product‑manager and project‑manager roles.

Tutorial Droid – the onboarding coach that guides new users through Factory’s features, learning paths, best‑practice training, and usage tips.

Two‑Stage Workflow

Spec Mode (Plan First)

Factory’s core design is the Spec Mode, a "plan‑then‑execute" approach. Users switch between default, auto, and spec modes with Shift‑Tab. In Spec Mode, the AI does not write code immediately; it first understands requirements, designs a solution, and creates a detailed plan, similar to an architect drafting blueprints.

> Add a feature for users to export their personal data as JSON.
> Include proper error handling and rate limiting to prevent abuse.
> Follow our existing patterns for API endpoints.

The generated specification includes acceptance criteria, implementation steps, technical details (libraries, patterns, security), file changes, and test strategy.

Build Mode (Execute)

After the plan is approved, Factory enters Build Mode where the Droids collaborate: Code Droid writes code, Reliability Droid monitors quality, Knowledge Droid provides technical support, etc. Build Mode offers three autonomy levels:

Manual approval (low) – changes are edited but each modification requires approval.

Safe commands (medium) – reversible changes are applied automatically, risky changes are queried.

Full autonomy (high) – Droids handle everything without human intervention.

It is recommended to start with low autonomy and increase trust over time.

Multi‑Layer Context Management

Layer 1 – AGENTS.md (Project‑Level Configuration)

The base context layer is the AGENTS.md file, analogous to Claude’s CLAUDE.md . It defines build commands, project layout, Git workflow, security requirements, performance standards, and forbidden actions. This file should be created at the start of every project.

Layer 2 – Dynamic Code Context

When a query is submitted, Droids automatically search the repository for the most relevant files, load build output and test results, and add them to the conversation, ensuring they work with up‑to‑date code and execution data.

Layer 3 – Tool‑Integration Context

Factory connects to external tools to break information silos: Monitoring and logging (Sentry, Datadog) Documentation (Notion, Google Docs) Project management (Jira, Linear) Communication (Slack) Version control (GitHub, GitLab) These integrations let Droids read code, review design docs, inspect tickets, and analyse logs, providing truly holistic assistance.

Layer 4 – Organizational Memory

Factory maintains two kinds of persistent memory: User memory (private) – personal environment settings, work history, preferences, and habitual patterns. Organization memory (shared) – company‑wide style guides, security policies, architecture patterns, onboarding processes, and best practices. When a user says "remember our staging environment is staging.company.com," Factory stores it in user memory; when a teammate mentions a naming convention like snake_case , it becomes part of organization memory, influencing all Droids.

Practical Case: Implementing a Notification System from a Notion Document

> Implement the notification system described in this Notion doc:
> https://notion.so/team/notification-system-architecture

Droid fetches the Notion document content.

It parses the architecture decisions and requirements.

It searches existing notification patterns in the codebase.

It recalls organization memory for any team conventions.

It shows where the notification code should live via AGENTS.md.

The Droid then combines the documented architecture, existing patterns, organizational conventions, and project structure to generate the implementation plan.

Enterprise‑Grade Features

CLI Installation : curl -fsSL https://app.factory.ai/cli | sh followed by droid to start a session.

Multiple Usage Modes : command‑line interface, web UI, IDE plugins (VSCode, JetBrains), and API for custom automation.

Session Management : each chat is a "Session" that can be project‑specific, shared across the team, run in parallel, and archived for later review.

Droid Exec (headless mode) : non‑interactive command execution, e.g.,

droid exec --auto high "run tests, commit all changes, and push to main"

, suitable for CI pipelines.

Custom Droids : define new agents in .factory/droids/ using markdown with YAML front‑matter to specify name, model, tools, and instructions.

Custom Slash Commands : static markdown templates or executable scripts that can be invoked from chat, such as /run-test to trigger the test suite.

Own Model API Key : switch to a personal model via the /model command while retaining Factory’s orchestration and memory features.

Value and Outlook

From several real‑world cases, Factory delivers three main benefits: a 40‑60 % boost in development efficiency (especially for repetitive tasks and knowledge retrieval), higher code quality and system stability thanks to Reliability Droid’s continuous monitoring, and long‑term cost reduction despite an initial investment. The tool shifts developers from "code monkeys" to architects and decision‑makers, redefines value from writing code to strategic problem solving, and evolves collaboration from individual acceleration to true human‑AI teamwork. Looking ahead, Factory, originally focused on enterprise deployments, is expanding toward a broader market. Independent developers may see it as similar to Claude Code, but large engineering teams with existing codebases gain a dramatically different experience when all tools are connected and Droids operate autonomously in the background.