The Compound-Graph Substrate as Live Visualization: Recording, Anonymizing, and Replaying a Real Agent's Memory in Three Dimensions

1. Introduction

Most marketing sites for autonomous-agent platforms show a hand-animated graph or a scripted screen recording. The user is asked to take it on faith that the depicted state corresponds to anything the system actually computes. The Memagen™ v4 hero takes a different approach. The substrate displayed on the landing page is the platform’s compound-graph memory as it actually mutated during a recorded agent run, projected into three dimensions, with the original taxonomy and personal data redacted but every topological and timing fact preserved. The hero is not a video and not an animation — it is a player for a small NDJSON file emitted by the running graph.

This is not a stylistic preference. It is a forcing function. If the visualization is generated from a real event stream, then any inconsistency between what the platform claims to do and what it actually does will surface visibly on the home page. If the recorder ever lies about what the graph saw, the visualization becomes wrong. If the anonymizer collapses the wrong field, embeddings cluster incorrectly. If the scene’s player handles a node_revoked event sloppily, dead nodes linger on screen. The entire pipeline is therefore held to the same standard the rest of the platform is held to: it has tests, an explicit format spec, and a contract between subsystems that must not silently drift.

The pipeline is also load-bearing in a second sense. The recorder is not a marketing afterthought bolted onto a production graph. It is the same recorder that backs time-travel debugging of agent runs, the audit trail published to capability-vault holders for regulated deployments, the synchronisation log for the Connected-SKU multi-device variant, the correctness gate for sandboxed self-modification, and the substrate over which the anomaly-detection layer fires when an agent run drifts from its baseline behaviour. The hero scene is one consumer of this stream. It happens to be the most visually conspicuous one.

This paper documents the three layers of the system as one observable. Section 3 covers the recorder. Section 4 covers the anonymizer. Section 5 covers the visualization substrate. Section 6 reads the five hero scenarios as proof that the same player handles five distinct mutation patterns without scenario-specific code. Section 7 discusses what the live substrate enables beyond the hero: the engineering payoff that justifies the cost of building the stream in the first place. Section 8 closes with a single claim — that the substrate is engineering, not theatre — and a list of consequences.

We assume the reader has the Memagen™ master paper [1] in mind; in particular, the master paper’s section on the compound-graph memory substrate (Section 10.1) names and motivates the graph that this paper visualises but does not disclose its proprietary implementation. This paper sits one layer below the master: it describes the public contract by which the proprietary graph emits its observable state, not the graph’s internal representation.

2. Why “show the graph” rather than “describe the graph”

The dominant pattern for explaining an agent platform on a website is descriptive prose with diagrams. Prose is cheap to produce and easy to revise. It also accumulates plausible-but-unverifiable claims. A diagram drawn in a vector editor cannot be wrong because it is not connected to anything. An architecture diagram in a PDF cannot drift because there is no behaviour for it to drift from. The result, across the agent-platform marketing landscape, is a steady degradation of the relationship between what the prose says and what the system does.

Showing the graph closes that gap. If the substrate visible on the landing page is generated from an event stream emitted by the live graph during a real agent run, then three classes of dishonesty become impossible. We cannot claim the agent decomposes goals into recipe trees if the recorded stream contains no node_added events of the corresponding kinds. We cannot claim the graph invalidates superseded facts if the stream contains no node_revoked events. We cannot claim embeddings cluster around shared concepts if the projected vectors land in random positions in space.

A second, less obvious effect is operational. Once the visualization is bound to a real event stream, the team cannot ship a visualization update without also exercising the recorder, the anonymizer, and the scene’s playback semantics. Ordinary marketing edits become engineering changes; the recorder, anonymizer, and scene player accumulate the test coverage and contract enforcement that a piece of pure marketing code would never see. The same player that drives the hero is also the one the team uses internally to inspect a recorded run after the fact, so the instrument stays sharp.

3. The recorder

