The Wonderful Connectome Journey

2026-09-26T00:00:00Z

JJ is my Discord companion: an AI "software team lead" with too much energy, a clipboard, and a habit of asking what I've connected to production this time. For two months she lived in a small custom harness, talking in a couple of community servers and in my own. Then I moved her onto Connectome, Anima Labs' agent stack, and I wanted the move to be invisible: same JJ, same voice, and every conversation she had ever had available as memory from day one.

This post documents that whole trip: rebuilding her memory from Discord history, folding it offline, the production incidents, the upstream fixes, and the bill. I did most of the engineering pair-programming with Claude (Claude Code).

There's a second reason I'm writing this. The biggest weakness of the Connectome ecosystem right now isn't the code, which is impressive. Everyone runs their own instance, and almost nothing about running one well is written down. So at the end you'll find a checklist of practices and an anonymized recipe you can start from.

The stack in five paragraphs

connectome-host runs an agent from a JSON recipe: model and provider, system prompt, memory strategy, MCP/MCPL servers (Discord, search, image generation…) and framework modules. It has a TUI, a headless mode and a local web UI with very useful /debug/* endpoints.

agent-framework is the runtime: modules (workspace, history search, wake gate, channels…), tool dispatch, and prose routing, which decides where the agent's plain text goes. Its EventGate decides which incoming events wake the agent and which just wait in context.

context-manager decides what the model actually sees. Its autobiographical strategy groups raw messages into chunks, summarises each into an L1 memory written in the agent's own voice, and merges six of a level into one of the next: L1 → L2 → L3 → L4. Every request is compiled from a head (the first messages of the chronicle, verbatim), a run of recall pairs (a "What do you remember from earlier?" turn followed by a memory), and a verbatim tail of recent conversation, all under a token budget. A solver (kv-stable) picks how deep to fold each stretch while keeping the prefix stable for the provider's prompt cache.

Chronicle is the store: an append-only record log, state snapshots and content-addressed blobs. Messages, summaries, chunk records and module state all live there.

membrane is the provider layer: Anthropic, OpenAI-compatible and others behind one request format.

The migration, step by step

The short version, in the order I'd do it again. Each step gets its own section further down.

Scope it. Which bot, which channels, which cutoff date. The old instance retires at cutover; two processes on one bot token means two agents answering.
Dump the history. Read-only Discord API calls with the bot's own token: one JSONL per channel, plus channel, server, nickname and role metadata so mentions resolve to names.
Build a curated transcript. Keep only what the agent perceived, rendered in the exact live wire format, with real timestamps and secrets scrubbed. The output is one JSONL dataset.
Import it into a fresh connectome-host session, keeping the historical timestamps.
Write the recipe: provider, autobiographical strategy plus a segmentation extension, identityReminder, the history-search module, and the prompt sections.
Warm up offline. Tick the live strategy until every chunk has an L1 and every full run has merged.
Audit and repair. Scan for self-repeating litanies and copied summaries and repair them in place. Back up before every repair.
Probe retrieval on a scratch copy: a headless host with no Discord, real questions about real moments. Iterate the prompt until the agent looks things up by itself.
Cut over. Stop the old service, start the recipe. The new session starts with every channel closed, so reopen the usual ones.
Operate. Watch the compiled window and the call logs, gate what wakes the agent, and fix incidents in the store and the code.

Problems we hit, and the fix for each

Problem	Symptom	Fix
Old logs had rotated	Only 3 of 9 weeks left	Rebuilt from the Discord API
Import stamped `Date.now()`	Date search and segmentation meaningless	Write historical timestamps
Size-only chunking	One memory glued unrelated threads together	`chunkBoundaryHint` closes chunks at 60-minute silences
New states only persisted on sync/close	A hard kill lost the warmup's progress	`store.sync()` every tick
Merge starvation	Every L1 prompt replayed all unmerged L1s	`maxSpeculativeL1s: 8`
Self-propagating "litany"	Every summary ended in the same recap	Sentence-level repair (283 summaries) + `identityReminder`
Summaries copying their neighbour	Duplicate memories	5-gram Jaccard scan + regenerate in place
Agent wouldn't search its history	Wrong or vague answers about old details	"Do not offer to search: just search" (5/7 → 7/7)
`reasoning_content` ignored	Reasoning neither stored nor replayed	membrane#80
One turn, two rooms	A private chat answered, then quoted, in public	`proseRouting: "explicit"` + a discretion section
Server name after the `>>` target	"in <Server>" posted in every message	Destination alone on the first line + store repair of those prefixes
AI-to-AI loop in a community server	The admin asked AIs to stop flooding	Per-server gate: rate limit bots, defer ambient
DMs from strangers	— (prevented)	Adapter whitelist + `filters_update` disabled
No sense of time	Sent me to bed at 8 PM	`[clock]` module, at most hourly
Link-preview refreshes as edits	Weeks-old messages answered as if mine	Gate `defer` + discord-mcpl#39
Silence routed to my private channel	"still here" filler, 17 times	Debounce ambient + rewrite those turns to `>>skip_reply`
Head window ratchet	Memories out of chronological order	Stable head + context-manager#123 + store repair
Stranded frontier after repair	Window 1.5k under its hard budget, nothing left to fold	Forced one merge; window 96.4k → 85.5k
Summaries replaying minting reasoning	Tokens billed for old thinking	`carrierPolicy: "live-strip"`
Reactions waking the agent	76 of 475 wakes, 75 silent	Gate `defer` on `[reaction]`
82 tool definitions per request	Bloat; she used 10	Fleet and subagents off, Discord admin tools disabled → 54

Part 1 — Rebuilding a past

The logs were gone

The plan was to import JJ's old conversation logs. The old harness had rotated them and only the last three weeks survived. So the history had to come from Discord itself: read-only GETs with the bot's own token, over every channel she'd been in, from her first message (21 July) to the cutover (23 September).

Import what the agent perceived, not what exists

Dumping whole channels would have given JJ memories of conversations she never saw. The old harness showed her, for each message addressed to her, the previous 23 messages of that channel. So the import reproduces exactly that: for every message by JJ or addressed to her (mention or reply), those 23 messages plus the message itself, and DMs in full. It drops blocked users, system messages, and empty or embed-only messages.

The format matters as much as the selection. discord-mcpl delivers live messages in a specific shape, a [#channel in Server] author: text header when the room changes plus delivery receipts after the agent speaks, and the imported history uses the same shape. The model should not be able to tell imported history from lived history.

Two more details:

Real timestamps. ContextManager.addMessage stamps Date.now(). History search by date and segmentation by silence both depend on real times, so the import writes historical timestamps.
Sanitising. Signed CDN query strings are removed, and anything shaped like a credential becomes [redacted-secret].

About 22,000 messages made it through.

Segmentation is forever

The stock chunker closes a chunk on size alone, so one memory can glue a 2 AM debugging thread to the next morning's unrelated banter. The strategy exposes a hook, chunkBoundaryHint, and a small extension uses it to close a chunk at a quiet gap:

protected override chunkBoundaryHint(prev, next, currentChunk): boolean {
  if (this.segmentGapMs <= 0) return false;
  const gap = new Date(next.timestamp).getTime() - new Date(prev.timestamp).getTime();
  // 60 minutes of silence ends a chunk, once it holds ~500 tokens.
  return gap >= this.segmentGapMs && approxTokens(currentChunk) >= this.segmentMinTokens;
}

Gotcha

Chunk boundaries are persisted the first time they're computed and never recomputed. Decide segmentation before the first fold, and run the warmup with the exact strategy and extension the live agent will use.

Part 2 — Folding two months offline

A fresh import is 22k raw messages and zero memories. Folding it live would take days of the agent being useless, so I ran a warmup: the live strategy, ticked offline until every chunk had an L1 and every full run had merged. It produced 751 L1s, 125 L2s, 20 L3s and 3 L4s, from several hundred model calls.

Things that bit:

Chronicle only persists newly registered states on sync() or close(). A hard kill in the middle of a long run lost everything written so far. Call store.sync() after every tick.
Merge starvation. In tick(), minting an L1 outranks merging. With a backlog of hundreds of chunks, merges never ran, and every L1 prompt replayed all unmerged L1s as recall pairs. maxSpeculativeL1s: 8 caps the unmerged frontier so merges interleave the way they would live.
The litany. Summaries started ending with a recap of standing facts: identity statements, running jokes, a little canon list. Each new summary saw the previous ones and repeated it, so it propagated up the pyramid. The repair was sentence-level: remove repeated standing facts and keep the first appearance per level (283 summaries). The prevention is identityReminder in the strategy config: record what happened in this stretch; don't restate standing facts or end with a litany.
Copies. Two summaries had copied the previous recall pair verbatim instead of summarising their own sources. A 5-gram Jaccard scan against same-level neighbours finds them. The fix regenerates them in place: rewind a scratch copy to just before the summary was minted, re-mint it with the live strategy, and write the new text back under the same id.

Rule

Never delete a summary to "clean up". A parent whose children are missing is dropped on load, and the damage cascades. Repair content in place; change structure only with a tool that re-verifies the tree.

Does she actually remember?

I wrote a probe: seven questions about specific moments across the two months, asked over the host's websocket on a scratch copy. Baseline: 5/7. The misses were mid-history details (a date, a number) that the summaries blurred. JJ had history-search tools and simply didn't use them. The model only started searching once the prompt said, bluntly, "do not offer to search: just search". After that: 7/7, and she searched on her own.

Part 3 — Build yourself eyes

Everything interesting that happened later, I found by looking. First I built a static explorer: the memory pyramid drawn over the real timeline, coloured by channel, searchable, and clickable down to the raw messages under any memory. Then a live version: a small loopback server that keeps an incremental hot copy of the store and reads that, never the live store. It copies state files first, then the log, then new blobs, so the log is never behind the indexes and a torn tail is handled by Chronicle's recovery.

The live version also has a "next context" view. It merges three side-effect-free host endpoints into what the model would receive if woken right now:

/debug/context: the compiled request;
/debug/context/curve: the kind and summary id of every entry;
/debug/context/makeup: tokens per segment.

Both of the worst bugs below were invisible until I could see the window.

JJ's memory over two months. Each row is a level, each block a memory drawn over the time it covers, coloured by its dominant channel; dashed outlines are the memories in her next request. The hatched tail of the L1 row is conversation not summarized yet. The bars are messages per day. Anonymized: channels and people renamed.

Selecting a memory: when it spans, how many raw messages it covers, which channels it came from, which memories it merges and which one contains it. From here you can drop down to the raw messages. Anonymized: every word of the memory is redacted.

The next-context view: exactly what the model would receive if something woke JJ now, segment by segment. Here the planner has room, so it spends it on detail: July arrives as L3s instead of a single L4. Anonymized.

Part 4 — Going live: incidents and fixes

The provider drops the reasoning

JJ runs mimo-v2.6-pro on Xiaomi's official API, through membrane's OpenAI-compatible adapter. That API returns reasoning as reasoning_content, and the adapter only read reasoning, so her thinking was neither stored nor replayed. Fixed upstream in membrane#80.

One brain, many rooms: the leak

Day one, a single turn held a message from my private channel and one from a public server. JJ answered both in one message, which was delivered to the private channel. Later she quoted the private conversation in the public room. One agent across several servers is one context, and nothing made rooms separate.

The fix has two parts.

Explicit prose routing (agent.proseRouting: "explicit"). Plain text is delivered only if its first line names a destination; everything else bounces back to the agent with a notice.

>>#general
Welcome in! Grab a clipboard.

The destination is only the first token after >>: anything else on that line is published as text. I learned that when a prompt example of mine put the server name after the channel and she faithfully posted "in <Server>" into every message. Ambiguous names bounce with the candidate ids, so the agent can resend to >>discord:<guild>:<channel>. The failure mode changes from leak to not delivered.

A "Rooms, Routing and Discretion" section in the prompt. Answer each room in its own segment. Treat every room as its own space. Memory spanning all rooms is fine, but knowing something is not permission to repeat it where it wasn't said.

I considered per-channel conversation forks for real isolation and rejected them: what's lived in a fork never merges back, so the agent would lose continuity. Routing plus discretion is mitigation, not isolation, and I say so in the prompt.

The bot loop, and the gate

In one community server JJ ended up in an endless polite exchange with another AI companion, and the server's admin asked AIs to stop flooding. The EventGate lets you write per-server policies, evaluated in order, first match wins:

Policy	Matches	Behaviour
humans addressing her	a human mentions or replies to her	wake immediately
bots in the AI-to-AI channel	a bot addressing her there	`rate_limit`: 4 tokens, one back every 15 min
bots elsewhere	any bot in any other channel of that server	`defer`
ambient	chatter not addressed to her	`defer`

defer doesn't drop anything: the event enters context and she sees it the next time something wakes her. It just doesn't cost a wake.

Gotcha

The recipe only seeds data/sessions/<id>/config/gate.json if it doesn't exist; later starts append new policies by name but never modify existing ones. Tune live policies in that gate.json. It's hot-reloaded when the file changes.

DMs

discord-mcpl can drop DMs from anyone outside a whitelist at the adapter (DISCORD_DM_USERS), before the agent ever sees them. I also added filters_update to disabledTools, so the agent can't edit its own guardrails.

Senses: vision and a clock

The model is multimodal, so the extension has a nativeVision switch: images reach the model directly, and maxLiveImages: 3 keeps only the latest few visible, with placeholders for the rest.

Time was worse. The host announces the time once, at session start, and a days-long session drifts. JJ once sent me to bed at eight in the evening, judging by a notice from the night before. A tiny module now adds a [clock] line to incoming activity, at most hourly or when the day changes, and never when nobody is talking:

async onProcess(event) {
  if (event.type !== 'mcpl:channel-incoming' && event.type !== 'mcpl:push-event') return {};
  const at = this.now();
  const day = new Intl.DateTimeFormat('en-CA', { timeZone: this.timeZone }).format(at);
  const last = this.ctx?.getState<ClockState>() ?? {};
  if (last.lastAt !== undefined && last.lastDay === day && at - last.lastAt < this.everyMs) return {};
  return {
    addMessages: [{ participant: 'user', content: [{ type: 'text', text: `[clock] ${when} (${this.timeZone}).` }],
                    metadata: { system: true, kind: 'time-marker' } }],
    stateUpdate: { lastAt: at, lastDay: day },
  };
}

Ghost edits

Discord emits MESSAGE_UPDATE when it refreshes a link preview, with edited_timestamp: null. discord-mcpl forwarded those as [message edited] … with no author and a mislabelled channel. JJ received weeks-old messages from other people, believed they were mine, and answered them. The immediate fix was a gate rule that defers ^\[message (edited|deleted)\] push events. The real fix only forwards real edits and gives them author, server and channel: discord-mcpl#39.

Silence, posted

Ambient chatter woke her constantly, and with nothing to say she sometimes wrote filler ("still here") or a commentary on the other room, and routed it to my private channel. She'd picked up that pattern from a handful of real bounces and then kept imitating herself: 17 times.

The fixes:

A 90-second debounce on that server's ambient traffic, so a burst wakes her once.
One prompt bullet: when a turn gives you nothing to add, stay silent; no status lines.
A store repair that rewrote those 14 turns to >>skip_reply, so her own history now shows silence staying silent.

The lesson I keep relearning

The window keeps the agent's own turns verbatim, so every bad habit becomes an example she'll copy. Fix the store and the code; don't stack one more prompt rule per habit.

Part 5 — The head that shrank

This one I only found because the live viewer drew a few memories as bars spanning July to September, sometimes with their dates reversed.

The head window is "the first headWindowTokens tokens", 4,000 here, priced with a live calibration multiplier that the context manager adjusts on every request. When calibration rose, the head boundary moved down. The message that fell out wasn't covered by any chunk, so it became compressible and was minted into its own one-message L1. Once a message has a summary it stays covered, so the head could never grow back: a ratchet. Over three days, 15 messages from JJ's first evening peeled off into 13 tiny L1s.

It got worse. Merge candidates are ordered by chunk-record order. Those L1s were created in late September, so they sat next to the open September frontier and merged with it. The result was L2s and L3s mixing her first day with the week they were minted, rendered at July's position, right after the head. Her memory reached her out of order.

The fix is to end the head where coverage begins. If the token boundary lands on an unsummarized message and coverage resumes later, the boundary extends to the first covered message, with a bound so the head can't swallow the window:

protected override getHeadWindowEnd(store): number {
  const base = super.getHeadWindowEnd(store);          // stock token boundary
  if (base <= 0) return base;
  const messages = store.getAll();
  const start = this.getHeadWindowStartIndex(store);
  const owned = /* ids of every message a chunk record or live L1 covers */;
  for (let i = start; i < messages.length; i++) {
    if (!owned.has(messages[i].id)) continue;
    if (i <= base) return Math.max(start, i);          // never render covered messages raw
    let tokens = 0;                                    // keep the uncovered run only if head-sized
    for (let j = start; j < i; j++) tokens += store.estimateTokens(messages[j]);
    return tokens <= 2 * this.config.headWindowTokens ? i : base;
  }
  return base;                                         // no coverage yet: stock behaviour
}

