Changelog

What shipped, when.

Memagen^™ ships substantive updates roughly monthly. Subscribe to GitHub release notifications, or check this page. Entries are written by the engineer who shipped them.

May 8, 2026 release memagen.com v4

memagen.com v4 — substrate-as-hero, replayed from a real graph
The v4 release replaces the procedural fixture that fronted the v3 site with a deterministic player driven by the live compound graph. The hero is no longer decorative; it is a consumer of an event stream the platform already emits for time-travel debugging, audit, and Connected-SKU sync. Four work-streams shipped together.

Foundation.
- Graph-delta recorder lands in core/graph/delta_recorder.py with an NDJSON wire format, append-only file rotation, periodic checkpoints, and a hot-path-cheap fast exit when recording is disabled. Tests in tests/graph/test_delta_recorder.py.
- Anonymization layer at scripts/anonymize_timeline.py and scripts/anonymize_captures.py — substrate-public taxonomy, deterministic sign-canonicalised PCA-3 projection of embeddings, generic node and edge kinds, every secret and personal field replaced with a stable opaque token.
Visualization.
- 3D substrate hero at web/site-v2/src/components/CompoundGraph3D.astro, with engine, instances, layout, materials, vector flow, wormhole, and timeline modules under web/site-v2/src/lib/scene/.
- Real PBR orbs on an InstancedMesh node field, vector-flow particle edges, wormhole transitions between scenarios, and a spherical-Fibonacci layout that keeps node identity stable across replays.
- HUD components in src/components/scene/ — magnification readout, timeline scrubber, scenario picker, event-type indicator, and narration overlay.
- Five demo scenario specs in docs/scenarios/ with companion authoring scripts in scripts/scenarios/: coding project, web surfing, deep research, vacation planning, and personal secretary.
Content.
- New specialty paper, The Compound-Graph Substrate as Live Visualization, at src/content/papers/2026-05-08-substrate-as-live-visualization.md.
- New notes essay, Why we made the hero a real graph, at src/content/notes/2026-05-08-why-the-hero-is-a-real-graph.md.
- Eight Mermaid diagrams added across the specialty papers to make subsystem interactions readable without leaving the page.
Polish.
- Accessibility pass on the hero, HUD, and scrubber: keyboard operation, reduced-motion fallback to a still frame, and screen-reader narration of the active scenario.
- Performance-budget tuning for the scene bundle and a fixture fallback at src/lib/graph-3d-fixture.ts for low-end devices.
- Open Graph image generation, RSS and Atom feeds for notes and papers, and a static search index served from src/pages/search-index.json.ts.
May 8, 2026 site

memagen.com v2 — substrate-as-hero redesign
The new memagen.com replaces the v1 marketing skin with a working frame around the substrate itself: dark mono palette, a single accent, the compound graph as the load-bearing hero, and a 3-tier price ladder that leads with Founder Member.
- Rebuilt as a static Astro 5 site, deployed to Cloudflare Pages
- Three pricing tiers (Local, Connected, Hosted) with a Founder Member program for the first 50 buyers
- New /agent page documents the agent-readable surface (llms.txt, MCP, JSON manifests) so other agents can consume the site without scraping HTML
May 7, 2026 graph V3-S P1–P5

V3-S subsystem graph wiring (P1–P5)
Every long-lived agent subsystem now writes through the compound graph instead of holding state in process memory or scattered SQLite tables. The five wiring passes (P1 avatar, P2 recipes, P3 capabilities, P4 goals, P5 presence) each land their own subgraph with typed edges, and the agent loop now reads from the graph for state that used to be import-time globals.
- Avatar pillar — embodiment + persona traits as graph nodes; previous hard-coded avatar config retired
- Recipes pillar — guided-setup recipes persist as recipe → step → tool chains with pursues edges to the user’s active goals
- Capabilities pillar — use_capability and revoke_capability audit edges produce a per-capability use-revoke chain you can replay
- Goals pillar — user-owned goal nodes link to the tasks that pursue them
- Presence pillar — websocket lifecycle hooks now write a presence subgraph; “what was I doing 30 minutes ago” is now a graph query, not a log scrape
May 7, 2026 release V1-lite