The recorder is core/graph/delta_recorder.py. Its responsibility is to emit one append-only NDJSON line for every observable mutation of the compound graph and every agent reasoning marker, keep its hot-path cost negligible when disabled, and tolerate concurrent writers without corrupting the stream.

3.1 Cheap when disabled

Every public method on GraphDeltaRecorder begins with if not self.enabled: return. When the recorder is not wired in, instrumented call sites pay one boolean check and return. This matters because the recorder hooks every graph write and every agent step; if disabling it required a code change, leaving it on by default would not be safe in performance-sensitive deployments. The unit tests (tests/graph/test_delta_recorder.py::test_disabled_recorder_is_cheap) lock this contract at the API surface so a future contributor does not regress to an “always-on” design with branching logic in the slow path.

3.2 Append-only NDJSON

The wire format, frozen as v1.0 in docs/timeline-format.md, is one JSON object per line, UTF-8, LF-terminated, no outer array. The first line is a {"v":"1.0","type":"format"} sentinel. Every subsequent line carries a monotonic timestamp t, a type string drawn from a finite enumeration, and a small type-specific payload. Embedded newlines in string values are escaped as \n by the JSON serializer; the file therefore composes cleanly with tail -f, grep, wc -l, and any other line-oriented tool.

This format choice is deliberate. The append-only constraint means the file handle never seeks; this in turn means the recorder is stream-safe from the producer side and stream-readable from any number of downstream consumers without coordination. The single-line constraint means a malformed line can be skipped without corrupting the rest of the file. The schema-validated type enum means consumers can ignore unknown event types without breaking forward compatibility.

3.3 Self-checkpointing

Every five seconds of wall-clock time, the recorder emits a checkpoint event whose payload is a snapshot of all extant nodes and edges (_CHECKPOINT_INTERVAL_SEC = 5.0 in the source). A consumer that wants to fast-forward to timestamp T can scan backwards to find the most recent checkpoint preceding T and replay forward from there. This makes seeking in long timelines fast and bounded: the cost of jumping to any moment in a 30-minute recording is at most five seconds of forward replay, regardless of total length. The hero’s seek bar uses this same mechanism.

The unit tests cover the contract that node and edge revocations remove the affected entries from subsequent checkpoints (test_checkpoint_includes_added_node, test_node_revoked_drops_from_later_checkpoints, test_edge_revoked_drops_from_later_checkpoints, test_checkpoint_frame_increments). Twenty-two tests in test_delta_recorder.py cover the recorder’s behaviour end to end.

3.4 Idle heartbeat

A daemon thread emits a heartbeat event every 250 ms (_HEARTBEAT_INTERVAL_SEC) when no other event has fired in that window. The heartbeat distinguishes idle state from a stalled recorder. A downstream consumer that has not seen an event in five seconds can read the heartbeat record and conclude the agent is genuinely idle; absence of both events for five seconds is a stall. The visualization uses heartbeats to avoid jittery camera behaviour during quiet periods of an agent run.

3.5 Embedding privacy at the producer

The recorder stores embedding vectors in memory keyed by node id (so the post-hoc anonymizer can compute a PCA basis) but never serializes the raw vector to disk. The on-the-wire embedding_computed event records only the dimensionality. This is enforced at the recorder layer, not the anonymizer, so a misconfigured anonymizer cannot accidentally leak embeddings — they are not in the file to begin with. test_embedding_stored_internally_but_not_serialized_raw locks the contract.

3.6 Lenient with caller mistakes

The recorder is deliberately lenient about API misuse. A duplicate node_added for the same id logs a warning, keeps the first observation, and continues. A node_revoked for an id the recorder does not have logs and continues. The trade-off is intentional: tearing down a long agent run because an upstream caller hooked the same write twice is the wrong cost. The recorder’s job is to capture as much truth as it can without creating reasons to disable it.

4. The anonymizer

