Cross Session Memory

    1

    Local, file-based memory for AI agents to track facts, tasks, and decisions across sessions without a database.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    cross-session-memory

    Example session with this skill installed

    I'm starting a new session. Please brief me on the current project state and any recent decisions we made regarding the API auth flow.

    • Read your context and instructions
    • Compiled the cross-session-memory

    I have processed the memory store for the current scope. Here is your session brief based on the 12 most relevant records.

    Session Brief: API Auth Flow

    Record IDKindKeyContentCreated
    FACT-001factauth-methodSwitched from OAuth2 to JWT for MVP simplicity.2024-05-10
    DECISION-042decisiontoken-expiryTokens will expire in 24 hours; no refresh tokens yet.2024-05-12
    TASK-009taskimplement-middlewareCreate the JWT validation logic in /src/middleware.2024-05-13
    PREF-003preferenceerror-formatAll auth errors must return a 401 with a JSON body.2024-05-10

    Summary of Last Episode:
    Yesterday we finalized the user schema and decided to move forward with JWT for the initial authentication layer. You were about to start writing the middleware for token validation before the session ended.

    Next steps

    1. Run python3 scripts/memory.py recall --query "middleware" to see technical notes on the implementation.
    2. Use remember task "test-jwt-endpoints" once the middleware is drafted.
    3. Export the current state to MEMORY.md for a full audit of the auth decisions.

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

    About this skill

    Stop agents from starting every conversation from zero. This skill provides a persistent memory layer using plain files, allowing agents to retain facts, decisions, and task states across separate sessions. It eliminates the need for expensive vector databases or cloud-based memory services by using local JSON storage that is easy to inspect and version-control.

    What it does

    • Persistent storage saves specific facts, preferences, and outcomes into a local JSON store.
    • Contextual resumes generates a condensed session brief to catch the agent up on recent history and open tasks.
    • Traceable updates maintains a history of changes using a supersede system instead of silent overwrites.
    • Automatic expiration clears stale records based on defined time-to-live settings.
    • Secret filtering blocks the storage of API keys, tokens, and passwords via regex-based auditing.

    How it works

    1. Initialize the store in your project root to create a dedicated memory file.
    2. Remember key information during a session by assigning it a scope, kind, and confidence level.
    3. Brief the agent at the start of a new session to load relevant context within a token budget.
    4. Supersede or Forget existing records to update information while preserving the audit trail in history.

    Frameworks & tools

    This skill is built with standard library Python 3. It requires no external packages, database drivers, or API keys. Memory is stored in a memory.json file and can be exported to a human-readable MEMORY.md.

    Why this beats prompting it yourself

    Prompting an agent to "remember" only works within the current context window. This skill provides a structured, durable mechanism to pass data between execution runs without manual copy-pasting or expensive RAG infrastructure.

    Use cases

    • Resume complex coding tasks across days without re-explaining the architecture.
    • Maintain user preferences and style guides across different projects.
    • Track decision logs to prevent an agent from suggesting previously rejected ideas.
    • Manage long-running task lists where the agent acts as an autonomous coordinator.

    Known limitations

    Recall uses keyword matching rather than semantic embeddings. The system is designed for single-writer access to prevent file race conditions. Token counts for briefs are estimated based on character length.

    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.

    Keyword-based recall only (no embeddings). One writer at a time to avoid race conditions. Token counts are estimates. No native semantic search.

    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

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 6 days ago

    • Free with an Agensi account

    Software
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed6 days ago

    What's inside

    Frequently Asked Questions

    This skill provides a durable, local JSON-based storage layer that allows agents to retain facts and task states after a session ends, whereas standard prompts are lost as soon as the context window is cleared.

    No database or cloud account is required; the skill uses standard Python 3 libraries to manage a local file, making it ideal for developers who want to avoid the cost and complexity of vector databases.

    Yes, because memory is stored in plain JSON files, you can easily track, review, and roll back changes to your agent's memory using standard Git workflows.

    The skill is designed for any Python-based AI agent or framework and works by integrating into your existing execution loop to save and load state between runs.

    The 'Brief' feature automatically selects the most relevant records based on your defined token budget, ensuring the agent gets the necessary context without overwhelming the current session window.

    To ensure data integrity and prevent file corruption, the current version is optimized for single-writer access where one agent process manages the memory file at a time.

    New in Agents & Orchestration

    Free