Project Memory 1

    1

    Maintain durable, repository-local memory and state between different AI coding agents and sessions.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    project-memory

    Example session with this skill installed

    I'm starting work on the authentication module. Initialize the project memory and set a checkpoint for the current state.

    • Read your context and instructions
    • Compiled the project-memory

    I have initialized the project memory files and recorded the starting state. The files have been added to your local git excludes to ensure they are not committed.

    Project Memory Initialized

    FileStatusPurpose
    AGENTS.mdCreatedStable operational instructions and repo-specific rules.
    AI_CONTEXT.mdCreatedEntry point, project purpose, and architectural constraints.
    docs/project-memory/CURRENT_STATE.mdCreatedCurrent branch status and verification baseline.
    .git/info/excludeUpdatedLocal-only memory files excluded from version control.

    Current Snapshot

    • Start Time: 2025-05-20T14:30:05-0700
    • Branch: feature/auth-module
    • Head: a1b2c3d
    • Status: 2 files modified (untracked)

    Next steps

    1. Review AI_CONTEXT.md to ensure the authentication entry points are correctly identified.
    2. Begin implementation of the login controller.
    3. A durable checkpoint will be created automatically in 15 minutes or at the next major task boundary.

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

    About this skill

    When switching between AI coding assistants like Claude Code and Cursor, or resuming work after a session timeout, context is lost. This skill solves the "AI amnesia" problem by maintaining a durable, repository-local memory that survives session resets and transitions between different LLM agents. It prevents agents from repeating mistakes, losing track of architecture decisions, or ignoring project-specific invariants.

    What it does

    • State persistence maintains a dated snapshot of Git branches, working tree status, and active tasks across sessions.
    • Agent synchronization enables different coding tools to share the same context files, ensuring consistency in instructions and progress.
    • Automated handoffs generates detailed recovery points including completed work, validation results, and exact resume commands.
    • Local-only storage manages exclusions in .git/info/exclude to keep AI-specific memory out of your repository's version history and Docker builds.
    • Project inventorying crawls local directories to map out existing repositories and their documentation status.

    How it works

    1. Bootstrap the memory structure by reading existing READMEs and manifests to determine the repo's architecture and conventions.
    2. Initialize local-only files like AGENTS.md and AI_CONTEXT.md to define operational rules and project entry points.
    3. Record durable checkpoints every 15 minutes of work to ensure no progress is lost during long-running tasks.
    4. Handoff the session by documenting verified facts, open questions, and specific next steps for the next agent session.

    Frameworks & tools

    This skill is designed for Git-based workflows and works with any AI coding agent including Claude Code and Codex. It uses standard shell utilities and a local Python inventory script.

    Why this beats prompting it yourself

    Manual prompting lacks the persistence needed for multi-day tasks and cannot automatically sync state between different AI tools. This skill enforces a standardized schema for project memory, ensuring that every agent follows the same invariants and respects your local environment limits without manual re-explanation.

    Use cases

    • Resuming a complex refactor after an LLM context window reset.
    • Handing off a partially completed feature from one AI agent to another.
    • Onboarding an AI assistant to a large, undocumented legacy repository.
    • Maintaining a local roadmap and decision log that isn't committed to the main branch.

    Known limitations

    Memory files are deleted by git clean -x commands. Local memory is checkout-specific and does not automatically follow the user to new git worktree instances without manual path naming.

    Memory is lost on git clean -x commands. It exists only in the local checkout and is not automatically shared across git worktrees or remote clones.

    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

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 7 days ago

    • Free with an Agensi account

    Requires

    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed7 days ago

    What's inside

    Frequently Asked Questions

    This skill creates a durable, local state layer in your repository that stores architectural decisions, progress snapshots, and task statuses, allowing AI agents to "remember" context even after a session reset or tool switch.

    Yes, the skill is tool-agnostic; it works with any Git-based AI agent, including Claude Code, Cursor, and Windsurf, by using standardized markdown-based memory files that all LLMs can parse.

    The skill automatically manages entries in .git/info/exclude, ensuring that all AI-generated memory files remain local to your machine and are never accidentally committed to your public version history.

    When you buy this skill, you receive the specialized Python inventory scripts, the memory schema templates (AGENTS.md/AI_CONTEXT.md), and the operational logic required to automate session handoffs.

    Because memory files are stored locally in the working directory, they will be deleted if you run 'git clean -x'; we recommend using 'git clean -d' to preserve your AI context files.

    The skill includes a 'Bootstrap' function that automatically crawls your existing codebase and READMEs to populate the initial AI_CONTEXT.md, so you don't have to write the documentation from scratch.

    New in Agents & Orchestration