puppyone for Cursor: shared workspace and SaaS context, mounted via MCP

TL;DR

• Cursor is excellent inside one repo, on one laptop. It reads your code, indexes it, runs the chat / agent against it. Outside the repo, Cursor doesn't really have a context layer.
• puppyone gives Cursor a workspace that lives outside the repo. Plug it in via MCP and Cursor can read_file from puppyone in the same chat where it's editing your code.
• That workspace contains: long-form specs and design notes, ingested SaaS data (Notion, Slack, Gmail, Postgres, GitHub issues), prior agent outputs, your team's shared context. All version-controlled, all scoped per agent.
• Cursor's repo features stay where they are (codebase indexing, .cursor/rules, project context). puppyone adds the layer Cursor doesn't natively own — durable, cross-session, cross-agent, SaaS-aware context.

What changes when you wire puppyone into Cursor

Cursor's job is your repo. It does that brilliantly. The seam shows up the moment your agent needs context that isn't in the repo:

• The Notion spec for the feature you're building.
• Yesterday's Slack thread where someone explained why X was decided.
• A Postgres slice your code talks to but doesn't define.
• The research a different agent did on Monday and wrote into a folder somewhere.
• Notes from your teammate's Cursor session, on a different machine.

Without puppyone you do the manual dance: paste content into chat, screenshot, @-attach a file, manually copy from another tab. With puppyone wired in, the same Cursor agent can read_file /integrations/notion/feature-x-spec.md directly. No copy-paste. Same chat. Same Cursor.

You also get:

• Durable cross-session writes. Cursor's agent can write a long summary or a multi-file plan into puppyone (/scratch/cursor/<date>.md) — and tomorrow's session can pick it up.
• Multi-agent visibility. Whatever Cursor writes is visible to your Claude Code session, your n8n research flow, your custom Python agent — all on the same workspace.
• Per-agent permissions. Cursor gets its own Access Point with explicit read/write scopes. It can read your specs but only write into its own scratch folder, for example.
• Automatic version history. Every write Cursor makes via puppyone is a commit with author, timestamp, diff, rollback.

Crucially: nothing about how Cursor handles your repo changes. We don't index your code; Cursor's existing codebase index is unchanged. We just bolt on the external context layer Cursor doesn't natively own.

What stays exactly the same

• Your repo stays in GitHub / locally. Cursor reads and writes it like always.
• .cursor/rules and project context features stay in your repo. Cursor uses them as before.
• Your code review / PR flow is unchanged. Code goes through GitHub PRs.
• Cursor's chat, agent, and inline edit features are unchanged. We're an MCP server, not a Cursor plugin or fork.

How to wire it up (the short version)

1. Create a puppyone workspace. Cloud (try.puppyone.ai) or self-hosted Docker.
2. Define an Access Point for Cursor with the path scopes you want (e.g. read /specs, /research, /integrations; read+write /scratch/cursor).
3. Add the MCP server to Cursor's MCP config. In Cursor's settings → MCP, point to the puppyone MCP endpoint with the Access Point token.
4. In a Cursor chat, the workspace is now available as a tool surface — Cursor can call read_file, list_directory, write_file, search against it.
5. Optional: add a one-liner to .cursor/rules telling Cursor what's in the puppyone workspace and when to use it ("Specs and team-shared notes are in puppyone under /specs and /notes. Read those first before designing.").

Workflows that actually get better

1. "What does the spec say?" — without leaving Cursor

Without puppyone: Open Notion, find the spec, copy a section, paste into Cursor chat.

With puppyone: Notion connector mirrors the spec into /integrations/notion/feature-x.md. In Cursor: "read /integrations/notion/feature-x.md and tell me what this feature is supposed to do." Done. Cursor reads it, you keep coding.

2. Resume a Monday session on Wednesday

Without puppyone: You spent Monday with Cursor designing an architecture. Wednesday you reopen and Cursor doesn't remember.

With puppyone: Monday's Cursor wrote /scratch/cursor/architecture-discussion.md. Wednesday's Cursor reads it and continues.

3. Two teammates, one workspace

Without puppyone: Your teammate's Cursor on their laptop has its own context. You can't see what they explored. They can't see what you did.

With puppyone: Both Cursors connect to the same puppyone workspace via MCP, each with their own Access Point. What you write to /notes/ your teammate sees. Cursor on either side of the room is reading the same workspace.

4. Cursor + Claude Code + n8n on the same project

Without puppyone: Each agent has its own per-product memory. Sharing context between them requires manual ferrying.

With puppyone: All three connect to the same puppyone workspace. Cursor reads what Claude Code wrote yesterday. n8n flows write research into /research/, Cursor sees it. No glue code, no manual copy.

5. Postgres / Slack / Gmail context inside Cursor

Without puppyone: Cursor doesn't talk to your DB or your Slack. You hand-summarise or use ad-hoc tools.

With puppyone: Connectors materialise SaaS sources as files. /integrations/postgres/active-users.csv, /integrations/slack/eng-channel/2026-04-22.md — Cursor reads them as files via MCP, no API knowledge required.

Patterns to avoid

• Don't try to put your codebase into puppyone. Cursor is already great at codebase context. Use puppyone for everything outside the codebase.
• Don't grant Cursor write access to canonical paths casually. Let it write to its scratch area; promote into canonical paths only when you've reviewed.
• Don't auto-mirror entire SaaS workspaces unfiltered. Pick the specific Notion spaces / Slack channels / Postgres queries that matter. A noisy workspace is a useless workspace.
• Don't expect puppyone to replace .cursor/rules. Repo-specific Cursor rules belong in the repo. Long-form, cross-repo, cross-agent context belongs in puppyone.

How this fits with the rest of your stack

• Cursor uses puppyone via MCP for external context.
• Claude Code uses the same puppyone workspace via MCP. See puppyone for Claude Code.
• n8n / LangChain / CrewAI use puppyone via REST or its connector layer. See puppyone for n8n.
• Custom code uses puppyone via SSH / Bash / REST.

Cursor stops being "an island that knows about my repo and nothing else" and starts being "the editor view onto a shared agent workspace".

FAQ

Does puppyone replace Cursor's codebase indexing? No. We don't touch your repo or your codebase index. Cursor's local indexing is unchanged. We add the outside-the-repo context.

Does Cursor's chat get slower if I mount a huge puppyone workspace? No. MCP tools are call-on-demand. Cursor only reads what it actually asks for. The workspace can be large; only the files that get read_filed enter the chat.

Can I use puppyone with Cursor's "Composer" / multi-file editing features? Yes. Composer can read context from puppyone via MCP just like the chat does. You can @-mention puppyone files in Composer prompts the same way.

Does puppyone work with Cursor's project rules (.cursor/rules)? They're complementary. Project rules live in your repo and govern Cursor's behaviour for that repo. puppyone provides the cross-repo, cross-agent, SaaS-aware context Cursor can pull from.

Can each teammate have their own scoped view of the workspace? Yes. Each Cursor session uses its own Access Point with appropriate read/write paths. Same workspace, different scopes per teammate.

I'm a solo dev with one repo. Do I need puppyone? Only if you have context outside that one repo (Notion specs, Slack threads, multi-session research) that Cursor needs to pull from. If everything you care about is inside the repo, you probably don't.

TL;DR (again)

Cursor is great at the repo. It's not a context layer for everything outside the repo. puppyone is. Mount it via MCP and Cursor can read your specs, your Notion, your Slack, your prior agent outputs — without leaving the chat. Same Cursor, much wider context.

Stop pasting Notion screenshots into Cursor. Mount the workspace instead.Get started→