codebase memory graph

    1

    Maintain persistent repository memory and structural AST call graphs across agent sessions without external databases.

    $1.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    codebase memory graph

    Example session with this skill installed

    Run /map-codebase and then use /recall-memory to show me what we know about the current project structure and rules.

    • Read your context and instructions
    • Compiled the codebase memory graph

    I have scanned the repository and initialized the architectural graph. I also retrieved the current project memory from the team learnings log.

    Repository Intelligence Summary

    Architecture Graph (.agent_memory/architecture_graph.md)

    ComponentResponsibilityPrimary Dependencies
    src/gateway/Entry point for all REST traffic, handles JWT auth.src/services/auth, src/lib/middleware
    src/services/Business logic for order processing and inventory.src/models/schema, src/lib/db
    src/models/Type definitions and Zod validation schemas.zod, drizzle-orm
    src/lib/db.tsConnection pooling and migration runner.pg, drizzle-orm/node-postgres

    Active Project Rules & Learnings

    Pattern: Type-Safe Validation (2024-05-12): Use Zod schemas in src/models/ for all incoming requests. Do not use manual if checks for types in controllers.

    Bug Fix: Race Condition (2024-05-15): Inventory updates must use db.transaction() to prevent double-spending items during peak load.

    Constraint: Naming (2024-05-18): All service methods must be prefixed with execute or fetch to distinguish between side-effects and reads.

    Next steps

    • Run /log-learning after your next task to update the regression guards.
    • Check session_state.json if you need to track active test assertions.
    • Review architecture_graph.md for the full dependency tree.

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

    About this skill

    Agents often forget architectural decisions across chat sessions or burn tokens by re-analyzing the same files repeatedly. This skill establishes a zero-dependency memory layer that persists technical learnings and symbol maps directly in your repository. It ensures every agent interaction is grounded in past bug fixes and verified architectural patterns.

    What it does

    • Persistent Memory Management creates and maintains a .agent_memory directory to store durable project knowledge.
    • Architectural Graphing maps core interfaces, service dependencies, and call hierarchies into a compressed markdown format.
    • Context Anchoring flags contradictions between new user requests and previously established technical decisions.
    • Automated Synthesis logs new bug resolutions and pattern discoveries into a living journal using a standardized schema.

    How it works

    1. Initialize the repository by running /map-codebase to generate the structural symbol graph and entrypoint map.
    2. Review active project rules and past regressions using /recall-memory before starting a new feature or fix.
    3. Execute coding tasks while the agent references the existing graph to avoid blind file scanning.
    4. Commit new insights using /log-learning to ensure future agents don't repeat the same mistakes.

    Frameworks & tools

    Works with any language or framework including TypeScript, Python, Go, and Rust. Designed for coding environments like Claude Code, Cursor, and Windsurf without requiring external servers or vector databases.

    Why this beats prompting it yourself

    Manual prompting lacks continuity across sessions, leading to "context amnesia" where agents repeat known errors. This skill forces a systematic write-back process to the file system, turning your repository into a self-documenting knowledge base that survives session resets.

    Use cases

    • Onboarding agents to complex legacy codebases by providing a pre-indexed map of core controllers and data flows.
    • Preventing regressions by logging specific anti-patterns and their approved replacements after every bug fix.
    • Syncing multi-agent teams by providing a shared source of truth for architectural decisions in the repo root.
    • Token optimization by replacing large-scale file reads with a targeted 200-line structural architecture graph.

    Known limitations

    Requires write access to the repository to maintain the memory directory. Effectiveness depends on the agent consistently logging learnings after completing tasks.

    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 file system write access for the .agent_memory directory. Graph accuracy depends on the agent's ability to parse specific language symbols during the mapping phase.

    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 8 days ago

    Permissions

    Write Files
    Listed8 days ago

    What's inside

    Frequently Asked Questions

    It stores structured data in a local `.agent_memory` directory within your repository, ensuring architectural insights and past bug fixes persist even after you reset a chat session or switch AI tools.

    No, this is a zero-dependency solution that functions entirely through your local file system, making it ideal for secure environments or projects where you want to avoid third-party data hosting.

    Yes, it is designed to be environment-agnostic and works seamlessly with agent-based editors like Claude Code, Cursor, and Windsurf, as long as the agent has file system read/write permissions.

    The skill uses a compressed markdown format to map your codebase's symbol hierarchy, allowing the agent to understand complex service dependencies while consuming significantly fewer tokens than full-file scanning.

    You receive the complete skill configuration including the specialized command set for mapping, recalling, and logging, along with documentation on how to integrate the memory schema into your project's workflow.

    While the initial mapping is automated, the 'living journal' aspect relies on the agent (or user) executing the `/log-learning` command to capture new insights, ensuring only verified patterns are stored.

    New in Agents & Orchestration