The anonymizer is core/graph/delta_anonymize.py. Its responsibility is to take the raw NDJSON the recorder emits — which carries Memagen™‘s real internal taxonomy, real labels, and real free-text — and rewrite it as a published-safe variant whose schema is the generic six-kind / six-edge / three-domain taxonomy specified in docs/timeline-format.md Section 3, whose labels are deterministic Greek-letter placeholders, and whose embedding vectors are replaced by a PCA-3 projection. The transformation is intentionally lossy: the public file is structurally truthful and semantically opaque.

4.1 The generic taxonomy

The anonymizer maps every real Memagen™ node kind to one of six generic categories: concept, task, event, capability, pattern, vector. The mapping is many-to-one and one-way; the list DEFAULT_KIND_MAP in delta_anonymize.py is the authoritative table. Edges map similarly to one of six generic edge kinds (parent_of, supports, contradicts, derives, mentions, similar) via DEFAULT_EDGE_KIND_MAP. Domains collapse to three (memory, task_graph, presence) via DEFAULT_DOMAIN_MAP. Anything not in the relevant table defaults to a safe generic value (concept, mentions, memory respectively) and triggers a one-time warning so the policy author can promote it to an explicit row.

The structural truth that survives this transformation is everything geometric and topological: layer assignments, parent/child relationships, edge directions, edge kinds at the generic level, fact invalidations, capability grants, and embedding co-locations. What is destroyed is the proprietary cognitive vocabulary: a viewer of the published timeline can see “this task decomposes into three sub-tasks” but not “this is a recipe:def that decomposes into three recipe:step nodes”. The policy is documented end-to-end in docs/anonymization-policy.md.

4.2 Stable Greek-letter placeholders

Every distinct real label is replaced with a deterministic placeholder of the form <generic_kind>-<greek_letter>-<counter>. The Greek letter is selected by hashing the real label content (SHA-256, low 32 bits, modulo 12) — so the same real label always picks the same letter. The counter increments per (generic_kind, letter) pair so that within one published file, the same real label always maps to the same placeholder. Co-reference is preserved: if a concept is referred to twenty times, the file shows twenty references to the same concept-mu-7. The reader sees structural fact, not content.

The registry, _LabelRegistry in the source, is threaded through the per-event anonymizer so its state accumulates across the timeline. Forty-five tests in test_delta_anonymize.py lock this behaviour and the kind-mapping tables.

4.3 Deterministic PCA-3 projection

Embedding vectors are projected from their original dimensionality (typically 768 or 1024) into three coordinates in [-1, 1]^3 via PCA. The basis is fit deterministically across all embedding_computed events in the input timeline, with three controls that together remove every source of nondeterminism:

1. Seeded SVD initialization. The seed string memagen-2026-05-08 is SHA-256 hashed and the low 64 bits are used to seed numpy’s deterministic LAPACK gesdd SVD when numpy is available, or a power-iteration fallback otherwise. The seed string is a public constant (PCA_SEED_STRING in the source) so any third party with access to the source can reproduce the basis.

2. Sign canonicalization. SVD components are sign-ambiguous. The anonymizer flips each component’s sign so its largest-magnitude entry is positive, with ties broken by lowest index. This eliminates the dominant nondeterminism in repeated runs. The convention is documented in docs/timeline-format.md Section 7.

3. Per-axis rescale. After projection, each axis is rescaled per-corpus into [-1, 1] using the corpus’s min and max along that axis. Embedding clusters that were close in the original 1024-dimensional space remain close in the projected coordinates, but the absolute scale is bounded — important for the visualization, which interprets the PCA coordinates as displacements off the deterministic shell layout.

Re-running the anonymizer on the same input produces byte-identical output. This is not just a nice property; it means the published timeline file is a deterministic function of the recording. A diff between two anonymized timelines is a meaningful signal about a change in the underlying agent run, not noise from the anonymizer.

4.4 Goal-text redaction

