Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    codeagent memory

    1

    Local code graph and solution memory for symbol-level navigation and persistent project knowledge.

    Free

    1 useSecurity scanned
    codeagent memory

    codeagent memory

    Example session with this skill installed

    How did we solve the race condition in the auth flow last week, and which functions call the login handler now?

    • Read your context and instructions
    • Compiled the codeagent memory

    I have queried the project memory and code graph to retrieve the previous solution and current call stack for the authentication flow.

    1. Memory: Hit #M-402 (reused).
    2. Code: Read src/auth/handler.rs/login_handler. References: callers (in) for login_handler.
    3. Write-back: nothing new to store.

    Project Context and Code Graph

    Resource TypeID/PathDetails
    Memory HitM-402Summary: Resolved race condition in JWT validation by implementing a Mutex on the session store.
    Symbolsrc/auth/handler.rs/login_handlerPrimary entry point for user authentication requests.
    Callers (In)src/router.rs/app_routerRoutes POST requests to the login handler.
    Callers (In)src/middleware/session.rs/refresh_taskTriggers login logic during session expiry.

    Symbol Definition: login_handler

    pub async fn login_handler(
        State(state): State<Arc<AppState>>,
        Json(payload): Json<LoginRequest>,
    ) -> Result<impl IntoResponse, AuthError> {
        let mut session = state.store.lock().await;
        // Implementation follows...
    }
    

    Next steps

    • Verify if the Mutex implementation in M-402 requires upgrading to a fair semaphore for high-concurrency loads.
    • Run cam ref src/auth/handler.rs/login_handler --dir out to see downstream dependencies.
    • Update the documentation in docs/auth.md to reflect the locked session store pattern.

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

    About this skill

    Context switching in large codebases leads to cognitive load and lost solutions. This skill manages a local SQLite code graph and project memory to track how problems were solved and how symbols relate across the project. It allows for precise symbol retrieval and relationship mapping without reading entire files into context.

    What it does

    • Persistent memory stores and recalls previous solutions or architectural decisions within the project.
    • Symbol-level reading retrieves specific function or class definitions without loading full source files.
    • Reference mapping tracks callers and callees to understand cross-file dependencies and impact.
    • Graph indexing builds a local database of symbols, files, and relationships for fast querying.
    • Local storage keeps all data within a .cam/ directory, ensuring no project code leaves the local environment.

    How it works

    1. Recall checks for existing solutions or facts by turning the current task into a query.
    2. Index/Sync builds or updates the local graph when the filesystem changes.
    3. Traverse identifies symbols and follows their call chains to build context.
    4. Store commits new architectural facts or solved bugs to the project memory for future reuse.

    Frameworks & tools

    This skill requires the cam CLI tool installed on the system path and uses a local SQLite database stored in the project root. It integrates with agents via MCP or standard shell execution.

    Why this beats prompting it yourself

    Standard LLMs lack persistence across sessions and often struggle to navigate deep call stacks in large repositories. This skill provides a structured method for an agent to maintain its own "long-term memory" of your specific codebase and navigate it via a graph rather than simple grep searches.

    Use cases

    • Querying how a specific error was handled in a previous sprint.
    • Finding all callers of a deprecated function before refactoring.
    • Reading a specific symbol's implementation without hitting token limits on large files.
    • Storing a complex integration logic summary for the next subagent to use.

    Known limitations

    Requires the cam CLI to be pre-installed on the host machine. Operates only on local project data and does not support remote database hosting.

    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 cam CLI pre-installed. Only supports local SQLite storage in .cam/ directory. Does not automate tool 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 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

    1 use

    Times used to date

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 24 days ago

    • Free with an Agensi account

    Permissions

    Read Files
    Listed24 days ago

    What's inside

    Frequently Asked Questions

    This skill creates a local SQLite-backed knowledge base that tracks code relationships and past problem-solving, reducing cognitive load and preventing the AI from repeating the same investigation steps across different sessions.

    The skill is compatible with any AI agent that supports Model Context Protocol (MCP) or standard shell execution, provided the `cam` CLI tool is installed on the host machine.

    No, all data is stored locally in a `.cam/` directory within your project root, ensuring your source code and architectural memory never leave your environment.

    Unlike simple text searches, this skill builds a symbol-level graph (classes, functions, calls) that allows the agent to navigate dependencies and call chains precisely without hitting token limits.

    Setup involves installing the `cam` CLI and initializing the index in your project root; once active, the skill automatically syncs with your filesystem to keep the symbol graph current.

    You receive the core agent skill configuration, documentation for integration via MCP/CLI, and access to future updates to the indexing logic and schema.

    New in Agents & Orchestration

    Free