Give Claude Code Permanent Memory

1. Local mode does not need an API key. Skip to step 3 if you only want local.
2. For cloud: register at aiagentsbay.com/register (free).
3. Open Dashboard → API Keys, click Create API Key, copy the ab_live_... key.

# In ~/.zshrc (Mac) or ~/.bashrc (Linux):
export AGENTBAY_API_KEY="ab_live_YOUR_KEY"
source ~/.zshrc

Edit (or create) ~/.claude/settings.json:

{
  "mcpServers": {
    "agentbay": {
      "type": "http",
      "url": "https://www.aiagentsbay.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${AGENTBAY_API_KEY}"
      }
    }
  }
}

For local-only mode, skip this step entirely — just install the SDK and call AgentBay().

Tells every Claude Code session to recall + store proactively. Append to ~/.claude/CLAUDE.md:

# Default memory: AgentBay

You have AgentBay MCP connected globally.

- Before starting work on a task, call agentbay_memory_recall with a query
  about what you're about to work on. Inject relevant memories into context.
- During work, store patterns, pitfalls, and decisions you discover with
  agentbay_memory_store. Don't wait to be asked.
- Use type="PATTERN" | "PITFALL" | "DECISION" | "ARCHITECTURE".
- Don't store raw code or secrets — those belong in git, not memory.

Start a new Claude Code session and run:

# In Claude Code:
> what MCP servers do I have connected?

# You should see "agentbay" in the list.
# Then test the round trip:

> store a test memory titled "phase-5 verification" with content "AgentBay is wired up"
> recall the test memory you just stored
> tell me which strategies the recall used (alias / fts / vector / tag)

Claude Code should call agentbay_memory_store then agentbay_memory_recall, and the result should include the per-strategy rationale recorded by the phase-2 quality instrumentation.

Real coding-agent workflow: a refactor that survives a session restart.

# Day 1, session 1 — refactoring auth middleware
> I'm refactoring src/middleware.ts. Recall what we know about auth.

  agentbay_memory_recall query="auth middleware"
    → Auth pattern (PATTERN, 87% confidence): JWT with 24h refresh
    → Don't trust upstream IP (PITFALL, 92%): use X-Forwarded-For chain

> Now write the rotation handler.
[Claude does the work, I review it.]

> Session is wrapping up. Hand off so I can resume tomorrow.

  agentbay_handoff_create
    summary="Wrote rotation handler in src/middleware.ts. Tests pass.
             Next: wire it into the SDK and update docs."
    nextSteps=["wire SDK", "update docs", "run integration tests"]
    completedSteps=["rotation handler", "unit tests"]
    filesModified=["src/middleware.ts", "src/middleware.test.ts"]
    keyDecisions=[{decision: "HS256 not RS256", rationale: "no KMS yet"}]
    → handoffId=ho_xyz, qualityScore=90, warnings=[]

# Day 2, new session, different machine
> Resume the most recent handoff for this project.

  agentbay_handoff_resume handoffId=ho_xyz
    → quality 90/100. summary, nextSteps, files all loaded into context.
    → recent failures in this area also surfaced (PITFALL list).
    → I pick up exactly where we left off.

The handoff quality score is computed deterministically from completeness (summary length, next steps, files modified, decisions, etc). The full breakdown is stored alongside the score so you can see why a handoff scored 90 vs 100 — never a mystery KPI. See memory architecture for the full scoring rules.