factory — ephemeral ai agent orchestration

walkaway.sh

$ factory start

✓ spawning agents slots: 8/8

workers:3 sensors:2 adversaries:1 kernel:running

$ _

factory start — run it.
walk away. come back to finished work.

an orchestration kernel for ephemeral AI agents that autonomously build, maintain, and improve software. runs locally in docker. one container per agent.

stay updated →

// 01 — what it is

not a dev tool. a living system.

factory runs on your repo like an organism. it perceives the gap between what you intended and what exists, acts to close that gap, defends against regressions, and learns from every failure.

┌──────────────────────────────────────────────────────────┐ │ factory — one per repo. isolated. local. ephemeral. │ ├──────────────────────────────────────────────────────────┤ │ │ │ intent layer principles · prohibitions · postmortems │ │ ↓ │ │ agent slots [worker][worker][worker] [sensor] [adversary] │ │ ↓ │ │ git the only persistent state │ │ ↓ │ │ postmortems failures → learning → better agents │ │ │ └──────────────────────────────────────────────────────────┘

isolation

one container per agent. one factory per repo. fully local in docker. no shared state, no cross-contamination.

persistence

git is the only state layer. agents die. commits survive. ephemeral compute, durable artifacts.

concurrency

agents execute in slots — max N concurrent. resource allocation like kubernetes, but for agent workloads.

federation

factories communicate by filing issues on each other's repos. no proprietary protocol. just git and github.

self-improvement

the factory's own code is a fork. agents file issues against the project and the factory fork. the system improves itself.

// 02 — agent types

three agent types. one nervous system.

agents are ephemeral. they spawn, do exactly one thing, commit, and die. the factory decides what runs next.

workers

build. fix. ship.

directed, task-scoped agents. they receive an issue, write code, open a pr, and terminate. no context between runs. no memory. just output.

the hands. directed. ephemeral. task-complete.

sensors

detect. report. repeat.

cron agents that compare intent (prds, specs, principles) against reality (code, behavior, tests). they generate work — not artifacts. they notice drift before you do.

the nervous system. perceives. creates issues. moves on.

adversaries

probe. break. report.

red team agents and synthetic users that hunt for weaknesses. they try to break what workers built. every failure is filed as an issue with a reproduction.

the immune system. attacks the system it protects.

// 03 — the feedback loop

failures become principles. principles become better agents.

three layers of intent govern every agent decision. the system learns from every postmortem and encodes that learning permanently.

agent runs. something breaks.

a worker ships code. an adversary finds a regression. the failure is captured with full context — what was tried, what failed, why.

postmortem is filed.

the factory writes a structured postmortem: root cause, contributing factors, what should have happened. filed as a durable artifact in the repo. postmortems/ is case law.

postmortem produces a principle or prohibition.

principles/ is the constitution — what the system strives toward. prohibitions/ is the guardrails — what it must never do. both are versioned, auditable, and agent-readable.

next agent spawns with that knowledge.

every new agent reads the full intent layer before acting. the mistake that caused the postmortem will not be repeated. the system is measurably better.