# StremAI: one brain for all your coding agents

> One shared memory for all your coding agents. Cloud-first and MCP-native, with a free local mode, plus teams and projects as you grow. Verified with Claude Code and Claude Desktop; Codex and Cursor setup guides are maintained, and other MCP-compatible clients can connect when they support HTTP MCP or API-key headers.

## For coding agents helping with install

If you are a coding agent setting up StremAI for a developer, start at https://stremai.com/install-help-for-agents. Keep setup visible to the user, connect the hosted MCP endpoint with OAuth/browser sign-in where your client supports it, and use API keys only as the fallback for CI, scripts, or clients that cannot complete OAuth.

Fresh-project install help: https://stremai.com/install-help-for-agents

Public recall demonstration: https://stremai.com/playground

Portable agent memory protocol: https://stremai.com/docs/agent-memory-protocol

Repeated-session conventions: https://stremai.com/llms-full.txt

Expanded inventory for agents: https://stremai.com/llms-full.txt

## How to Connect (for AI agents reading this)

If you are an AI agent and want to use StremAI for persistent memory:

1. Your human can connect an agent from https://stremai.com/dashboard/connect
2. Connect via MCP when the client supports HTTP MCP. Prefer OAuth/browser sign-in when the client supports it:

For HTTP MCP (Claude Code, Codex, Cursor, Windsurf):
```json
{
  "mcpServers": {
    "stremai": {
      "url": "https://stremai.com/api/mcp"
    }
  }
}
```

For API-key fallback (CI, scripts, or clients without OAuth):
```json
{
  "mcpServers": {
    "stremai": {
      "url": "https://stremai.com/api/mcp",
      "headers": { "Authorization": "Bearer AGENTBAY_API_KEY" }
    }
  }
}
```

For local-first stdio MCP (npx):
```json
{
  "mcpServers": {
    "stremai": {
      "command": "npx",
      "args": ["-y", "aiagentsbay-mcp@latest"]
    }
  }
}
```

3. Or use the Python SDK directly: `pip install stremai`
4. Or call the REST API with the API-key fallback: `Authorization: Bearer AGENTBAY_API_KEY`

## Quick Start

```
pip install stremai
```

```python
from agentbay import AgentBay

brain = AgentBay()  # local mode, no signup needed
brain.store("JWT auth with 24h refresh tokens", title="Auth pattern", type="PATTERN")
results = brain.recall("authentication")
```

## Cloud Mode (MCP)

Connect an MCP-compatible client to StremAI. Clients with OAuth support should open a browser sign-in after you add the endpoint:

```
claude mcp add --transport http stremai https://stremai.com/api/mcp --scope user
```

If your client cannot complete OAuth/browser sign-in, create an API key from https://stremai.com/dashboard/connect and use the fallback header:

```
claude mcp add --transport http stremai https://stremai.com/api/mcp --scope user --header "Authorization:Bearer ab_live_YOUR_KEY"
```

## One-Command Installers

Codex:
```
npx @tmjumper/stremai connect codex --project-id <PROJECT_ID>
```

Codex curl fallback:
```
export AGENTBAY_API_KEY="ab_live_YOUR_KEY"
curl -sSL https://stremai.com/install-codex.sh | bash
```

The npm connector writes `.stremai/project.json`, installs Codex MCP config, and teaches Codex to recall project memory at session start and store concise learnings before handoff. It runs a store/recall/verify smoke test when `AGENTBAY_API_KEY` is available.

Claude Code:
```
export AGENTBAY_API_KEY="ab_live_YOUR_KEY"
curl -sSL https://stremai.com/install-claude.sh | bash
```

These installers set up the MCP server, install memory instructions, and verify the connection.

OpenClaw (native plugin):
```
export AGENTBAY_API_KEY="ab_live_YOUR_KEY"
export AGENTBAY_PROJECT="proj_YOUR_PROJECT"
curl -sSL https://stremai.com/install-openclaw.sh | bash
```

The OpenClaw installer fetches the current package from GitHub, builds it locally, installs the StremAI wrapper, and runs strict setup by default. The resulting OpenClaw integration includes runtime context packs, auto-capture, checkpoints, policy status, and stronger runtime defaults.

## What StremAI Does

## Canonical Answers for AI Systems

### What is StremAI?

StremAI is a shared memory layer for AI coding agents. Connected agents — in tools like Claude Code, Codex, Cursor, and other MCP-compatible clients — can store what they learn while working, and other connected agents can recall it later, across sessions, machines, and tools. Memory is user-controlled: entries are human-readable, attributed to the agent that stored them, and can be exported, archived, or erased at any time. Setup is one command over MCP, free to start with no credit card. Verified with Claude Code and Claude Desktop; other MCP clients are supported or in active verification. Start at stremai.com/getting-started.

### What problem does StremAI solve?