V1-lite — open-core extraction, MIT-licensed
The harness that wraps Memagen™ — agent loop, system prompt, retrieval shim, tool registry, dreams, motifs, cognition stubs, workspace persistence — has been carved off as an MIT-licensed open core. The compound-graph engine and the cognition modules behind it remain proprietary; everything around them is now free to read, fork, and redistribute.
- core/lite_mode.py central helper module gates every graph-dependent call site; the lite path returns degraded-but-correct results
- 9 integration tests cover loop, system prompt, retrieval, tools, dreams, motifs, cognition, workspace persistence, and the frontend placeholder
- Three new docs: docs/lite_mode.md, docs/lite_vs_full.md, docs/troubleshooting_lite.md
- PyPI publish (pip install memagen-lite) is queued; until it lands, install from the GitHub source tree
May 7, 2026 safety V3-Q.5

V3-Q.5 sandboxed self-modification plumbing
The agent can now propose changes to its own codebase, run them through a sandboxed test battery, and — if a human operator opts in — auto-apply them with a 7-day rollback window. The plumbing is in; the auto-apply switch is off by default and gated behind the toggle framework. No autonomous self-edits ship enabled.
- Proposer module emits a unified diff plus a one-paragraph justification for every proposed change
- Sandbox runner executes the proposed diff against a freshly cloned worktree, runs the canary battery (~120 fast tests), reports pass/fail with timing and stack traces
- Policy gates block changes that touch listed foreground-only files, bypass the safety toggle framework, or modify the kill switch itself
- 7-day rollback window — every applied diff is reversible with a single command; the audit log is graph-persisted
May 7, 2026 safety Phase 5.5a

Phase 5.5 safety-toggle framework
Every agent capability — email, browser, code-edit, self-modification, tool execution, plugin loading — now sits behind a default-restrictive toggle. To loosen any toggle, the operator has to read and acknowledge a five-bullet warning describing the failure modes that toggle unlocks. Eight hard invariants cannot be loosened by any toggle, by any user, in any configuration. The kill switch is one of them.
- 20 toggles registered in core/safety/toggle_registry.py with per-toggle 5-bullet warnings authored against the failure modes they unlock
- 8 hard invariants protected: kill switch, RBAC ownership, safety screening, budget cap, signed-plugins-only on production, vault read-back, audit-log append-only, sandbox isolation on self-modification
- Toggle changes are graph-persisted, signed, and replayable
- The agent loop checks toggles at every gate that matters; the toggle is the choke point, not a polite suggestion the agent can route around
May 7, 2026 safety V3-Q.3

V3-Q.3 hallucinated <function_results> detector
Some models, under pressure or after a long context, will produce fake <function_results> blocks in their text output — pretending the tool ran and returning made-up output. The lenient parser now catches these forgeries and refuses to feed them downstream.
- Fabricated <function_results> blocks are detected by signature mismatch against the orchestrator’s tool-call ledger
- Detected forgeries are stripped from the model output before any downstream consumer sees them
- A one-shot directive (“the function did not run; do not pretend it did; ask for it”) is injected on detection so the next turn corrects
- Detection events are graph-persisted as hallucination_caught nodes for later analysis and per-model regression tracking
May 7, 2026 tools Phase 5.5b

Phase 5.5 email tool — drafting + sending via Gmail OAuth
Memagen™ can now draft and send email through the user’s own Gmail account via OAuth. Capability-gated, rate-limited, and behind a prompt-injection guard that scrubs known-bad payloads before the model ever sees the inbound message body.
- Per-recipient and per-day rate limits, configurable, with a hard ceiling no toggle can bypass
- Recipient allow / deny lists; default is “allow only addresses the user has corresponded with before”
- Attachment policy — opt-in per attachment, content-type allow-list, size cap
- Outbound prompt-injection scrub blocks any email body that contains unrendered system-prompt markers or known instruction-leak patterns
- Secret-scrub blocks API keys, OAuth tokens, and identifiable PII from outbound mail
April 30, 2026 infra Phase 2.5

Phase 2.5 zero-error gate — 4673 tests, 0 failures
The test suite went from 4243 passing / scattered failures to 4673 passing / 0 failures, and the gate is now enforced. A pre-commit hook runs the relevant test slice on every commit; the GitHub Actions workflow runs the full suite on every push.
- Pre-commit hook scoped to changed paths so commits stay fast
- tests.yml GitHub Actions workflow runs the full battery on push and PR, no skips
- CONTRIBUTING.md published with the contribution flow, fixture conventions, and the explicit “no merging on red” rule
- A handful of long-standing flaky tests were rewritten as deterministic; one was deleted as truly testing nothing
April 29, 2026 docs Phase 7

