Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    vibo memory protocol

    1

    Local, dependency-free agent memory protocol using layered JSONL storage and lexical recall for cross-session state.

    Free

    Security scanned
    vibo memory protocol

    vibo memory protocol

    Example session with this skill installed

    May I store your project preferences? I need to remember you prefer PDF invoices for Anna and that we are currently migrating the demo to v9.23.

    • Read your context and instructions
    • Compiled the vibo memory protocol

    I have successfully initialized the memory protocol and stored these facts. I have also categorized the migration status as a handoff snapshot for our next session.

    Memory Operation Log

    ActionLabelContentLevel
    ADDclient annapays on the 1st, wants PDF invoicesL1
    ADDstatetask: migrate demo to v9.23 | done: db dumpL1
    STATSsummary2 entries, 0 secrets, 100% localN/A

    Next steps

    • I will now check these facts using verify before mentioning invoice terms or migration steps.
    • You can run python3 scripts/memory.py stats at any time to see the storage size.
    • If you need to clear this data, tell me to "forget all" or delete the .memory/ folder.

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

    About this skill

    Managing state across agent sessions often leads to massive token costs or repetitive user questioning. This skill implements a disciplined memory layer using a local JSONL file and a standard-library Python script, removing the need for external vector databases or expensive embedding calls.

    What it does

    • Layered persistence categorizes information into public (L1), private (L2), and secret (L3) levels for controlled visibility.
    • Lexical recall uses keyword relevance to fetch specific facts without loading the entire history into context.
    • Claim verification checks agent assertions against stored facts to prevent hallucinations or contradictions.
    • Secret pointers handle sensitive tokens by storing environment variable names instead of raw values.
    • Handoff snapshots summarize current task status to bridge the gap between session restarts.

    How it works

    1. Consent triggers a request to the user for permission to store specific types of project data.
    2. Search runs lexical queries before the agent asks the user for information it might already know.
    3. Persist writes facts or state snapshots immediately to a local .memory/memory.jsonl file.
    4. Verify cross-references names, dates, or prices against the store before outputting them to the user.

    Frameworks & tools

    The protocol requires Python 3.9+ and uses only the standard library. It operates entirely on local Markdown and JSONL files within the project repository.

    Why this beats prompting it yourself

    Prompt-based memory is volatile and grows context windows until performance degrades. This skill enforces a strict "find-then-write" loop that keeps context small, utilizes provider-side caching, and ensures sensitive data never hits the disk.

    Use cases

    • Long-term project tracking to remember architectural decisions made weeks ago.
    • Client preference management for storing specific formatting or delivery requirements.
    • Crash recovery by loading the latest handoff snapshot after a session timeout.
    • Secure configuration by managing API key pointers without leaking them in logs.

    Known limitations

    Recall uses lexical keyword matching, not semantic embeddings, making it unsuitable for massive document sets. It requires Python 3.9+ available in the agent environment.

    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 Python 3.9+ and filesystem access. Uses lexical keyword matching (BM25-style) rather than semantic vector search. No support for remote database syncing.

    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

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 10 days ago

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Environment Variables
    Listed10 days ago

    What's inside

    Frequently Asked Questions

    The protocol uses a local, keyword-based 'lexical recall' system rather than vector embeddings. This allows for near-instant retrieval of facts without the latency, token costs, or privacy concerns associated with external database calls.

    It is designed for any Python-based AI agent environment (3.9+) and works by interacting with a local `.memory/` directory. Because it relies only on the Python standard library, it can be integrated into most custom agent frameworks or terminal-based assistants.

    The protocol implements 'Secret Pointers' (L3 storage), which store environment variable references rather than raw strings. This ensures that sensitive credentials stay in your secure environment while the agent retains the logic to call them.

    You will receive the core Python implementation script, a template for the `.memory/` directory structure, and a comprehensive integration guide. The package includes the logic for the layered persistence, claim verification, and handoff snapshotting features.

    Since the protocol stores data in a flat JSONL format, it is most effective for project-specific state and structured facts. It is not intended for indexing massive, multi-gigabyte document libraries that would typically require semantic search.

    New in Agents & Orchestration

    Free