Free, Local-First Shared Memory for Cursor & Claude Code

Shared Memory & Rules for Cursor and Claude Code

Free, local-first shared memory for Cursor and Claude Code. Meto compiles .cursor/rules and CLAUDE.md from a single source of truth and exposes live ADR memory over Model Context Protocol (MCP).

Get Started Free

npx meto-cli sync

Direct Answer · Shared Memory for Cursor and Claude Code

Meto is a free, local-first shared memory and context protocol for Cursor and Claude Code. It compiles project conventions simultaneously into .cursor/rules/*.mdc and CLAUDE.md while exposing an open Model Context Protocol (MCP) server so both agents share the exact same architectural decision records (ADRs) and negative antipatterns.

✓ Best for:Sharing context and persistent memory across Cursor and Claude Code without a hosted service.

The Problem: The Copy-Paste Handoff Dance

Developers who adopt both tools quickly discover an irritating friction loop:

Context Isolation

You run an architecture plan in Claude Code. Then you open Cursor, only to realize Cursor has zero awareness of what Claude Code just deduced. You manually copy paragraphs between windows.

Rule Divergence

You configure strict TypeScript conventions in your .cursor/rules. When you run Claude Code in your terminal, it ignores those rules because it looks for CLAUDE.md, generating code with outdated patterns.

State Overwrite

Cursor edits files while Claude Code is midway through a multi-step refactor. Without a shared session lock or shared state file, one tool breaks the assumptions of the other.

Groundhog Day Amnesia

Every new terminal window and every new Cursor composer chat resets the assistant back to a generic AI. You find yourself explaining your stack for the tenth time today.

Dual-Agent Topology

A Unified Shared Memory Protocol

Meto treats developer context as an independent, local-first layer that sits beneath both editors:

Claude Code CLI

Deep terminal agents, CLI tooling, test suites, multi-file refactoring

Meto Context Layer

Shared ADRs, directives, stack rules & active session memory

Cursor IDE

Real-time inline code edits, Copilot-style Tab completions, visual git diffs

Real-Time Synchronized Execution Pipeline:

1. You refine a convention in Meto or directly in your codebase.

2. Meto compiles the directive into native CLAUDE.md and .cursor/rules/*.mdc formats.

3. Both agents query the live MCP context endpoint for active task state and architectural decision records (ADRs).

4. Zero divergence: Both tools speak the exact same architectural language.

Quickstart: Setting Up the Cursor & Claude Code Bridge

Follow this 3-minute setup to connect both tools to your unified Meto context:

1Initialize Meto in your project root

Terminal

npx meto init

2Connect Claude Code CLI via MCP

Terminal

# Add Meto context protocol to Claude Code CLI
claude mcp add meto npx -y @meto/mcp@latest

# Or generate synchronized CLAUDE.md and .cursor/rules
npx meto sync

3Enable Meto MCP in Cursor Settings

In Cursor, open Cursor Settings → Features → MCP and add:

~/.cursor/mcp.json

{
  "mcpServers": {
    "meto": {
      "command": "npx",
      "args": ["-y", "@meto/mcp@latest"]
    }
  }
}

Workflow Comparison: Fragmented vs. Unified

Workflow Dimension	Manual / Fragmented	Meto Unified Protocol
Rule Definition	Duplicate edits in .cursorrules and CLAUDE.md	Single source of truth compiled to all targets
Architectural Decisions (ADRs)	Forgotten as soon as context compresses	Persistent ADR ledger queried on-demand via MCP
Code Style Enforcement	Inconsistent styles between editor & terminal	100% unified linting & naming constraints
Cold Start Amnesia	5-10 minutes re-explaining stack per session	0 seconds — instant context loading
Multi-Repository Support	Rules trapped inside individual git repos	Global developer profile sync across every repo

Frequently Asked Questions

Can I use Cursor and Claude Code together on the same codebase?

Yes. In fact, pairing Cursor (for inline visual editing, tab completions, and diff inspection) with Claude Code (for autonomous terminal execution and deep architectural refactoring) is one of the highest-leverage developer setups. The challenge is state synchronization, which Meto solves by compiling a single context source into both .cursor/rules and CLAUDE.md simultaneously.

Why do Cursor and Claude Code drift out of sync?

Cursor stores project rules in .cursor/rules/*.mdc or .cursorrules, whereas Claude Code relies on CLAUDE.md. When you refine rules or make architectural choices in one tool, the other tool is unaware, resulting in conflicting code styles and duplicated work. Meto provides a unified protocol that updates both environments automatically.

Does Meto replace Cursor or Claude Code?

No. Meto is the shared context and memory infrastructure layer. It sits between you and your AI coding tools, providing the persistent directives, architectural guardrails, and project state that feed into both Cursor and Claude Code via native MCP and rule files.

Is any proprietary codebase code uploaded to Meto's servers?

No. Meto operates local-first. Your private source code stays strictly on your local disk and in your Git repository. Only high-level developer directives, stack definitions, and rule schemas are managed and compiled.

Bridge Cursor and Claude Code in 60 Seconds

Stop losing architectural context when switching between your editor and your terminal.

Get Started Free Context Protocol