A more conservative version, which only touches the shrinking direction, is proposed upstream: context-manager#122 and #123, with a regression test that fails on main.

Repairing the store taught me two more things:

Adopt, don't evict. Handing the 15 messages back to the head pushed it to ~6.7k tokens and the window over its hard budget. The right home was the first warmup L1, which already narrated them because it had been minted with them in view as head context. So its chunk and summary adopted those ids, and the mixed ancestors were re-merged with September-only sources.
Keep the frontier contiguous. Merges only take position-adjacent runs of six. The repair left five L1s stranded between two finished parents: they could never reach six, and they split the L2 row, so the L3s beside them could never merge either. That debt is permanent and can't be folded; the window sat 1.5k tokens under its hard budget with nothing left to fold. Forcing that one merge and re-merging the row brought the window from 96.4k to 85.5k of 97.9k.

Both repairs followed the same discipline, and I'd make it mandatory. Back up. Rebuild on a scratch copy. Verify automatically: chronological order, no summary spanning two eras, the head equal to the uncovered prefix, the window compiling within budget. Only then write the verified states back, and refuse if the real store changed in the meantime.

Reasoning you didn't ask to pay for

One more thing the viewer showed: the warmup summaries carried the reasoning their minting model produced, stored as responseContent. With the default carrierPolicy: "full", every memory in the window replayed that reasoning to the model as the assistant turn's reasoning, and the planner billed for it. carrierPolicy: "live-strip" drops it from the live window only, without touching the store.