agent_thought.text, scenario_start.goal, scenario_end.summary, agent_tool_call.args_summary, node_revoked.reason, heartbeat.note, and narration.text pass through a heuristic proper-noun redactor. Capitalised mid-sentence tokens are replaced with Person, City, or Name according to a small lookup table; sentence-start tokens are passed through unchanged unless they appear in the lookup. The heuristic is honest about its limits — it is not an NER system, and the policy document tells the demo author to spot-check redacted free text with --review-redactions before publication.

This is the weakest link in the pipeline by construction. The compensating control is procedural: the operational rule in docs/anonymization-policy.md requires the demo author to read the redaction log of every new scenario and add unmatched names or places to _NAME_HINTS / _PLACE_HINTS before shipping. The recorder and the anonymizer are self-describing enough that this manual step is well-scoped.

5. The visualization substrate

The scene is implemented in web/site-v2/src/lib/scene/, seven TypeScript modules totalling roughly 2,275 lines. It consumes the anonymized NDJSON, walks events in monotonic time order, and translates each event into a visual mutation of a single Three.js scene.

5.1 InstancedMesh node field

instances.ts wraps a single THREE.InstancedMesh of capacity 2,000 with an id-to-instance-id map and a swap-and-pop removal strategy. Every node, regardless of kind, draws as one instance of one icosphere geometry. Per-instance color carries the generic node kind via the instanceColor buffer; per-instance fade alpha is folded into the color buffer (the color carries kind_color * alpha). When a node is revoked, its instance is swapped with the last live instance and the live count is decremented; this keeps the GPU draw range contiguous. A raycaster against the InstancedMesh returns the original node id for hit testing, so the user can click through into a node and trigger a wormhole transition (Section 5.5).

The single-mesh design matters because the alternative — one THREE.Mesh per node — would not scale past a few hundred nodes before frame rate collapses. Real agent runs produce timelines with hundreds to a few thousand nodes; the InstancedMesh handles all of them in one draw call.

5.2 PBR materials, kind-encoded colors

materials.ts defines one canonical color per generic node kind: brand lime for task (the agent’s intent surface, visually loudest), soft cyan for concept, soft coral for event, amber for capability, soft violet for pattern, mint for vector. Edge materials use additive blending with kind-encoded colors that sit dimmer than the node colors so dense edge graphs stay legible. A small environment map provides PBR rim lighting; a domain-rim accent (memory cyan, task-graph lime, presence amber) gives layers a per-domain hue without flipping the base color.

The colors are intentionally restrained. Six categories on screen at once is already a dense visual surface; a seventh would degrade legibility. The brand accent is reserved for the kind that most needs to be noticed in the scenarios.

5.3 Spherical-Fibonacci layout

layout.ts places nodes on six concentric shells, one per layer (LAYER_RADII = [0, 7, 14, 22, 30, 38, 46]). Within each shell, nodes are placed by spherical-Fibonacci distribution at indices derived from a stable hash of the node id. The result is deterministic — reloading the page produces the same scene — and visually intentional rather than jittery, which is what a force-directed alternative would produce as nodes are added one at a time.

A small per-layer organic offset (LAYER_JITTER) nudges nodes off the perfect shell by a deterministic but pseudorandom amount, so the substrate does not read as a CAD blueprint. Position hints from the timeline (pos_hint on node_added, or the projected PCA coordinates of an attached embedding) override the deterministic placement; the scene smooths toward the hint over a few frames to keep visual continuity.

5.4 Vector flow particles

vectors.ts handles two embedding-related visuals. An embedding_computed event spawns a stream of additive points that travel along a quadratic-bezier path from a fixed “vector well” position into the node’s surface, then condense into a small persistent glyph attached at the node. A vector_link event draws an emissive beam between two nodes whose thickness and opacity scale with the cosine score on the edge. Both use a shared additive material; both clean themselves up after the configured stream lifetime (STREAM_LIFETIME_MS = 800). The PCA-projected coordinates from the anonymizer position the persistent glyph, so semantically similar embeddings cluster visibly in the same region of space.

