How DuoDuo works.

If digesting experience had to happen inside the conversation, it would never happen, because the foreground always has something more urgent to do. DuoDuo runs a second loop instead. The foreground cortex handles the current request. On its own cadence, the subconscious reads the Spine WAL, where a terminal turn, a Feishu/Lark thread, an editor session, something said out loud in a room, and a scheduled job all land, whichever runtime did the work. It consumes that history in arrival order and folds what holds up into the intuition layer.

channel message
  → canonical event on disk
  → foreground session → result
             ↓
          cadence
             ↓
  subconscious partition
  → text gradients, dossiers, lessons, grooves
  → intuition layer
             ↓
     future foreground sessions

How one subconscious tick works#

1. Cadence emits a tick even when no one is chatting.
2. The meta-session reads subconscious/playlist.md.
3. It chooses the next enabled partition that is eligible after cooldown and backoff.
4. The partition runs from its own CLAUDE.md prompt with a bounded execution budget.
5. The runtime records usage and result or error events.
6. The playlist advances and the partition's scheduling state is settled.

The playlist is round-robin, and each tick wakes one eligible partition. For a completed run, the runtime records and settles success, timeout, invalid output, or error before advancing.

The active partitions#

Nobody queues the work by hand. On each tick the mechanical lints measure the kernel's memory/ tree and post a bounded .pending signal into the inbox of the partition that owns it: which day of history still has no gradients written for it, which gradients are waiting to be woven in, which dossiers have drifted apart. A partition ranks what is in its inbox and works down the list until its time budget runs low, acknowledging each item as it finishes, so a wake that dies mid-item loses only that item.

A partition whose frontmatter disables it stays on disk and out of the loop; the playlist is built from enabled partitions only.

How experience becomes intuition#

The pipeline in one line: events —distill→ text gradients —weave→ intuition layer.

A text gradient names the line of the intuition layer it tested, cites the events it tested it against, and says which way the line should move: it helped, it should have fired and did not, or it had nothing to act on. Without the evidence it cites, it does not exist.

Saving a transcript preserves the past, and the filesystem already does that. The pipeline's job is intuition: compact instincts a new session starts with, under a strict context budget.

The append-only event history records external experience before execution. The subconscious extracts evidence from it rather than trusting a recap, and the weaver folds what holds up into the compact intuition layer under a fixed line budget; deeper dossiers stay linked on disk. Past work becomes future context only after it is distilled into a useful trigger, direction, and supporting evidence.

Only external experience counts#

Learning starts from external interactions and their task results: what a person said, what a task returned. The daemon's own scheduling, the partitions' own reports, and other internal chatter travel inside externally driven turns as context, never as sources. The distiller's source gate rejects an internal origin outright, and a rejected origin creates no gradient. A pass that finds nothing worth keeping ends with no new rule, and that is a correct result.

The layer is measured#

A line of intuition that nobody reads still costs a slot in every prompt and returns nothing. An activation report counts how often each line is read during real sessions and hands that back to the weaver as evidence, next to the gradients. A line that never fires is a candidate to be rewritten, re-pointed at something reachable, or retired, so the budget goes to the lines that earn it.

That count is kept in days when someone worked with DuoDuo, not calendar days, so a quiet week does not age out a good line.

The committer does not judge#

Its only two operations are git add and git commit. It never edits, never deletes, and never holds a file back for being poor.

Quality is the writers' job at the moment they write. A gate here would guard only the Git history, while every foreground session reads the working tree, which already has the line in it. Holding a bad line back from a commit would withhold the thing that makes it recoverable. A bad line lands in a commit and is one revert away from gone, which is why the kernel is kept in Git.

Configuration is files too#

How the subconscious runs is also stored in the kernel: each partition's prompt, the playlist that decides which partitions run and in what order, and the channel descriptors. DuoDuo ships defaults for all of them. They are plain files, so changing one does not require a runtime code change, and every change to them lands in the same Git history as the intuition layer.

Boundaries#

What the subconscious may write is deliberately narrow:

• the append-only event history is evidence, not an editing surface
• runtime locks and ownership state belong to the daemon
• partitions coordinate through directed inbox files, not by editing each other's files
• machine-read contract frontmatter stays owned by the matching runtime release
• each file the subconscious keeps (the intuition layer, a dossier, a rule node) has a single writer, so two partitions never contend over the same file
• a change to the intuition layer carries the evidence it came from, and lands in Git where it can be read as a diff and reverted

Observe and maintain it#

duoduo daemon status
duoduo daemon config
duoduo memory check --dry-run

Status reports cadence heartbeat and subconscious progress. Config shows each partition's effective schedule and runtime settings. duoduo memory check exposes mechanical gaps and convergence work without requiring a model to guess what is missing.

Partition prompts are read from disk on each tick, so a reviewed local prompt edit does not require a daemon restart. Package upgrades preserve those files, so the prompts on a host can differ from the shipped defaults; git log in the kernel shows when and why. When you want to compare them with newer defaults and adopt some, ask your DuoDuo: duoduo-runtime-admin carries the refresh, and you approve each change.

Cost and control#

Subconscious work uses model time. Cadence, cooldown, and per-partition execution budgets are visible operating controls. A shorter cadence reacts sooner and spends more. Tune it from your own workload and cost: ask your DuoDuo, which reads the usage ledger for you.