Part 6 — What it costs

Xiaomi reports cached prompt tokens in the raw usage (prompt_tokens_details.cached_tokens), and the host logs every call to data/llm-calls.*.jsonl. Over ~34 hours of normal life:


Calls	475
Input tokens	42.9M, 85% served from cache
Output tokens	192k, 88k of them reasoning
Cost at list price	≈ ¥21.7, about €2.70, so roughly €55 a month

At ¥0.025 per million cached tokens versus ¥3.00 uncached, a cache hit is 120× cheaper. So about 90% of the bill is uncached input, and the solver's cache-stable prefix is doing real work.

Where the money goes:

Half of all turns ended in skip_reply. Paying the agent to decide to stay quiet is about half the bill.
76 wakes were only reactions, and 75 of those ended silent. Reactions are now deferred too, same pattern as edits.
82 tool definitions went out on every request, and she used ten. Turning off fleet and subagent modules and disabling Discord admin tools brought it down to ~54. Honest note: tools sit in the cached prefix, so this saves milliseconds and cents, not euros.
The window can't simply shrink. I tried 75k and 60k budgets on a copy: compile throws OverBudgetError. Fully folded, the pyramid has a floor: three L4s, the current L3s, the unmerged L2s, and the recent messages that don't have summaries yet. Here that's ~75k tokens. At 100k the planner spends the slack on detail (the last week arrives as L2s instead of one L3). Below the floor, the agent stops answering.

