Skip to content

How it works

From one goal to a plan you can follow

Six stages, in a loop. You say what you want. PO plans it, orders the tasks, recalls what the project knows, runs the work, checks it and saves what was learned. Under each stage you can open the technical details.

Plan → Order → Recall → Run → Verify → Learn, then back to Recall. What stage 6 saves is what stage 3 recalls on the next plan.

Try: hover or focus a stage to read it, select it to jump to it

The loop

The loop, stage by stage

Scroll: each picture is drawn like the screens of the product. The example is a team weekend.

Stage 1 of 6: Plan, reading stop 5 of 5: Approved

You say what you want, you get a plan

You describe the result in one sentence. The assistant turns it into a plan with tasks. Each task has steps, and each step says how to check it is done.

Under the hood

The result is saved as a plan with a priority and its constraints, then split into tasks. Each task says what it depends on and lists its steps. Each step carries the check that proves it is done.

Plans, tasks and steps are saved as data, not as free text in a chat. The screens and the runner read the same statuses.

plan(action: "create", title, description, priority: 8, constraints: [{ constraint_type: "performance", … }])task(action: "create", plan_id, title, depends_on: [task_id], steps: [{ description, verification }])
  • Plan status: draft, approved, in_progress, completed, cancelled.
  • Constraint types: performance, security, style, compatibility, other.
  • code(action: "plan_implementation", auto_create_plan: true) drafts a plan from the code graph.

Try: select a stop, step with the arrows or press play; the diagram follows the scroll again after a pause

Stage 2 of 6: Order, reading stop 5 of 5: Ready now

Tasks that do not depend on each other go together

PO sorts the tasks. A task waits only for the tasks it needs. All the others can start now, at the same time.

Under the hood

A task starts only when everything it depends on is completed. PO turns these links into waves: wave 1 holds every task with no unmet prerequisite, wave 2 holds what wave 1 unlocks, and so on.

Tasks in the same wave are independent, so they run at the same time. The longest chain of dependencies, the critical path, sets the minimum number of waves.

plan(action: "get_waves", plan_id)plan(action: "get_critical_path", plan_id)
  • plan(action: "get_dependency_graph") returns the task DAG.
  • task(action: "get_next") returns the next unblocked task, highest priority first.
  • When a run is resumed, waves are recomputed and finished waves are skipped.
Plan · dependency graph
Wave 13 in parallelWave 22 in parallelWave 31 taskT1 Venuesno prerequisiteT2 Availabilityno prerequisiteT3 Budgetno prerequisiteT4 Bookingafter T1, T2T5 Mealsafter T3T6 Share planafter T4

Try: select a task to see what it waits for and unblocks

6 tasks3 waveswave 1 is ready now

Try: select a stop, step with the arrows or press play; the diagram follows the scroll again after a pause

Stage 3 of 6: Recall, reading stop 5 of 5: Handed over

The assistant looks up what the project already knows

Before each task, the assistant reads the notes and decisions that apply. So it does not ask the same questions again.

Under the hood

Before a task, the assistant reads the project memory: notes (warnings, guidelines, patterns), decisions with their reasons and, for a code project, the code around the files it will touch. A search by meaning finds the closest matches first.

Then PO follows the links between notes. A note that did not match the question can still appear, because a note that did match is strongly linked to it. The link weakens at each step, and notes that have faded are left out.

note(action: "search_semantic", query, project_slug)decision(action: "search_semantic", query)admin(action: "search_neurons", query, max_hops: 2)note(action: "get_context", entity_type: "file", entity_id)
  • Spreading activation defaults: 20 seed notes, 2 hops, the signal halves at each hop, 10 results.
  • 40% of the result slots are reserved for notes reached through synapses.
  • A propagated score is the parent score x synapse weight x note energy x decay.
Memory · recall
taskdirecthop 1hop 20.910.840.720.460.410.350.300.170.15

Try: select a node to follow the activation back to the task

Given to the assistant

  • The team prefers a quiet place
    0.91
    guidelinedirect match
  • The weekend is 14 and 15 June
    0.84
    decisiondirect match
  • Two people need vegetarian meals
    0.46
    gotcha1 hop
  • Last year the venue was too far from the station
    0.17
    guideline2 hops

Try: select a stop, step with the arrows or press play; the diagram follows the scroll again after a pause

Stage 4 of 6: Run, reading stop 5 of 5: Wave 2 starts

Assistants do the tasks, group by group

Each task goes to its own assistant. The tasks of a group run at the same time, and the next group waits.

Under the hood

plan(action: "run") starts the runner on its own git branch. For each wave it starts one agent session per eligible task and runs them in parallel, up to a limit (4 by default).

Each task gets a prompt built from the project memory: its description, steps and constraints, the notes linked to it, the persona and skills that match, and a summary of what earlier waves did. A guard watches the session for idle time, repeated calls and timeouts, and sends a hint when the agent drifts.

plan(action: "run", plan_id, cwd, project_slug)plan(action: "run_status", plan_id)
  • A task is profiled simple, complex or creative from its tags, steps and files. The profile sets its time limit and cost budget.
  • Simple: 600 s and $0.50. Complex: 3600 s and $2.00. Creative: 1800 s and $1.00.
  • Runs are saved, so a run can be resumed after a restart. plan(action: "cancel_run") stops one.
  • The assistant that delegates a task can name the provider and the model for it: plan(action: "delegate_task") takes provider, model and task_class. The project must have allowed that provider.

Try: select a stop, step with the arrows or press play; the diagram follows the scroll again after a pause

Stage 5 of 6: Verify, reading stop 5 of 5: Completed

A group is done when its checks pass

Before the next group starts, PO checks the work. The steps must be closed and no sensitive file may be left in the changes. For a code project, PO also checks that it still builds.

