Real-world use cases

See how teams use Engram to ship better code, faster.

For Humans

For team leads & engineering managers

Where Engram realistically speeds up engineering work: agent onboarding, repeated incidents, repo conventions, and multi-tool teams.

Recovering after context compaction

A long Engram or English.cash session gets compacted. Instead of guessing from a short summary, the agent calls engram_rehydrate and gets decisions, open loops, and gotchas back.

Before Engram

The agent depends on a short summary, loses why a choice was made, and repeats investigation.

After Engram

The agent restores the working map, then verifies current code and logs before editing.

terminal

$ engram_get_context({ repo: "main-api" }) -> 200 memories loaded

Scraper and production gotchas

A production data pipeline regresses after a long break. Engram recalls the known constraint, the expected environment shape, and which live checks should be trusted.

Before Engram

The same risky debug path repeats, and the live pipeline can be disturbed.

After Engram

The agent sees the known bottleneck first, then verifies with live logs and DB counts.

terminal

$ engram_recall({ query: "auth service down" }) -> "JWT expiry in .env.production, set to 24h not 1h"

Keeping product decisions alive

English.cash changes guest practice. Engram recalls that guest mode should use the real product API and component path, not a separate toy flow.

Before Engram

Guest and paid flows drift apart, and quality tests stop meaning much.

After Engram

The agent recalls the product decision first, then runs topic/context quality gates.

terminal

$ engram_store({ type: "CONVENTION", content: "API responses use { data, error, meta } envelope" })

Reporting quality without overclaiming

In SkillBridge, a batch can pass structurally without every question being academically approved against the textbook. Engram keeps that distinction visible.

Before Engram

The agent may report structural pass as real quality approval.

After Engram

The agent states what is verified, what is risky, and what still needs audit.

terminal

$ engram_store({ type: "GOTCHA", content: "Pool exhaustion: max 20 connections, use pgbouncer" })

Learning across tools and repos

Codex fixes a mobile Safari chat bug. Cursor or OpenCode can later pull that lesson through cross-pollinate when a similar panel/keyboard issue appears.

Before Engram

Each tool rediscovers the same UX problem in its own transcript.

After Engram

One fix enters team memory; the next agent starts ahead, regardless of tool.

terminal

$ engram_recall({ query: "code conventions" }) -> 12 CONVENTION memories loaded

Context recovery

When the chat gets compacted, the work should not disappear.

Long coding sessions lose raw chat history after compaction or resume. Engram rehydrates the session journal: decisions, gotchas, open loops, and the lessons stored since the last checkpoint.

Without Engram

The agent reads a short summary, misses why a choice was made, and may repeat the same investigation.

With Engram

The agent calls engram_rehydrate, gets the working map back, then verifies current code, logs, and data before editing.

engram_rehydrate

engram_rehydrate({
  repo: "housecompass.uk",
  task: "continue listing search after compaction",
  reason: "chat was compacted",
  depth: "standard"
})
→ latest checkpoint restored
→ decisions, gotchas, open loops, and next actions loaded

How humans help

Your agent can use Engram alone. Clear context makes it much better.

Engram guides agents through MCP, but the first user message still matters. Give project, repo, role, stack, market, and task. Then the agent knows when to start, recall, cross-pollinate, store, and rehydrate after compaction.

1Name the project and repo.

2Describe the immediate task.

3Tell the agent to reuse team memory before planning.

first message

You:
Call engram_start with this project context:
  project: HouseCompass
  repo: housecompass.uk
  role: frontend product engineer
  market: UK property
  stack: Next.js, TypeScript, PostgreSQL
  task: build listing search and map UX
Before choosing an approach, recall relevant memory.
If another repo may have solved this pattern, cross-pollinate first.
If this chat was compacted, call engram_rehydrate before continuing.

For Agents

Machine-readable examples

Copy-paste patterns for AI coding agents. Each example shows the MCP tool call and expected response.

Session Bootstrapping

You just started a new session. Before writing any code, load context.

MCP tool call

engram_get_context({
  repo: "api-backend",
  task: "add payment endpoint"
})

Response

15 memories loaded (conventions: snake_case DB, gotchas: Stripe webhook idempotency...)

Pre-Decision Check

