An orchestrator runs a swarm of specialist agents through a strict phase pipeline — hard gates, full traces, automated GitHub, and a visualizer that shows every phase, cost, and decision.
A dedicated agent that launches factory runs, watches every trace, and steers via chat — it never writes code itself. You talk to it, it dispatches the work.
Each agent owns one role in the chain — scout, planner, builder, reviewer, documenter. Every agent call is traced, metered, and gated.
A read-only observability UI that shows every session, phase, event, cost, gate, and decision. Sessions, waterfall traces, stats, memory — all in one place.
Type a task in the orchestrator chat, or run `sssf run --roster <team> "your task"`. The orchestrator receives it and prepares the run.
Kaia converges the environment (LM Studio, visualizer, tunnel, watchdog), spawns the ADW chain, and begins watching the event stream.
Each agent takes its turn — scout reconnoiters, planner phases the work, builder codes, reviewer confirms, documenter writes. Every action is traced to SQLite.
Phases have hard gates: `tests_pass`, review approval, quality checks. A phase defaults to fail until its gates pass. No gate = no ship.
Git branch, commit, test suite, PR creation, and diff capture are deterministic code phases — the pipeline runs them, not an agent improvising git.
Events stream to the visualizer live. Costs, tokens, prompts, thinking, decisions, and gate results are all stored. Every run is replayable.
You launch, converge & observe — the factory's agents own the work. If a run fails, the failing phase is visible in the trace; the fix is a deliberate config, prompt, or chain change.
A read-only observability UI backed by SQLite. Sessions, phases, events, costs, gates, prompts, thinking, memory, decisions — every run becomes a case study you can step through.
Every run as a card — status chip, per-agent timeline dots, cost, runtime, tokens. Polls every 500ms. Filterable and searchable.
Per-lane timeline: engineer, code workspace, and each agent. Phase blocks with colored gradients, tool-call tick marks, and queued phases shown dashed.
Click any phase block. Compiled prompts (system.md + user.md), model thinking/reasoning, gate results with per-item evidence, token costs, output envelopes.
Total runs, success rate, token optimization, cache-hit ratio. Local vs online split. Per-model cost breakdown. Commercial vendor comparison.
Kaia's engram memory: semantic search, timeline, recent episodes. Decisions view groups failed runs by diagnosis type with fixes.
Talk to Kaia. Launch runs, steer live sessions, switch models, view session side-panel with live progress. Tool calls and session launches inline.
sessions and live events refresh automatically
pagination never re-fetches seen events
Bun reads SQLite — no writes except archive
neutral dark and classic deep-space aurora
stacks:
local-fast: # your roster name
tier: local # pulls every model from tiers:local
agents: [planner, builder, reviewer]
frontier: # pin models per team
agents:
planner: { model: claude-opus-5, thinking: high }
builder: { model: gemini-3.6-flash }
you: any mix, any names → sssf run --roster you "ask"sssf run --roster local-fast "polish the homepage"Any team under `stacks:` — run it with `--roster <name>`.
One preset pulls every agent's model. Or pin a model per agent.
Chain agents in any order — scout, planner, builder, reviewer, documenter.
`make_adw.py` scaffolds a new chain from the agents you name.
The chain says what runs; the config says who runs it. Build a team per project, per task, or per model budget — never recompile a thing.
Each git step is its own traced phase — the pipeline opens the branch and raises the PR, not an agent improvising git.
Success must be earned. Every phase defaults to fail until it clears review & the suite is green. `quality.py` is the CI — `tests_pass` is a gate.
The visualizer shows every phase block, gate result, and tool call tick. Click any block to see the full inspector.
The visualizer polls sessions every 500ms. Cursor-based event pagination means you never re-fetch seen events. Watch live without stalling anything.
Every session is saved — events, prompts, thinking, gates, costs. Click into any run and step through every phase in the waterfall trace.
The Decisions view groups failed runs by diagnosis type and model. `sssf audit`, `sssf diagnose`, and `sssf recover` turn a failure into a deliberate fix.
`sssf emergency-stop` halts a runaway run instantly — SIGTERM to children, finalize the DB. `sssf learn` records the lesson into knowledge.
Every plan item becomes a Way of Teams ticket before work starts. Decisions get recorded in Way of Teams memory & knowledge. The WOT MCP server exposes tickets, memory, knowledge, standups, teams, and GitHub review tools — so the factory's runs are coordinated like any other team's.
Factory runs are becoming a Way of Teams feature — per-tenant pipelines, visible runs, review gates, and results surfaced right in the platform. Paying teams run their own build & release loops.
Try it today: install the harness, then run your own factory on a hosted workspace.
Boot a workspaceInstall the harness, boot a hosted workspace, and dispatch your first roster. The visualizer shows every phase, cost, and decision. The Discord is where operators trade runbooks.
We build on the real, open-source AI toolchain. These are the engines we extend, configure, and run — with links that actually go somewhere.
Our AI engineering harness — 51+ battle-tested skills, 14 agents, and workflows wired into 7 AI coding tools. Install once, use everywhere. MIT / Apache-2.0.
The open source AI coding agent we drive from. Terminal, desktop, or IDE — 75+ LLM providers through models.dev, plan mode, LSP, and your existing Copilot/ChatGPT subs.
The minimal, extensible coding agent by Mario Zechner. Adapt Pi to your workflow — not the other way around — via extensions, skills, prompt templates, and packages.