Sutra MCP가 있는 AI 에이전트를 위한 영구 메모리: 개인용, 휴대용 및 재사용 가능

Your AI agent understands the project today. Tomorrow, you open another agent and explain the same architecture, preferences, and decisions again.

The model changed. The chat history stayed behind. Your context did not move with you.

I built Sutra MCP to make that handoff explicit: one private, portable memory layer and reusable skill library that can be accessed by supported AI agents through the Model Context Protocol.

This article shows what that means, how the pieces fit together, and how to connect an MCP client in a few minutes.

What is Sutra MCP?

Sutra is a hosted MCP service for user-controlled AI agent memory and reusable skills.

Instead of treating every conversation as memory, Sutra exposes deliberate operations to:

• Save an observation after the user asks or agrees
• Search for only the memories relevant to the current task
• Isolate unrelated work in named project clusters
• Share selected context across supported agents
• Store reusable SKILL.md workflows separately from personal memory
• Export the complete memory dataset for portability

The same Streamable HTTP endpoint works across clients:

https://sutra-c3or.onrender.com/mcp

Enter fullscreen mode Exit fullscreen mode

Sutra is published in the Official MCP Registry as io.github.shivnathtathe/sutra.

Memory and skills solve different problems

Agent memory and agent skills are often discussed as if they are interchangeable. They are not.

Layer Question it answers Example Memory What should this agent know about me or this project? “This service uses UTC internally and displays local time at the UI boundary.” Skill How should an agent perform a repeatable task? A tested release checklist stored as a reusable SKILL.md workflow.

Memory carries durable facts, preferences, corrections, and decisions. Skills carry reusable operating knowledge.

Sutra keeps both available through MCP without permanently injecting everything into every prompt.

How to share persistent memory across AI agents

Here is a practical handoff you can try after connecting two supported clients.

1. Save one deliberate project decision

In Agent A, ask:

Use Sutra to save this project decision in my payments cluster:
"All internal timestamps use UTC; localization happens only at the presentation boundary."
I authorize this memory write.

Enter fullscreen mode Exit fullscreen mode

The explicit authorization matters. A normal conversation should not silently become permanent memory.

2. Retrieve it from another agent

Open Agent B and ask:

Search my Sutra payments cluster for our timestamp convention.
Use only the context relevant to this question.

Enter fullscreen mode Exit fullscreen mode

Agent B does not need Agent A’s chat transcript. It retrieves the specific durable decision through Sutra.

3. Load a reusable skill only when needed

In any connected agent, ask:

List my enabled Sutra skills. If there is a release checklist, show me its resource index before loading any supporting files.

Enter fullscreen mode Exit fullscreen mode

This keeps procedural knowledge discoverable without filling the context window with every workflow you have ever saved.

That is the core idea: store intentionally, retrieve selectively, and reuse across agents.

Connect your MCP client

First, create a Sutra account. Then choose the authentication method supported by your client.

Authentication Best for Behavior OAuth 2.1 Remote MCP clients with browser authorization The client requests consent and stores a revocable grant. API key Clients that expect an Authorization header Create a dedicated, revocable key and keep it in the client’s secret storage.

Cursor with OAuth

Add this to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "sutra": {
      "url": "https://sutra-c3or.onrender.com/mcp"
    }
  }
}

Enter fullscreen mode Exit fullscreen mode

Connect the server and complete Sutra’s browser authorization flow.

OpenCode with OAuth, DCR, and PKCE

Merge this into your global or project opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "sutra": {
      "type": "remote",
      "url": "https://sutra-c3or.onrender.com/mcp",
      "oauth": {}
    }
  }
}

Enter fullscreen mode Exit fullscreen mode

Authorize and inspect the connection:

opencode mcp auth sutra
opencode mcp list

Enter fullscreen mode Exit fullscreen mode

VS Code and GitHub Copilot with a revocable API key

Create .vscode/mcp.json, or merge this into your user MCP configuration:

{
  "inputs": [
    {
      "id": "sutra-api-key",
      "type": "promptString",
      "description": "Sutra API key",
      "password": true
    }
  ],
  "servers": {
    "sutra": {
      "type": "http",
      "url": "https://sutra-c3or.onrender.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:sutra-api-key}"
      }
    }
  }
}

Enter fullscreen mode Exit fullscreen mode

VS Code requests the key through a masked input instead of storing it in the configuration file.

Claude Code with guided setup

npm install -g @shivnathtathe/sutra-cli
sutra connect claude-code

Enter fullscreen mode Exit fullscreen mode

The CLI requests a dedicated key and writes the supported local configuration.

Current instructions for 22 clients are available in the Sutra integration catalog.

The ten MCP tools

Sutra separates reads from deliberate writes, uploads, and exports.

Tool Access Purpose read_context Read Load the user’s shared identity context. search_memory Read Find targeted memories by keyword. list_clusters Read Discover available project clusters. get_cluster Read Load one known project cluster. write_observation Write Save one durable preference, decision, correction, or fact. export_all Export Export all user memories for data portability. list_skills Read Discover skills explicitly enabled by the user. get_skill Read Load an enabled skill and its resource index. get_skill_resource Read Read one supporting resource from an enabled skill. upload_skill Write Upload a new immutable skill version after explicit authorization.

After authorization, use this connection check:

Use Sutra to list my project clusters, then ask before saving anything.

Enter fullscreen mode Exit fullscreen mode

Your client should discover all ten tools.

What “private” means here

Sutra is a hosted service, not a local-only database. Private means access-controlled, user-specific context with explicit data boundaries; it does not mean data never leaves your machine.

Sutra:

• Stores observations deliberately saved by a user or authorized agent
• Isolates unrelated context in named project clusters
• Supports revocable OAuth grants and per-client API keys
• Provides explicit export for portability

Sutra does not:

• Copy every conversation from a connected client
• Share every cluster with every request
• Require one permanent credential across all agents
• Turn an ordinary chat into a hidden memory write

The connected AI client has its own data-handling policies. Review both the Sutra Privacy Policy and your client’s policy before sending sensitive information.

Never commit a Sutra API key, OAuth token, password, or memory export to source control.

How this differs from common memory approaches

Approach Strength Tradeoff Chat history Automatic and convenient Usually tied to one product or conversation. Project instruction files Transparent and versionable Often project-specific and loaded as static context. Local memory servers Maximum infrastructure control You operate the database, runtime, backups, and client connectivity. Vendor-native memory Deep integration with one assistant Portability depends on that vendor. Sutra MCP Hosted, selective memory plus reusable skills across supported agents Requires a Sutra account and network connection.

Sutra is not intended to replace every memory architecture. It is for people who want their useful context and repeatable workflows to outlast one chat window or one AI client.

Open integrations, hosted service

The Sutra MCP integrations repository contains the open manifests, client configurations, documentation, and artwork needed to connect MCP clients. Those integration files are MIT licensed.

The hosted backend, dashboard, APIs, infrastructure, datasets, service implementation, and trademarks remain proprietary and are not included in that repository.

You can inspect Sutra through:

• Official MCP Registry
• GitHub integration repository
• Smithery
• Glama
• Security and data boundaries

Try the handoff

Connect Sutra to two agents you already use. Save one non-sensitive project decision with explicit authorization, retrieve it from the second agent, and see whether that small handoff removes a repeated explanation from your workflow.

If context should outlast the chat window, it should also remain under the user’s control.

Create your private Sutra workspace or review the integration guide.

I would value feedback on three questions:

1. Which agent-to-agent handoff causes you the most repetition?
2. What should an agent always ask before remembering?
3. Which reusable workflow would you want available across every AI client?