Skip to content
/
Tier A A8 Cross-runtime harness

Factory Droid

droid-factory · factory.ai/

Primitive shape 12 total
Commands 3 Hooks 9
00

Summary

Factory Droid — Summary

Factory is an AI-native software development platform whose primary product is Droid — an AI coding agent available as a CLI (droid), desktop app (Factory App), and headless/CI mode (Droid Exec). Factory has rich public documentation revealing a sophisticated architecture: custom droids (subagents as YAML-frontmatter Markdown files in .factory/droids/), SKILL.md-based skills, hooks (9 events: PreToolUse, PostToolUse, UserPromptSubmit, Notification, Stop, SubagentStop, PreCompact, SessionStart, SessionEnd), custom slash commands, plugin system, Specification Mode with mixed models (different model for planning vs. implementation), AGENTS.md support, MCP integration, and Factory Missions (orchestrated multi-step project execution).

The hook system is nearly identical to Claude Code's (PreToolUse, PostToolUse, SessionStart, Stop, SubagentStop, PreCompact) — Factory likely built on top of or heavily mirrors Claude Code's lifecycle. Droid Computers (persistent cloud/local machines), AutoWiki (auto-generated repo documentation), Droid Control (browser/terminal automation for QA), Droid Shield (secret detection), and Agent Readiness reports (repository autonomy maturity scoring) round out the platform.

Closest seed: superpowers (skills-based behavior extension for Claude Code-compatible agents) — Factory appears to build on Claude Code's architecture while adding a commercial platform layer. However Factory is closer to kiro in commercial scope and taskmaster-ai in structured task management.

01

Overview

Factory Droid — Overview

Origin

Factory.ai — commercial AI development platform. Self-described as "Agent-Native Software Development." Has open source components (Factory for Science initiative) and enterprise products. Active development with changelog showing releases 1.8, 1.9, 1.10 (features: MCP Manager, custom completion sounds, Droid hooks, headless CLI, Slack/Linear integrations, mixed models, custom subagents, GitHub PR reviews).

Philosophy

"Your software Factory powered by Droid" — the platform framing. Factory positions itself not as a single agent but as a complete software factory infrastructure:

  • AGENTS.md: "Teach agents everything they need to know about your project with a single Markdown file"
  • Skills: "Add reusable capabilities that Droid can invoke on demand"
  • Hooks: Turn suggestions into "app-level code that executes every time it is expected to run" — encoding rules as deterministic enforcement rather than prompts
  • Missions: "Plan and execute larger projects with structured multi-step workflows"
  • Agent Readiness: "Measure repository maturity and track autonomy progress over time"

Key Manifesto Quotes

From hooks documentation: "By encoding these rules as hooks rather than prompting instructions, you turn suggestions into app-level code that executes every time it is expected to run."

From Missions documentation: "The biggest value we have found in Missions is in the planning phase. Getting the upfront plan right — the features, the ordering, the milestones, the skills involved — is what determines whether the execution succeeds."

Positioning

Factory targets enterprise and startup engineering teams who want structured, reproducible AI-assisted development — not just ad-hoc prompting. The "Agent Readiness" report (measuring repository autonomy maturity) implies a progression model: teams should improve their repos to enable more autonomous agent work over time.

02

Architecture

Factory Droid — Architecture

Distribution

  • Type: SaaS + CLI + desktop app (proprietary)
  • CLI binary: droid

Install Methods

# CLI (macOS/Linux)
curl -fsSL https://app.factory.ai/cli | sh
# Homebrew cask
brew install --cask droid
# Windows
irm https://app.factory.ai/cli/windows | iex
# npm
npm install -g droid

Config Files

  • AGENTS.md — project-level agent instructions (root of repo)
  • .factory/droids/<name>.md — project-scoped custom droids (subagents)
  • ~/.factory/droids/<name>.md — personal custom droids
  • .factory/skills/<name>/SKILL.md — project skills (inferred)
  • ~/.factory/skills/<name>/SKILL.md — personal skills (inferred)
  • ~/.factory/settings.toml (or equivalent) — settings
  • ~/.factory/hooks/ — global hooks