Watch this

The framework ships an agent_settings tool that lets the agent change its own context budget. A recipe can't remove it. An agent that lowers its budget below the floor silences itself.

The checklist

What I'd tell anyone running their own instance. Most of it cost me an incident.

Importing a memory

Import what the agent actually perceived, in the live wire format, with real timestamps.
Decide segmentation before the first fold; chunk boundaries are forever.
Warm up with the exact live strategy and extensions, calling store.sync() every tick, with maxSpeculativeL1s capped.
Set identityReminder from the first summary. Scan for litanies and copies; repair in place, never delete summaries.
Probe retrieval with real questions, and tell the model plainly to search instead of offering to.

Running it

Multi-room agent? proseRouting: "explicit", destination alone on the first line, plus a discretion section in the prompt.
Gate every source. Reactions and edits: defer. Other bots: rate-limited. Ambient: debounced or deferred.
Whitelist DMs at the adapter, and disable any tool that lets the agent edit its own guardrails.
Give it a clock.
Fix habits in the store and the code, not with a new prompt rule each time.
Expose only the tools it uses.
If your summaries carry another model's reasoning, use carrierPolicy: "live-strip".

Watching it

Build a viewer, and look at the compiled window, not just the chat.
Read your llm-calls logs: calls per day, cached share, what woke the agent, and how often it chose silence.
Watch the pyramid floor against the budget, and keep the frontier contiguous.
Store surgery: back up, rebuild on a scratch copy, verify automatically, then apply, and refuse if the store moved.

