Research and analysis: 2026-03-17
| System | Provider | Type | Access |
|---|---|---|---|
| ChatGPT Memory | OpenAI | Consumer product | Cloud, proprietary |
| Claude Consumer Memory | Anthropic | Consumer product | Cloud, proprietary |
| Claude Memory Tool (API) | Anthropic | Developer tool | Self-hosted by dev |
| OpenClaw Native Memory | OpenClaw (open source) | Agent framework | Local, open source |
| ClawVault | Versatly (open source) | OpenClaw plugin | Local, open source |
| AITeam Memory v2.1 | INOSX (this project) | AITEAM-X agent dashboard | Local, proprietary |
ChatGPT stores 6 opaque categories, pre-built and injected into every conversation:
- Bio Tool (saved memories) — facts the user explicitly asked to remember
- Response preferences — ~15 entries inferred automatically about communication style
- Past conversation topics — ~8 summaries from early user sessions
- User insights — ~14 biographical and professional data points extracted automatically
- Recent history — ~40 recent conversations with timestamps and user messages only (no model replies)
- Interaction metadata — device, local time, usage frequency, quality scores, intent tags
Users can only view and edit category 1 (Bio Tool). The rest are managed opaquely by OpenAI.
Claude stores memories in 4 structured categories:
- Role & Work — role, industry, professional context
- Current Projects — active initiatives discussed
- Preferences — communication style, preferred format
- Personal Content — personal facts shared
Memories are scoped per Project — no global memory across different projects.
Fully free-form storage — the developer defines the schema. Official docs suggest avoiding verbatim history and favoring:
- Facts and preferences of the user/client
- Historical decisions
- Project state and progress
- Context for recurring workflows
Format: Markdown, XML, or plain text files under /memories. The model reads and writes them autonomously via tool calls.
Three layers of local Markdown storage:
- Daily notes (
memory/YYYY-MM-DD.md) — append-only log of the day’s activities and decisions - Long-term memory (
MEMORY.md) — curated distilled knowledge: preferences, important facts, active projects, lessons learned - Session transcripts (
sessions/YYYY-MM-DD-<slug>.md) — full conversations with LLM-generated descriptive slugs
Typed memories routed to 8 structured categories in Markdown with YAML front matter:
| Category | What it stores |
|---|---|
decisions/ |
Strategic choices with rationale |
lessons/ |
Learnings from outcomes |
people/ |
Contact and relationship data |
tasks/ |
Goals and execution items |
projects/ |
Initiative tracking |
inbox/ |
Captures pending triage |
preferences/ |
User preferences |
progress/ |
Milestones reached |
Structured memories in 5 categories per agent, plus global context:
| Category | What it stores |
|---|---|
decisions |
Technical or project choices with context |
lessons |
Fixed bugs, insights, learnings |
handoffs |
Last session summary + next step |
tasks |
Open items as [ ] checklist |
projects |
General agent context |
_project.md |
Global context shared by all agents |
| System | Automatic | Manual | Extraction method |
|---|---|---|---|
| ChatGPT | Yes (async, outside chat) | Yes (“remember X”) | Proprietary OpenAI inference; details not public |
| Claude Consumer | Yes (LLM synthesis when toggle on) | Yes (“remember X”) | Claude synthesizes categories from history |
| Claude API Tool | Yes (Claude decides what to write) | Yes (system prompt instructions) | Claude writes files autonomously via tool calls |
| OpenClaw Native | Yes (agent writes during session + pre-compaction flush) | Yes (explicit instruction) | Agent-driven: Claude writes daily notes continuously |
| ClawVault | Yes (observe --compress session.jsonl) |
Yes (CLI: remember decision "X") |
LLM (Gemini Flash) or rules extract observations with scores |
| AITeam v2.1 | Yes (on chat close, via POST /sleep) | Yes (Memory Vault UI: + New entry) | Cursor Agent CLI analyzes transcript and returns structured JSON |
Key difference: ChatGPT and Claude Consumer extract asynchronously and invisibly — users do not know exactly when or what is extracted. AITeam, ClawVault, and Claude API Tool make extraction observable and controllable, with a veto window (AITeam) or explicit CLI (ClawVault).
This is the largest architectural difference:
| System | Retrieval strategy | Semantic search? | Keyword search? |
|---|---|---|---|
| ChatGPT | Full injection — all 6 categories pre-built into every chat. No live search. | No | No (everything injected) |
| Claude Consumer | File read + “reference conversation history” toggle. Not vector RAG. | No (consumer) | No |
| Claude API Tool | Agent picks files — Claude lists /memories, reasons about names, reads relevant ones. No embeddings. |
No | No (reasoning-based) |
| OpenClaw Native | Hybrid BM25 + vector — SQLite with sqlite-vec and FTS5. Local embeddings (gemma-300M) or API. Fusion with configurable weights (70% vector + 30% BM25). |
Yes | Yes |
| ClawVault | Hybrid BM25 + vector + knowledge graph — RRF reranking + wiki-link graph traversal for multi-hop retrieval. | Yes (optional) | Yes |
| AITeam v2.1 | BM25 via MiniSearch — relevance search inside the selected agent’s vault. No embeddings. | No (BM25 only) | Yes |
Note on AITeam: The system uses pure BM25 (no vector embeddings). It is fast and has no external dependencies, but misses semantic matches that embeddings capture. OpenClaw and ClawVault offer richer retrieval with optional semantic search.
How and when memories reach the model:
| System | Mechanism | Budget / limit |
|---|---|---|
| ChatGPT | Pre-built Model Set Context block in system prompt. Full injection every chat. |
Not public. ~40 recent conversations. |
| Claude Consumer | Project context + conversation history at start. | Not public. |
| Claude API Tool | view tool reads files on demand. Content enters context as tool results. |
Proportional to files read. |
| OpenClaw Native | Daily notes loaded automatically + memory_search / memory_get MCP tools. |
Configurable. |
| ClawVault | clawvault inject "query" — CLI returns relevant snippets to inject before the model call. |
Configurable per profile (default, planning, incident, handoff). |
| AITeam v2.1 | injectContext() in lib/memory/inject.ts called automatically in /api/agents/command before spawning CLI. |
2,000 tokens priority: handoff → tasks → decisions/lessons → projects. |
Design differences:
- ChatGPT injects everything always — simple but wasteful. No relevance, no budget.
- Claude API Tool is the opposite — the model chooses what to read, at extra tool-call cost per session.
- AITeam has an explicit budget with deterministic priority — more predictable than ChatGPT, cheaper than Claude API Tool.
- ClawVault has context profiles (planning, incident, handoff) that change injected memory sets — a concept absent in the others.
| System | User can view? | User can edit? | User can delete? | Transparency |
|---|---|---|---|---|
| ChatGPT | Bio Tool only | Bio Tool only | Bio Tool only | Low — auto-inferred categories fully opaque |
| Claude Consumer | Yes (curated categories) | Partially | Yes (per project) | Medium — categories visible, synthesis automatic |
| Claude API Tool | Yes (filesystem) | Yes (any editor) | Yes | High — developer controls all |
| OpenClaw Native | Yes (local Markdown) | Yes | Yes | High — plain files on disk |
| ClawVault | Yes (Markdown + YAML) | Yes | Yes | High — zero telemetry |
| AITeam v2.1 | Yes (Memory Vault UI) | Yes (inline) | Yes | High — 🤖 llm badge marks auto entries, 10-minute veto |
AITeam differentiator: The 10-minute veto window is unique among systems analyzed. No other offers a grace period to review and discard auto-extracted memories before they go “live.” ChatGPT does not — wrong memories sit there silently.
| System | Where | Format | Semantic search | Knowledge graph |
|---|---|---|---|---|
| ChatGPT | OpenAI cloud | Proprietary (internal SQL/KV) | Unknown | No |
| Claude Consumer | Anthropic cloud | Structured categories | No (consumer) | No |
| Claude API Tool | Client (developer) | Files (MD, XML, text) | No | No |
| OpenClaw Native | Local (filesystem + SQLite) | Markdown + sqlite-vec | Yes (local or API embeddings) | No |
| ClawVault | Local (filesystem + JSON) | Markdown + YAML front matter | Yes (optional) | Yes (wiki-links + RRF) |
| AITeam v2.1 | Local (filesystem + JSON) | Markdown + JSON per category | No (BM25 only) | No |
| System | Works offline? | Note |
|---|---|---|
| ChatGPT | No | Requires OpenAI cloud |
| Claude Consumer | No | Requires Anthropic cloud |
| Claude API Tool | Yes (local storage) | But Claude inference needs API |
| OpenClaw Native | Yes | Local gemma-300M for embeddings |
| ClawVault | Yes (BM25 mode) | Optional embeddings via API |
| AITeam v2.1 | Partial | Local storage, but LLM extraction needs Cursor Agent CLI |
| Dimension | ChatGPT | Claude Consumer | Claude API Tool | OpenClaw Native | ClawVault | AITeam v2.1 |
|---|---|---|---|---|---|---|
| Memory categories | 6 (opaque) | 4 | Free-form | 3 layers | 8 | 5 + global |
| Auto extraction | Yes | Yes | Yes (agent-driven) | Yes | Yes | Yes |
| Semantic retrieval | No | No | No | Yes | Yes | No (BM25) |
| Context budget | Not public | Not public | Proportional to reads | Configurable | Per profile | 2,000 tokens |
| LLM memory veto | No | No | N/A | No | No | Yes (10 min) |
| Multi-agent | No | No | No (single tenant) | No | No | Yes (vault per agent) |
| Shared global memory | No | No | No | MEMORY.md (single) |
No | Yes (_project.md) |
| User control | Low | Medium | High | High | High | High |
| Transparency | Low | Medium | High | High | High | High |
| Offline | No | No | Partial | Yes | Yes | Partial |
| Cloud dependency | Full | Full | Local storage | None | Optional | Local CLI |
| Knowledge graph | No | No | No | No | Yes | No |
| Visual UI | Yes (settings) | Yes (settings) | No (code) | No (CLI) | No (CLI) | Yes (Memory Vault) |
| Operating cost | Included in plan | Included in plan | Pay per token | Zero (local) | Zero (local) | Zero |
1. Multi-agent with isolated vaults
No other system analyzed has native multi-agent support with per-agent isolated memories. ChatGPT and Claude have one memory per user. OpenClaw and ClawVault have one memory per framework instance. AITeam lets AITEAM-X Master, Winston, Amelia, and the other 11 agents have separate vaults, with per-agent context injection — plus shared global _project.md.
2. LLM memory veto window
AITeam is the only system with an explicit pre-persistence review mechanism. The 🤖 llm badge + 10-minute veto addresses what others ignore: what if the LLM extracts a wrong memory? On ChatGPT it stays. On Claude it stays. On AITeam you have 10 minutes to discard it before the next session injects it.
3. Visual management UI
ChatGPT and Claude have settings pages. OpenClaw and ClawVault are CLI. AITeam has the Memory Vault — a full visual UI inside the dashboard with categories, search, counts, inline edit, and manual creation. Most accessible for non-technical users.
4. Deterministic injection priority
The 2,000-token budget with explicit order (handoff → tasks → decisions/lessons → projects) is documented and predictable. ChatGPT and Claude consumer users do not know exactly what is injected when limits hit.
1. Semantic retrieval (embeddings)
OpenClaw Native and ClawVault use hybrid BM25 + vectors. AITeam uses BM25 only (MiniSearch). A query for “auth problem” may not find a memory that says “login failed” — semantically identical. Local embeddings (e.g. @xenova/transformers or sqlite-vec) would improve retrieval quality.
2. Knowledge graph
ClawVault builds a wiki-link and entity graph for multi-hop retrieval (“auth-related decisions” → “decisions affecting user module”). AITeam does not. For projects with many interlinked memories, a graph would help.
3. Context profiles
ClawVault has planning, incident, handoff profiles that change injected memories by task context. AITeam could inject more architectural decisions for architecture questions, more tasks when starting a dev session, etc.
4. Finer-grained extraction
AITeam LLM extraction caps at 3 items per category. Long or complex sessions may drop relevant info. ClawVault uses observation scores to rank what persists — a richer filter.
| Strengths | Limitations | |
|---|---|---|
| ChatGPT | Transparent for end users (no setup); detailed user profile | Fully opaque; user cannot control auto-inferences; only ~40 sessions accessible; forgetting is unclear |
| Claude Consumer | Per-project scoping; incognito; visible categories | No semantic search; memory siloed per project (no global view); relatively new feature |
| Claude API Tool | Maximum dev control; self-hosted; any schema; model is its own retrieval agent | No semantic search or embeddings; relies on Claude to pick files; no UI |
| OpenClaw Native | Mature hybrid search (BM25 + vector + SQLite); offline; open source; auto pre-compaction flush | Setup complexity; ~500MB/year growth; no UI; framework-specific |
| ClawVault | Knowledge graph; context profiles; RRF reranking; powerful CLI; zero telemetry | No UI; Node 18+; compression LLM needs API key; single-user |
| AITeam v2.1 | Native multi-agent; 10-minute veto; full visual UI; deterministic budget; shared global memory | No vector embeddings; no knowledge graph; no context profiles; extraction capped at 3 items/category |
- Memory and new controls for ChatGPT — OpenAI
- What is Memory? — OpenAI Help Center
- How ChatGPT Remembers You: A Deep Dive — embracethered.com
- Memory tool — Claude API Docs
- Anthropic Brings Automatic Memory to Claude — MacRumors
- Memory — OpenClaw Official Docs
- OpenClaw Memory Architecture Guide — zenvanriel.com
- GitHub — Versatly/clawvault
- ClawVault Official Site