Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    MaxGraph Memory Protocol

    1

    Persistent-memory discipline for AI agents: prime context at session start, write facts immediately, track open tasks and bugs, close sessions cleanly — nothing gets lost between sessions.

    Free

    1 useSecurity scanned
    MaxGraph Memory Protocol

    MaxGraph Memory Protocol

    Example session with this skill installed

    Start a new session for project 'web-portal'. We just decided to switch from REST to GraphQL for the user-service. Mark the old REST architectural decision as stale.

    • Read your context and instructions
    • Compiled the maxgraph memory protocol

    I have initialized the session for the web-portal project and updated the architectural records. The REST decision has been superseded by the new GraphQL requirement.

    Memory Update Log

    ActionEntity/FactDetails
    Session Startweb-portalContext primed: 4 open tasks, 2 open bugs, 12 recent facts.
    Supersedearch-decision-01Marked "Use REST for internal services" as stale.
    New Observationuser-serviceAdded: "Switch to GraphQL for service communication."
    New Decisiongraphql-migrationVerbatim: "Switch from REST to GraphQL for the user-service."
    Relationuser-serviceCreated: user-service -> uses -> graphql.

    Next steps

    1. Call task_add to create a migration checklist for the user-service GraphQL implementation.
    2. Search for all entities that currently depend-on the user-service REST endpoints to identify downstream impact.
    3. Update the README.md to reflect the new architectural direction before closing the session.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Your agent forgets everything between sessions. This skill fixes that.

    MaxGraph Memory Protocol is the operating discipline we run on our own agents every day. It turns a knowledge-graph memory server into reliable long-term memory: the agent always knows the project's decisions, open bugs and unfinished work — no matter how many sessions, context windows or compactions happened in between.

    What the agent learns

    • Session priming — one call at session start loads a budgeted context block: project facts, owner decisions (verbatim), open bugs, open tasks, past session outcomes. No more re-explaining the project every morning.
    • Write immediately — facts are saved the moment they appear, never batched to the end of a conversation that might get compacted or crash.
    • Atomic observations — one fact per record, dated when it matters. Searchable, supersedable, never a wall of stale text.
    • Stale-fact hygiene — outdated facts (old prices, reversed decisions) are superseded, not duplicated: the old line leaves search results but stays in the archive.
    • Open-loop tracking — explicit task and bug statuses, so «what's left?» is a query, not a guess.
    • Heartbeat work-state — after each stage, one dated fact records «done X → next Y». Context loss costs nothing.
    • Clean session close — one call writes the day's summary and links everything the session touched.
    • Re-priming after compaction — when the harness compresses the conversation, the agent re-reads the graph and continues exactly where it stopped.

    Why it works

    Agents fail at memory in predictable ways: they batch writes to the end (and lose them), they duplicate entities, they can't tell stale facts from current ones. This protocol names each failure mode and gives the agent an exact, mechanical rule against it. It is model-agnostic and host-agnostic — any agent that can call the memory tools can run it.

    Requirements

    A running MaxGraph server (open source, self-hosted, one Docker container, MCP + REST + dashboard) — or any compatible knowledge-graph memory backend. The protocol itself is tool-name-agnostic.

    Who it's for

    Teams running agents across long-lived projects: the agent remembers architecture decisions, active bugs, deferred tasks and owner preferences — and picks up mid-sentence after a compaction, a crash, or a week away.

    Requires a running MaxGraph MCP server. Project isolation relies on consistent slug naming. Context restoration is manual after compaction events.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    Git

    Permissions

    No special permissions declared or detected

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    Stateless agents lose context when sessions reset, but this protocol uses a MaxGraph knowledge-graph to store atomic facts and task statuses, allowing agents to "remember" previous decisions and bugs even after a crash or timeout.

    This skill is compatible with any AI agent or platform that supports the Model Context Protocol (MCP) and has an active connection to a MaxGraph-compatible knowledge-graph server.

    Unlike generic memory prompts that lead to data duplication, this skill enforces a strict schema for atomic facts and versioning, ensuring the agent only retrieves the most relevant, up-to-date information without bloating the context window.

    Your purchase includes the specific MCP tool configuration, the disciplined schema for entity/observation management, and the standardized workflow instructions (Initialize, Execute, Maintain, Conclude) for your agent.

    Yes, the protocol relies on 'project slugs' to isolate data, allowing you to manage multiple distinct projects or clients within the same MaxGraph server without cross-contamination of facts.

    New in LLM Ops