Why we made the hero a real graph

The first version of the 3D hero on memagen.com was a lie. Not a hostile lie — a marketing-shaped one. A few hundred nodes, an animated layout, edges fading in and out on a sine wave, the camera drifting on a slow orbit. It looked like a graph. It looked, even, a little bit like Memagen™‘s graph. It was not Memagen™‘s graph. It was a procedural fixture written in a single afternoon, with random node placement and a hand-tuned color palette to feel “AI-ish.”

It looked nice. Several people told us it looked nice. We were ready to ship it.

Then someone whose opinion we trust looked at it for ten seconds and said: I’m not impressed. Show me real data. Hundreds of nodes. Live graph mutation. Actual tasks running. And the moment they said it we knew they were right. The hero was the place on the website where we got the most square inches to argue that Memagen™ is a substrate, not a chat box. We were squandering that argument by filling those square inches with decoration.

This note is about what happened next.

The trade

We had two ways forward, and they were not equally sized.

Path A. Keep the procedural fixture. Tune it harder. Throw more particles at it, tighten the easing, add a parallax layer, run it through a CSS shader to get some chromatic separation. The fixture gets prettier. The fixture is still a lie. We ship in two days.

Path B. Build a recorder that captures real graph mutation events out of a real Memagen™ session. Build an anonymization layer so the captured stream can be published without disclosing the internal schema or the user’s labels. Rebuild the 3D engine to play back a real event stream rather than animate a static fixture. Run actual agent scenarios through the recorder, capture the deltas, ship those as the hero. We ship in two weeks.

Path A was honestly tempting. The fixture already existed. The new particles already existed. The product looked the same to a casual visitor either way.

Path B won for a reason that had nothing to do with the hero itself. We had been talking for months about wanting telemetry on the graph — not metrics-style aggregate telemetry, the actual sequence of node and edge events, captured cheaply, replayable. We had been talking about it and not building it because there was no forcing function. The hero turned out to be the forcing function. If we were going to build the recorder anyway, building it now and getting the hero out of it was the right trade.

We took Path B.

What it actually took

Four pieces, in this order:

1. The graph-delta recorder. A subscriber on the same event bus the curators use. When a node is added, an edge is added or revoked, or a body field changes, the recorder writes one NDJSON line with a timestamp, a delta kind, and the affected ids. When recording is off — which is the default everywhere — the subscriber is unregistered and the cost is zero. The recorder lives at core/graph/delta_recorder.py and it is about five hundred lines of code, most of which is the schema for the delta kinds.

2. The anonymization layer. This was the load-bearing part. Memagen™‘s real internal node kinds — recipe:def, presence:focus_change, capability_use, motif, the rest — are exactly the taxonomy a competitor would want to reconstruct from a marketing video. The published demo cannot leak them. We wrote a post-processor that walks the raw NDJSON and transforms it into a published-safe variant: topology preserved verbatim, timing preserved, layers and domains preserved, ids opaque and stable. All the strings — labels, kinds, summaries — replaced by placeholders drawn from a small generic vocabulary, with co-reference preserved so a viewer can see “this concept is the same as that concept” without learning what the concept is. The policy is documented in full at docs/anonymization-policy.md and the implementation at core/graph/delta_anonymize.py. The output is, by design, truthful at the structural level and useless at the semantic level.

3. The 3D engine rebuild. The first hero was a static-scene animation: load a fixture, animate parameters. The new hero plays back an event stream. Different shape entirely. The engine consumes the anonymized NDJSON, materializes nodes and edges as it sees them appear, applies a deterministic per-file PCA basis to project the preserved embedding structure into three dimensions, and runs the camera on a path that is itself part of the recording. Mutations that happen in the source stream — a node revoked, an edge added, a supersedes relationship landing — happen in the visualization at the original cadence. We do not loop a frozen frame. We replay a recording.

4. Five scenario captures. A research session. A coding session. A scheduling-and-presence session. A recipe-execution session. A dream-consolidation pass. Five separate recordings, anonymized, each one a few minutes long. The hero rotates through them.

The unexpected wins

