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) | BMAD agent dashboard | Local, proprietary |
ChatGPT stores 6 opaque categories, pre-assembled and injected into every conversation:
- Bio Tool (saved memories) — facts explicitly requested by the user
- Response preferences — ~15 entries automatically inferred about communication style
- Past conversation topics — ~8 summaries from the user's first interactions
- User insights — ~14 biographical and professional data points automatically extracted
- Recent history — ~40 recent conversations with timestamp and only the user's messages (without model responses)
- Interaction metadata — device, local time, usage frequency, quality scores, intent tags
The user can only see and edit category 1 (Bio Tool). The rest are managed opaquely by OpenAI.
Claude stores memories organized into 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 by Project — there is no global memory across different projects.
Completely free-form storage — the developer defines the schema. The official documentation suggests avoiding verbatim history and favors:
- User/client facts and preferences
- Historical decisions made
- Project state and progress
- Recurring workflow context
Format: Markdown, XML, or plain text files in a /memories directory. The model writes and reads these files autonomously via tool calls.
Three layers of storage in local Markdown:
- Daily notes (
memory/YYYY-MM-DD.md) — append-only log of the day's activities and decisions - Long-term memory (
MEMORY.md) — curated file with distilled knowledge: preferences, important facts, ongoing projects, lessons learned - Session transcripts (
sessions/YYYY-MM-DD-<slug>.md) — complete conversations with descriptive slug generated by LLM
Typed memories routed to 8 structured categories in Markdown with YAML frontmatter:
| Category | What it stores |
|---|---|
decisions/ |
Strategic choices with rationale |
lessons/ |
Learnings from outcomes |
people/ |
Contact data and relationships |
tasks/ |
Goals and action items |
projects/ |
Initiative tracking |
inbox/ |
Captures pending triage |
preferences/ |
User preferences |
progress/ |
Milestones achieved |
Structured memories in 5 categories per agent, plus global context:
| Category | What it stores |
|---|---|
decisions |
Technical or project choices with context |
lessons |
Bugs resolved, insights, learnings |
handoffs |
Last session summary + next step |
tasks |
Open items in checklist format [ ] |
projects |
Agent's general context |
_project.md |
Global context shared across all agents |
| System | Automatic | Manual | Extraction method |
|---|---|---|---|
| ChatGPT | Yes (async, outside the conversation) | Yes ("remember X") | Proprietary inference by OpenAI; details unpublished |
| Claude Consumer | Yes (LLM synthesis when toggle is activated) | Yes ("remember X") | Claude synthesizes categories from history |
| Claude API Tool | Yes (Claude itself decides what to write) | Yes (instructions in system prompt) | 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 rule-based extracts observations with score |
| AITeam v2.1 | Yes (on chat window 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 memories asynchronously and invisibly — the user doesn't know exactly when and 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 biggest architectural difference between the systems:
| System | Retrieval strategy | Semantic search? | Keyword search? |
|---|---|---|---|
| ChatGPT | Full injection — all 6 categories pre-assembled in every conversation. No real-time search. | No | No (everything is injected) |
| Claude Consumer | File reading + toggle "reference conversation history". Not vector RAG. | No (consumer) | No |
| Claude API Tool | Agent selects files — Claude lists /memories, reasons about names, and reads the relevant ones. No embeddings. |
No | No (reasoning-based) |
| OpenClaw Native | Hybrid BM25 + Vector — SQLite with sqlite-vec and FTS5. Local embeddings (gemma-300M) or via API. Fusion with configurable weights (70% vector + 30% BM25). |
Yes | Yes |
| ClawVault | Hybrid BM25 + Vector + Knowledge Graph — RRF (Reciprocal Rank Fusion) reranking + wiki-link graph traversal for multi-hop retrieval. | Yes (optional) | Yes |
| AITeam v2.1 | BM25 via MiniSearch — text relevance search within the selected agent's vault. No embeddings. | No (BM25 only) | Yes |
Note on AITeam: The current system uses pure BM25 (no vector embeddings). This is faster and has no external dependencies, but misses semantic matches that embeddings capture. OpenClaw and ClawVault have more sophisticated retrieval with optional semantic search support.
How and when memories are delivered to the model:
| System | Mechanism | Budget / Limit |
|---|---|---|
| ChatGPT | Pre-assembled Model Set Context block in the system prompt. Injected whole in every conversation. |
Unpublished. ~40 recent conversations. |
| Claude Consumer | Project Context + conversation history injected at start. | Unpublished. |
| Claude API Tool | view tool calls read files on demand. Content enters the context window as tool result. |
Proportional to the number of files read. |
| OpenClaw Native | Daily notes loaded automatically + memory_search / memory_get MCP tools. |
Configurable. |
| ClawVault | clawvault inject "query" — CLI returns relevant excerpts to inject before the model call. |
Configurable by profile (default, planning, incident, handoff). |
| AITeam v2.1 | injectContext() in lib/memory/inject.ts called automatically in /api/agents/command before spawning the CLI. |
2,000 tokens with 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 itself decides what to read, at the cost of extra tool calls per session.
- AITeam has an explicit budget with deterministic priority order. More predictable than ChatGPT and cheaper than Claude API Tool.
- ClawVault has context profiles (planning, incident, handoff) that change the set of injected memories based on the task — a concept absent in other systems.
| System | User can see? | User can edit? | User can delete? | Transparency |
|---|---|---|---|---|
| ChatGPT | Bio Tool only | Bio Tool only | Bio Tool only | Low — auto-inferred categories are completely opaque |
| Claude Consumer | Yes (curated categories) | Partially | Yes (per Project) | Medium — categories visible, but synthesis is automatic |
| Claude API Tool | Yes (files on filesystem) | Yes (any editor) | Yes | High — developer controls everything |
| 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 identifies automatic entries, 10-min veto |
AITeam differentiator: The 10-minute veto window is unique among the analyzed systems. No other system offers a grace period where the user can review and discard automatically extracted memories before they go into production. ChatGPT doesn't have this — an incorrect memory stays there silently.
| System | Where it lives | 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 frontmatter | Yes (optional) | Yes (wiki-links + RRF) |
| AITeam v2.1 | Local (filesystem + JSON) | Markdown + JSON per category | No (pure BM25) | 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 requires API |
| OpenClaw Native | Yes | Local gemma-300M model for embeddings |
| ClawVault | Yes (BM25 mode) | Embeddings optional via API |
| AITeam v2.1 | Partial | Local storage, but LLM extraction requires 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 |
| Automatic extraction | Yes | Yes | Yes (agent-driven) | Yes | Yes | Yes |
| Semantic retrieval | No | No | No | Yes | Yes | No (BM25) |
| Context budget | Unpublished | Unpublished | 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 | Total | Total | 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 vault per agent
No other analyzed system has native support for multiple agents with isolated memories per agent. ChatGPT and Claude have one memory per user. OpenClaw and ClawVault have one memory per framework instance. AITeam allows BMad Master, Winston, Amelia, and the other 11 agents to have completely separate vaults, with context injection specific to each one — plus the shared global _project.md memory.
2. LLM memory veto window AITeam is the only system with an explicit pre-persistence review mechanism. The 🤖 llm badge + 10-minute veto solves the problem that all other systems ignore: what happens when the LLM extracts an incorrect memory? In ChatGPT, the wrong memory stays. In Claude, it stays. In AITeam, you have 10 minutes to discard it before it's injected in the next session.
3. Visual management UI ChatGPT and Claude have settings pages. OpenClaw and ClawVault have CLI. AITeam has the Memory Vault — a complete visual interface accessible within the dashboard itself, with categories, search, entry counts, inline editing, and manual creation. It's the most accessible system for non-technical users.
4. Deterministic injection priority The 2,000 token budget with explicit priority order (handoff → tasks → decisions/lessons → projects) is documented and predictable. In ChatGPT and Claude consumer, the user doesn't know exactly what will be injected when the limit is reached.
1. Semantic retrieval (embeddings)
OpenClaw Native and ClawVault have hybrid BM25 + vector embedding search. AITeam uses only BM25 (MiniSearch). This means a search for "authentication problem" won't find a memory that uses the term "login failed" — even though they're semantically identical. Adding local embeddings (e.g., @xenova/transformers or integrating with sqlite-vec) would significantly increase retrieval quality.
2. Knowledge graph ClawVault builds a wiki-link and entity graph that enables multi-hop retrieval ("decisions related to authentication" → "decisions that affect the users module" → etc.). AITeam doesn't have this. For projects with many interconnected memories, a knowledge graph would be valuable.
3. Context profiles
ClawVault has planning, incident, handoff profiles that change the set of injected memories based on the task context. AITeam could have something similar — inject more architectural decisions when the user asks an architecture question, more tasks when starting a development session.
4. More granular extraction AITeam's LLM extraction has a limit of 3 items per category. For long or complex sessions, this can discard relevant information. ClawVault uses observation scores to rank and select what persists — a more sophisticated filtering mechanism.
| Strengths | Limitations | |
|---|---|---|
| ChatGPT | Transparent to the end user (no configuration needed); detailed user profile | Completely opaque; user doesn't control auto-inferences; only ~40 accessible sessions; doesn't know what will be forgotten |
| Claude Consumer | Project scoping is elegant; incognito mode; visible categories | No semantic search; memory siloed by project (no global view); relatively new feature |
| Claude API Tool | Maximum control for devs; self-hosted; any schema; the model is its own retrieval agent | No semantic search or embeddings; depends on Claude's reasoning to select files; no UI |
| OpenClaw Native | Mature hybrid search (BM25 + vector + SQLite); offline; open-source; auto-flush pre-compaction | Setup complexity; ~500MB/year growth; no UI; framework-specific |
| ClawVault | Knowledge graph; context profiles; RRF reranking; powerful CLI; zero telemetry | No UI; requires Node 18+; LLM compression requires API key; single-user |
| AITeam v2.1 | Native multi-agent; 10-min veto; complete visual UI; deterministic budget; shared global memory | No vector embeddings; no knowledge graph; no context profiles; extraction limited to 3 items/category |
The standalone npm library extracted from the AITeam memory design is a local, file-first system: Markdown vault per agent, BM25 (MiniSearch), buildContext / buildTextBlock for injection, checkpoints, compaction, and Cursor transcript automation (watch, process, heuristic extraction — no LLM required for that path).
| Topic | Behaviour |
|---|---|
| Automatic capture from Cursor | Optional fs.watch on ~/.cursor/projects/<slug>/agent-transcripts/*.jsonl; npm install can merge a VS Code folder-open task so watch --wait-for-transcripts runs without a manual terminal; process is CLI-only for one-shot catch-up. |
| Injection into the model | Not started by those tasks; the Cursor rule asks the agent to run inject preview (or the host app calls buildContext). |
| Veto window | Unlike the AITeam dashboard’s 10-minute 🤖 llm flow described above, heuristic transcript entries go straight to the vault — review/edit in the viewer or Markdown. |
| UI | Optional agent-memory viewer CLI (built-in HTTP UI), not the full AITeam Memory Vault. |
This section was added 2026-04-07 to sit alongside the earlier product comparison dated 2026-03-17.
- 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