Dark Factory Operator - Level 2: The Dark Factory

Course: scale one assistant into a multi-agent factory. Orchestrator, task board, RAG memory, local-model cost control. Unattended, on your hardware. $129 one-time.

Price: $129 one-time.

Modules

Module 00: What You're Building (15 min)

• The architecture at a glance: memory hub, task board, orchestrator, workers
• How Nexus orchestrates the worker roster: scout, forge, audit, and support roles
• What you'll have by M07, and what M08 through M11 add on top

Module 01: The RAG Stack: Your Agent's Brain (50 min)

• What the stack is: FastAPI + PostgreSQL + pgvector + SQLite task board
• Installing and starting the stack: start-fastapi.sh, systemd service with health check
• Core endpoints: /search, /ingest, /memories, /tasks, /library, /symbols
• Symbol search (tree-sitter): 100–200x token savings over embedding search

Module 02: The Task Board & Worker Pattern (55 min)

• Task lifecycle: pending → in_progress → done (also: error, stalled)
• The worker script pattern: poll → claim → execute → store result → mark done
• Heartbeat: why workers send it every 30 seconds
• Stall detection: >5 min no heartbeat = auto-reassign

Module 03: Skills & The Library (55 min)

• SKILL.md format deep dive: frontmatter fields, library metadata, auto vs manual loading
• What makes a good skill: focused, composable, self-contained
• The library: four item types (skill, agent, prompt, hook) stored centrally, retrieved from any agent on any machine
• Symlinks: one skill file, all agents, one update, all agents get it

Module 04: Nexus: The Orchestrator (75 min)

• Nexus's role: sole orchestrator, never implements directly
• Task decomposition: research → implement → validate routing
• The 5-minute heartbeat: error sweep with LLM analysis, stall detection
• Definition of Done: compare all outputs against original spec before closing

Module 05: Memory at Scale (60 min)

• The problem with naive memory: issue + fix = two memories, agent re-fixes the same thing
• Cross-agent memory: Nexus stores routing, audit-1 stores validation, forge-1 stores task results, all searchable by all
• The RAG Explorer UI: browsing, filtering by agent, semantic search, editing
• Friday maintenance script: classify unsorted, prune garbage, dedup, age-prune

Module 06: SpecWeaver: Spec to Deployment (80 min)

• SpecWeaver: the spec format, required sections, specweaver validate
• The full workflow: spec → scout-1 researches → forge-1 implements → audit-1 validates → forge-1 fixes → done
• Validation loop: audit-1's fix instructions → forge-1 applies → audit-1 re-validates
• What makes a good spec for delegation: concrete, testable, single deliverable per section

Module 07: Production Operations (95 min)

• Failure handling: the 3-tries rule, immediate-stop cases (401, 404, wrong tool)
• Systemd service management: start, restart, logs, auto-restart on failure
• Cost control: rate-limit proxy, budget thresholds, token reduction techniques
• Desktop/laptop team coordination: cross-machine task routing via Tailscale
• Credential vault: add, rotate, test, and delete secrets from a dashboard (without ever displaying one) plus one audited run that migrates your whole .env

Module 08: Graph Engineering (~95 min)

• The spectrum of determinism: which parts of your factory are code, which are one model call, which are full agents
• Primitives, typed state, and checkpointers vs stores, plus the two schema mistakes that break in-flight runs
• Supervisor, hierarchical, swarm, and dynamic fan-out, and why your task board is already fan-out
• Tool design, deployment tiers, and three-level evaluation, including the one level nobody checks
• The competitive landscape and the emerging standards, fact-checked, with the honest weaknesses of the graph approach

Module 09: Loop Engineering (80 min)

• Anatomy of a loop: the recurring run-verify-decide cycle behind every automation you've built
• The Loops Stack: four loop layers across both courses, and which pattern fits which job
• Validating a loop: the 4-condition test and the KEEP/REVERT gate, know it works before it runs unattended
• Anti-patterns: the eight ways loops fail, their symptoms, and the fix for each

Module 10: Spec-Driven Development & Dark Code Defense (75 min)

• Spec-driven four-phase workflow: Specify → Plan → Tasks → Implement
• What is dark code and why it multiplies: AI-generated code that passes tests but no human understands
• Three-layer solution: spec-first, self-describing systems, eval-driven
• Comprehension gate principle: before merging, can you explain it?

Module 11: The Project Management Suite (80 min)

• Client context layer: brand voice, ICP, project files, fetched by agents on demand
• Live integrations: Stripe, N8N, Google Workspace, all accessible via one API endpoint
• Daily briefings with real business data: revenue, open tasks, calendar, active projects
• Cross-agent project rooms: structured handoffs so any agent picks up where the last left off

Module ★: Bonus: Anti-Patterns Library & Mission Control ()

• Anti-patterns: how each one shows up in a running factory, and the fix
• Optimization patterns for cost, latency, and throughput
• Course 2 glossary in the reader top bar: every new tool and term in one place
• Mission Control: the hub's dashboard at /ui and the smoke suite that proves it loads
• Per-module downloads (M01-M11) and the 6-hook library

Frequently asked questions

What are the prerequisites?

Level 1 or equivalent experience. You should know how your agent harness (OpenCode or Claude Code) works, how skills load, and how to direct your agent. Level 1 covers all of this, take it first if you haven't. Level 1 runs on Mac, Windows, and Linux. Level 2 needs a Linux environment: Windows via WSL2 (Windows' built-in Linux environment, tested) or 64-bit Linux (tested; the setup script targets Debian/Ubuntu and RHEL-family distributions). On a Mac, run it in a Linux VM or on a small VPS; the setup scripts do not run natively on macOS. Budget roughly a few dollars a month for a VPS if you go that route, plus some extra setup time.

How is this different from LangChain or AutoGen?

LangChain and AutoGen are libraries. This is infrastructure. The course teaches you to build the memory system, the task board, the orchestrator. The layer that makes agents actually cooperate. You can use those libraries inside this system if you want.

Does this require a second computer?

No. The full system runs on one machine. Module 7 covers a multi-machine setup via Tailscale for scaling. That's optional, not required.

What is SpecWeaver?

SpecWeaver is a CLI tool for creating and validating engineering specs in a format your agent team can act on. Module 6 covers it in full, specweaver validate checks your spec before you hand it to Nexus, so you catch gaps before agents start working. The module can be followed without the toolkit; the CLI toolkit is a separate $37 product, included in the $196 Architect Bundle.

What about privacy?

The full Dark Factory (shared memory, spec-to-deployment) runs on a single laptop with no cloud dependencies. Every component works locally. Nothing leaves your machine unless you choose a hosted model (your prompts and file contents go to that provider) or turn on an external integration (whatever it sends leaves too).

Do I need GPU hardware?

No GPU required. The system runs on CPU inference. Minimum 16GB RAM; 32GB recommended for running multiple agents simultaneously.

How long do I have access?

Lifetime access. All future updates included, and the field moves fast, so there will be updates.

What is founder's pricing?

The current prices are held for the first 50 students, in exchange for an honest review once you've built. After the first 50, pricing moves to the regular rate.

What if it doesn't work for me?

30-day guarantee. Read all 12 modules in the browser, risk-free. Not for you? Email support@darkfactory.education for a full refund. Downloading the kits makes the purchase final. The files are the product. Full policy: /refund.