How It Works

Agents change. Your intelligence compounds. This page is the mental model — watch each mechanism run, then read what it's doing.

One intelligence, every agent

Your agents come and go — new models, new CLIs, new sessions. Digital Me is the part that stays. Every agent you run connects to the same brain: one wiki of knowledge, one set of tastes, one task board, one trace history.

The hub is not a metaphor: it's an openclaw gateway daemon running on your machine. Two plugins make it a brain — memory-core (retrieval: memory_search, memory_get, owned by upstream openclaw) and brain-orchestrator (operations: tasks, learning_capture, traces_*, owned by this repo). Each spoke is a thin runtime adapter that wires one CLI to those tools.

The lifecycle, in every agent

Every agent turn runs the same deterministic lifecycle: apply (matching knowledge and taste inject into the prompt before the model sees it) → work (the agent does the task with your context already loaded) → capture (anything reusable flows back as a learning). Watch it play out across four different agents — same brain, four very different surfaces:

Claude CodeCodexOpenClawHermes

Claude Code~/motus/billing

$ claude “refactor the billing retry logic”

[Digital Me] Applying “architecture_design_principles”...

✓ taste attached · 2 knowledge assets in context

● Editing src/billing/retry.ts

- setTimeout(retryCharge, 1000)

+ // architecture_design_principles: retries are

+ // idempotent + jittered — never naive timers

+ queue.retry(charge, {backoff: 'expo', key: chargeId })

✓ 2 files changed · tests pass

Learning captured → “architecture_design_principles”+ retry paths carry idempotency keys

Codexmotus/api

Review PR #214 — error handling

[Digital Me] Applying “code_review_checklist”...

✓ taste attached · house error taxonomy loaded

- } catch (e) { console.log(e) }

+ } catch (e) {

+  throw new ApiError(e, { retryable: isTimeout(e) })

+ }

requested changes · 1 comment posted

Learning captured → “api_error_handling_pattern”wrap, classify, rethrow — never log-and-continue

asset · tastex_news_research_tldr_formatso-what first · 3 bullets · sources linked

10:08

OpenClawresearch agent

#daily-intel

you10:06

morning — what happened on X overnight?

[Digital Me] Applying “X news research TLDR format”...

OpenClaw10:08

Overnight — TL;DR

1Agent interop spec ships — three labs adopt it day one

2Open-weights 30B model tops the coding evals

3EU guidance window extended — no action needed yet

full thread + sources → #research

Message #daily-intel

Learning captured → “x_news_research_tldr_format”prefer primary posts over screenshots

asset · knowledgeskill_updates_guidanceversion everything · post the changelog

10:08

Hermesops agent

#agent-ops

you10:05

new release is out — update my skills?

[Digital Me] Applying “Skill updates guidance”...

Hermes10:08

Crafting skills

✓research-digest — rewritten for longer context

✓inbox-triage — thresholds retuned

＋release-watch — new skill drafted

3 skills updated · changelog → #agent-ops

Message #agent-ops

Learning captured → “skill_updates_guidance”+ retune thresholds on every model change

No re-briefing, no cold starts: the architecture exists so that a lesson paid for once in any agent is owned by every agent.

The closed loop

Capture alone isn't knowledge — raw learnings are noisy. The loop closes overnight:

• Apply — runtime adapters prepend matching wiki entries to the prompt.
• Work — the agent acts; everything is tracked (tasks, traces_record).
• Capture — noteworthy outcomes land in the inbox via learning_capture.
• Distill — the nightly dream-cycle compiles raw captures into clean, deduplicated wiki entries (plain markdown, reviewable in git).
• Recall — memory_search indexes the wiki; the next turn's apply step retrieves it.

Cut any node and the loop stops — that's the architectural test for every package in the repo.

The package map

Each package has one job, categorized by where it runs and who triggers it:

Your data stays yours

This repo contains no personal data. Your wiki, inbox, and config live in a separate local directory (~/digital-me/, ideally a private git repo), loaded at runtime through the documented environment contract. Knowledge is plain markdown files — no opaque vector store, nothing you can't read, diff, or delete.