Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    okf memory

    1

    Durable Markdown-based project memory and change tracking using the Open Knowledge Format (OKF).

    $3

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    okf memory

    okf memory

    Example session with this skill installed

    Save a discovery note for the shop-backend project. We migrated the auth flow to OAuth2 PKCE and deprecated the old /token route in src/auth/oauth.py.

    • Read your context and instructions
    • Compiled the okf memory

    I have recorded the discovery and updated the project manifest. The new discovery note has been saved, and the project-level discovery.md has been updated to reflect these changes.

    OKF Memory Update

    Status: Discovery recorded in shop-backend
    File Created: ~/.okf-memory/shop-backend/2025/05/2025-05-22-new-auth-flow-and-token-migration.md

    ---
    type: Discovery
    title: "New Auth Flow and Token Migration"
    description: "Migrated to OAuth2 PKCE endpoints and deprecated legacy /token route."
    tags: [auth, discovery, changes]
    timestamp: 2025-05-22T14:30:00Z
    ---
    
    # Discovered Changes
    - Replaced custom token exchange with PKCE endpoints in `src/auth/oauth.py`.
    - Deprecated `/api/v1/token` in favor of `/api/v2/oauth/token`.
    - Added automatic refresh worker in background service.
    
    Related: [Discovery Manifest](discovery.md)
    

    Next steps

    • Run okf.py discover --project shop-backend after your next commit to auto-sync remaining changes.
    • View the project history by reading ~/.okf-memory/shop-backend/log.md.

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

    About this skill

    You lose project context every time you start a new session or switch tools. This skill implements the Open Knowledge Format (OKF v0.1) to maintain durable, agent-readable project memory in a plain-text filesystem.

    What it does

    • Persistent storage saves decisions, findings, and runbooks to ~/.okf-memory using YAML-frontmatter Markdown.
    • Change discovery tracks architectural shifts, modified endpoints, and schema migrations automatically.
    • Progressive disclosure organizes knowledge through hierarchical indexes so agents only load relevant notes.
    • History logging maintains a chronological record of changes across all projects or within specific ones.
    • Cross-session recall ground answers in past project state by reading discovery manifests and dated logs.

    How it works

    1. The agent identifies the project slug and checks ~/.okf-memory/index.md for existing context.
    2. Use the save command to record specific documents like Decision, Schema, or Metric types.
    3. Use the discover command to inspect git status and file modifications, updating the discovery.md manifest.
    4. Retrieve knowledge by walking YYYY/MM directories or grepping for specific tags and types in the YAML frontmatter.

    Frameworks & tools

    The skill uses a Python helper script to manage files. It relies on standard filesystem operations, Grep for searching, and Git for change detection.

    Why this beats prompting it yourself

    Manual prompts forget details as soon as the context window flushes. This skill enforces a standardized directory structure and metadata schema that ensures your agent can query its own history without you re-explaining the codebase every morning.

    Use cases

    • Record why a specific database was chosen to prevent re-litigating the decision later.
    • Track what new changes occurred in a repository between two development sessions.
    • Maintain a live runbook of project-specific commands and environment setups.
    • Generate a session summary that another agent can consume to pick up where you left off.

    Known limitations

    Knowledge can become stale if not updated; agents must verify file-based notes against the current codebase. Does not store secrets, tokens, or credentials.

    Memory can become stale; agents must verify notes against current code. Requires Python to run the helper script. Does not store secrets or credentials.

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

    Requires

    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables
    Listed29 days ago

    What's inside

    Frequently Asked Questions

    This skill implements the Open Knowledge Format (OKF) to create a persistent, file-based memory that survives session resets. It prevents context loss by organizing project decisions, schemas, and logs into a structured Markdown hierarchy that agents can query later.

    The skill requires a Python environment and standard filesystem access. It is compatible with any AI agent or LLM that has the capability to execute scripts and read/write local files, such as AutoGPT, Open Interpreter, or custom LangChain agents.

    No, the skill is designed to supplement your workflow by watching for file modifications and git changes via the `discover` command. It creates a secondary, agent-optimized record of your progress without cluttering your primary source code repository.

    You receive the core Python management script, the OKF v0.1 directory schema templates, and the integration logic required for your agent to read, write, and index project notes.

    Because the memory is stored in plain-text Markdown and YAML on your local machine, you have full ownership and can manually edit or audit the files at any time. The agent uses a discovery manifest to 'walk' these files, ensuring it only loads relevant context rather than the entire history at once.

    New in Agents & Orchestration