Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    twin: Obsidian Memory for AI Agents

    1

    Persistent project memory for your coding agent, saved as plain Markdown in your Obsidian vault.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    twin: Obsidian Memory for AI Agents

    twin: Obsidian Memory for AI Agents

    Example session with this skill installed

    Where did we leave off on this project?

    • Read your context and instructions
    • Compiled the twin

    Loaded twin context for my-app (~/Work/my-app). Here's where we left off:

    Last session: 2026-10-17, "Stripe webhooks + retry queue"

    You finished the webhook handler and the retry queue. Signature verification is in; idempotency is not.

    File / ThingWhat changed
    src/api/webhooks/stripe.tsNew handler, verifies Stripe-Signature
    src/jobs/retry.tsExponential backoff, max 5 attempts
    prisma/schema.prismaAdded WebhookEvent table

    [!warning]
    Stripe sends the same event more than once. WebhookEvent.id must be unique or orders get double-fulfilled.

    Next steps (from the README)

    1. Add a unique constraint on WebhookEvent.stripeEventId and skip duplicates
    2. Write a test that replays the same event twice
    3. Deploy to staging and point the Stripe test webhook at it

    Relevant brain notes

    • payments: checkout flow, which Stripe objects we store, refund rules
    • gotchas: local webhooks need stripe listen --forward-to localhost:3000/api/webhooks/stripe

    Want me to start with step 1, the idempotency fix? When we're done I'll log the session and update next steps so the next session picks up from there.

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

    About this skill

    Stop starting every coding session from zero. Without memory, your agent forgets the architecture, repeats failed experiments and rediscovers the same gotchas every time you restart it. This skill gives it persistent project memory through the free, open-source twin MCP server, stored as plain Markdown in your Obsidian vault.

    What it does

    • Persistent context: saves a project README, daily session logs and topic notes as Markdown you can read and edit in Obsidian.
    • Topic merging: updates broad topics like auth or database instead of piling up one-off notes.
    • Session tracking: records what changed, why, and the concrete next steps for the next session.
    • Discovery logging: captures verified facts, bug root causes and setup steps as they happen.
    • Mermaid support: saves system flows and diagrams into the project's notes.

    How it works

    1. Start: the agent calls get_project_context to load the README, next steps and today's log.
    2. Work: it calls save_knowledge when it learns something a future session would otherwise have to rediscover.
    3. Look up: search_knowledge / get_knowledge pull up details from past sessions.
    4. Wrap up: log_session summarises the work and set_next_steps queues what's next.

    If twin isn't installed yet, the skill walks the agent through installing and connecting it.

    Requirements

    • twin MCP server: https://github.com/neonn0d/twin (MIT, free)
    • Node.js 18+
    • An Obsidian vault, or any folder for notes. The Obsidian app itself is optional.

    Why use the skill and not just the server

    The server only provides tools; on its own the agent uses them only when you ask. This skill tells the agent when to load context, what is worth saving, how to name topics so notes merge cleanly, and to never save secrets.

    Use cases

    • Record why a library version was pinned so a future agent doesn't "fix" it.
    • Keep env var requirements and deploy steps in one place.
    • Keep a running log of a feature across several days.
    • Save Mermaid diagrams of data flows the agent can reference and update.

    Privacy

    Everything stays on your machine as Markdown files in your vault. No cloud, no API keys. The skill tells the agent to store where secrets live, never their values.

    Known limitations

    The agent must pass the absolute project root as cwd so notes land under the right project.

    Requires twin MCP server installation. Uses absolute paths for project identification. Not suitable for storing secrets or raw customer data.

    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

    Twin MCP
    Node.js 18+
    Obsidian vault or notes folder
    Git

    Permissions

    Terminal / Shell
    Read Files
    Network Access
    Environment Variables

    twin reads and writes Markdown files only inside the twin/ folder of the vault path you configure (OBSIDIAN_VAULT). Shell and network access are only used once, to clone and install the server if it isn't set up yet. No data leaves your machine.

    Listed29 days ago

    What's inside

    Frequently Asked Questions

    It creates a persistent memory layer for AI agents by storing project context, architectural decisions, and session logs in Markdown format, preventing agents from "forgetting" details between restarts.

    The skill requires the twin MCP server and Node 18 or higher; it works with any AI agent or IDE (like Claude Desktop) that supports the Model Context Protocol (MCP).

    Yes, since all data is saved as standard Markdown files, you can point the skill to an Obsidian vault to visualize your project's knowledge graph and Mermaid diagrams.

    No. Nothing is written to your repo. Notes live in your vault under twin/<project path>/, and saving to an existing topic merges into that note instead of creating a new file, so knowledge stays in a few stable notes like 'auth' or 'database'.

    A $5/month subscription gives you the twin skill, which teaches your agent when and how to use twin: loading context at the start, what's worth saving, how to name topics so notes merge cleanly, and wrapping up sessions with next steps, plus updates as the skill improves. The twin MCP server itself is free and open source (MIT) at github.com/neonn0d/twin, and the skill walks your agent through installing it if needed.

    The skill requires an absolute file path to your project root to organize notes correctly, and users should avoid storing sensitive API keys or secrets within the memory files.

    New in LLM Ops