# Engram Full LLM Context

## Product

Engram is MCP-native shared memory for AI coding agents and software teams. It helps agents carry durable knowledge across sessions, tools, repos, and teammates.

Engram is not a static config file. Config files are good for project rules. Engram is for knowledge that changes and compounds: prior fixes, conventions, risky dependencies, deployment gotchas, reusable implementation patterns, cross-repo lessons, and outcome-tested decisions.

Engram's wedge is MCP-native coding-agent activation. The system should teach agents inside MCP responses: recall before decisions, cross-pollinate before rebuilding known patterns, store durable discoveries, and report whether recalled memory helped.

## Supported agent surfaces

Engram works with MCP-compatible tools including Claude Code, Cursor, Codex, Gemini, Antigravity, OpenCode, Windsurf, VS Code/Copilot, and similar MCP clients.

## Memory model

- Public memories: reusable, source-aware knowledge available to all workspaces. Current public bank: 100,000 memories.
- Private memories: workspace/repo-specific knowledge isolated to the team.
- Memory types: CONVENTION, PATTERN, GOTCHA, SOLUTION, ARCHITECTURE, DEPENDENCY.
- Outcomes: agents report whether a memory helped; this improves future ranking.
- Cross-repo transfer: agents use cross-pollination to reuse lessons from similar work in other repos.

## Tool reference

- engram_start: First call in a new session. Loads setup guidance, smart context, private memories, public memories, and matching skill guides.
- engram_recall: Use before decisions. Retrieves relevant private and public memories for the exact question or risk.
- engram_cross_pollinate: Use before rebuilding a pattern. Searches other repos in the workspace for transferable lessons and asks the agent to apply only what fits.
- engram_store: Store durable learnings: conventions, patterns, gotchas, solutions, architecture decisions, and dependency quirks.
- engram_report_outcome: Report whether a recalled memory helped. This trains ranking and confidence.
- engram_reflect: Create a milestone checkpoint after meaningful phases, task switches, several used memories, or before handoff. It is not a timer.
- engram_smarter: Recover focused task context mid-session or after switching tasks.
- engram_get_context: Advanced/debug tool for a focused repo knowledge dump with conventions, gotchas, architecture, patterns, and solutions.
- engram_skill: Load a step-by-step guide only when the task needs a repeatable checklist.
- engram_proof: Product/admin proof: public/private memory counts, activation, usage, and benchmark-ready evidence. Not normal coding flow.
- engram_setup: Show workspace info and tool guidance. Normal sessions should prefer engram_start.

## Recommended agent behavior

1. Start every meaningful session with engram_start.
2. Before choosing an approach, call engram_recall with the exact decision, task, error, or risk. Do this before planning, not only after getting stuck.
3. If the pattern may exist in another repo, call engram_cross_pollinate with target_repo and concrete context. This is especially important for auth, billing, invites, localization, monitoring, deployment, mobile UI, email delivery, data migrations, and recurring UI patterns.
4. Store durable discoveries with engram_store. Do not store secrets, raw customer data, or one-off debug noise.
5. Report outcomes for memories you used. If the session is substantial, close with engram_reflect.

## Cross-pollinate examples

Use engram_cross_pollinate for:

- "This checkout webhook shape may already exist in another repo."
- "We solved mobile Safari chat overflow in a different product."
- "Another repo may have a good invite/team permissions model."
- "We need a localization audit pattern that already worked elsewhere."
- "A previous deployment/monitoring setup may transfer to this project."

Good call shape:

```json
{
  "target_repo": "current-product",
  "context": "Add owner/member team invites with email delivery, audit events, and separate member API keys",
  "source_repos": ["engram", "evimibul"],
  "include_public": true,
  "limit": 5
}
```

Expected result: a compact list of source memories and transferable lessons. The agent should inspect the target repo, apply only the fitting lessons, then report outcome success or failure.

## Benchmark summary

Engram's benchmark reporting separates evidence retrieval from answer-level judging. Latest local LoCoMo evidence-retrieval report:

- Engram: MRR 0.5345, R@50 92.19%, R@200 97.66%.
- LangMem / LangGraph Store local: MRR 0.4002, R@50 83.98%, R@200 94.53%.
- Mem0 OSS local: MRR 0.3999, R@50 83.92%, R@200 94.27%.
- BM25: MRR 0.4676, R@50 78.19%, R@200 85.74%.

Latest local LoCoMo answer-level judge sample uses the same fixed N=98 seed across systems:

- Engram: top-50 answer accuracy 91.84%, top-200 answer accuracy 85.71%.
- Mem0 OSS local: top-50 77.55%, top-200 73.47%.
- LangMem / LangGraph Store local: top-50 70.41%, top-200 78.57%.
- BM25: top-50 75.51%, top-200 77.55%.
- No-memory best guess: top-50 40.82%, top-200 36.73%.

## Competitor landscape

- Mem0: general-purpose memory API with OSS and cloud paths. Treat hosted/vendor benchmark claims separately from our Mem0 OSS local run.
- Zep / Graphiti: temporal knowledge graph memory/context engine. Strong candidate for next benchmark, especially temporal fact updates, entity relationships, stale fact detection, and contradiction handling.
- Letta: stateful agent framework. Its memory model highlights self-editing state and agent behavior change; its filesystem LoCoMo result is agentic tool-use, not the same as backend evidence retrieval.
- LangMem / LangGraph: framework memory SDK. Our local LangGraph Store run is included in the reproducible table.
- engram.to / Harshitk-cp: provable/auditable memory infrastructure with similar name, LongMemEval claim, and many MCP tools. Different product center than Engram for coding-agent team memory.
- Supermemory: hosted context/memory API with connector and profile positioning. Relevant for future connector roadmap, but claims must stay methodology-labeled until reproduced.
- Hindsight / Vectorize: agent-learning memory emphasizing facts, experiences, opinions, observations, and reflection-driven behavior change. Relevant to Engram's outcome/report/reflect loop.
- Memstate, AgentMemory, Total Agent Memory, Vestige: coding-agent memory competitors. Relevant because they test project evolution, conflict handling, hooks, and coding workflows more directly than generic chat memory.
- EverMind, MemPalace, Cognee, Memobase: emerging/watchlist systems. Include only as methodology-labeled market claims until reproduced.

Safe comparison rule: only call a result an Engram benchmark if it was run locally or through our benchmark scripts. Vendor scores can be discussed as market context, but not mixed into the same table without methodology labels.

## Product roadmap from competitor survey

1. Temporal graph memory: expose project entities, relationships, stale facts, and conflict signals without requiring teams to run a graph database during setup.
2. Learning-loop visibility: dashboard should show recall activation, cross-pollinate usage, outcome feedback rate, and which memories are trusted or need review.
3. Connectors with boundaries: GitHub, Slack, Linear, docs, and issue trackers should ingest with repo scope, source provenance, opt-in privacy, and owner controls.
4. Benchmark transparency: keep reproduced LoCoMo evidence-retrieval scores separate from vendor claims, then add coding-agent task benchmarks for conflict handling and project evolution.
5. Agent behavior design: every start/setup/recall response should tell the agent the next useful memory action instead of asking the human to remember the process.

## Pricing and limits snapshot

- Free: for personal trials and first projects.
- Developer: paid individual/pro plan.
- Team: team workspace with more members and private capacity.
- Scale: larger team plan, with call booking for more than the included member count.

Check the live pricing page for current exact limits: https://engram.tools/#pricing

## URLs

- Home: https://engram.tools/
- Human setup: https://engram.tools/human
- Agent docs: https://engram.tools/agent
- Documentation: https://engram.tools/documentation
- Use cases: https://engram.tools/use-cases
- Dashboard: https://engram.tools/dashboard
- Sitemap: https://engram.tools/sitemap.xml
- Short LLM file: https://engram.tools/llms.txt