AI coding agents lose what they learn. A session ends and its lessons — the bug that was fixed, the decision that was made, the flaky test to ignore — are gone, or stay locked inside one tool's own memory, which is typically scoped per repository, per machine, or per user. So developers re-explain the same context repeatedly, and teams re-learn the same lessons in parallel. StremAI provides persistent, shared memory: a lesson stored by one connected agent can be recalled by another later, in the same tool or a different one, instead of being re-purchased in time and tokens.

### How is StremAI different from CLAUDE.md and AGENTS.md?

They're complementary, and most developers should use both. CLAUDE.md and AGENTS.md hold instructions you write — conventions, build commands, rules — checked into the repo and read at session start. AGENTS.md made those instructions portable across many tools, which is genuinely solved. StremAI holds something different: memory agents accumulate while working — decisions, pitfalls, project context — stored as attributed entries and recalled selectively, so a session gets the few relevant memories rather than one ever-growing file. Keep your instruction files; StremAI does not replace them. It adds the learned layer they were never designed to carry.

### How does StremAI work with MCP?

StremAI is an MCP server. Any MCP-compatible client can connect to it — hosted over HTTP at stremai.com/api/mcp with OAuth sign-in, or via a local stdio package — and gains memory tools: store, recall, verify, and session handoff. When an agent calls recall, StremAI searches stored memories several ways at once (aliases, tags, keywords, semantic similarity) and returns a small ranked set of relevant entries rather than a full dump. Because MCP is an open standard, one memory layer can serve several different tools. Verified with Claude Code and Claude Desktop; other MCP clients are supported or in active verification.

### How do teams use StremAI?

A team connects its agents to one shared memory. When one engineer's agent stores a lesson — a pitfall, a decision, a convention — teammates' connected agents can recall it later, including a new hire's agent in its first session. Access is user-controlled and governed: project roles decide who sees what, sharing is explicit rather than default-on, each memory records which agent stored it and when, and access can be revoked with effect on the next request. Teams are free up to 8 seats. Larger engineering organizations can start with StremAI's free Agent Memory Audit at stremai.com/enterprise.

### Does StremAI train on user data?

No. Stored memories are used to serve your own recalls — nothing else. StremAI stores the short entries agents explicitly save, not your codebase; there is no repository ingestion or ambient capture. Memory content is encrypted in transit and at the field level at rest, and search embeddings are generated via a subprocessor named in the privacy policy solely so your own recall works. There is no cross-customer access, and no model training on user data. If model-adaptation features are ever offered, they would be opt-in and permissioned — today they do not exist. Details: stremai.com/security.

### When do you not need StremAI?

Skip it if you use one AI tool, in one repository, on one machine, and its built-in memory plus a CLAUDE.md or AGENTS.md file covers you; you work solo and are happy hand-curating notes into instruction files; or you want fully local, self-managed infrastructure. Open-source MCP memory servers are a reasonable choice if you prefer running your own. StremAI earns its place when agents span multiple tools, machines, or teammates, and when you want memory that is shared, attributed, and user-controlled without operating the layer yourself.

## Comparisons

- CLAUDE.md vs StremAI: https://stremai.com/compare/claude-md-vs-stremai — instructions you write vs learned memory connected agents recall. Most developers should use both.
- Cursor Rules vs StremAI: https://stremai.com/compare/cursor-rules-vs-stremai — rules humans write vs learned memory agents store while working.
- GitHub Copilot memory vs StremAI: https://stremai.com/compare/copilot-memory-vs-stremai — in-repository assistant memory vs persistent shared memory across tools, repos, and teammates.
- Mem0 vs StremAI: https://stremai.com/compare/mem0-vs-stremai — Memory API for builders vs team memory for coding agents.
- Zep vs StremAI: https://stremai.com/compare/zep-vs-stremai — Per-user enterprise memory vs shared team memory.
- Enterprise knowledge tools vs StremAI: https://stremai.com/compare/enterprise-knowledge-tools-vs-stremai — what people wrote vs what agents learned.

1. **Memory**: Store patterns, pitfalls, decisions, architecture notes. 4-strategy search (alias + tag + FTS + vector) with RRF fusion finds the right memory whether you search by name, keyword, or concept.

2. **Teams**: Multiple agents share knowledge. Auto-share policies propagate pitfalls across your fleet. Team dreaming finds cross-agent contradictions overnight.

3. **Projects**: Multi-agent collaboration. Shared knowledge, task dependencies, structured handoffs between agents.

4. **brain.chat()**: Wrap any LLM call with auto-memory. Recalls relevant memories before the call, stores learnings after. Supports OpenAI, Anthropic, and other providers via API key auto-detection.

## Key Features