You are about to choose between REST and GraphQL. Check team memory first.

MCP tool call

engram_recall({
  query: "REST vs GraphQL decision"
})

Response

ARCHITECTURE memory found: "REST for external APIs, GraphQL for internal dashboard. Decision made 2024-06."

Bug Fix Documentation

You just spent 30 minutes debugging. Store the fix so no agent wastes time on this again.

MCP tool call

engram_store({
  type: "SOLUTION",
  content: "TypeError in Prisma 7: use PrismaPg adapter, not raw PrismaClient()",
  tags: ["prisma", "typescript"]
})

Result

Memory stored successfully. Available to all agents in this workspace.

Feedback Loop

You recalled a memory and it helped. Report it so the system learns.

MCP tool call

engram_report_outcome({
  memory_id: "mem_xyz",
  success: true,
  detail: "Migration worked perfectly"
})

engram_report_outcome({
  memory_id: "mem_abc",
  success: false,
  failure_reason: "outdated",
  detail: "This was for Prisma 5, we use 7 now"
})

Result

Memory stored successfully. Available to all agents in this workspace.

Cross-Model Collaboration

A Cursor agent stored a gotcha yesterday. You are a Claude Code agent. You benefit from it today.

MCP tool call

engram_recall({
  query: "Neon database"
})

Response

GOTCHA (stored by cursor, confidence: 0.82): "Neon drops connections at 10s. Fix: connect_timeout=30"

Used in real projects

Agents forget. Engram brings the important context back. We saw it across six real projects.

Across six long-running projects, agents used Engram to recover prior decisions and repo-specific gotchas faster. Instead of researching the same problems again, they continued from where the work had stopped.

Engram is a map, not blind authority: recall first, then verify against live code, logs, and data.

English.cash

Guest practice, auth, email, UX

★★★★★

“In long product work, Engram reduces the cost of remembering where we left off.”

Guest-practice and product-flow decisions survived across new sessions instead of being rediscovered.

Preserved product decisions around guest practice using real APIs/components.
Helped treat topic normalization bugs as system rules, not isolated symptoms.
Kept deployment, email tracking, localization, and security gotchas visible.

Evimibul

Production data, schema, live checks

★★★★★

“Use Engram as the starting map, then verify live screens, DB counts, and logs.”

The agent checked live data from the right place instead of retrying a path already known to be risky.

Recovered the known production data constraint before the agent retried a risky path.
Recovered expected environment shape and the known data-quality bottleneck.
Kept schema gotchas like bathroomCount and imageUrls available after compaction.

AkilConnect

Scoring, matching, data model

★★★★★

“It answers why we chose a path without digging through commits first.”

Engram surfaced the earlier architecture decision before a scoring-order regression spread further.

Recalled the Best Match architecture before scoring changes.
Exposed when a V3 scorer was being weakened by an older use-case layer.
Warned about backend field assumptions before risky state/city changes.

SkillBridge

Quality audits, coverage, deploy risk

★★★★★

“Engram helps the agent remember what is verified, what is risky, and what should not be overclaimed.”

Engram preserved the distinction between passing structural checks and proving real content quality.

Separated structural completion from real academic quality approval.
Recovered batch coverage, audit state, and what still needed direct textbook review.
Remembered Vercel scope, root directory, and account gotchas before deploy.

RateEat

Imports, search, data health

★★★★★

“The value is remembering the few things that prevent repeated mistakes.”

Known import and search bottlenecks were available before the agent repeated the same investigation.

Kept Ankara import, global search limits, currency normalization, and hang-prone query gotchas alive.
Helped recover context after branch, deploy, and data-import resets.
Acted as a pre-change brake for search, data, deploy, and localization work.

Afrochat

Chat, ports, regression tests, deploy

★★★★★

“It does not replace thinking. It keeps old regressions from becoming new work.”

Previously solved chat and port regressions did not become fresh investigation work in later sessions.

Remembered local port conventions and separated real failures from server setup misses.
Recovered the catalog chat pending-question fallback after context loss.
Reinforced the static, backend, Playwright, and prod smoke test sequence.

The pattern is consistent

Long-running projects do not mainly lose facts. They lose decisions, gotchas, deploy rules, audit state, and why something was done. That is the memory layer Engram is building.