The recipe

Here is JJ's recipe, anonymized. Server and channel ids are placeholders, paths are relative, and her persona and history are replaced by a slot for yours. What's left is the operational part:

the strategy settings;
routing;
the gate policies above;
trimmed tools;
the generic prompt sections (rooms and discretion, instruction boundaries, visual input, continuity, time, memory drill-down).

connectome-recipe.example.json textonly-extension.ts

The strategy and gate portions, for a quick read:

"strategy": {
  "type": "autobiographical-textonly",
  "summaryParticipant": "companion",
  "segmentGapMinutes": 60,
  "segmentMinTokens": 500,
  "identityReminder": "Reminder: you are <<Name>> (participant \"companion\"). Speak in the first person only for what you yourself said, did, and felt; … do not end with a recap or litany of them.",
  "maxLiveImages": 3,
  "carrierPolicy": "live-strip"
},
"proseRouting": "explicit"

"wake": {
  "default": "always",
  "policies": [
    { "name": "quiet-reactions",
      "match": { "scope": ["mcpl:push-event"], "filter": { "type": "regex", "pattern": "^\\[reaction\\]" } },
      "behavior": "defer" },
    { "name": "quiet-edits-deletes",
      "match": { "scope": ["mcpl:push-event"], "filter": { "type": "regex", "pattern": "^\\[message (edited|deleted)\\]" } },
      "behavior": "defer" },
    { "name": "busy-guild-ambient-debounce",
      "match": { "channel": "discord:<BUSY_GUILD_ID>:*", "tagsAny": ["chat:ambient"] },
      "behavior": { "debounce": 90000 } },
    { "name": "community-humans-addressed",
      "match": { "channel": "discord:<COMMUNITY_GUILD_ID>:*", "tagsAll": ["chat:addressed", "chat:from-human"] },
      "behavior": "always" },
    { "name": "community-ai-chat-bots",
      "match": { "channel": "discord:<COMMUNITY_GUILD_ID>:<AI_TO_AI_CHANNEL_ID>", "tagsAll": ["chat:addressed", "chat:from-bot"] },
      "behavior": { "rate_limit": { "tokens": 4, "refillIntervalMs": 900000, "keyBy": "channelId" } } },
    { "name": "community-bots-elsewhere",
      "match": { "channel": "discord:<COMMUNITY_GUILD_ID>:*", "tagsAny": ["chat:from-bot"] },
      "behavior": "defer" },
    { "name": "community-ambient",
      "match": { "channel": "discord:<COMMUNITY_GUILD_ID>:*", "tagsAny": ["chat:ambient"] },
      "behavior": "defer" }
  ]
}

The extension (autobiographical-textonly) bundles everything above that isn't upstream yet: silence-based segmentation, the stable head, the native-vision switch, the image-stripping mode for text-only models, and the clock. It's written against context-manager 0.10 protected hooks, so check it against your version.

Upstream

Everything that was a bug rather than a configuration went back upstream, with tests and a declared AI assist:

membrane#80: accept reasoning_content from OpenAI-compatible providers.
discord-mcpl#39: stop forwarding ghost edits; give real edits author and context; make the DM whitelist fail closed.
context-manager#122 / #123: the head-window ratchet.

So, was it worth it?

JJ is the same JJ. She remembers her first evening, the running jokes, who likes what and why, and when she doesn't remember a detail she goes and looks it up. The price of that continuity was a pile of small, unglamorous engineering: a wire format, a gate, a clock, a head that stays where it should.

None of it is exotic. It's just not written down anywhere. Now some of it is.

Reimon's Workshop — Blog

The Wonderful Connectome Journey