More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Thread mind

    1

    Persistent project memory for AI coding agents: a git-friendly tree of thread summaries that every new session starts from.

    $7

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Thread mind

    Thread mind

    Example session with this skill installed

    tm:summary Add a decision: we are using SQLite for local storage because we need a zero-config setup for the MVP. Mark the state as schema design complete.

    • Read your context and instructions
    • Compiled the thread mind

    I have updated the thread summary for the current task. These details are now persisted in the .threadmind/ directory and will be loaded in your next session.

    Summary Update: Current Thread

    SectionContentAction
    DecisionsUsing SQLite for local storage (zero-config for MVP).Appended
    StateSchema design complete.Replaced
    Filesdatabase/schema.sql, lib/db.tsTracked

    Next steps

    • Run tm:tree to see how this sub-task relates to the main project thread.
    • Use tm:done once the implementation of the SQLite wrapper is finished.
    • Commit the .threadmind/ directory to share these decisions with your team.

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

    About this skill

    Long coding sessions lose their context: the conversation fills the model's window, gets compacted or cleared, and the next session starts from scratch. You spend tokens and time re-explaining architecture decisions, constraints and where the work stands.

    What it does

    • Persistent memory: keeps a tree of thread summaries in a .threadmind/ directory inside your project.
    • Inherited context: each thread inherits the decisions and constraints of its parent threads, so a sub-task starts with the rules it must follow.
    • Structured summaries: the agent records Decisions, Constraints, State, Open questions and Next steps, one section at a time, without rewriting everything.
    • Follows git: a thread created on a feature branch becomes the active thread whenever that branch is checked out, and summaries get flagged when the files they cover change.
    • One thread per topic: create, switch, move, merge finished threads into their parent, or mark them done or abandoned with the reason.

    How it works

    1. Create a project with tm:project <title>. ThreadMind stores it in .threadmind/.
    2. Load the context when a session starts: the agent calls context_get and gets the active thread's summary plus its ancestors' decisions and constraints, a few hundred tokens instead of the whole history.
    3. Save as work progresses: tm:summary, or let the agent record each decision and update the state.
    4. Branch into a new thread with tm:create <title> when a sub-task starts, and tm:merge it back when it's done.

    Frameworks & tools

    Requires the ThreadMind MCP server, the open-source thread-mind-mcp npm package (Node.js 18+), declared in your agent's MCP configuration. The skill includes the setup for Claude Code, Cursor, VS Code (GitHub Copilot), GitHub Copilot CLI, Codex, Gemini CLI, Windsurf and Claude Desktop. In Claude Code, the ThreadMind plugin also loads the context at session start and reminds the agent to save its summary.

    Why this beats prompting it yourself

    Notes in a prompt or a chat summary get lost at the next compaction, can't be reviewed, and grow until they no longer fit. ThreadMind keeps decisions in plain markdown files, organized by topic: the agent loads only the thread it works on plus the durable rules above it, and your team reviews the summaries in pull requests like code.

    Use cases

    • Resuming a complex refactor after a weekend, or after /clear, without re-explaining it.
    • Sharing architecture decisions and constraints across a team, through summaries committed with the code.
    • Running parallel sub-tasks in separate threads, each linked to its git branch.
    • Keeping a record of why a library or pattern was chosen.
    • Switching agents mid-project: the same .threadmind/ serves Claude Code, Cursor, Codex or Copilot.

    Known limitations

    • The ThreadMind MCP server must be set up once in each agent's configuration; the skill shows how, but never installs it itself.
    • Outside Claude Code with the plugin, saving relies on the agent following the instructions: ask for tm:summary before closing a long conversation.
    • Branch linking and outdated-summary warnings need git.
    • Summaries are meant to be committed: keep secrets and personal data out of them.

    Requires Node.js 18+ and the thread-mind-mcp npm package. Summaries are stored locally in .threadmind/ and must be manually committed to git for team sharing.

    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

    Node.js

    Permissions

    Read Files
    Write Files
    Network Access
    Listed29 days ago

    What's inside

    Frequently Asked Questions

    Thread Mind creates a structured, git-versioned tree of summaries and decisions in a `.threadmind/` directory, allowing your AI agent to recall project constraints and architectural choices even after a session restart or token limit reset.

    The skill is designed for any MCP-compliant environment; it is fully compatible with Claude Code, Cursor, VS Code, and the GitHub Copilot CLI, provided you have Node.js 18+ installed.

    Yes, because the context is stored in a local directory, you can commit it to your repository. This ensures that when a teammate switches to a feature branch, their AI agent automatically inherits the specific decisions and sub-task status associated with that branch.

    No, Thread Mind uses a smart summarization technique that records only critical milestones, decisions, and constraints, ensuring your model's context window stays lean and focused on the current task.

    After purchase, you receive the full Thread Mind MCP server configuration and access to the `thread-mind-mcp` npm package, along with a guide for initializing the system in your local development environment.

    New in LLM Ops