wire-memory

Persistent memory for AI coding agents.

Every AI session starts from zero. Your agent doesn't know what you decided yesterday, what patterns you established last week, or the correction you gave it three conversations ago. wire-memory fixes that. It gives your agent a persistent memory layer that captures decisions, corrections, and patterns, then retrieves them when they're relevant.

The problem

• No continuity. Your agent forgets everything between sessions.
• Repeated corrections. You fix the same mistake session after session.
• Re-explaining context. Every conversation starts with "here's how our project works..." again.
• No cross-project awareness. Preferences and coding style don't carry over between repos.

How wire-memory solves it

• Automatic logging. Decisions, corrections, and patterns are captured as they happen.
• Automatic retrieval. Before responding, your agent searches past context for relevant decisions and patterns.
• Scoped by project and user. Every write is tagged with your current project and identity.
• Portable. Memory is stored in a Wire container, accessible from any MCP-compatible tool.

Quick start

# Add the Wire marketplace (one-time)
claude plugin marketplace add usewire/wire-plugins

# Install wire-memory
claude plugin install wire-memory@wire-plugins

Then inside Claude Code:

/wire-memory:connect

This opens your browser to authenticate and select a container. No account required. The connect flow can spin up a free ephemeral container you can test for 7 days, then claim by creating an account.

After connecting, restart Claude Code. Your memory tools are ready.

Choosing a scope

Claude Code will ask you to choose an installation scope:

• User scope (default): Available in all your projects. Best for individuals working across multiple repos with one memory container.
• Project scope: Committed to the repo. Best for teams sharing a single container where everyone's agents contribute to the same memory.

Either way, every write is tagged with project and user context. Retrieval is scoped automatically regardless of install scope.

What gets remembered

wire-memory works in the background. Your agent captures context as structured entries:

Decisions (when you pick an approach or evaluate trade-offs):

{
  "type": "decision",
  "project": "my-app",
  "user": "Charlie",
  "scope": "project",
  "title": "Use React Query for server state",
  "decision": "React Query over Zustand for API data",
  "why": "Automatic cache invalidation, background refetching, request deduplication"
}