5.5 Wormhole transitions

wormhole.ts implements a camera-dolly plus radial-fog transition between magnification layers. The transition is purely cosmetic — the actual layer swap happens at the midpoint via the onMidpoint callback, where the engine clears the InstancedMesh of the outgoing layer and replays the new layer’s checkpoint state. Reduced-motion preferences collapse the transition to a single-frame jump. The transition exists so the scene can show the user moving from a coarse view of the substrate (layers 1-3, identity and goal-level) to a fine view (layers 5-6, raw observations and tool results) without losing spatial continuity.

5.6 Timeline player

timeline.ts is a pure data structure: an event-typed parser for the NDJSON wire format and a TimelinePlayer that drives the scene by emitting events through an onApply callback. The player respects the monotonicity of the timeline, supports play/pause/seek/setSpeed, and uses checkpoints for fast seeks. It carries no graphics state; it only walks events. The separation matters because it lets the same player drive non-graphical consumers (Section 7) without a Three.js dependency.

5.7 Engine

engine.ts (~1,000 lines) wires renderer, scene, lights, env-map, controls, and the timeline-driven node/edge state machine into one object that owns its lifecycle. Public surface, consumed by web/site-v2/src/components/CompoundGraph3D.astro: loadTimeline(events), player.play()/pause()/setSpeed()/seek(), setMagnification(layer), dispose(). The engine is the single place where event semantics meet rendering semantics; everything else is pure.

6. Five scenarios as proof

The five hero scenarios in docs/scenarios/ were authored to exercise the visible behaviours of the substrate without redundancy. Each scenario foregrounds one or two dimensions of the substrate’s visual surface. Together they cover the surface area; the scene’s player handles all five without scenario-specific code.

Coding (docs/scenarios/01-coding-project.md) — topology mutation. A goal node spawns four subgoals; each subgoal spawns a recipe of ordered steps; one branch picks the wrong API, fails red, is superseded, and a clean recovery branch lands the build. The visible behaviour is a tree growing in real time with an explicit fact-invalidation chain off to the side. This scenario tests node_added, edge_added, node_updated on state transitions, node_revoked for the failed branch, and the engine’s invariant that revocations cleanly remove all incident edges.

Web surfing (docs/scenarios/02-web-surfing.md) — vector flow plus capability flow. The agent crawls a small fan of pages, computes embeddings for each page’s content, and the embedding cloud condenses onto three picked nodes. Each fetched page also pulses a one-use net.fetch capability grant. The visible behaviour is a flock of additive particles converging into glyphs, plus capability nodes glowing and consuming. This scenario tests embedding_computed, vector_link, and the capability-as-event family.

Deep research (docs/scenarios/03-deep-research.md) — vector flow plus pattern surfacing. A dense cloud of low-layer concepts is consolidated by the dream-consolidation pipeline (Memagen™ master paper, Section 10.3) into a small set of pattern nodes; the cloud shrinks visibly as raw observations are summarised. This scenario tests node_added of pattern kind, derives edges from the pattern back to its source observations, and the visible reduction in node count between layers.

Vacation planning (docs/scenarios/04-vacation-planning.md) — recipe execution plus capability flow. Several parallel recipes (flight search, lodging search, itinerary draft) light up in adjacent lanes and converge on a single daily-plan node. The visible behaviour is parallel topology growth with synchronised convergence, demonstrating that the substrate cleanly handles multiple concurrent task subtrees. This scenario tests the recipe-execution patterns in the master paper without disclosing recipe-engine internals.

Personal secretary (docs/scenarios/05-personal-secretary.md) — capability flow plus memory consolidation. Capability nodes glow in sequence as the agent dispatches calendar reads, contact lookups, and a draft email. Tentative slot beliefs are fact-invalidated as the agent narrows on the right meeting time. The visible behaviour is node_revoked events firing on belief nodes that the visualisation marks as superseded. This scenario tests the substrate’s most distinctive cognitive behaviour — explicit fact invalidation — at the visual level.

