Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    dreamd

    2

    Agent memory you can trace, review and roll back. Every lesson cites its source, and a bad memory can be removed with a receipt.

    Free

    Security scanned
    dreamd

    dreamd

    Example session with this skill installed

    Note that: use thiserror for library error types and anyhow only in the CLI binary. Never return Box<dyn Error> from public APIs.

    (Next session) Before you add the parser, check what we decided about errors.

    • Read your context and instructions
    • Compiled the dreamd

    Summary

    The agent saved the decision to dreamd in the first session, then recalled it in a new session before writing code. The tool calls and responses are real output from dreamd-mcp 1.2.1 in a fresh test repo; the agent replies are an example of how it uses them.

    Session 1: recording the decision

    The agent calls append_node:

    {
      "content": "Use thiserror for library error types and anyhow only in the CLI binary. Never return Box<dyn Error> from public APIs.",
      "source_harness": "claude-code",
      "skill_action": "rust::error_handling",
      "importance": 8
    }
    

    dreamd returns:

    {"id":"evt_01M6HB60ZEJF8RV8SMX8HDX22M","timestamp":"2026-11-03T18:36:43.374794432+00:00","deduplicated":false}
    

    The event is now a line in .agent/episodic/AGENT_LEARNINGS.jsonl, committed with your code.

    Agent: Saved to dreamd as event evt_01M6HB60ZEJF8RV8SMX8HDX22M under rust::error_handling.

    Session 2: recalling it before acting

    The agent calls search_nodes with {"query": "error handling rust library", "k": 5} and gets:

    scoresourceskill_actioncontent
    1.087episodicrust::error_handlingUse thiserror for library error types and anyhow only in the CLI binary. Never return Box<dyn Error> from public APIs.

    Agent: We decided earlier to use thiserror for library errors and keep anyhow to the CLI binary, so the parser gets its own error enum:

    #[derive(Debug, thiserror::Error)]
    pub enum ParseError {
        #[error("unexpected token {found:?} at line {line}")]
        UnexpectedToken { found: String, line: usize },
        #[error("unexpected end of input")]
        UnexpectedEof,
    }
    

    Next steps

    • Commit .agent/ so every teammate and every future session shares the same memory.
    • Run dreamd dream when you want recurring events consolidated into cited lessons.
    • If a memory turns out to be wrong, dreamd blame traces what it fed and dreamd forget removes it with a receipt.

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

    About this skill

    dreamd gives your agent long-term memory that lives in your repo, so it stops starting every session from zero and stops repeating mistakes another session already fixed.

    What it does

    • Recall before acting. At the start of a task your agent calls search_nodes and gets back the decisions and corrections your team already made, ranked by relevance and salience.
    • Record what it learns. When you correct the agent, state a decision, or say "remember this", it calls append_node and saves your words as an event.
    • Memory you can audit. Everything is plain files in .agent/ that you commit with your code. A dreamd dream cycle turns recurring events into lessons, and every lesson cites the events it came from.
    • Remove bad memories. When an agent acts on something wrong, dreamd blame shows which memories drove it and dreamd forget removes the bad one with a receipt.

    Why it's different

    Most agent memory is a black box. dreamd is glass-box: local-first, git-versioned and reviewable in a pull request. Recall and append make no network calls, and there is no account or API key.

    What's included

    This skill connects the open-source dreamd MCP server (npx -y dreamd-mcp, stdio, Apache-2.0) and tells your agent exactly when to call its two tools and how to fill their arguments.

    Requirements

    Node 18 or later. Linux x86_64 or macOS (Intel or Apple Silicon). On Windows, use WSL2.

    Requires Node 18+ and tar. Prebuilt binaries for Linux x86_64 and macOS only; Windows needs WSL2. Lessons are not written automatically: you run dreamd dream yourself, and it needs an Anthropic or OpenAI API key. Search queries must be plain words, since a colon is query syntax.

    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

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 13 days ago

    • Free with an Agensi account

    Requires

    Dreamd MCP
    Node.js 18+
    tar
    macOS
    Node.js

    Permissions

    Terminal / Shell
    Network Access
    Write Files
    Read Files

    File Scopes

    .agent/**

    Terminal: runs npx -y dreamd-mcp to start the stdio MCP server and dreamd-mcp setup once per project. Read/write files: memory lives in .agent/ in your project. Network: only on first run of a version, to download the prebuilt binary from the dreamd GitHub release (SHA-256 checked). Recall and append make no network calls.

    Listed13 days ago

    What's inside

    Frequently Asked Questions

    Unlike cloud-based memory, dreamd stores all data locally in a `.agent/` directory within your project. This ensures your data stays private and allows you to commit memory files to version control, sharing context across your entire team.

    The skill is built for any MCP-compliant environment, including Claude Code and Cursor. It requires a Node.js environment (v18+) and works best on macOS, Linux, or Windows via WSL2.

    dreamd solves "context amnesia" by providing a searchable, persistent record of project decisions. It prevents agents from repeating previously corrected mistakes and helps them adhere to your specific coding standards without wasting token space on massive system prompts.

    The skill installs and wires the open-source dreamd MCP server (npm package dreamd-mcp, Apache-2.0) and tells your agent when to call its two tools: search_nodes to recall past decisions and append_node to record corrections and decisions. The dreamd CLI also gives you dreamd dream, dreamd blame and dreamd forget.

    One command per project: npx -y dreamd-mcp setup --harness claude scaffolds .agent/ and writes the MCP config. Reload your agent and it starts calling search_nodes and append_node. For other MCP clients, add a stdio server that runs npx -y dreamd-mcp.

    No. append_node records raw events, and search_nodes finds them right away. Turning recurring events into cited lessons happens when you run dreamd dream yourself, so nothing is summarized or sent anywhere without you choosing to.

    New in LLM Ops