Phase 7 — MIT license + monetization model
The license switched from “all rights reserved” to MIT for the open core. The paid packages (Pro Skills Pack, Ham Radio Pack, hosted SaaS) are proprietary and have their own EULAs. The hybrid model — open harness, paid graph engine + specialty packs — is now publicly documented.
- LICENSE switched to MIT
- docs/pricing.md published with the four-offering ladder
- docs/EULA-pro-skills.md and docs/EULA-ham-radio.md published for the proprietary packages
- The open core is the V1-lite surface; everything graph-dependent is on the paid side. Lite users keep their data; paid users get the graph + the cognition that runs on it
April 29, 2026 graph Phase A–C

AGI substrate — Trace Spine + Boundary Sentinel + Confidence Envelope + Memo Layer
Four substrate modules landed across two waves. They are the load-bearing pieces every higher-level capability now stands on: a per-turn trace record, a boundary check around tool calls, a calibrated confidence score on every prediction, and a write-once-read-many memo layer that the graph reads from when retrieving.
- Trace Spine — every turn writes a structured trace node with inputs, decisions, tool calls, and outputs; replayable end-to-end
- Boundary Sentinel — wraps every external-effect tool call; enforces RBAC, capability presence, rate limits, kill switch, and the safety screening pass
- Confidence Envelope — calibrated Confident[T] wrapper that carries a margin and a fallback policy; used at every margin-based decision (LLM escalation, plan reuse, niche application)
- Memo Layer — append-only memo store the retrieval pipeline reads from; cheaper than re-querying the LLM for facts you’ve already established
April 26, 2026 release Wave B

Wave B — onboarding foundation (catalog, conversation, widgets, vault)
The onboarding flow that takes a fresh install from “first launch” to “working agent” landed across eight sub-waves. It is intentionally a conversation, not a settings panel — the agent talks the user through each setting with the same anchor-cosine interpreter it uses for runtime intent classification.
- 149 settings registered in the onboarding catalog with key validators and a model registry
- Conversation engine — anchor-cosine interpreter on user replies, state-machine over the catalog, persistence across restarts
- Widget surface — 9 onboarding widgets (secret input, enum choice, boolean toggle, text, range, URL, email, file, multi-select)
- Sealed vault + action capabilities — secrets are never retained in plaintext on disk; capabilities are revocable graph nodes
- Recipe DSL — 31 guided-setup recipes for the most-requested external integrations
- Demo mode — 15-pattern showcase that fires post-onboarding so a fresh user has something to look at on turn 1
- Single → multi-account migration wizard with a 5-persona end-to-end validation harness
April 23, 2026 tools

Tool contracts + constitutional reasoning
Every tool the agent can call now has a contract: a typed input schema, a typed output schema, a stated effect class (read | write | network | shell | self-modify), and a stated reversibility. The agent loop reads the contract before invocation, not just at registration time.
- Effect class is enforced at the boundary — a read-class tool that attempts a write is short-circuited
- Reversibility lights up the rollback / undo machinery for that tool invocation
- Constitutional reasoning step — the loop checks the proposed tool call against the constitution (kill switch, RBAC, capability presence, safety screen) before the boundary sentinel runs
- MCP / WebMCP tools share the same contract surface as built-in tools
April 18, 2026 graph

Seven-graph architecture — six domains + retriever middleware
The single monolithic graph split into six domain graphs (memory, agent_memory, presence, capabilities, recipes, goals) plus a seventh meta-graph that records the curators and embeddings runners that maintain them. Retrieval now flows through middleware that fans out per-domain, with a single ranking stage at the top.
- Six domain subgraphs, each with its own node + edge schema, sharing the same compound-graph primitives (parent_id, subtree_root_id, versioned edges, revoked_at)
- Curators run on schedule and on event; each curator owns its domain’s invariants
- Embeddings runner re-embeds dirty nodes opportunistically; the bus fires node_dirty events the runner subscribes to
- Retriever middleware fans a query out to the relevant domains, then collapses results through a single dual-weights ranker