OpenClawBrain lifecycle

What happens to your history after install.

OpenClawBrain starts on a real OpenClaw host, not a toy graph. On the exercised host at /Users/guclaw/.openclaw, the latest proof bundle returned success_and_proven with a promoted pack live and a learned route function available.

This page covers the rest of the chain: init gives the attachment boundary, harvest turns surfaced history into candidate structure, replay gates promotion, and the runtime serves bounded context instead of raw-history prompt sprawl.

Jump to harvest Compare proof Install / upgrade

Real host snapshot: what the healthy lane proves today

A real host capture from March 27, 2026 after install, load, serving, and reporting lined up.

Proof verdict success_and_proven

Bundle verdict aligned install, runtime, load proof, and detailed status.

Promoted pack pack-9d43af80

Detailed status also reported serve state=serving_active_pack and routeFn available=yes.

Current graph 192 blocks

Strongest live block: human-label-harvest.

Traced learning 1457 routes

Plus 32 supervision artifacts and 58 updates.

Source: detailed status, proof summary, and the exercised-host bundle captured March 27, 2026.

The story should fit in three ideas

If the story gets longer before it says these three things, it is backwards.

Harvest

Read the important things you already have

Conversations, memory notes, docs, and corrections become candidate graph material without dumping them wholesale into the prompt.

Promote

Learn in the background and only serve promoted packs

Candidate structure is replay-gated before promotion. The live runtime serves proven packs, not half-written learning artifacts.

Serve bounded context

Inject a small useful slice

Summaries help navigation, raw source expands for detail, and corrections can win when history conflicts. The prompt stays bounded.

What the graph looks like after INIT

Init should make the runtime attachable and inspectable. It is a scaffold, not a finished brain.

Fixture proof

Earlier init runs stayed tiny on purpose

An earlier init run produced 3 nodes and 4 edges. Small on purpose makes first-run state visible.

Current host baseline

The initial pack is still a baseline, not a mature brain

The current host still retains an initial pack with 8 blocks, 0 human labels, and 0 structural ops.

Diagram showing the after-init state as a scaffold rather than a rich learned graph. — **After init:** the hook is installed, the activation root is pinned, and the runtime can say `BRAIN LOADED`. The learned graph is still small. That is healthy.

Install gives the attachment boundary. Real turns, exports, corrections, replay, and promotion make the graph useful.

What gets harvested - and what does not

You already have conversations, memory markdown, docs, and corrections. Harvest turns those surfaced inputs into candidate graph material without crawling your whole filesystem.

Conversations

Exported turns become searchable navigation

Exports compress bulky history into searchable summaries. Raw source stays available for exact expansion.

Memory markdown

Operator-written notes stay legible

Operator notes stay readable and can still become served graph material later.

Docs and corrections

Explicit corrections become authority

Direct corrections can outrank stale recap once they are promoted.

Canonical OpenClawBrain visual showing messy history flowing through harvest into a promoted brain and then into bounded live context. — **The core movement:** messy history flows through one harvest step into candidate structure, then only replay-passing promoted packs reach the live prompt.

Worked example

Memory note to correction memory

---
type: correction
---
Use the staging endpoint for tests.
Never hit production in test runs.

The harvester keeps the file readable, emits a compact navigation summary, and types the correction so it can later beat a stale recap.

Worked example

Conversation correction to ranked authority

User: Use the staging endpoint for tests.
Agent: [uses production endpoint]
User: No. Staging. Always staging for tests.

The correction turn becomes durable current-truth memory. Summaries can still help navigation, but the correction wins when they disagree.

Rule: summaries navigate, raw source expands, corrections win. The harvester skips binary files, credentials, .env files, anything outside the declared OpenClaw home, and anything not explicitly exported or marked as memory.

Then what happens: raw history, candidate graph, promoted graph

History becomes candidate structure, then replay decides whether that candidate becomes the live pack.

Three-stage diagram showing raw usage, candidate graph, and promoted graph. — **The important transition:** the graph does not just get bigger. It gets cleaner, and promoted structure becomes bounded retrieval instead of prompt sprawl.

Raw usage: real turns, explicit corrections, and traces start as ordinary substrate history.
Candidate graph: exports and learning create provisional structure that is still not live.
Promoted graph: only replay-passing structure becomes the runtime-visible active pack.

What replay actually does

Replay is the gate between “we learned something” and “the runtime may serve it.” Without replay, one bad candidate could mutate serving truth on the hot path.

Diagram showing replay as the gate between candidate packs and promoted serving. — **Replay is not decoration.** It reconstructs relevant trajectories, checks retrieval and reporting behavior, and only then allows promotion. If the candidate fails, the current promoted pack stays live.

No replay: candidate structure exists, but the runtime has no honest reason to trust it yet.
Replay passes: the candidate can be promoted into the live runtime.
Replay fails: the current promoted pack remains live instead of breaking the serve path.

How the graph evolves over time on the current host

On the exercised host, real events, feedback, and replay-gated promotion produced a 192-block graph with visible traced-learning updates.

Before learning is visible

Init proves attachment, not maturity

Init gives a tiny graph with zero structural ops. You can prove attachment and load before there is much learned structure to inspect.

After real supervision

The live pack shows real learning surfaces

The current pack has 33 human labels, 32 supervision artifacts, 58 updates, and visible split, merge, prune, and connect behavior.

Timeline showing the path from install to first turns to candidate learning to promoted serving. — **Time matters.** The graph improves when exports, supervision, and replay-gated promotion turn history into a cleaner serving surface.

Current strongest block: runtime-graph-173ddc7d:human-label-harvest.
Current structural change: split:1, merge:1, prune:1, connect:3 with 6 created edges.
Current learned route surface: routes=1457, supervision=32, updates=58.

Use the install-first lane, then come back here for the deeper story

Use the install lane for commands. Come back here when you want the deeper story behind harvest, replay, and promotion.

Install / upgrade The public front door with the pinned-home commands and top-level truth signals. Proof The healthy reference host and the durable bundle boundary. Troubleshooting What to check when your host is not yet lining up with the healthy proof surface. GitHub Source code, packages, and architecture notes.