Surfaces

  1. Droid CLI (droid) — full-screen TUI in terminal
  2. Factory App — desktop application
  3. Droid Exec — headless/non-interactive for CI/CD
  4. Factory App (web) — cloud workspace (app.factory.ai)

Custom Droid (Subagent) Format

---
name: code-reviewer
description: Focused reviewer that checks diffs for correctness risks
model: inherit
tools: read-only
---

You are the team's senior reviewer. Examine the diff the parent agent shares and:
- flag correctness, security, and migration risks
...

Hook Events (9)

PreToolUse, PostToolUse, UserPromptSubmit, Notification, Stop, SubagentStop, PreCompact, SessionStart, SessionEnd

Integrations

  • GitHub/GitLab/Bitbucket — automated PR reviews, AutoWiki
  • Slack — workspace context, notifications
  • Linear — planning/issue tracking
  • JetBrains IDEs — IDE integration
  • Zed — IDE integration
  • MCP servers — any external MCP tool
03

Components

Factory Droid — Components

Named Primitives

1. AGENTS.md

Project-level instruction file at the repo root. Teaches agents "everything they need to know about your project with a single Markdown file." Scoped to project; read at session start.

2. Custom Droids (Subagents)

Files: .factory/droids/<name>.md (project-scoped) or ~/.factory/droids/<name>.md (personal). Format: YAML frontmatter + Markdown body. Frontmatter fields: name, description, model (inherit or specific), tools (read-only or full). Invoked by the parent droid; bidirectional context sharing.

3. Skills

Files: .factory/skills/<name>/SKILL.md (project) or ~/.factory/skills/<name>/SKILL.md (personal). Reusable capabilities Droid can invoke on demand. Compatible with Agent Skills open standard (agentskills.io). Shareable via Plugins.

4. Hooks (9 events)

Event Phase
PreToolUse Before any tool call
PostToolUse After any tool call
UserPromptSubmit On user prompt submission
Notification On notification
Stop On agent stop
SubagentStop On subagent stop
PreCompact Before context compaction
SessionStart On session start
SessionEnd On session end

Stored in ~/.factory/hooks/ (global) or project-local hooks directory. Philosophy: "turn suggestions into app-level code that executes every time it is expected to run."

5. Factory Missions

Accessed via /missions command. Phases: collaborative planning → feature list + milestone ordering → Mission Control orchestration view → feature workers + validation workers. Key insight from docs: "The biggest value we have found in Missions is in the planning phase. Getting the upfront plan right — the features, the ordering, the milestones, the skills involved — is what determines whether the execution succeeds."

6. Mixed Models (Specification Mode)

/model command → configure separate model for Specification planning vs. default coding model. Allows high-capability model for spec generation, efficient model for implementation.

7. Custom Slash Commands

Project-defined or personal commands extending the default / command set. Stored in .factory/ directory structure.

8. Plugins

Shareable packages bundling skills, commands, and tools. Install via plugin registry.

9. Droid Computers

Persistent cloud or local machines for long-running tasks. Persistent state across sessions; Droid can "spin up" a computer for extended work.

10. AutoWiki

Automatic repository documentation generation. Integrates with GitHub/GitLab/Bitbucket. Keeps wiki in sync with codebase changes.

11. Droid Control

Browser and terminal automation for QA workflows. Enables agents to control web browsers and terminal sessions for end-to-end testing.

12. Droid Shield

Automatic secret detection — scans outputs/commits for leaked credentials and API keys before exposure. Droid Shield Plus: Enhanced tier with Palo Alto Networks Prisma AIRS integration for enterprise security posture.

13. Agent Readiness

