Every subsystem.

Compound-graph memory Pro

Typed memory primitive. Tracks entities and relationships across multiple semantic domains. Replaces flat chat history or vector-only memory with structured state the agent can query, traverse, and update without forgetting context.

Fact invalidation Pro

Memagen™ does not delete facts. When a new fact contradicts an old one, the prior version is preserved with a revocation marker. The agent can ask "what did I think was true six months ago" and the memory substrate answers — useful for continuous-learning agents that need to know not just what they know, but when they learned it and what changed.

Retrieval extensions Pro

Beyond simple anchor-and-neighborhood retrieval, Pro adds bounded multi-hop traversal, motif surfacing across conversation history, and relatedness queries between entities. All bounded to defend against adversarial prompt-injection inputs.

Motif detection Pro

Background workers identify recurring patterns in the agent's interaction history. Future agent runs match against motifs for faster planning and better continuity.

Dream consolidation Pro

Periodic memory consolidation. Compresses long execution chains into summaries, extracts patterns, surfaces user-relevant insights as suggestions you review on your schedule. Runs only during user-idle by default — the user is the priority.

MCP integration Lite

Native consumer of the Model Context Protocol (Anthropic, 2024). Connect any MCP server, Memagen™ surfaces the tools to the agent. Federation, evolution, hybrid-routing, and tool-contract tracking implemented at core/mcp/.

UIMCP — adaptive catalog compression Lite

Long-running sessions with dozens of MCP tools enabled cost tokens proportionally to catalog size. UIMCP ranks tools by recency, context relevance, and tier. Always-injected vs. on-demand summoning. Production observation: 42.7× token compression on a 90-tool catalog without measurable loss in tool-selection quality.

Specialty paper forthcoming.

AutoMCP — macro inference from action graphs Lite

The macro layer for MCP servers. Memagen™ observes which tools the agent uses in which sequences and which parameter shapes co-occur. Stable patterns get proposed as named macros — "checkout_workflow", "deploy_to_staging" — for user approval. Approved macros become first-class tools. Recognition operates over the typed action graph, which means parametric macros are inferable from a small number of observations.

Specialty paper forthcoming.

AutoWebMCP — generate MCP tools from any web page Lite

Given a URL, the generator fetches the HTML, parses structure (forms, links, tables, headings), sniffs OpenAPI/Swagger specs if linked, and produces an MCP tool schema covering the page's interactive surface. A user-approved schema becomes a runnable tool: submit_contact_form(name, email, message).

SSRF-protected at the call boundary: the generator refuses private network ranges. Reference at core/mcp/webmcp_generator.py.

Specialty paper forthcoming.

AutoWebMCP macros Lite

The macro recorder for WebMCP-generated tools. Same observation-and-pattern approach as AutoMCP, applied to web-page interactions. Records form-fill sequences, link-walks, multi-page workflows; proposes parametric macros after stability detection.

PCMCP — vision-free computer control Lite

Programmatic Computer MCP. Vision-based agents (Claude Computer Use, OpenAI Operator) process every screen as pixels — slow, expensive, fragile. PCMCP introspects the OS accessibility tree (AT-SPI on Linux, UIA on Windows, AXUIElement on macOS) and renders it as a structured, addressable surface. The agent issues semantic commands (click_button(label="Save")) which PCMCP translates to OS-level events.

Result: computer control without per-action vision LLM calls, typically 10-100× faster and at near-zero token cost beyond the initial tree dump.

Implemented atop core/ui_control.py (mouse/keyboard backends — pyautogui, xdotool, ADB) and core/tools/computer.py (multi-platform dispatcher).

Specialty paper forthcoming.

Tool contracts and evolution Lite

Per-tool argument schema validation, automatic schema evolution tracking, federation across multiple MCP servers, and hybrid routing (combine MCP, AutoWebMCP, UIMCP, and PCMCP tools in a single agent catalog).

Multi-format tool-call parser Lite

Recovers tool calls from four production-observed emission patterns:

• Format A — native (OpenAI function-calling, Anthropic tool_use, Gemini function calls)
• Format B — XML invoke (<invoke name="..."> blocks within text)
• Format C — JSON in sentinel (<tool_call>...</tool_call>)
• Format D — Kimi-special-tokens (<<<function_call>>>...<<</function_call>>>)

Detects which format is in play per emission, extracts and canonicalizes, produces a single ToolCall shape.

Per-tool argument coercion (V3-Q.1) Lite

When the model emits a recognizable but non-canonical argument shape, a registered coercer per tool converts it to the declared schema. Example: widget_create({type, text}) coerces to widget_create({name, spec: {kind, props.text}}).

Catalog gate + fuzzy resolver (V3-Q.2) Lite

Validates that the proposed tool name is in the agent's declared catalog. Fuzzy resolver maps loose tool names to canonical ones ("widge_create" → "widget_create"). Rejected tool calls produce structured errors that surface in the next system prompt so the model can correct.

Hallucinated <function_results> detector (V3-Q.3) Lite