Here is the part we did not plan for.

The recorder is not just for the demo. Once the NDJSON exists as a first-class artifact of an agent run, a lot of things that we had been treating as separate problems collapse into the same problem.

Time-travel debugging. A user reports that the agent did something weird at 3:42pm. The recorder file for that session contains every graph mutation in order. We can replay the session to 3:42pm and see exactly what the graph looked like one event before the weird thing happened. There is no other way to do this with a stateful agent. Without the recording, the agent has already moved on; the present-tense graph no longer reflects the moment of interest.

Audit trail. The same NDJSON, with a different post-processor, is the input to the capability audit framework. Every grant, every use, every revoke — already in the stream, already timestamped, already ordered. The audit chain we wrote about in the master paper is not a separate datastructure; it is a view over the recording.

Connected SKU sync. The Connected variant of Memagen™ Pro reconciles state across machines. The reconciler does not need a diff algorithm; it needs an event log. The recorder is the event log. Two machines exchange recordings since the last sync point and each one applies the other’s deltas. The thing we were going to have to build separately turned out to already exist.

Self-modification correctness gate. When a sandboxed self-modification proposal is evaluated, the proposed change is run on a recorded scenario and the resulting deltas are diffed against a baseline run of the same scenario. If the proposal changes the behavior on the scenario in ways the gate does not approve, the proposal is rejected. The recorder is what makes this comparison possible. There is no other way to compare two agent runs.

Anomaly detection. Statistical patterns in the delta stream — unusual rates of node creation, unusual edge kinds, capability uses in unusual sequences — are now detectable because the stream exists. We had been thinking about anomaly detection as a thing we would have to instrument separately. It turned out to be a consumer of the recorder.

Five subsystems, one piece of infrastructure. The marketing decision forced an engineering decision and the engineering decision paid off across the stack.

The honest caveat

The captures shown on the site today are simulated. We wrote the scenarios — the script of what the agent does — and ran them through a simulator that produces the same shape of graph mutations a real session would produce. We did this because we wanted the hero to ship this week and the recorder-on-real-sessions plumbing wanted another revision before we trusted it in production.

The infrastructure is real. The recorder is real, the anonymizer is real, the 3D engine that plays back the NDJSON is real. The events in the published files are realistic — same kinds, same cadences, same topological patterns — but they are not records of users. The next step is running real Memagen™ sessions through the recorder and replacing the simulated captures with real ones. When that lands it is a swap of files, not a rebuild of the system.

We are saying this out loud because the alternative — letting people believe they are watching live user activity when they are watching a simulator — is the kind of marketing-shaped lie we wanted to escape from in the first place. The hero is real graph infrastructure. It is not yet real graph traffic. Both pieces matter; we are not pretending we have shipped both.

What we learned

When a marketing decision forces an engineering decision and the engineering decision pays off across the stack, that is the thing to optimize for. The hero is now an honest hero. It plays back a real event stream against a real recording schema. The recorder that exists to feed it also feeds time-travel debugging, audit, the Connected reconciler, the selfmod gate, and anomaly detection. None of those existed three weeks ago. All of them exist now because we let a marketing complaint reach the engineering team unfiltered and took the larger of the two paths it pointed at.

The other lesson — and this is the one I want to keep in front of me — is that we almost did not. Path A was right there, ready to ship in an afternoon, and it would have been fine. The version of this story where we shipped the prettier fixture is not a story anyone notices. The version where we shipped the recorder is the one where five other things start working too. The asymmetry is hard to see from inside the moment.

If you are building agent infrastructure and you find yourself choosing between a marketing-shaped lie that ships tomorrow and a piece of instrumentation that ships in two weeks and that nine other subsystems will quietly want, take the instrumentation. Take it every time. The hero gets to be honest, and you get the rest of the stack as a side effect.

For more on the substrate the hero visualizes, see the paper Substrate as Live Visualization and the survey paper Memagen™: An Open-Core Agent Platform. The recorder source is core/graph/delta_recorder.py; the anonymization policy is docs/anonymization-policy.md.

— Tab Levitas, founder of Memagen™