More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    ctxmem agent skill

    1

    Git-native local project memory for tracking architectural decisions and context across agent sessions.

    Free

    1 useSecurity scanned
    ctxmem agent skill

    ctxmem agent skill

    Example session with this skill installed

    I'm starting the migration to the new auth provider. Can you check if we made any specific decisions about the JWT implementation in previous sessions?

    • Read your context and instructions
    • Compiled the ctxmem agent

    I have queried the local project memory for decisions related to "JWT implementation" and "auth provider migration."

    Project Memory Search Results

    IDTypeTitleSummaryPath
    rec_01j8decisionJWT Algorithm SelectionUse RS256 for all service-to-service auth; avoid HS256.docs/arch/auth.md
    rec_05x2decisionToken Expiry PolicySet access tokens to 15m and refresh tokens to 7d.src/auth/config.py
    rec_09y1correctionAuth Header FormatUse 'Bearer' prefix strictly; previous 'Token' prefix is deprecated.src/api/middleware.ts

    The memory store indicates a strong preference for RS256 and specific expiry windows. I also found a correction record (rec_09y1) that supersedes the older header format used in the prototype. I will proceed with the migration using these constraints.

    Next steps

    1. Review src/auth/config.py to ensure the 15m/7d expiry logic matches these records.
    2. Initialize the migration script using the RS256 algorithm as recorded.
    3. Run ctxmem sync once the initial boilerplate is committed to update the index.

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

    About this skill

    Stop losing track of architectural decisions and project context between coding sessions. Developers often struggle with agents that forget previous discussions or hallucinate outdated patterns in growing repositories. This skill implements a Git-native memory layer that keeps your project knowledge where it belongs: in the repository.

    What it does

    • Persistent recall uses local keyword search to retrieve relevant project history before starting new tasks.
    • Context management generates task-specific context within token budgets to prevent LLM noise.
    • Decision tracking records architectural choices and rationales with a built-in superseding mechanism for updates.
    • Git-native storage saves memories in JSONL format within your repo for easy versioning and sharing.
    • State reconciliation identifies when current code conflicts with historical records to ensure accuracy.

    How it works

    1. Inspection checks for the presence of the ctxmem CLI and repository configuration files.
    2. Setup installs the local utility and configures persistent agent instructions for automatic recall.
    3. Retrieval runs targeted queries against the local memory store to gather evidence for the current prompt.
    4. Recording captures new decisions or corrections using specific types and file path associations.

    Frameworks & tools

    This skill requires Python 3.8+ with SQLite FTS5 support and Git. It operates locally using the ctxmem CLI tool.

    Why this beats prompting it yourself

    Manual prompts rely on the agent's short-term context window which clears every session. This skill provides a structured, searchable database that persists across tool restarts and different developer environments.

    Use cases

    • Onboard new agents or developers to a complex codebase with historical context.
    • Prevent regressions by surfacing previous architectural "why" decisions.
    • Synchronize project knowledge across a team using standard Git workflows.
    • Manage large-scale refactors where decisions must be tracked over multiple days.

    Known limitations

    Requires local execution permissions for Python and Git. Does not store secrets or credentials. Memory recall performance depends on the quality of recorded titles and descriptions.

    Requires Python 3.8+, SQLite FTS5, Git, and local command execution with project read/write permissions. Automatic recall across sessions depends on the host loading and following persistent project instructions. Reload the agent session after setup. Network access is needed only for installation.

    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

    Python
    Their Own MCP

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    ctxmem provides persistent, searchable project memory that survives across AI coding sessions. It stores architectural decisions, technical notes, and project context in a Git-native format. Once configured, compatible coding agents are instructed to retrieve relevant memories before starting tasks, helping them maintain consistency, avoid repeating mistakes, and reuse previous decisions.

    ctxmem requires Python 3.8 or higher with SQLite FTS5 support, Git, and an AI coding agent capable of executing local terminal commands. The skill provides setup instructions and integration with supported agent configurations, including Codex and GitHub Copilot. No cloud services, API keys, or external accounts are required for normal operation.

    Yes! ctxmem stores project memory in Git-friendly JSONL files that can be committed and shared alongside your code. Team members can pull the repository and access the same architectural decisions, technical notes, and project context using ctxmem. Memory stays local and follows your existing Git workflow, without requiring a centralized cloud service.

    ctxmem supports decision superseding, allowing outdated architectural decisions to be replaced by newer ones while preserving their history. When retrieving context, the agent is instructed to compare stored memories with the current codebase and prioritize up-to-date information. This helps reduce inconsistencies without silently discarding historical decisions.

    The free skill includes agent instructions, a setup helper, configuration guidance, and documentation for integrating ctxmem into your coding workflow. The ctxmem Python package is distributed separately through PyPI and is available as open-source software on GitHub under the MIT license. Once configured, compatible agents can retrieve, record, and synchronize project memory across coding sessions.

    Not yet! ctxmem is currently free and open source under the MIT license. A premium offering is planned for the future, introducing additional advanced features and workflows for AI coding agents. The existing core functionality will remain free and open source. Premium features will be optional, allowing developers to continue using ctxmem without any subscription or payment.

    New in Agents & Orchestration