AIFactory — a guided tour

AIFactory turns a written spec into merge-ready code through the PARR loop — Prepare · Act · Reflect · Review — in an isolated git worktree, with you in control at every gate. Here’s what that looks like in the product.

Mission control

Every unit of work moves left-to-right across a board you can read at a glance — from Backlog through In Progress, AI Review, Human Review, and Done — with live PARR-stage dots and progress on each card.

Board columns — **The board**Backlog → In Progress → AI Review → Human Review → Done, at a glance.

Work flowing into review — **Flow**Runs land in Human Review and Done as they complete.

Human review column — **Human review**Completed and errored runs wait for your verdict — nothing merges itself.

A task card mid-flight — **Live progress**A card mid-flight: PARR stage dots and a coding progress bar.

Stuck task recovery — **Self-healing**A stalled run is detected and offered a one-click Recover.

Inside a task

Open any task for the full story: the intent, the decomposed plan, the generated spec, the streamed PARR log, live resource/token observability, and a read-only mirror of the agent’s terminal you can attach to at any time.

Task overview — **Overview**The one-line intent and timeline for the run.

Task subtasks — **Subtasks**The plan decomposed into independently verifiable units.

Generated spec file — **Files**The generated, editable spec — every run starts spec-first.

PARR logs — **Logs**The PARR loop in the open — Prepare, Act, Reflect, every step streamed.

Task observability — **Observability**Live token spend by bucket, CPU/memory, and a channel to message the agent.

Live agent console — **Live console**A read-only mirror of the agent's terminal — click Attach to take control.

QA test run — **Verify**The QA phase: the full pytest suite running and passing live.

Stuck task subtasks — **Recovery**6/7 subtasks done and a clean Recover & Restart when a run stalls.

Per-worker, per-provider observability

AIFactory runs parallel coding workers across providers — Claude, Gemini, and local Ollama models side by side. Now it emits real OpenTelemetry per-worker metrics from the web-server (labelled by provider and model, with bounded cardinality), streams live worker events with a 10-second heartbeat, and reports cost per worker through the v1.3 completion event (workers[] / by_provider / by_model) instead of collapsing it to a single model string. A soft, observe-only budget alert surfaces when a task crosses a threshold without ever killing the run. The result: you can finally answer, per task and live, what a build cost, on which model, and where the time went.

Feeds the live build map, and proves it ran

The build stage now exposes per-subtask depends_on and started_at / completed_at timing on /api/tasks/{id}, which CFactory turns into the code-stage of its live execution diagram — the same DAG you watch in the cockpit. AIFactory also honours the RFC-0001a evidence gates: a build only claims “passed” when it carries proof it ran — non-zero tokens and completed phases — so an expired-credential build that consumes zero tokens is reported as failed, not silently green.

Memory & settings

AIFactory keeps persistent cross-session memory so agents carry context forward — backed by an embedded knowledge graph with selectable, local-first embedding models.

Memory and embeddings settings — **Agent memory**Persistent cross-session memory via MCP, with local-first embedding models — semantic search optional, keyword search always works.

← Back to the products