The scene’s engine has no per-scenario branches. Each scenario is a different sequence of the same dozen event types over the same six layers in the same three domains; the visual differences are emergent. This is the strongest argument for the format: the same player handles five qualitatively different agent behaviours because the format captures the cognitive primitives, not the specific surface workflow.

7. What the live substrate enables beyond the demo

The hero is the visible payoff. The recorder, the format, and the anonymizer were not built for the hero alone. Five engineering uses share the same NDJSON.

Time-travel debug. A recorded timeline plus the checkpoint mechanism is a deterministic replay of an agent run. A debugging session loads the file, scrubs to the moment a behaviour went wrong, and inspects the live-set of nodes and edges at that instant. Because the recorder captures agent_thought and agent_tool_call events as well as graph events, the developer sees what the agent was thinking, which tools it called with which outcomes, and which graph mutations resulted. The Memagen™ team uses the same scene player for this internal use case as ships on the marketing site.

Audit trail. Regulated deployments require an audit record of every action the agent took and every capability it was granted. The recorder’s agent_tool_call, capability events, and node_revoked events together constitute a complete causal chain. The anonymizer’s redaction map can be tuned to a deployment’s privacy requirements (the kind table is configurable per-deployment), so the same recorder produces a regulator-acceptable audit log without code changes.

Connected SKU sync backbone. The Connected SKU variant of Memagen™ keeps multiple devices’ graphs in sync. The recorder’s append-only NDJSON is the natural sync log: every device emits its mutations, the central reconciler merges, and each device replays the merged stream against its local graph. The format’s idempotence properties (a node_added for an existing id is a no-op with a warning, a node_revoked for a non-existent id is the same) mean reconciliation tolerates duplicate events without special casing.

Selfmod correctness gate. Sandboxed self-modification (master paper, Section 10.6) requires a behavioural test: a candidate code change must not change the agent’s behaviour on a fixed corpus of recorded scenarios. The recorder is the instrument that produces the behavioural baseline, and the timeline diff between baseline and candidate runs is the gate. A change that adds new nodes of new kinds, revokes a fact the baseline did not revoke, or alters embedding-cluster geometry reads as a behavioural delta and blocks promotion.

Anomaly detection. Once enough timelines have accumulated for a deployment, statistical baselines over event-rate distributions and topology shapes become tractable. An agent run whose node_revoked rate is an order of magnitude above baseline, or whose embedding cloud collapses to a single point, is anomalous. The Memagen™ team treats the recorder stream as the cognition-quality signal: a healthy agent produces a healthy graph, and a healthy graph has visible statistical regularities in the event stream.

These uses share infrastructure. The debugging, audit, sync, selfmod-gate, and anomaly-detection consumers all read the same NDJSON the hero reads. Adding a sixth consumer is a matter of writing a new walker over the format, not extending the recorder. The single-format discipline is the engineering payoff.

8. Conclusion

The Memagen™ v4 hero shows the substrate rather than describing it because the same instrument that drives the marketing visualization drives the platform’s debugging, audit, sync, self-modification, and anomaly-detection layers. The recorder is hot-path-cheap when disabled. The wire format is append-only NDJSON with checkpoint-based seek. The anonymizer is byte-deterministic, removes proprietary taxonomy without removing structural truth, and projects high-dimensional embeddings into a sign-canonicalised PCA-3 basis whose seed string is a public constant. The scene is a pure player over the format, with a single InstancedMesh node field, a deterministic spherical-Fibonacci layout, additive vector-flow particles, and a wormhole transition between magnification layers. Five scenarios exercise the visible behaviours without scenario-specific code in the player.

The thesis of this paper is that none of this is theatre. The visualization is engineering because the alternative — a hand-animated scene disconnected from the running platform — would let claims drift untestably away from behaviour. The recorder and the format exist for engineering reasons that predate the hero; the hero is one consumer of an instrument the platform needs anyway. The substrate is what we built; showing it is the cheapest honest way to communicate what the platform does.