Some smaller models occasionally hallucinate not just tool calls but tool results, emitting role-played <function_results> blocks as if a tool had returned data. Without detection, this poisons the conversation. Memagen's detector recognizes the pattern, suppresses the block from visible output, and emits a synthetic hallucinated_results_detected event that triggers a one-shot directive injection in the next system prompt. Bounded to two retries per session to avoid loops.

Multi-provider LLM router Lite

Provider abstraction supporting OpenAI, Anthropic, Google Gemini, OpenRouter, NIM, Cohere, Ollama, llama.cpp, vLLM. Per-agent routing rules. Bring your own keys; Memagen™ Lite never proxies LLM traffic through Memagen™ servers. Pro Connected adds bundled tokens.

V3-P capability vault Lite

Fernet-encrypted at-rest store of credentials and tool grants. Grants are minted per-use with action kind + payload-summary constraint + time-to-live. Audited via capability_use graph nodes edged to the originating capability_policy.

Audit chain as structured records Lite

Every grant, use, and revocation produces a structured audit record. Audit queries ("show everything net.fetch was allowed to do in the past 30 days") are structured queries rather than log archaeology. The audit trail is the application.

Safety toggle framework Lite

Approximately twenty user-controllable safety toggles, each defaulting to its restrictive state. Loosening transition requires: 5-bullet warning text, typed acknowledgment phrase (paste-only entries rejected), password re-auth, optional cap input, 60-second cooldown. Tightening is single-click.

Hard invariants beyond toggles Lite

Eight guards that no toggle bypasses:

• secret_scrub_block — vault-managed credential never leaves the runtime
• authentication_required — every state-changing action requires authenticated session
• audit_logging — all transitions write to the audit log
• final_human_review_on_grant_submission — application form submission requires explicit human click
• force_push_to_main_blocked — git force-push to main requires per-action consent
• csrf_and_session_protection — web layer
• prompt_injection_external_content_scan — external imperative-mood directives downgrade to confirm-before-act regardless of toggle state
• pii_export_block — bulk PII export requires per-export confirmation

SSRF protection Lite

All outbound HTTP fetches (including AutoWebMCP generation) flow through core/security/ssrf.py which rejects private network ranges, link-local addresses, and metadata service IPs.

Recipe execution with crash-resume Pro

Named, versioned tool sequences with parameterized arguments. After a crash, the executor resumes mid-recipe from the last successfully-completed step rather than starting over — restoring argument context and continuing from there. Structurally similar to durable workflow systems (Temporal, Cadence) but at agent-action granularity rather than service-call granularity.

Sandboxed self-modification Pro

The agent can propose changes to its own core code via a tool that is enabled only by an opt-in toggle. Proposed changes execute in a worktree-isolated sandbox against the real test suite plus a battery of behavioral canaries before any change reaches master. User-facing properties:

• The agent cannot ship a change that breaks tests
• The agent cannot disable the kill switch
• The agent cannot modify the safety framework or the audit logger
• You can roll back any auto-applied change for seven days with one command

Multi-source kill switch halts in-flight sandbox work immediately; its source files are recursively forbidden from self-modification. The full mechanism is described in the forthcoming specialty paper.

Cognition modules Pro

Persistent typed state for preferences, beliefs, and goals. Each is a distinct subsystem. Goals support recall against historical goals; preferences propagate to relevant interactions; beliefs are revocable via the fact-invalidation mechanism.

Avatar voice and persona Pro

Voice synthesis (on-device by default; cloud TTS optional). Persona and archetype choices persist across sessions. Identity continuity without the agent forgetting who you've configured it to be.

Presence subsystem Pro

Tracks user activity transitions (connect, focus change, idle, disconnect). Answers questions like "when did the user last work on X" without scanning logs.

Onboarding conversation Lite

Schema-driven first-run conversation that captures the user's environment (provider keys, OS, project context) and bootstraps the initial graph state. Recipe-driven so the experience is itself a replayable / resumable artifact.

Bifurcated landing Lite

memagen.com serves a different page to humans and to LLM crawlers. The agent variant is at /agent; structured plain text at /llms.txt and /llms-full.txt. Architecture rather than rhetoric: agents are an audience that buys software.

Capability-gated outbound by default Lite

The agent cannot perform external actions (network, filesystem, shell) without an explicit capability grant. Grants are time-bounded, scope-bounded, and audited. Default-restrictive: a fresh install is quiet by default.

Lite-mode flag Lite

MEMAGEN_LITE_MODE=1 activates V1-lite mode at every relevant gate point. Graph reads return empty bundles; graph writes are no-ops; dream agents and motif detection do not start; the settings table is the only persistence layer.

Open changelog and roadmap

/changelog publishes every substantive shipping event with calendar dates. /roadmap publishes targets honestly — what's shipped, what's in flight, what's aspirational.

Engineering notes

/notes hosts long-form essays on the technical choices behind Memagen™. Signed by author, time-anchored, no marketing voice.

Research papers

/papers hosts the master overview paper and per-subsystem specialty papers. Published as both HTML and PDF.