Reactor Get started

From a design to tested software. With a team of agents you review.

Stories, one Claude Code or Codex agent per repository, a live preview, tests that file their own bugs and a wiki for people. Self-hosted, on your own subscriptions.

Get started See the workflow
The Stories board of a bakery e-shop: epics as rows, the steps from story to done as columns, each card with its tasks per layer
8steps, from the Figma design to the wiki
1agent per repository, all of them in parallel
3modes: Studio, the agentic IDE and vibe coding
5platforms: web, mobile, desktop, backend, libraries

Work flows by story, like in Jira.

Epic, story, task and bug with keys like KV-7. Every step has one colour and one icon, on the cards, the tasks and the agents, so you always see where work stands.

A breakdown per repository

The Architect splits stories into frontend, backend and test tasks for the right repository and keeps one OpenAPI contract for all of them.

The breakdown: repositories and the approved API contract on the left, stories with their tasks per layer on the right

Every result waits for review

Follow the agent step by step, open the changed files side by side, then accept or return the task with a comment.

A task in review with the agent's timeline: files read, written and the typecheck

Click through the real app

It runs in an isolated container. A note on any element is a bug for the right agent.

The running bakery e-shop in the preview, with the annotation panel

Tests that file bugs

Playwright tests map to stories by key. A failing one opens a bug; passing again closes it.

Tests grouped by epic and story, one failing test under the cart story

A wiki for people

After green tests the Documenter writes what each feature does and how. You accept the change.

The wiki page of the catalog epic with how-to steps and rules

What waits for you, at a glance.

The overview: stories per step, the items waiting for you and who of the agent team works on what

Design stays in Figma

Frames become screens and layers become elements. Notes, linked stories and what is being worked on live beside them.

Agents as a team

Analyst, Architect, FE and BE developers, Tester and Documenter, each with its role in the steps it owns.

Not only the web

Repositories for web, mobile, desktop, backend or a library, each built by its own agent against one contract.

New: the agentic IDE

Write prompts and code. The backlog writes itself.

  1. A composer that plans per repository

    One prompt becomes tasks for each repository's agent, running side by side in the grid. The agents' diffs show inline in the editor, and ⌘K sends a selection straight to its agent.

    The IDE: files of two repositories, the editor with the agent's inline diff, the agents grid and the composer

  2. The Scribe keeps the trace

    A new topic becomes a story, a follow-up adds criteria, a technical change stays a task. Nothing is guessed: unsure prompts wait unsorted, and every AUTO record can be reverted.

    The trace: prompts and the stories, tasks, contract and wiki pages written from them

  3. Dive in

    The Ponor shows only the running app and one prompt line. Click an element to talk about it; finished runs rebuild the preview, and the code still waits for review.

    The immersive mode: the running app full screen, agent rings and the prompt line

Agents on your own servers.

Workers run where Claude Code or Codex is signed in on a subscription. They connect out to a relay, so no server opens a port, and everything they exchange is end-to-end encrypted.

$ npx aforge-worker enroll <token> \
    --name build-01 --labels build,review
$ npx aforge-worker run
  • orchestrator
  • build
  • review
  • claude
  • codex
  • docker

The orchestrator plans a pipeline; the hub hands independent tasks to free workers by capability, label and load. Tokens and cost are reported, never estimated from prompt length.

Agent runs with their worker, step, context window and cost

You stay in charge.

  • Agents propose, people decide

    The consultant answers with proposals you accept or reject. Code from every run waits for your review.

  • Everything has a way back

    Every change is a git commit; descriptions and wiki pages keep their versions; Scribe records can be reverted.

  • Isolated runs

    Previews, tests and production agents run in bounded containers with filtered networking, never with the host's environment.

  • Self-hosted

    Your server, your Keycloak, your subscriptions. Projects are plain JSON and git repositories on your disk.

One project, three ways to work.

Switch a session between the Studio, the IDE and vibe coding at any time; every story, task and prompt stays. In the clean Finder look, light or dark with the system.

Reactor in the Studio
The whole flow, from the design to the wiki, story by story.

Run Reactor.

Node.js 22, Docker and a signed-in Claude Code (or Codex). Free and open source under the GPL.

$ git clone https://github.com/DanielHromadka/aforge.git
$ cd aforge && npm install
$ npm run runtime:build # once: the preview image
$ AFORGE_AUTH=off npm run dev # http://localhost:5310
Read the guide

Going further