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.

A proposal, a decision and a hand-off

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.

October 11, 2026 Read →
When the answer isn't specified yet

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.

September 27, 2026 Read →
A project two agents can build from

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.

September 26, 2026 Read →
What your agents inherit

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.

August 21, 2026 Read →
Give your agent a memory of its own

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.

August 8, 2026 Read →
Capture a coding session from inside it

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.

August 3, 2026 Read →
See how your project was built — generate a Build Timeline from any repo

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.

August 2, 2026 Read →
Give your agent harness a memory — coordinate a fleet through shared, governed memory

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.

July 23, 2026 Read →
Keep your memory current — revise a fact, catch a contradiction, never lose the past

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.

July 20, 2026 Read →
Atlas grows a team — orchestrating sub-agents with shared memory

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.

July 13, 2026 Read →
Give your agents a shared memory — scoped per project

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.

July 11, 2026 Read →