Tutorials

Every agent you connect to ENGRAM already reads something as authoritative — retrieval is associative, so it finds what is related, which is the wrong instinct when a question has a right answer. Ground truth lets a project declare which articles are authoritative, and the agent needs to know nothing about it: it declares the project it works in, and the brief comes with it. This walks through reading what a project resolves today, the input that is silent (inheritance), the difference between being informed by a document and bound by one, and how to read the whole brief rather than only the parts that happen to rank.

An assistant using your access token remembers into your memory — and its working notes end up mixed with your decisions. Give it its own identity instead, and you get two memories that share deliberately rather than one that blurs. Along the way, the three things an agent gets wrong that a person never has to think about: whose memory it is writing to, which owner ring a memory belongs in (an agent's default is session-local, not durable), and whether the remember → recall loop actually closed.

The file-watcher only sees Claude Code CLI — and only while the transcript survives. Capture at the source instead: from inside a live session, gather the exact commit, the files you touched, and a distilled "what we built" summary and hand them to ENGRAM with the capture_session MCP tool or the /capture-session skill. Harness-neutral — works from Cowork, Claude Desktop, a Goose agent, anywhere a shell and git exist — and converges on the watcher's node, landing the exact signals the Build Timeline needs.

Install the engram-build-timeline tool, point it at any git repo, and turn its history into a living component-lifecycle timeline — every component moving scaffolded → wired → tested → deployed, with a dependency graph, release milestones, feature arcs, a build-activity heatmap, and automatic gap flags. Deterministic and zero-touch: it reads what git already knows, changes nothing in the repo, and syncs straight into ENGRAM's Coding Sessions tab.

Provision an orchestrator and three workers as real ENGRAM identities, seed their vocabulary, keep the harness's own operating facts current, then let the fleet coordinate entirely through memory — no message bus. Scout diagnoses a bug, Forge fixes it, neither ever talks to the other, and the orchestrator recalls both findings isolated per project before handing the work back to you for review. The capstone: create_sub_agent, create_project, project-scoped remember / share_memory / recall, and a human hand-off gate.

Take one fact through its whole life — taught, corrected, contradicted, reviewed, and recovered — and watch recall always return the current truth while the history stays intact. A hands-on tour of supersede-don't-delete: the revise / forget / revert verbs, automatic contradiction detection, a human review inbox for the calls the machine isn't sure about, and point-in-time recall that proves nothing is ever deleted.

Promote an agent to Agent Manager, have it spin up a team of sub-agents — each a real Claude Code process with its own identity — fan work out across projects, and recall the team's findings back per project through shared memory. The sequel to tutorial 1: from two peers sharing memory to an orchestrator that grows and runs its own team with create_sub_agent, issue_sub_agent_pat, and recall.

Stand up two agents, share one agent's project memory to the other, and watch cross-agent recall respect project boundaries. A hands-on walkthrough of the MCP verbs remember, share_memory, and recall — ending in one call that returns an agent's own memory alongside a teammate's, then isolates it the moment the project changes.