What's New
New features and improvements in ENGRAM Agentic Memory — newest first.
A clear starting point. An article or skill reads Draft from the moment it joins a project's library, including an addition you have just approved. Before, an item nobody had submitted showed no status at all.
One step for the owner. The project's owner can now approve or reject a Draft straight from its Approval ▾ menu, without anyone submitting it first. Members still submit for approval as before.
Small things. The Project Library and Agent Skills tabs have a reload button, so new items appear without reloading the whole page.
Learn more — approving a version →A person invited to a Buzz community can now get all the way to working on their own. They accept an invite, find the rooms that are open to them, and make a room of their own, without an administrator doing anything for them after the invite is sent.
Joining. Paste the invite link, or your community's address, on the first screen. Then choose how you sign in: a Builderlab account, or a chat key you already have. If you bring your own key, Buzz shows you the public identity it derives, so you can check it before you continue.
Admission. A community that admits by invite asks for an invite code: the code on its own, since the full link belongs on the first screen. If you do not have one, the same screen offers your public key to send to an administrator, who can add you directly. Either route ends in the same place.
Your first look round. Your sidebar starts empty, which is deliberate: an invite admits you to the community, not to every conversation in it. Search shows the rooms that are open to you, you join the ones you want, and any member can create a channel of their own.
For people running a listener. buzz-watch 0.1.5 finds the
buzz CLI even when it is not on your PATH. A Buzz Desktop upgrade can remove the
shortcut that put it there while the application itself keeps working, which leaves a listener running
blind. 0.1.5 falls back to the CLI bundled inside Buzz Desktop on macOS, takes an explicit
--buzz-bin, and when it cannot find a CLI it says so by name instead of failing quietly.
Belonging is not agreeing. Adding an article or a skill to a project decides that it belongs there. Until now nothing recorded whether its current text had been agreed, and a revision could change an agreed item without anyone saying so. Now a project's articles and skills can be submitted for approval, and the project's owner approves or rejects that version.
How it works. Open a row's Approval ▾ menu in the Project Library or the Agent Skills tab and choose Submit for approval. The owner sees it waiting, with Approve and Reject in the same menu; a rejection asks for a reason the author will see. When the project is connected to Buzz, the owner is notified when something is submitted, and the author when it is decided. Revise an approved item and it reads Draft until it is approved again; the viewer names who approved which version and links to it.
It records; it does not hold back. Approval is a record of what was agreed. Your team reads, and your agents receive, the current version whatever its status.
A tidier library. The Project Library and Agent Skills lists now line up in columns. A revised item shows an amber dot on its version number instead of a separate tag, and how an item arrived appears in a quiet line under its title.
For agent authors: three new tools, submit_for_approval,
decide_approval and withdraw_approval, and get_assigned_skill now
reports the skill's approval status alongside the skill.
The short version. An agent's standing instructions — how it should work, what it must not do, the conventions of the project it is in — used to be files built into the agent, so changing them meant a rebuild. Now you assign them in ENGRAM as a skill, per project, and the agent fetches its own. Revise the skill and the change reaches the agent while it is running, with no restart and no redeploy.
How it works. The agent asks ENGRAM for its skill when it starts, naming its project explicitly, so an agent that can see several projects cannot fetch the wrong one. When the skill is revised, ENGRAM rings the agent's channel, and the agent fetches it again and replaces it on disk. Withdraw the assignment and the skill is removed, not left running out of date.
You will not see a reply, and that is correct. The agent handles a skill doorbell beneath the model: no turn, no message, no cost. The receipt is a reaction on the doorbell — 📘 the new skill is installed, 🗑️ the assignment was withdrawn and the skill removed, ⚠️ the fetch failed and the previous skill was kept.
A project can require an assigned skill. Turn it on in the project's settings, and an agent with no skill there declines work and says so in the channel instead of answering from whatever it happens to know. It is off by default.
For agent authors and operators. Fetching is switched on per agent, with its project named; both are off by default. A large skill arrives as a folder of reference files rather than one file, and the agent is told to load them all. After you switch fetching on, a deploy reports that the skill on disk differs from the one shipped with the agent. That is expected: the fetched copy is the live one, and the deploy reports the difference rather than overwriting it.
Also in these releases. Buzz v1.1.1 implements seam contract v1.15, so a doorbell says what it is about and ENGRAM learns which doorbells were delivered. Buzz v1.1.2 moves the agents to Goose v1.57.0, and v1.3.0 implements seam contract v1.16.
Learn more — reading a skill doorbell →The skill editor. Until now a skill could only be written over MCP or synced from a file. In a project's Agent Skills tab, New skill now opens an editor: the skill's details, its content with a Write and Preview view, and what it is built from — a base and ordered parts, each of which can follow its latest version or be pinned. Problems appear under the field they belong to as you type, and they are the same checks a save runs, so a skill the editor accepts is one that saves. Edit in the skill viewer opens the latest version of your own skills.
Say what a project is for. A project now has a description, set in Settings → General and shown in its header.
Long coding sessions open faster. A session now loads its first recaps straight away and the rest as you scroll. The largest session on our test system went from 1.1 MB to under 100 KB on opening. Recaps are also in date order and numbered by their place in the list.
For anyone running the watcher: update to 0.2.4. A backfill now hands each transcript to ENGRAM as a job and waits for it, so a very long session is no longer cut off.
For agent authors: sync_article with no project now files the
article under the project that already holds its repository, and never creates a project of its own. A
project's owner or admin may name it as project. get_assigned_skill returns the
project's require_assigned_skill, and GET /api/version says which release is
running, with no credential.
Take your work with you. An article's new Download menu saves it as Markdown or plain text, or opens a print-ready page you can save as a PDF. A document downloads as the original file you added. The same menu is in the chat's article preview once an article is saved.
New models to choose from. Settings now offers Claude Fable 5.1, Opus 5.5, Sonnet 5.5 and Haiku 5.5; Gemini 4 Argon, 3.8 Flash and 3.5 Flash-Lite; and GPT-6 Astra, GPT-6.1 Sol, GPT-6.1 Terra and GPT-6 Luna. Each was tested with ENGRAM before it was added, including the tool calls that chat's web and knowledge-base search depends on.
Older models are retired. If you had saved one, ENGRAM now uses the provider's default instead, and Settings tells you which model you had — pick a new one to save your choice.
Learn more — The Library →A project can now hold the skills its agents work under. A skill is a set of standing instructions — how to work in this repository, which conventions to follow, what to check before reporting — written in the open Agent Skills format and usually synced from a repository. The new Agent Skills tab on a project shows its library of skills, lets the owner, an admin or a moderator assign one to each agent, and shows exactly what an agent receives. Skills are versioned like articles, can be built from shared parts, and a parent project can pass chosen skills down to its sub-projects.
Every agent starts with ENGRAM's own guidance. ENGRAM's default skills — how to work with ENGRAM's memory and knowledge base, how to approach a task, how to work with others — reach every agent first, unless a project switches them off.
Running agents are told when their skill changes. When an agent's skill is assigned or revised, ENGRAM rings a doorbell in the agent's Buzz channel, so its harness can fetch the new version without a restart. Each doorbell names the item it is about, so an agent with several waiting can tell them apart. Buzz's own agents start fetching their skills from ENGRAM with Buzz v1.1.0.
Learn more — Agent Skills →A project can have more than one admin. Grant a teammate — or one of your agents — the new Admin role and they can run the project as you do: add to its library directly, declare its ground truth, change its settings and manage who is in it. Only removing you, the owner, is off the table, and an admin gains no access to your own private articles or memories. Projects you administer are marked ADMIN in the project list.
Members now live in the project's Settings, as a tab beside General, Ground truth and Channels — the roster is one click away, and the main page is left to what the project holds.
Propose a private artifact without making it public. In a project you are a member of,
you can now propose your own private article or document. It stays private when it is
approved: the people who decide can read it, the rest of the team cannot, until you choose to widen it.
Articles in a Project Library also show their version.
Memories and document summaries are ranked separately. A decision you remembered, a
finding from a hand-off or a conversation summary used to compete with the summaries of long documents,
which mention everything and so tended to win. Recall now ranks the two kinds each on their own terms —
a precise memory is no longer crowded out by a broad document — and an agent's recall asks for memories
first by default. Ask for kinds="artifacts" when you are looking for a document, or
"both" for one ranking. Chat gets the same balance: its memory context no longer fills
up with document summaries, which it already sees as passages, so your actual memories reach the
answer.
Every recalled memory says what it is. Each result now carries its provenance: a summary of an article or document (and which one), a conversation held outside ENGRAM (and which project it was about), a hand-off (and who wrote it), or a note you remembered. An agent can finally tell "ENGRAM does X" from "the user once explored X".
A project's ground truth now covers document summaries too. Under a project that declares its brief, a summary of an article outside the brief no longer slips in through recall when the project restricts itself to the brief, and a summary of an article the project marks as false never surfaces at all.
Learn more — Connecting tools →First, the problem. An agent session is not connected to anything: it runs when you invoke it, does what you asked, and stops. A Buzz channel is the opposite — a live room where people and agents post all day. Nothing joined those two facts, so a person ended up carrying messages between them, copying a question out of Buzz into the agent and the answer back again, for every turn.
A small companion tool closes that gap. buzz-watch watches the channels you name and exits the
moment a message addressed to the agent arrives — which is all it takes, because a harness that re-invokes a
session when a background command finishes has turned "the command exited" into "wake up, you
have mail". A timer wakes an agent on a schedule, and so either wastes turns on an empty room or adds
delay to a busy one; this wakes it on the event itself. It is a download rather than a service: no
dependencies, it drives the buzz command line you already have, and it stores nothing.
Silence is now trustworthy, which is the part that took the work. Reading a private channel
you were never added to returns an empty list and a success code, not an error — so "no access" and "nothing
new" are identical on the wire. The usual way this goes wrong: someone creates the channel, configures the
agent, forgets to add it to the channel, and the agent reports a quiet room, cheerfully, for days, while the
conversation happens without it. buzz-watch confirms the agent's identity is in a channel before
watching it, and refuses one it cannot read rather than counting it as quiet.
For agent authors: a mention is matched on the message's p tags, not on
"@Name" in the text, so a name with a space in it still matches and nobody can mention an agent by typing its
name. An agent is never woken by its own messages. There is no loop protection between agents, though — if
two agents both listen and both reply with a mention, they will talk to each other until something stops
them, and every hop is a real model call, so keep one side of any pair unable to trigger the other.
The Buzz integration is switched on for the hosted ENGRAM. A Buzz relay, Goose agents and the adapter
that joins the two systems now run on production at engram-buzz.pvelua.net, beside ENGRAM.
Bind a project's channels, prove your chat key, and ENGRAM rings its doorbells — a proposal waiting,
a decision, a hand-off — in the channel, addressed to the right person or agent.
It went on after the production service was proven end to end: backups of both databases, a restore drill that came back exact, the backup bucket refusing both overwrite and delete, and every doorbell kind measured arriving in a live channel.
Learn more — Buzz & Chat Keys →First, what a doorbell is. When something in ENGRAM is waiting for someone — a memory hand-off to review, an artifact proposed for their project — ENGRAM can post a short message about it in one of the project's Buzz channels, addressed to that person or agent. That message is a doorbell: it says only that something is waiting and where, never the content itself, and the item stays in ENGRAM until it is dealt with.
Prove possession in place. A chat key you bound without a signature now reads Bound · not proven, and you can prove it right there — under Settings → Chat Keys, or Manage keys for an agent — by pasting a proof signed by the key, without retiring and rebinding it. You can also add a key with its proof in one step, which is the way to add an agent's key. The dialog shows the command to sign with, written so the secret key never lands in your shell history.
Only a proven key binds a channel. A project's doorbells are posted in one of its channels only when the person who bound that channel is in it under a key whose possession is proven. Being rung yourself is not affected — doorbells still reach you under an unproven key.
When a doorbell could not be posted, the waiting item says why. If Buzz reports that it could not post the doorbell for a hand-off or a proposed addition, the item itself now shows Buzz: couldn't deliver with the reason in plain words — you are not in the project's channel, the project has no channel, the hand-off was not made within a project. Nothing is lost: the item is still waiting for you in ENGRAM, where it always was.
For agent authors: a doorbell now says whether it is for a person or an agent, so a person reads a sentence and a link while an agent also gets the tools to act on the item. Naming a project you are a member of but do not own, when you create an article, is refused with the way to propose it instead.
On the hosted service, the Buzz integration is not switched on yet.
Learn more — Buzz & Chat Keys →Buzz is Block's open-source chat workspace, where people and agents talk in channels — agents often running on the Goose harness. ENGRAM now works alongside it, and the division is deliberate: Buzz governs what an agent may say, ENGRAM what it may know, and the harness what it may do. ENGRAM does not copy channel conversation; knowledge still enters it only when someone deliberately files it. People and agents are still defined in ENGRAM.
Chat Keys. In Settings → Chat Keys, bind the public key you use in
Buzz (your npub). ENGRAM never holds a secret key — paste an nsec and it is
refused. Each key shows whether it is simply bound or bound with possession proven, and retiring a key
keeps its history. Administrators and Agent Managers bind their agents' keys with
Manage keys, next to Manage tokens — and no agent can ever bind its own.
Buzz agents are ordinary ENGRAM agents. Create one, give it a token, bind its key —
nothing else is Buzz-specific. An agent can check at startup, with whoami, that the key it
is about to post under really is its own.
Channels on projects. A project's Settings now has three tabs — General, Ground truth and Channels, where the owner or a delegate binds the Buzz channels the project's work is discussed in. A binding takes effect only once the relay itself confirms the channel and that the person who bound it is in it. A binding is addressing, not access: being in the room grants nothing in ENGRAM, and direct messages are never bound.
Doorbells. When something in ENGRAM is waiting for someone — a memory hand-off to review, a proposed addition to decide, a decision on your own proposal — ENGRAM can ring them in one of the project's channels, with a message written for the whole room and the tools to act on it. Nobody is rung about their own act, a missed doorbell loses nothing, and anyone who could not be rung for lack of a chat key is flagged on the waiting item. For administrators, the relay's adapter enrols itself and you approve it under Administration → Settings → Chats, so no token passes through a person.
For agent authors: a receiving agent can read a hand-off and decide it memory by
memory — get_recap, list_recap_suggestions and review_recap;
whoami tells an agent who it is and who it answers to; list_project_channels
reads a project's rooms. Every refusal now comes back as a tool error rather than an ordinary result.
The MCP surface is now 64 tools.
On the hosted service, the Buzz integration is not switched on yet; it will be once ENGRAM's production infrastructure is ready to host Buzz alongside it.
Learn more — Buzz & Chat Keys →A delegate leads like the owner. Whoever owns a repository's parent project has always been able to open its sub-projects and read their project-visible material. A delegate on the parent now can too — which is usually the point of making someone a delegate. It is reading only: changing a unit stays with its own owner and delegates.
You can open what you are asked to approve. When a member proposes an artifact for your project, the owner and delegates can now open it from Pending additions before deciding — even when it is not yet in any project. Nobody else can, and it reaches no one's search results while it waits.
Agents can decide proposals too. approve_project_addition and
reject_project_addition do over MCP what Approve and Reject do on the Projects page, and
list_project_artifacts lists what is pending — so an orchestrating agent that owns a
project can promote its workers' results without waiting for a person.
A colleague or an agent working in a sub-project writes something the whole team should hold. Until now that move was impossible from both ends: you could not add it, because only an artifact's owner may place their non-public work in a project — otherwise adding would be a way to grant yourself a read of someone else's material — and they could not add it either, because only a project's owner changes what it holds. Both rules were right, and together they left no path.
Now a member proposes, and the owner decides. Tick a project you belong to in an
article's Projects control and your own artifact is recorded as a
pending addition. The project's owner — or a delegate — sees it under
Pending additions in the Project Library with Approve and Reject. Approving files
it, and a project-visible artifact becomes readable by the team at that moment and not
before: a pending proposal grants nobody anything. Rejecting removes the proposal
and leaves the artifact untouched, so it can be proposed again once you have agreed on it, and you
can withdraw your own at any time.
The Projects control now shows the projects you are IN, not only the ones you own. A project that holds the article is ticked and marked member where curating it is not yours to do; an unticked one you belong to proposes when you click it. Previously those projects were missing from the list entirely, and an article held by one of them could report that it was in no project at all.
Captures no longer overwrite each other. Capturing a long session a second time used to replace the first summary — on a multi-day session, exactly the record you wanted kept. Each capture now keeps its own narrative, in the order they happened, while re-running an unchanged capture still updates in place rather than piling up duplicates.
Coding Sessions reads cleaner. A session that captured nothing is no longer written at all, so the list stops filling with empty rows, and a recap with nothing to recall is no longer created. For anyone running the watcher: update to 0.2.3 — a backfill now finds the repository in the transcript shapes Claude Code writes today, so historical sessions are filed under the repository they belong to instead of being skipped or landing under a folder name.
For agent authors: add_to_project is the same call — as a member it
succeeds and reports that your artifact was proposed rather than added, so an agent can promote its
own work into the parent project and wait to be ratified. A project you are a member of can also be
named by name now, not only by id. And a hand-off reflects the author's working
memory rather than the receiver's, so what a worker committed is what the receiver reviews.
Adding an article to a project, or declaring it as ground truth, used to ask for something nobody has in hand: a 36-character id. Getting one meant leaving the page, finding the article in the Library, copying the id, and coming back. Now you type the title and pick it from a list. The id field is still there — it is exactly right when you are pasting from a script or an agent's output — but it is no longer the only way in.
The list shows what you can actually add. Ground truth excludes private articles — including your own, because no membership widens a private article and a brief nobody on the team can open is not a brief. The list says which question it is answering, so "no matches" never leaves you wondering whether search is broken.
Where an artifact came from, and where it belongs, are two different facts. An article written by an agent inside a project's work is produced there — that is its origin. Putting it in the project is a decision someone makes, and it is the one with consequences: the project ranks it up in retrieval, its agents may maintain it, and if the article is set to project visibility, the team can read it. The Projects control on an article now shows both — a created here note where it came from, and a checkbox for whether it is in the project. They are independent, and an article can be either, both, or neither. If something an agent wrote looks like it belongs to a project but is not in it, that is now visible, and one click fixes it.
Projects get a display name you can change. Renaming lives in the project's Settings, and a delegate can do it, not only the owner. What changes is the label you read; the project's identity stays fixed, so nothing filed under it comes loose.
A project can say what is NOT true. Ground truth has always had two halves — what
a project answers from, and what it must not repeat. The second half now carries: a project
inherits ENGRAM's own list of known-false claims, and agents can read and set a project's list over
MCP with get_project_refuted and set_project_refuted, bringing the tool
surface to 53. It matters because the two behave differently on purpose: a brief is ranked
up and reaches a worker on its own, while a list of falsehoods is never retrieved as
truth — so an agent has to ask for it, and now it can.
Visibility reads at a glance. Private, project and public artifacts now carry the same labelling everywhere they appear — Library, Viewer and Projects page — so you can tell what an article is exposed to without opening it.
For agent authors: when remember is given entity ids that do not
resolve, ENGRAM now extracts entities from the content instead and says so in the response,
naming what it discarded. A memory that would otherwise be unreachable gets stored and stays
findable — and you are told the links are not the ones you asked for.
Until now a project was yours. You could curate what it held, declare what it answered from, and split it into units — but only you could see any of it. A project can now have members: add a colleague or one of your agents, and they can read the project and the material in it. It is the difference between a folder and a team.
Ground truth your team can keep to itself. Anchoring a project used to mean publishing the brief — the only way to make it readable by the people working from it. Now an article set to project visibility can be a project's ground truth: governed by the team, invisible outside it, and resolved by every worker on the project exactly as a public one is. A brief no longer has to be public to be shared.
A unit sees what its repository is working from. Sub-projects can now read the artifacts their parent holds, so a unit starts from the repo's material instead of an empty shelf. They stay the parent's — listed separately, never claimed by the unit — and a unit that wants to work only from its own material can turn the inheritance off. An inherited brief stays readable either way.
What membership does not do is worth saying plainly, because it is usually assumed. A member can read; they cannot edit the project, change its settings, or reach anyone's memories — those stay personal and are shared one at a time, deliberately. A private artifact stays private to its owner no matter who joins.
And now the agents on a project can actually work together. A token marked Restricted used to be all-or-nothing — safe, and unable to collaborate: an agent could be put on a project and curate what it held, yet not share a single memory with the person who added it. That line was drawn around the agent, back when there was nothing smaller to draw it around. A project is smaller. Agents now sit on a ladder — Contributor, Project Collaborator, Agent Manager — and on the middle rung and above, a Restricted token keeps exactly the abilities that only make sense between collaborators: sharing a memory or live working state with someone it shares a project with, and raising its own article from private to project. It is still one toggle; the rung decides how far it reaches. See Roles & agent management.
An agent manager can delegate again, and publishing is clearly yours. Restricting a manager's token used to remove the one thing that made it a manager — it could not create a sub-agent or hand out a token. Now it can, under a rule simpler than the ban it replaces: a token can never mint one more powerful than itself, so a delegation tree only narrows as it grows. Meanwhile anything an agent writes can be private, or project-visible for the team — but making something readable by everyone is an act for a full-authority token. Until project visibility existed there was no way to give a team a brief without publishing it to the whole instance; now there is.
Seven more tools for agents, bringing the MCP surface to 51: curate what a project
holds (add_to_project, remove_from_project,
list_project_artifacts), manage who is on it (add_project_member,
remove_project_member, list_project_members), and read a single memory
back by id with get_memory — the missing counterpart to correcting one, which until now
meant editing something you could not first read.
A project used to be something you filtered by. It is now something you can curate. The new Projects page — a top-level tab, beside Knowledge Base — lists every project you own and, for the one you pick, shows what it holds, what it answers from, and how it is set up. One screen instead of a filter chip and a lot of inference.
An artifact can belong to more than one project, and now says so. Open any article or document and the new Projects control lists the projects it belongs to; tick or untick to change that on the spot. A research note can sit in two teams' projects at once, which is usually the truth of it. The Library's project filter now finds an artifact under every project it belongs to rather than just one.
Adding to your Library says where things will land. The Add to Library panel now carries a project chip, so a page you fetch or a file you upload goes where you meant it to. With no project selected it tells you plainly that the artifact will go to your default project rather than quietly choosing one for you.
Two words worth knowing on the Projects page. Artifacts marked created here came out of the project's own conversations; everything else was added on purpose. Only the latter is a claim anyone made about the work — and only the latter can be maintained by the project's agents.
Learn more — Managing projects →An access token has always said who you are. It now also says how much it may do. Every token you hold can be set to Restricted: it reads everything you can read and adds articles, documents and memories as before, but it cannot create accounts or hand out credentials — it can't mint a sub-agent, issue or rotate a token, or change a user. The toggle is on each key in Settings → API Keys, and on each agent token under Administration → Agents.
The point is the tools that read things you didn't write. A desktop assistant that ingests documents and web pages, an agent triggered by a webhook, a CI job — each of them takes in text from somewhere else and acts on it, while holding a token that can do everything your account can. Restricting that one token leaves the assistant working exactly as it did and takes the account-creating power off the table. The token you drive yourself stays Owner; authority is set per token, not per account, so one agent can hold both.
Nothing changes until you change it. Every existing token keeps full authority, so no integration breaks on upgrade — this is opt-in, one key at a time. New keys can be created Restricted from the start, rotation preserves whatever a token had (so routine rotation never quietly hands power back), and a Restricted token can't lift its own restriction — that takes the browser or another Owner token.
Learn more — Token authority →Retrieval is associative — it finds what's related. That's what you want when you're exploring, and not what you want when a question has a right answer. Ground Truth lets a project declare which articles are authoritative, so questions asked in that project are answered from the documents you chose rather than from whatever happens to be nearby. Declare a set and retrieval prefers it; switch a project to restrict and the answer comes from that set only — the difference between being informed by a document and being bound by one.
It grounds your agents, not just your articles. A coding agent working in a project reads its ground truth the same way you do — so the contract, the conventions and the decisions your team agreed are what it builds against, rather than whatever it inferred from the code in front of it. Two agents on the same project work from the same document instead of two plausible readings of it, and a new agent starts out already knowing how the system behaves. The same set is also what the accuracy checks verify against, so an article that contradicts your ground truth gets caught before it reaches your knowledge base.
Your default project already has one. ENGRAM now ships its own documentation as a ground-truth corpus, and every user's default project draws on it automatically — so asking “how does recall actually work?” is answered from ENGRAM's own reference rather than from whatever you happen to have saved. Nothing to configure, and nothing changes for projects where you've already declared your own ground truth: those keep exactly the scope you gave them. Agents inherit it too, which means a new agent starts out knowing how the system it's working in behaves.
Learn more — Ground Truth →Your coding sessions capture what happened day to day. The new Build Timeline turns that history into the shape of the whole system — and how it got there. Open a project in Coding Sessions and you'll see every component your agents have built move through its life: scaffolded → wired → tested → deployed, on a real timeline, with the releases that shipped it marked along the top. A dependency graph shows what's connected to what. A Features view groups a run of releases into the initiative they delivered — so a project like Memory Fact Update becomes a single arc you can click into to see its releases, the components it touched, and the very sessions that built it. A Build activity heatmap shows your true development pace — git commits, not just captured sessions — and gap flags surface anything dormant or never shipped. It's sourced from git, which is authoritative about what actually shipped, joined to your session history for the why. Nothing to set up: it reads the history you already have.
Learn more — Coding & Build Timeline →Decisions get reversed, versions bump, preferences update — and now your memory keeps pace without ever losing the past. When you correct something, ENGRAM supersedes the old memory instead of overwriting it: recall returns the current truth, while the previous belief stays on record, so you can always see what you used to think — and undo a correction if it was wrong. Three plain-language moves do it: revise a fact, forget one that's no longer true, or revert to bring a retired memory back. ENGRAM also notices contradictions on its own — a confident update is applied automatically, and anything it isn't sure about is set aside for you to decide in Knowledge Health → Gaps → Memory, where you see the two beliefs side by side — Retiring and Keeping — and approve or reject. And the whole story is now visible in the Memory Explorer: every memory shows whether it's the current belief or a retired one, along with the dates it was valid — and opening any memory reveals a History tab with the full trail of what you used to believe, newest first, including when and why each version was retired. Your connected tools get the same three moves over MCP. Nothing is ever silently rewritten, and nothing is ever deleted.
Try the walkthrough — keep your memory current →
You can now bring sources into your Knowledge Base without going through Chat. Add from URL
fetches a web page, pulls out just the article — dropping nav bars, ads, and cookie banners — and files it as
a clean document you can later summarize, compare against your notes, or ground a report on. Upload
file adds a PDF, Markdown, or text file directly. Both live in a new Add to Library
panel that stays open so you can queue several at once and watch each one index. The Library's filters are
cleaner too: pick a source (web pages, uploaded files, conversation, and more) and
visibility as two simple controls. Agents can do the same over MCP with the new
ingest_url_as_document tool. And when you build a report grounded on those sources, chat now
shows a “Grounded on” badge above the answer — listing exactly which documents
fed it, and whether each went in in full or was summarized to fit — so you
can see what the report actually stands on, distinct from the related reads it merely referenced.
A new Agent Manager role lets people you designate create and manage their own connected agents — the bots and assistants that connect to ENGRAM as their own accounts — without granting full administrator access: they provision agents, manage their access tokens, and see an activity history for just the agents they own, up to a per-manager limit. Building on that, an orchestrator agent can now grow its own team — promote an agent you own to Agent Manager and it can create specialist sub-agents, each a distinct identity with its own memory, and fan work out to them. The Agents page shows the whole team as a delegation tree, with the person at the top as the single point of limits, audit, and control; and disabling an agent now pauses it (re-enabling restores it) rather than tearing it down. Grant the role from Administration → Users.
Try the walkthrough — Atlas grows a team →Long research PDFs and other documents are now captured completely and in reading order — every section makes it into your knowledge base, in the order the author wrote it. That means more complete search results and better-grounded articles when you build on an attached source. Documents you'd added earlier were rebuilt to the same standard, so your existing library benefits too.
When an assistant drafts an article to fill a knowledge gap, ENGRAM now checks its claims about how ENGRAM itself works against the real system before the draft reaches your inbox. Drafts that get it wrong are flagged for a closer look — or set aside — and when you review a proposal you can see the exact concerns highlighted in the draft text, so you approve accurate knowledge rather than plausible-sounding mistakes. Auto-drafted articles also carry a clear “AI-drafted” marker in your Library until you've reviewed them.
When you share a memory with an assistant you collaborate with, you can now scope that share to a project — so the assistant draws on those memories only while it's working in that project, and a single assistant helping you on several projects keeps each one's memory separate. Pick a project or conversation in Your Memories and the share dialog offers it as the scope; or use Share all to hand over a whole project or conversation at once. New scope badges mark memories that are private to a conversation or task, so you can see what you're widening before you share. (Sharing with people is unchanged — they recall everywhere they work.) And a new Help button in the Memory Explorer explains how memory, suggestions, and sharing fit together, right where you need it.
The Memory Explorer is reorganized into three tabs — Your Memories, Suggestions, and Sharing — so each has room to breathe. In Your Memories you can now filter long-term memories by where they came from (a project, a conversation, a source) and see your total at a glance; click any memory to read its full content in a side panel. Suggestions lets you review a batch memory-by-memory — keep the ones worth keeping, skip the rest — and tells you when one was handed off by someone else. And a dedicated Sharing view shows what you've shared and what's been shared with you, by name, with a preview of each memory and a click to read it in full.
The assistants you already work in — Claude Code, Claude Desktop, and other connected tools — can now recall your ENGRAM memories on demand, not just inside ENGRAM chat. Ask one to look up what you decided, and it brings back what's relevant — your own memories, or any shared with you — each tagged with why it surfaced. You can share a memory with a collaborator and hand off a piece of work for them to review, and an assistant can discover who you're able to share with so it picks the right recipient. It all stays private by default and fail-closed: nothing surfaces that isn't yours or explicitly granted to you, sharing is enabled by your operator, agent recipients are opt-in, and any grant is revocable.
For owners running ENGRAM, a new operations dashboard makes the memory features observable at a glance — how often memories are reinforced through use, what's being shared, and which inferred suggestions are kept versus set aside. It pairs with a refinement to reinforcement itself: the memories ENGRAM actually draws on to answer you now count toward growing stronger, so “sharper with use” reflects the answers they helped produce. As always, these memory behaviors stay off by default — the dashboard helps owners decide when to turn them on and confirm they're working as intended.
The memories you actually rely on now grow stronger the more they're used. Each time ENGRAM recalls a memory to help answer you, that memory's pull on future retrieval ticks up a little — so the notes that keep proving useful surface more readily over time, the way spaced repetition strengthens what you revisit. It's entirely automatic: there's no action to take and nothing new to manage, and it only ever strengthens your own memories. Like inferred suggestions, this is off by default — your operator decides whether to enable it.
ENGRAM memory has always been private to you. Now you can deliberately share a memory — a single fact, or everything tied to one task or project — with another ENGRAM user, so it surfaces in their retrieval too. Sharing is explicit, bounded, and revocable: you choose what and with whom, you can set a grant to expire, and you can pull it back at any time; the recipient can recall what you shared but never edit or re-share it. A new Sharing section in the Memory Explorer shows everything you've shared and everything shared with you. The same rails power hand-offs between assistants working on your behalf. Private-by-default doesn't change — nothing is shared until you create a grant.
Learn more in the docs →Until now ENGRAM only kept the memories you deliberately committed. Now it can also notice the salient things you didn't stop to flag — a decision you landed on, a fact you established, a preference you voiced — and gather them at the close of a task into a set of suggested memories. Nothing inferred is ever recalled on the quiet: every suggestion first passes an independent reviewer, and only the clearly worth-keeping ones are kept automatically — the rest wait for you. A new Suggestions inbox in the Memory Explorer collects everything awaiting your review — inferred proposals and your own committed recaps, each badged by where it came from — to Accept or Reject in one place. Inferred suggestions are off by default, and nothing inferred becomes recallable without the reviewer's approval or your accept.
ENGRAM has always remembered by quietly observing your work. Now you — or an assistant working alongside you — can deliberately decide this is worth remembering: a decision and its rationale, an established fact, a preference. One remember action commits it, and it becomes part of what ENGRAM recalls for you. At the close of a coding session or task, ENGRAM can gather the whole arc into a recap — proposed for your review, not saved behind your back. Accept it to make those memories recallable, or set it aside. Nothing durable is kept without your say-so.
Group everything that belongs to one body of work — conversations, coding sessions, captured research, and the articles and documents drawn from them — into a project. A Projects panel across Chat, Knowledge Base, and Coding Sessions lets you search, create, and switch projects; new chats file into your active project automatically, and you can move items between projects at any time. ENGRAM also now traces where each piece of knowledge came from, so every article and document shows its source.
Learn more in the docs →A brand-new account is no longer an empty room. Ask “What is ENGRAM?” or “How does the Knowledge Hub work?” and get grounded answers right away, drawn from a set of public onboarding articles — no setup or content of your own required. Your own knowledge then builds on top as you research and save.
Learn more in the docs →ENGRAM moved from a single-machine setup to a proper hosted service: reach it at its own address over your private Tailscale network from any of your machines, sign in with a magic link, and — for owners — manage accounts and runtime settings from an Administration area. Releases now ship through an automated build-and-deploy pipeline.
See your knowledge base the way a librarian would. The Knowledge Health panel surfaces gaps (topics you've discussed but never written down, islands that never connected), a Coverage & Depth view of how well each topic is covered, and a Vitals dashboard of recent activity — so you know what's missing and where to grow.
Learn more in the docs →The core of ENGRAM: chat with long-term memory that recalls by relevance rather than recency; a Knowledge Base of articles and documents that become part of your personal graph; a Graph Explorer to navigate your topics; capture of research from other assistants (Claude Desktop, ChatGPT, Gemini) and of your Claude Code sessions; and bring-your-own-LLM so you choose the model behind it. Your conversations and the memories drawn from them stay private to you.
Learn more in the docs →