More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Persistent Agent Memory for Claude Code — Context Engine

    1

    Stop re-explaining your project architecture and coding preferences every time you restart your agent session.

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Persistent Agent Memory for Claude Code — Context Engine

    Persistent Agent Memory for Claude Code — Context Engine

    Example session with this skill installed

    I've decided we should use pnpm instead of npm for this project because it handles our monorepo dependencies faster. Remember that for all future installs.

    • Read your context and instructions
    • Compiled the persistent agent memory

    I have recorded this rule and updated the project index. I will use pnpm for all future package management tasks in this repository.

    Memory Stored

    IDClassSubjectStatement
    m-20250522-package-managerrulepackage managerUse pnpm for package management, not npm.

    Frontmatter Recorded:

    • ID: m-20250522-package-manager
    • Class: rule
    • Scope: project
    • Confidence: 0.9 (user_stated)
    • Why: faster handling of monorepo dependencies (stated 2025-05-22)

    Next steps

    1. I have appended the session event to LOG.md.
    2. I will now check for a package-lock.json to see if we need to migrate it to pnpm-lock.yaml.
    3. The rule is now pinned in projects/github-com-user-repo/INDEX.md and will be loaded in all future sessions.

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

    About this skill

    Stop re-explaining your project architecture and coding preferences every time you restart your agent session. This skill provides a private, local memory system for AI coding agents that ensures corrections, project rules, and task states persist across restarts and context compactions. It manages memory through plain Markdown files stored on your machine, using a deterministic project key based on your git repository to share context between different agents like Claude Code and Cursor.

    What it does

    • Persistent memory stores durable project facts, user preferences, and standing rules in local Markdown files.
    • Task state management tracks multi-step goals, progress, and next steps to resume work exactly where you left off.
    • Automatic stale detection uses git anchors to flag memories that might be out of date because the underlying code changed.
    • Smart recall retrieves relevant memories using grep and synonyms only when needed to keep the context window lean.
    • Conflict resolution prioritizes user-stated rules over inferred facts and manages supersession when instructions change.

    How it works

    1. Initialize the project by computing a unique key from your git remote or root hash.
    2. Review the session periodically to extract durable lessons, decisions, and environment quirks into discrete memory files.
    3. Recall context automatically when you refer to the past or perform high-stakes actions like deployments.
    4. Maintain health via Python scripts that lint for secrets, archive old items, and rebuild the search index.

    Frameworks & tools

    This tool uses Python 3.8+ for maintenance scripts and relies on standard git commands for repository identification and file hashing. It is designed for file-capable agents including Claude Code, Cursor, Windsurf, and Cline.

    Why this beats prompting it yourself

    Manual prompting loses context once the session ends or the buffer fills up. This skill enforces a strict "one fact per file" rule and a durable log, ensuring that "don't do that again" actually sticks for the life of the project.

    Use cases

    • Preventing the agent from repeating the same library or styling mistakes after a correction.
    • Resuming complex refactors after a model's context window has been cleared or compacted.
    • Sharing project-specific conventions between different IDE agents working on the same repo.

    Known limitations

    Requires a local environment capable of running Python scripts and git. It does not support cloud-based storage or syncing between different machines without manual file transfers.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Requires Python 3.8+ and git. Local file access required. No built-in cloud sync. Does not store secrets. Context limit for INDEX.md is approximately 1,200 tokens.

    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 buying a skill.

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 10 days ago

    Accounts
    GitHub
    Software
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    Allowed Hosts

    api.github.com
    Listed10 days ago

    What's inside

    Frequently Asked Questions

    The Context Engine creates a 'long-term memory' by storing project rules, task states, and previous corrections in local Markdown files, ensuring your agent doesn't repeat past mistakes even after context window resets.

    Yes, since the skill uses a deterministic key based on your git repository, context and rules created in Claude Code are accessible to Cursor, Windsurf, or Cline as long as they are working in the same local directory.

    The skill is designed for any file-capable AI agent and requires a local environment with Python 3.8+ and Git installed to manage the memory indexing and maintenance scripts.

    All memory is stored locally on your machine in plain Markdown files within your project directory, ensuring your proprietary project data never leaves your infrastructure or gets sent to a third-party cloud.

    Unlike manual prompts, this skill uses a 'one fact per file' architecture and git-based stale detection to automatically flag and archive outdated memories when your codebase changes.

    Your purchase includes the core memory management logic, Python maintenance scripts for linting and indexing, and a set of standardized templates for task tracking and project rule persistence.

    New in Agents & Orchestration