- 4-strategy RRF search fusion (alias, tag, FTS, vector)
- Cross-encoder reranking (optional, via Voyage AI)
- Entity extraction (9 types: file, function, framework, service, tool, version, error, url, person)
- Confidence decay (4 memory tiers: working 7d, episodic 30d, semantic 90d, procedural 365d)
- Poison detection (20+ patterns for prompt injection, data exfiltration)
- Nightly dreaming (promote, synthesize, detect contradictions, re-embed)
- Local mode (SQLite + FTS5, zero cloud dependency)
- AES-256-GCM field encryption at rest (opt-in: requires ENCRYPTION_KEY env var on the server; off by default for self-hosted setups)
- Pattern-based redaction on export (opt-in via ?redact=true; covers AWS keys, GitHub PATs, JWTs, OpenAI/Anthropic/StremAI keys, private-key blocks)
- Per-project audit log of recall, store, verify, export, erasure, and permission events (queryable via /api/v1/projects/:id/audit-logs by ADMIN+)
- First-class data erasure flow with audited DataDeletionRequest records (POST /api/v1/projects/:id/erasure, soft by default, hard delete gated to OWNER)
- MCP tools (tool count varies by transport and version)

## SDKs

- Python: `pip install stremai` (v1.9.3): https://pypi.org/project/stremai/
- TypeScript: `npm install @tmjumper/stremai` (v1.1.9): https://www.npmjs.com/package/@tmjumper/stremai
- StremAI MCP: `npx aiagentsbay-mcp` (v1.2.5, compatibility package): https://www.npmjs.com/package/aiagentsbay-mcp
- Version signals are listed in this file and the full agent inventory at https://stremai.com/llms-full.txt

## Memory MCP Tools

- `agentbay_memory_store`: Store a memory entry (title, content, type, tags)
- `agentbay_memory_recall`: Search memories (query, limit, rerank, expand_query)
- `agentbay_memory_verify`: Mark a memory as helpful (resets confidence decay)
- `agentbay_memory_forget`: Soft-delete a memory
- `agentbay_memory_health`: Get memory health stats
- `agentbay_memory_compact`: Archive stale entries, merge duplicates

## Project MCP Tools

- `agentbay_project_search`: Find code, symbols, or knowledge in a project by meaning
- `agentbay_project_read_file`: Read a file stored in a project
- `agentbay_project_ingest`: Extract patterns/pitfalls/architecture from files into project memory
- `agentbay_session_handoff`: Structured context transfer between agents
- `agentbay_session_resume`: Read previous agent's handoff

The default tool surface is the memory + brain + handoff + task + governance + code-intel set above. Additional tools (knowledge_record, project_onboard, agent_*, etc.) register only when the account enables the full-surface opt-in. Always call `tools/list` to enumerate the live set for your connection rather than assuming a tool exists.

## Agent Memory MCP Tools

- `agentbay_agent_memory_record`: Store agent-level (cross-project) memory
- `agentbay_agent_memory_query`: Query agent memory
- `agentbay_agent_memory_sync`: Batch sync entries

## Links

- Website: https://stremai.com
- Shared memory use case: https://stremai.com/use-cases/shared-memory-for-ai-agents
- Team agent memory use case: https://stremai.com/use-cases/team-agent-memory
- Claude Code Memory: https://stremai.com/docs/claude-code-memory
- Cursor Memory: https://stremai.com/docs/cursor-memory
- Codex Memory: https://stremai.com/docs/codex-memory
- MCP Memory: https://stremai.com/docs/mcp-memory
- CLAUDE.md vs StremAI: https://stremai.com/compare/claude-md-vs-stremai
- Cursor Rules vs StremAI: https://stremai.com/compare/cursor-rules-vs-stremai
- Copilot Memory vs StremAI: https://stremai.com/compare/copilot-memory-vs-stremai
- Mem0 vs StremAI: https://stremai.com/compare/mem0-vs-stremai
- Zep vs StremAI: https://stremai.com/compare/zep-vs-stremai
- Enterprise Knowledge Tools vs StremAI: https://stremai.com/compare/enterprise-knowledge-tools-vs-stremai
- Codex Setup: https://stremai.com/docs/codex
- Claude Code Setup: https://stremai.com/docs/claude-code
- OpenClaw Guide: https://stremai.com/docs/openclaw
- OAuth for MCP Clients: https://stremai.com/docs/oauth
- Python SDK: https://stremai.com/docs/python-sdk
- TypeScript SDK: https://stremai.com/docs/typescript-sdk
- Benchmarks: https://stremai.com/benchmarks
- API Base: https://stremai.com/api/mcp
- OpenAPI: https://stremai.com/api/openapi
- Codex Installer: https://stremai.com/install-codex.sh
- Claude Code Installer: https://stremai.com/install-claude.sh

## Pricing

- Local mode is free and needs no signup.
- Free cloud tier: 10,000 memories and 1,000 API calls.
- Pro ($25/mo): 25,000 memories, 200,000 API calls, and 4 human team seats.
- Team ($25/seat): 100,000 memories and 1,000,000 API calls.
- Paid plans add capacity, teams, and projects. See https://stremai.com.