Command: /readiness-report Measures repository maturity and tracks autonomy progress. Scores how well a repo is prepared for autonomous agent work. Implies a progression model: teams improve their repos over time to enable more autonomous execution.

14. MCP Integration

Any external MCP server can be connected. MCP Manager (introduced in v1.8) provides UI for managing MCP server connections.

15. BYOK (Bring Your Own Key)

Supported providers: Anthropic, OpenAI, Ollama, Groq, DeepInfra, Fireworks, Baseten, Hugging Face, OpenRouter.

16. IDE Integrations

  • JetBrains IDEs
  • Zed
  • (VS Code implicit via CLI)

17. GitHub/GitLab/Bitbucket Integrations

Automated PR reviews, AutoWiki sync.

18. Slack Integration

Workspace context ingestion, notifications.

19. Linear Integration

Planning and issue tracking synchronization.

Component Hierarchy

Factory Platform
├── Droid CLI (droid)
│   ├── AGENTS.md (project instructions)
│   ├── Custom Droids (.factory/droids/)
│   ├── Skills (.factory/skills/)
│   ├── Hooks (~/.factory/hooks/)
│   ├── Commands (custom slash)
│   └── Plugins
├── Factory App (desktop)
├── Droid Exec (headless/CI)
├── Factory App (web/cloud)
│   ├── Droid Computers
│   ├── Mission Control
│   ├── AutoWiki
│   └── Agent Readiness
└── Security Layer
    ├── Droid Shield
    └── Droid Shield Plus
05

Prompts

Factory Droid — Prompts & Instructions

AGENTS.md (Project Instructions)

Factory describes AGENTS.md as: "Teach agents everything they need to know about your project with a single Markdown file."

The file lives at the root of the repository. It is read by Droid at session start to establish project context. Factory explicitly promotes AGENTS.md as the primary mechanism for encoding project-specific knowledge — preferred over prompting at runtime.