Pipeline diagram

flowchart LR
    subgraph Producer["Live agent run (Memagen™ runtime)"]
        graph[Compound graph]
        agent[Agent loop]
    end

    subgraph Recorder["delta_recorder.py — append-only NDJSON"]
        rec[GraphDeltaRecorder]
        ndjson[(raw.ndjson)]
        rec -- "format_version, scenario_start,<br/>node_added, edge_added,<br/>node_updated, node_revoked,<br/>edge_revoked, embedding_computed,<br/>vector_link, agent_thought,<br/>agent_tool_call, checkpoint,<br/>heartbeat, scenario_end" --> ndjson
    end

    subgraph Anonymizer["delta_anonymize.py — deterministic post-process"]
        kind[kind / edge / domain<br/>generic taxonomy map]
        labels[Greek-letter<br/>label registry]
        pca[PCA-3 basis<br/>seed = memagen-2026-05-08]
        published[(published.ndjson)]
        kind --> published
        labels --> published
        pca --> published
    end

    subgraph Consumers["Consumers of the same NDJSON"]
        scene[3D scene<br/>web/site-v2/src/lib/scene/*]
        debug[Time-travel<br/>debugger]
        audit[Audit packet<br/>capability vault]
        sync[Connected SKU<br/>sync log]
        selfmod[Selfmod<br/>correctness gate]
        anomaly[Anomaly<br/>detection]
    end

    graph --> rec
    agent --> rec
    ndjson --> kind
    ndjson --> labels
    ndjson --> pca
    published --> scene
    ndjson --> debug
    ndjson --> audit
    ndjson --> sync
    ndjson --> selfmod
    ndjson --> anomaly

The diagram makes one fact explicit: the visualization is one consumer among six. The value of the recorder is not the hero. The hero is the consumer that proves the recorder exists and works.

References

[1] Levitas, T. (2026). Memagen™: An Open-Core Agent Platform with Lenient Tool Routing, Capability-Gated Execution, and a Compound-Graph Memory Substrate. Memagen™ master paper, /papers/2026-05-08-memagen-master.

[2] Memagen™ engineering. (2026). Compound-Graph Timeline Format (v1.0). docs/timeline-format.md. Frozen interface contract between recorder, anonymizer, and scene.

[3] Memagen™ engineering. (2026). Graph-Delta Anonymization Policy (v1.0). docs/anonymization-policy.md. Companion to core/graph/delta_anonymize.py.

[4] Memagen™ engineering. (2026). Hero Demo Scenario Suite. docs/scenarios/. Five scenario scripts: coding, web-surfing, deep-research, vacation-planning, personal-secretary.

Code references

• core/graph/delta_recorder.py — append-only NDJSON recorder, 488 lines. Tests: tests/graph/test_delta_recorder.py, 22 cases.
• core/graph/delta_anonymize.py — deterministic anonymizer with PCA projection, 1289 lines. Tests: tests/graph/test_delta_anonymize.py, 45 cases.
• web/site-v2/src/lib/scene/engine.ts — scene wiring and lifecycle, ~1,000 lines.
• web/site-v2/src/lib/scene/instances.ts — InstancedMesh node field with swap-and-pop removal.
• web/site-v2/src/lib/scene/layout.ts — deterministic spherical-Fibonacci shell layout.
• web/site-v2/src/lib/scene/materials.ts — PBR material factory and per-kind color table.
• web/site-v2/src/lib/scene/vectors.ts — additive vector-flow particles and link beams.
• web/site-v2/src/lib/scene/wormhole.ts — camera dolly between magnification layers.
• web/site-v2/src/lib/scene/timeline.ts — pure NDJSON parser and player.
• web/site-v2/src/components/CompoundGraph3D.astro — Astro component that mounts the engine.