Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    mimir agent memory

    5

    Benchmark-gated agent memory that only retains lessons proven to improve performance.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    mimir agent memory

    mimir agent memory

    Example session with this skill installed

    Our coding agent keeps failing when pushing changes or running async endpoints, making the exact same mistakes across sessions. Set up Mimir benchmark-gated memory for our workspace, configure automatic episode capture, and import the Next.js 15 and Git guardrails starter pack so we stop repeating these errors.

    • Read your context and instructions
    • Compiled the mimir agent memory

    ⚡ Mimir Benchmark-Gated Memory: Workspace Setup Complete

    Mimir has been configured as your agent's persistent memory layer. Unlike traditional memory tools that hoard every chat turn and bloat your context window, Mimir enforces an

    $\varepsilon$-noise gate and a

    bi-temporal lifecycle: only lessons mathematically proven to improve task completion are stored and recalled.


    1. Integration & Capture Verification

    Passive fast-path hooks and stdio MCP tools are now active:

    ComponentStatusTarget / EndpointDetails
    Capture HookActive~/.claude/settings.jsonPostToolUse & SessionEnd (non-blocking, $O(1)$)
    MCP SurfaceConnectedmimir-serve (stdio)Exposes recall, capture, consolidate, forget
    Vector StoreReady~/.mimir/lance/LanceDB persistent vector index with token hashing
    Auto-ConsolidateArmedThreshold: $\ge 5$ failuresTriggers judge distillation in background every 4h

    2. Imported Day-1 Guardrail Packs

    Pre-calibrated, HMAC-certified starter lessons have been injected into ~/.mimir/lessons.json to eliminate the cold-start penalty:

    IDStackRuleConfidenceStatus
    next-001Next.js 15Mark files using useState, useEffect, or browser APIs with 'use client' at line 1.0.96Active
    next-002Next.js 15Dynamic route params and searchParams are async promises; always await before property access.0.95Active
    git-001Git / CIAlways run git fetch and rebase upstream before pushing to prevent non-fast-forward rejections.0.89Active
    git-002SecurityNever stage .env or credential files; verify via git status --ignored before committing.0.98Active

    3. Verification & Gating Benchmark

    Ran token-free integration probe to confirm recall gating:

    $ python -m mimir.cli export --digest
    
    # Mimir digest
    - **Next.js dynamic params are async: await params** (confidence: 0.95, id: next-002)
    - **Always fetch & rebase before git push** (confidence: 0.89, id: git-001)
    - **Enforce 'use client' on interactive components** (confidence: 0.96, id: next-001)
    
    $ python -c "from mimir.mcp_server import recall; res = recall(store, 'route params in Next 15'); print(f'Retrieved {len(res.lessons)} lesson(s), Uncertain={res.uncertain}')"
    Retrieved 1 lesson(s), Uncertain=False
    --> Found lesson: Next.js dynamic params are async: await params (Confidence: 0.95)
    

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

    About this skill

    Stop wasting tokens on agents that repeat the same mistakes. Most agent memory layers keep every interaction, cluttering context with irrelevant noise. Mimir solves this by implementing benchmark-gated memory, ensuring only lessons proven to improve performance are retained. It captures failures, extracts rules, and validates them via a rigorous before-and-after testing phase.

    What it does

    • Benchmark-gated retention ensures only lessons that measurably improve agent scores are promoted to the permanent store.
    • Bi-temporal lifecycle management tracks lessons through active, quarantined, superseded, or retired states without hard-deleting history.
    • HMAC-signed citations provide cryptographic proof that every lesson is traceable back to the specific failure episodes that created it.
    • Multi-tool integration supports Claude Code, Cline, Hermes, and any system capable of running shell commands with JSON on stdin.
    • MCP server support exposes recall and consolidation tools to agents via standard Model Context Protocol.

    How it works

    1. Capture logs episode data including actions, context, and consequences into an append-only JSONL file.
    2. Consolidate triggers an LLM judge to extract candidate rules from failure episodes and perform contradiction checks.
    3. Admit runs a counterfactual probe to verify the rule clears the epsilon noise-band gate before writing to the vector store.
    4. Recall retrieves ranked, confidence-gated lessons during active sessions to guide agent behavior.

    Frameworks & tools

    Built with Python 3.10+, LanceDB for vector storage, and fastembed for local ONNX-based semantic embeddings. It integrates directly with Claude Code and Cline settings.

    Why this beats prompting it yourself

    Manual prompting cannot verify if a "lesson" actually helps or hurts future performance. Mimir automates the WARM vs. COLD benchmarking process, preventing context bloat by filtering out speculative or ineffective instructions.

    Use cases

    • Coding agents that need to learn project-specific architectural constraints after a single failed PR.
    • Long-running workflows where agents must avoid repeating expensive API errors or logic loops.
    • Standardized engineering teams looking to distribute HMAC-signed "lesson packs" across multiple developer environments.
    • Performance auditing to visualize how specific memory injections correlate with task success rates.

    Known limitations

    Requires Python 3.10 or higher. The default bag-of-words embedder is basic, and semantic recall requires the optional fastembed dependency. Manual consolidation is needed if auto-logs show low episode counts.

    Requires Python 3.10+. Semantic recall requires the optional fastembed dependency. Auto-consolidation requires a minimum of 5 failure episodes. Windows requires manual PATH configuration.

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

    Requires

    Python 3.10+
    pip

    Permissions

    Terminal / Shell
    Read Files
    Environment Variables
    Write Files

    File Scopes

    ~/.mimir/**
    ~/.claude/settings.json

    Mimir stores its episode logs, lessons JSON, and LanceDB vector store locally in the user's home directory under ~/.mimir/. It registers a capture hook command in ~/.claude/settings.json. No source code or proprietary repository files are transmitted off-device.

    Listed29 days ago

    What's inside

    Frequently Asked Questions

    Mimir solves "context bloat" and performance degradation by using a benchmark-gated system that only stores lessons proven to improve agent scores, preventing your agent from repeating mistakes or being distracted by irrelevant history.

    Mimir is designed for flexibility and works with Claude Code, Cline, Hermes, and any agent system that can execute shell commands or utilize the Model Context Protocol (MCP).

    The package includes the core Mimir engine, an MCP server for easy integration, the HMAC-signing utility for lesson verification, and a pre-configured LanceDB setup for local vector storage.

    Yes, Mimir requires Python 3.10 or higher and includes an optional 'fastembed' dependency if you wish to use local ONNX-based semantic embeddings for more advanced memory recall.

    Mimir uses a 'Consolidate and Admit' workflow where an LLM judge extracts rules and verifies them through counterfactual probes, ensuring only high-confidence, performance-enhancing lessons enter the permanent vector store.

    While Mimir can automate much of the process, users can trigger manual consolidation if episode counts are low or use the bi-temporal lifecycle tools to retire or supersede specific lessons as their codebase evolves.

    New in Agents & Orchestration