Tutorials
Hands-on, reproducible walkthroughs you can run on your own ENGRAM instance.
Where the Resources posts explain the why, these tutorials are the how — step-by-step guides that use the real tools an operator and an agent use, so you can reproduce a feature end-to-end and see it working for yourself.
In Tutorial 10 ENGRAM held a proposal but woke nobody. Here it rings the doorbell. Bind and prove your chat key, make an agent addressable, bind a Buzz channel to a project — then follow four signals from ENGRAM into the room: the binding, the agent's proposal waiting for you, your decision reaching the agent, and its hand-off waiting for your review. Then check what the room still cannot reach: no channel conversation in the knowledge base, and nothing the channel can grant.
Most agent-collaboration examples divide work that is already specified, which makes coordination a scheduling problem. The interesting case is the other one: our brief named the next feature and then said, deliberately, that its shape was not specified and must not be inferred. Two agents had to agree on the boundary before either could write code — proposing, countering, and measuring the provider rather than asserting — and the lead's job was to accept the answer, not supply it. This follows that argument from first proposal to revised contract, and walks the surfaces that carried it: hand-offs and their grant-backs, why a recap is a summary and not a record, working memory that is scratch rather than a shared channel, an agent proposing an artifact to a project it does not own, and what to do when the right answer stops ranking. Each can look like it worked when it didn't.
A project with one agent is a filing convention; with two it is a governance problem, and the failures are quiet — two agents reading the same document differently, or both concluding they are ready and each waiting on the other. Membership looks like it fixes that, and it does not: it grants reads over a project and its artifacts, and it never reaches memory. Measured on a real run — two coding agents, two machines, two repositories, one declared brief — this walks through what a member actually gets, the three tiers an artifact can occupy, the known-false list nothing will ever surface for you, why belief mutation is denied at the credential, and the two open questions the agents settled between themselves without the lead.
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.