Skip to main content
Early access — The Loop is a behavioral contract; individual UIs may not expose every step yet. Join the Product Brain Community to compare habits with other teams.
The Loop is the habit that makes the Chain useful. You ask in plain language; your agent runs pb or MCP tools behind that intent. The Product Brain Loop: Orient, Triage, Define, Build, Capture, Close. Each pass through the loop should make the next pass less fragile. The agent orients from the Chain, works with current context active, then captures what future sessions should inherit. Most AI work starts as an isolated task. The Loop turns it into compounding product knowledge.
  1. Orient against the Chain.
  2. Triage what matters now.
  3. Define the work when the problem is unclear.
  4. Build and review with Chain context active.
  5. Capture the durable learning.
  6. Close the session.

​
Why the loop matters

Without a loop, useful product context stays in chat history, uncommitted notes, and provider memory. The next agent may have context, but it cannot tell which parts have drifted. With the loop, each session’s captures become the next session’s orientation. That is the compounding effect: the Chain gives the next session a better starting point every time you close the loop. The same loop works whether Product Brain is used through MCP in Cursor or Claude, through the web app at work.productbrain.io, or through the CLI. The human learns the practice; the agent or tool handles the mechanics.

​
Orient & Triage

Before work starts, your agent orients against the Chain. It loads the decisions, tensions, standards, work packages, and context relevant to the task, then uses that context to decide what matters now. Triage is the moment where you avoid treating every task as isolated. Ask:
  • What is already decided?
  • What constraint must not be broken?
  • What tension is still unresolved?
  • What is out of scope for this work block?
Example: if the task is “improve mobile onboarding,” orientation should surface the current onboarding work package, the mobile-auth tension, the release standard for user-visible changes, and any recent insight about drop-off.

​
Define the Work

When the task is ambiguous, define the work before building. This does not require a formal product process. It means naming the problem, the intended outcome, the effort boundary, and what you will not do. A good definition answers:
  • What problem are we solving?
  • What outcome would count as progress?
  • How much time or effort are we willing to spend?
  • What is explicitly out of scope?
  • Which Chain entries anchor the work?
This makes the work smaller and easier to review. It also gives the next agent a clearer record of why the scope was chosen.

​
Build & Review

Do the work with Chain context active. That may mean editing code, writing a product spec, changing docs, planning a release, or reviewing a decision. Before finishing, compare the result against the relevant decisions and standards. Did the work respect the active constraints? Did it reopen something that was already decided? Did it create a new decision, tension, or insight future sessions should know about? For code work, this often includes reading relevant files, making the smallest coherent change, running focused checks, and reviewing the diff against Chain context. For product work, it may mean checking the proposal against the active work package, unresolved tensions, and launch standards.

​
Capture & Close

Capture only knowledge future sessions should be able to rely on. Do not capture narration. Bad capture:
Good capture:
Closing the session makes the work traceable and gives the next agent a better starting point. The point is not ceremony. The point is continuity. Next: dive into Orient & triage, Shape, Build & review, and Capture & sessions. Try the week-long habit in Your First Week, or connect tools via Install pb + Quickstart.