No verbatim schema is publicly documented (Factory's docs describe the concept but not a rigid schema). Content is freeform Markdown describing:

  • Project structure
  • Key conventions
  • Development workflows
  • Dependencies and constraints
  • Testing approach

Custom Droid (Subagent) Format

---
name: code-reviewer
description: Focused reviewer that checks diffs for correctness risks
model: inherit
tools: read-only
---

You are the team's senior reviewer. Examine the diff the parent agent shares and:
- flag correctness, security, and migration risks
...

Frontmatter fields:

  • name — identifier used to invoke the droid
  • description — human-readable purpose description (also used by parent droid to select appropriate subagent)
  • model — inherit (use parent's model) or specific model identifier
  • tools — read-only (no write/execute) or full (all tools)

The body is a freeform system prompt written in Markdown.

Hooks Philosophy

From Factory's documentation:

"By encoding these rules as hooks rather than prompting instructions, you turn suggestions into app-level code that executes every time it is expected to run."

This is the core design principle: move behavior from prompts (probabilistic) into hooks (deterministic enforcement). Hooks are configured as executable scripts that run on lifecycle events.

Specification Mode Instructions

When Spec Mode is active (configured via /model), the planning model receives the user's goal and generates a structured specification/plan. This specification is then handed off to the implementation model. The exact prompt templates are not publicly documented.

Missions Planning Prompt Guidance

From Factory's documentation:

"The biggest value we have found in Missions is in the planning phase. Getting the upfront plan right — the features, the ordering, the milestones, the skills involved — is what determines whether the execution succeeds."

This implies the Mission planning phase involves structured prompting to produce: feature list, milestone ordering, skills manifest, and execution plan.

Skill Instructions (SKILL.md)

Skills live at .factory/skills/<name>/SKILL.md. Each skill file contains:

  • Instructions for how Droid should invoke the skill
  • The capability description used during skill selection
  • Implementation details or delegated actions

Compatible with the Agent Skills open standard (agentskills.io).

System Prompt Source

Factory Droid is closed-source. Internal system prompts are not publicly available. The above represents the documented, user-facing instruction mechanisms.

09

Uniqueness

Factory Droid — Uniqueness

Differs From Seeds

The closest seed is superpowers (skills-based behavior extension for Claude Code-compatible agents), since Factory explicitly uses SKILL.md, AGENTS.md, and a hook system nearly identical to Claude Code's lifecycle events. However, Factory goes far beyond a skills framework — it is a full commercial platform.

The second-closest is kiro (closed-source commercial IDE product with proprietary primitives). Like Kiro, Factory is a commercial, closed-source product with a rich proprietary primitive set. Unlike Kiro's spec-steering approach, Factory's distinctive bet is hooks as enforcement: encoding rules as deterministic code rather than probabilistic prompts.

Distinctive Opinion

Factory's stated philosophy: "By encoding these rules as hooks rather than prompting instructions, you turn suggestions into app-level code that executes every time it is expected to run."

This is a strong, falsifiable claim that distinguishes Factory from every other framework in the corpus. No seed framework makes this argument this explicitly. The implication: prompting is unreliable governance; hooks are reliable governance.

The corollary from Missions: "The biggest value we have found in Missions is in the planning phase. Getting the upfront plan right — the features, the ordering, the milestones, the skills involved — is what determines whether the execution succeeds." This is a planning-primacy thesis — execution quality is a function of specification quality, not execution sophistication.

Unique Features Not Found in Seeds

  1. Agent Readiness report — no seed framework scores repository maturity for agent-readiness. Factory implies a progression model: repos improve over time to become more agent-autonomy-friendly.

  2. Factory Missions — hierarchical orchestration with collaborative planning, Mission Control view, feature workers + validation workers. More structured than any seed's orchestration approach. The planning phase is first-class.

  3. Mixed Models (Spec Mode) — factory routes different phases to different models. Most frameworks are single-model or allow model selection; Factory's novelty is that the planning and implementation phases explicitly use different models as an architectural decision.

  4. Droid Shield Plus — Palo Alto Networks Prisma AIRS integration. Enterprise security posture at the AI layer. No seed framework has a named security product integration.

  5. AutoWiki — living documentation auto-generated and auto-maintained from codebase changes. No seed framework maintains documentation as a first-class platform feature.

  6. Droid Control — browser and terminal automation for QA. Extends agent capability to end-to-end UI testing as a platform-level feature, not just a tool call.

  7. Droid Computers — persistent cloud/local machines for cross-session state. More sophisticated than simple file-based memory; actual persistent compute environments.

Hook Architecture Mirror

Factory's 9 hook events (PreToolUse, PostToolUse, UserPromptSubmit, Notification, Stop, SubagentStop, PreCompact, SessionStart, SessionEnd) overlap substantially with Claude Code's hook system (PreToolUse, PostToolUse, PreCompact, Stop, SubagentStop, SessionStart). The UserPromptSubmit and Notification events are additions. This strongly suggests Factory built on top of or heavily mirrors Claude Code's lifecycle architecture.

Positioning

  • Primary competitors: Devin (cloud coding agent), Cosine (first-party model coding agent), Cursor (IDE)
  • Target: engineering teams wanting structured, reproducible AI-assisted development — not ad-hoc prompting
  • Enterprise focus: Droid Shield Plus, Droid Computers, Agent Readiness reporting, BYOK

Cross-References

  • Cosine — similar three-surface strategy (CLI + Desktop + Cloud); Cosine's differentiator is proprietary models vs. Factory's platform depth
  • Devin — similar cloud execution model; Factory has more local-first options
  • Zed — both support AGENTS.md and SKILL.md; Zed is open-source IDE vs. Factory is closed commercial platform
  • superpowers — both use SKILL.md convention; Factory extends far beyond skill execution
04

Workflow

Factory Droid — Workflow

Standard Session Workflow

  1. Session Start hook fires
  2. Droid reads AGENTS.md at repo root
  3. Droid loads project skills from .factory/skills/
  4. User submits prompt → UserPromptSubmit hook fires
  5. Droid plans and executes:
    • PreToolUse hook before each tool call
    • Tool executes
    • PostToolUse hook after each tool call
  6. Subagents (custom droids) spawned as needed → SubagentStop hook on completion
  7. Context compaction if needed → PreCompact hook
  8. Agent stops → Stop hook fires
  9. Session End hook fires

Factory Missions Workflow

Phase 1: Collaborative Planning

  • User invokes /missions
  • Droid and user co-develop the mission plan:
    • Feature list
    • Milestone ordering
    • Skills to involve
  • "Getting the upfront plan right — the features, the ordering, the milestones, the skills involved — is what determines whether the execution succeeds."

Phase 2: Mission Control Orchestration

  • Mission Control view activates
  • Feature workers execute assigned features in parallel
  • Validation workers run checks at milestone boundaries
  • Progress tracked in structured multi-step workflow

Phase 3: Completion

  • All milestones validated
  • Mission marked complete
  • Optional AutoWiki update

Droid Exec (Headless/CI Mode)

  • Non-interactive execution for CI/CD pipelines
  • No TUI; output is structured log/JSON
  • Suitable for: automated PR reviews, scheduled tasks, pipeline integration
  • GitHub Actions / GitLab CI / Bitbucket Pipelines integration

Specification Mode (Mixed Models)

  1. User configures spec model via /model → "Configure Spec Mode Model"
  2. High-capability model generates specification / plan
  3. Default (efficient) model handles implementation
  4. Reduces cost while maintaining plan quality

PR Review Workflow (GitHub/GitLab/Bitbucket)

  1. PR opened/updated in connected repository
  2. Factory webhook triggers
  3. Droid analyzes diff against codebase context
  4. Review posted as PR comments
  5. Optional AutoWiki update on merge

AutoWiki Sync

  • Triggered on push/merge events
  • Droid reads changed files
  • Updates wiki entries corresponding to changed components
  • Maintains living documentation in sync with code

Approval Gates

Factory Droid has no explicit approval gate described in public docs for standard sessions — the interactive TUI is the gate. For Droid Exec (headless), execution is fully autonomous within the configured scope.

Agent Readiness Loop

  • Run /readiness-report on demand
  • Receive scored report: what's missing, what's well-configured
  • Improve: add AGENTS.md, add skills, configure hooks
  • Re-run to track progress toward autonomous execution maturity
06

Memory Context

Factory Droid — Memory & Context

Session-Level Context

AGENTS.md

Loaded at session start. Provides static project context: conventions, structure, workflows. Persists for the lifetime of a session. The primary mechanism for long-lived project knowledge.

Skills Catalog

Project skills (.factory/skills/) and personal skills (~/.factory/skills/) are loaded at session start. Droid can invoke skills on demand — skills are retrieved by relevance during task execution.

Conversation History

Standard in-context conversation history within a session. Context compaction is handled via the PreCompact hook, which fires before any compaction occurs. This allows hook scripts to persist or log important context before truncation.

Cross-Session Persistence

Droid Computers

Persistent cloud or local machines that maintain state across sessions. A Droid Computer retains:

  • File system state
  • Running processes
  • Browser/terminal sessions (via Droid Control)
  • Previously downloaded dependencies

This is Factory's answer to cross-session memory: instead of summarizing context, the machine state itself persists.

Cloud Workspace (app.factory.ai)

Factory's cloud platform maintains session history and project context. Users can resume work across devices.

Knowledge Architecture

AutoWiki

Auto-generated repository documentation kept in sync with code changes. Serves as persistent, automatically-maintained documentation that agents can query for project understanding. Acts as a durable, externally-stored knowledge base derived from the codebase itself.

Agent Readiness Report

Repository-level audit of agent-readiness. Not a memory mechanism per se, but a persistent score/report tracking how much project knowledge has been encoded into agent-accessible formats (AGENTS.md, skills, hooks).

Context Sources (Ranked by Specificity)

  1. Droid Computer state — most specific, current machine state
  2. AGENTS.md — explicit project instructions
  3. Skills — reusable capability definitions
  4. AutoWiki — derived documentation
  5. Conversation history — ephemeral in-session context
  6. Integrations — Slack workspace context, Linear issues

Memory Type Classification

Dimension Value
Primary memory type file-based (AGENTS.md, skills) + cloud-persistent (Droid Computers)
Cross-session yes (Droid Computers, cloud workspace)
Compaction handling PreCompact hook
Search mechanism skill retrieval (inferred relevance matching)
External knowledge AutoWiki, Slack context, Linear issues
State files AGENTS.md, .factory/droids/.md, .factory/skills//SKILL.md
07

Orchestration

Factory Droid — Orchestration

Multi-Agent Architecture

Factory Droid uses a parent-subagent model. The primary Droid is the orchestrator; custom droids are subagents invoked by the parent.

Custom Droid Spawning

  • Parent droid selects a subagent based on the subagent's description field
  • Subagent receives delegated task + relevant context from parent
  • Subagent executes with its configured tool scope (read-only or full)
  • SubagentStop hook fires when the subagent completes
  • Results returned to parent droid

Parallel Execution

Factory Missions explicitly uses feature workers + validation workers — implying parallel subagent execution. The orchestration pattern is parallel fan-out: multiple feature workers run concurrently, each handling a distinct feature/milestone.

Factory Missions Orchestration

User → /missions → Planning Phase
                        ↓
               Feature List + Milestones
                        ↓
               Mission Control View
               ┌────────────────────┐
               │  Feature Worker A  │
               │  Feature Worker B  │ (parallel)
               │  Feature Worker C  │
               └────────────────────┘
                        ↓
               Validation Workers
                        ↓
               Milestone Complete

Mission Control provides a visibility layer showing which workers are active, what they're doing, and milestone progress.

Mixed Model Orchestration

Factory's Specification Mode uses two models in sequence:

  1. Spec model (high-capability) → generates structured plan/specification
  2. Default model (implementation-optimized) → executes against the spec

This is a sequential, handoff-style orchestration rather than parallel. The spec is the artifact that bridges the two model invocations.

Hook-Based Governance

Hooks fire at 9 lifecycle points and can block or modify agent behavior:

  • PreToolUse — can block tool calls (e.g., prevent destructive operations)
  • PostToolUse — can validate outputs (e.g., run linter after code write)
  • UserPromptSubmit — can augment or gate user prompts
  • PreCompact — can persist important context before compaction

Hooks provide deterministic guardrails around otherwise probabilistic agent behavior. Factory's philosophy: hooks convert suggestions into enforcement.

Isolation Mechanism

Custom droids have configurable tool scopes:

  • read-only — subagent cannot modify files or execute code
  • full — unrestricted tool access

No container isolation is documented for subagents (unlike trae-agent which uses Docker). Tool scope is the isolation boundary.

Consensus / Validation

Validation workers in Missions provide post-feature validation. No consensus mechanism between agents — validation is sequential after parallel feature work.

Droid Exec (Headless Orchestration)

Droid Exec enables fully autonomous execution without a human in the loop. Used for:

  • CI/CD pipeline tasks
  • Scheduled repository maintenance
  • Automated PR reviews (GitHub/GitLab/Bitbucket integration)

The orchestration model in headless mode mirrors interactive mode but without the TUI surface.

08

Ui Cli Surface

Factory Droid — UI & CLI Surface

CLI Binary: droid

Install Methods

# macOS/Linux (curl)
curl -fsSL https://app.factory.ai/cli | sh

# Homebrew cask
brew install --cask droid

# Windows (PowerShell)
irm https://app.factory.ai/cli/windows | iex

# npm
npm install -g droid

CLI Behavior

The droid binary launches a full-screen TUI (Terminal User Interface) in the terminal. It is not a thin wrapper — it is the primary interactive surface for local development.

Key Commands (Slash)

Command Function
/missions Open Factory Missions planning view
/model Configure model / Specification Mode model
/readiness-report Run Agent Readiness assessment
Custom slash commands User/project-defined extensions

Surface 1: Droid CLI (TUI)

  • Full-screen terminal interface
  • Designed for interactive development sessions
  • Supports custom droids, skills, hooks, slash commands
  • Local execution with optional cloud connectivity

Surface 2: Factory App (Desktop)

  • Native desktop application
  • Mirrors Droid CLI functionality with graphical interface
  • Mission Control view for orchestration visibility
  • Multiple agent states visible simultaneously

Surface 3: Droid Exec (Headless)

  • Non-interactive mode for CI/CD
  • Invoked without TUI; structured output (logs/JSON)
  • GitHub Actions / GitLab CI / Bitbucket Pipelines integration
  • Enables automated PR reviews, scheduled maintenance, pipeline tasks
  • Same agent capabilities as interactive mode, without human-in-the-loop requirement

Surface 4: Factory App (Web)

  • Cloud workspace at app.factory.ai
  • Cross-device session continuity
  • Droid Computers management
  • AutoWiki viewer
  • Agent Readiness dashboard

IDE Integrations

JetBrains IDEs

Factory Droid integrates with the JetBrains plugin ecosystem. Exact plugin name not in public docs at analysis time.

Zed

Factory Droid integrates with Zed editor. Notably, Zed itself has its own agent system — the Factory integration provides Factory's Droid capabilities within Zed's editing surface.

GitHub/GitLab/Bitbucket Integration

  • Webhook-triggered automated PR reviews
  • AutoWiki updates on push/merge
  • Droid comments on PRs with analysis results

Slack Integration

  • Workspace context ingestion — Droid can query Slack for project context
  • Notifications — Droid can send notifications to configured channels

Linear Integration

  • Issue tracking sync
  • Planning context — Linear issues available as context during Missions planning

MCP Manager

Introduced in v1.8. UI component (in Factory App / CLI) for managing connections to external MCP servers. Provides install, configure, enable/disable for MCP tools.

Configuration Files

Path Purpose
AGENTS.md Project-level agent instructions (repo root)
.factory/droids/<name>.md Project-scoped custom droids
~/.factory/droids/<name>.md Personal custom droids
.factory/skills/<name>/SKILL.md Project skills
~/.factory/skills/<name>/SKILL.md Personal skills
~/.factory/settings.toml User settings
~/.factory/hooks/ Global hooks

Related frameworks

same archetype · same primary tool · same memory type

claude-mem (thedotmack) ★ 78k
A8 Cross-runtime harness

Background worker service captures every tool call as an observation, AI-compresses sessions, and auto-injects relevant past…

pi (badlogic/earendil) ★ 55k
A8 Cross-runtime harness

A minimal, hackable, multi-provider terminal coding agent that adapts to your workflows via npm-installable TypeScript Extensions…

Agent Skills (Addy Osmani) ★ 46k
A8 Cross-runtime harness

Encodes senior-engineer software development lifecycle as 23 auto-routed skills and 7 slash commands for any AI coding agent.

wshobson/agents Plugin Marketplace ★ 36k
A8 Cross-runtime harness

Single Markdown source for 83 domain-specialized plugins that auto-generates idiomatic artifacts for five AI coding harnesses.

TabbyML/Tabby ★ 34k
A8 Cross-runtime harness

Self-hosted AI coding assistant server (alternative to GitHub Copilot) with admin dashboard, RAG-based completions, and multi-IDE…

Compound Engineering ★ 17k
A8 Cross-runtime harness

Make each unit of engineering work compound into easier future work via brainstorm→plan→execute→review→learn cycles.