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 CLIMuseMuseDotsDots+21 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`) | Component | Responsibility | Primary 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.ts` | Connection 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.

    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 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

    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