Under the hood

When a wave ends, the runner verifies it before the next one starts. It checks that the agents produced commits, that every step is completed or skipped, that the project builds and that the diff contains no sensitive file.

The run itself is a state machine. A lifecycle protocol moves from approved to executing to post_run, and every move needs an explicit trigger. A task whose agent fails or times out is retried once by default, with the error as context.

protocol(action: "transition", run_id, trigger: "child_completed")step(action: "get_progress", task_id)
  • Build check: cargo check, npm run build or go build ./..., by detected language.
  • Sensitive files refused: .env, credentials.json, *.pem, *.key and similar.
  • Tests are an option, off by default. plan-runner-reviewed adds an awaiting_review state for a person.

Try: select a stop, step with the arrows or press play; the diagram follows the scroll again after a pause

Stage 6 of 6: Learn, reading stop 6 of 6: Back to Recall

What was learned is saved for next time

When the work is done, what was decided and learned is written back to the project memory. The next plan starts with it.

Under the hood

When a task completes, the runner writes back without calling a model: it links the commits to the task and the plan, creates a context note from the git log, and ties decisions to the files they affect.

The assistant adds what only it knows: decisions with their alternatives, warnings, patterns. Notes used together grow closer. Notes that are never used lose energy and go stale. An episode records the request, the path through the states and the outcome. The next plan starts at stage 3 with all of it.

decision(action: "add", task_id, rationale, alternatives)note(action: "create", note_type: "gotcha", content, anchors)episode(action: "collect", run_id, project_id)admin(action: "reinforce_neurons", note_ids)
  • Staleness grows with the time since the last activity, at a rate that depends on the note type. note(action: "confirm") resets it.
  • Skills emerge from clusters of strongly linked notes (admin(action: "detect_skills")).

Try: select a stop, step with the arrows or press play; the diagram follows the scroll again after a pause

Responsibilities

Who does what

PO handles the mechanics, so the assistant can focus on the work.

PO does, without being asked

  • Sorts the tasks into groups and starts the assistants.
  • Checks each group: steps closed, no sensitive file, and the build for a code project.
  • Links the changes to the task and writes a note about what happened.
  • Keeps the changes of each run on its own git branch.
  • Records which persona and skills helped.

The assistant does, through its tools

  • Searches notes and decisions before it starts.
  • Creates plans, tasks and steps, and updates their status.
  • Saves decisions with their alternatives and what they affect.
  • Writes warnings, guidelines and patterns, tied to what they are about.
  • Moves a procedure forward, step by step.

Entry points

Three ways to start the loop

From your AI tool

Claude Code, Cursor or another AI tool connected to PO. You describe the result. It plans, orders and recalls, then saves what it learned at the end.

From the chat

The chat built into PO talks to the same assistant. Each message carries the matching skills, the notes and decisions that apply, and what is in progress. Type # to point at a plan, a task, a note or a decision. You pick the engine of a conversation, Claude Code by default or another engine (alpha), or set it to Auto and PO picks the model; a model you chose yourself is never replaced. A timeline above the conversation shows what ran, and for how long. A message you send while the assistant is busy waits in a queue kept by the server, so it is not lost if you switch conversation or reload. On the native engine, Codex and ACP, a turn cut by a server restart resumes by itself; a Claude Code turn is closed with a visible error and your next message picks the conversation up.

On its own

A plan can run when nobody is there. It starts on a schedule or when an event happens, with a pause between two starts. The start types are schedule, webhook, event and chat.

Memory

PO remembers what you decide and learn

Notes, decisions and the links between them stay attached to your project. PO finds them again when they are useful. Scroll to watch a memory grow.

  1. 1

    Your files become a memory

    PO starts from what is in the project: documents, spreadsheets, files. Each one becomes a node you can find again.

  2. 2

    Plans and tasks join in

    Plans and tasks are added to the same picture. Each task is linked to the files it touches.

  3. 3

    Notes and decisions stay linked

    What you learn becomes a note. What you decide becomes a decision. Both stay linked to the files and to each other.

  4. 4

    Items about the same subject move close to each other. You see the main themes of the project at a glance.

  5. 5

    You ask a question. PO finds the notes that match (cyan). Then it follows the links to related items (violet), even when the words are different.

Memory

Invented example: a small event project. The names in the graph are illustrations, not your data. Colors and shapes are those of the product graph.

Under the hood: the names of the links

These are the names the product uses for the links in its graph. You do not need them to use PO.

  • CONTAINSA plan contains its tasks.
  • IMPORTSA file uses another file.
  • AFFECTSA task touches a file.
  • CO_CHANGEDTwo files that often change together, seen in the history of the code.
  • SYNAPSEA link between notes, decisions and files. Links nobody uses fade away.

Try it

Watch an assistant work with PO

Pick a request. You see the answer in plain words, and the calls the assistant makes to PO behind the scenes. Open a call to see its details.

Chat · team-weekendSimulated demo
Organize a weekend in June for my team of 12. We want a quiet place near a train station.

Two notes apply: the place must be close to a train station, and last year the menu had nothing vegetarian. I will write the plan around both.

The plan has 3 tasks in 2 waves. The shortlist and the date poll do not depend on each other, so they happen at the same time. Booking waits for both.

Scripted replies. No server is contacted.

Try: type your own request, open a call to see its details, then copy the whole exchange.

Simulated demo: the answers are scripted and no server is contacted. The calls and their arguments are the real ones.

Get started

Give your agents a memory and a plan

Install the orchestrator, connect your assistant over MCP, and let your first agent read the project before it writes a line.

The app is free. You only pay for the AI you already use, such as your own Claude Code subscription or a key for another model. See what it costs

Or start from the terminal

brew install this-rs/tap/project-orchestrator