Corrections (when you fix the agent's approach):

{
  "type": "correction",
  "project": "my-app",
  "user": "Charlie",
  "scope": "project",
  "title": "Don't mock the database in integration tests",
  "what_happened": "Agent suggested mocking Postgres",
  "correction": "Use real database. Mocks masked a broken migration last quarter."
}

Patterns (coding conventions and established approaches):

{
  "type": "pattern",
  "project": "my-app",
  "user": "Charlie",
  "scope": "project",
  "title": "Permission checks use requirePermission middleware",
  "description": "All protected API routes use requirePermission({ resource: ['action'] })"
}

Preferences (global, cross-project):

{
  "type": "preference",
  "user": "Charlie",
  "scope": "global",
  "title": "Concise responses",
  "preference": "Skip preamble, lead with action, no trailing summaries"
}

What is Wire?

Wire is a Context as a Service platform. You create containers, add your files and context, and Wire transforms everything into structured, AI-optimized content. Every container gets its own MCP server that any AI tool can connect to.

wire-memory uses a Wire container as its storage backend. Your memory is not locked into any single AI tool. It's portable context that follows you across Claude Code, Cursor, and any MCP-compatible client.

Learn more about Wire

Tools

Your agent gets these MCP tools from your Wire container:

Tool	Purpose
wire_search	Search memory by text, semantic similarity, or filters
wire_write	Save decisions, patterns, corrections, preferences
wire_explore	Browse what's stored: types, schemas, entry counts
wire_delete	Remove outdated entries
wire_analyze	Re-analyze the container's contents

Commands

Command	Description
/wire-memory:connect	Authenticate and connect to a Wire container
/wire-memory:configure	Configure settings (transcript capture, etc.)
/wire-memory:status	Show connection status and container info
/wire-memory:claim	Claim an ephemeral container to make it permanent
/wire-memory:disconnect	Remove credentials and disconnect

How it works

1. Connect. /wire-memory:connect opens your browser to authenticate. Pick a container or create one. No account needed for the 7-day trial. During connect you'll be asked whether to enable transcript capture.
2. Configure. The connect script writes your MCP endpoint and API key to the plugin's .mcp.json. Restart Claude Code to activate. Run /wire-memory:configure anytime to change settings.
3. Use. A bundled skill teaches your agent when to search and write memory. It happens automatically as part of normal conversation.

Transcript capture

wire-memory can automatically capture session transcripts and upload them to your Wire container. This gives your memory layer the full conversation history, not just what the agent explicitly logs, but every question, decision, and tool call.

Enable during connect or anytime via /wire-memory:configure:

/wire-memory:configure

Wire Memory Configuration
─────────────────────────
✓ Connected to container "Memory"

Transcript Capture
  Automatically upload session transcripts to your Wire container.
  Secrets are redacted before upload. Tool results are stripped.

  Enable transcript capture? [y/N]: y

  When to capture:
  [1] Before compaction + end of session (recommended)
  [2] Before compaction only
  [3] End of session only

  Choice [1]: 1

  Minimum session length (turns) [4]: 4

✓ Transcript capture: enabled

How it works:

• PreCompact hook fires before Claude compresses the context window. It captures the full, uncompressed conversation before it's lost.
• Stop hook fires when Claude finishes responding. It captures sessions that never hit the compaction threshold.
• If PreCompact already uploaded for a session, Stop skips the upload.
• Stop also skips sessions below the minimum turn threshold (default 4).

What gets uploaded:

• Native JSONL format, one turn per line. Preserves structure for search and filtering.
• Tool result lines are stripped. The returned file contents are derivative data.
• Secrets are redacted before upload. Covers ~20 patterns including API keys, tokens, passwords, and connection strings.
• Files are named transcript-{date}-{session-id}-{trigger}.jsonl.

Disabled by default. Transcript capture is opt-in. No data leaves your machine unless you explicitly enable it.

Ephemeral containers and claiming

When you connect without an account, Wire creates an ephemeral container. It's fully functional but expires after 7 days. Your agent reads and writes memory, decisions are captured, and corrections stick, just like a permanent container.

The difference is the clock. After 7 days the container and its data are deleted.

How you'll know it's ephemeral:

• /wire-memory:connect prints a warning with the expiry date
• /wire-memory:status shows "Ephemeral" with a countdown
• Your agent sees a reminder at the start of each session

To keep it permanently, run /wire-memory:claim. This opens your browser to create a Wire account. Once you sign up, your existing container and all its memory transfer to your account. Nothing is lost. The plugin detects the change automatically on the next session start.

If you claim through the Wire website directly (outside the plugin), the plugin self-heals. It checks ephemeral status on session start and updates your local config when it sees the container has been claimed.

Plugin structure

wire-memory/
├── .claude-plugin/plugin.json    # Plugin manifest
├── .mcp.json                     # MCP server config (placeholder until connected)
├── skills/memory/SKILL.md        # Teaches agent when to read/write memory
├── hooks/hooks.json              # Hook registration (eval, transcript capture)
├── commands/
│   ├── connect.md                # /wire-memory:connect
│   ├── configure.md              # /wire-memory:configure
│   ├── status.md                 # /wire-memory:status
│   ├── claim.md                  # /wire-memory:claim
│   └── disconnect.md             # /wire-memory:disconnect
├── scripts/
│   ├── connect.mjs               # Nonce auth flow
│   ├── configure.mjs             # Interactive settings (transcript capture, etc.)
│   ├── eval-hook.mjs             # Prompts memory check on each interaction
│   ├── transcript-upload.mjs     # PreCompact/Stop hook: upload transcripts via REST
│   ├── redact.mjs                # Secret redaction (~20 patterns)
│   ├── status.mjs                # Connection info
│   ├── claim.mjs                 # Claim ephemeral container
│   └── disconnect.mjs            # Cleanup
├── package.json
└── LICENSE

Zero dependencies. Plain Node.js built-ins only.

Requirements

• Node.js >= 18
• Claude Code >= 1.0.33
• No Wire account required. The connect flow offers a free ephemeral container for 7 days. Create an account anytime to keep it permanently.

Privacy and security

• Credentials stored locally at ~/.wire-memory/config.json with owner-only permissions (0o600)
• .mcp.json marked --skip-worktree after connect to prevent accidental commits of your API key
• All data stored in your Wire container. You own it, you control access.
• API key is scoped to your specific container
• Transcript capture is disabled by default. Opt-in only via /wire-memory:configure.
• Transcripts are redacted for secrets before upload. Covers ~20 patterns including API keys, tokens, passwords, connection strings, and private keys.

License

MIT, Superloops LLC