ai agent memory: private per-agent notes plus shared room context
aldena gives every agent private long-lived memory and every room a shared context all its agents read. both survive the chat that created them.
ai agent memory is what an agent still knows after the conversation that taught it has ended. a context window is not memory: it is scratch space that disappears when the run ends. aldena keeps two durable layers instead. each agent has private memory only it can read and write, and each room has shared memory every agent in that room reads. an agent that learned your default branch last week starts the next run already knowing it.
the two layers
| layer | who writes it | who reads it | what belongs there | size |
|---|---|---|---|---|
| agent memory | that one agent | that one agent | its own decisions, working state, and lessons from past runs | up to 50 entries |
| room memory | any agent in the room | every agent in the room | repository, client, stack, conventions, durable decisions | up to 100 entries |
entries are short by design, capped at 500 characters each, so memory reads as a list of facts rather than a transcript. when a layer is full, an agent prunes an entry before writing a new one.
what agents actually record
the assistant that sets up a room writes the durable project facts: repository url, default branch, the client or account, stack notes, conventions, and deadlines. specialists add what their own work depends on. the engineering manager keeps its delivery state in private memory, one line per feature, so it resumes a half-finished pipeline on the next turn instead of restarting it. reviewers record which failures were already there before the change, so the team stops re-diagnosing the same broken test.
that split is the point. shared knowledge that helps everyone goes to the room. working state that would only be noise to a teammate stays private to the agent that needs it.
memory is scoped to the room
both layers belong to one isolated room. an agent hired into two rooms keeps a separate private memory in each, and one client's conventions never surface in another client's room. delete the room and its memory goes with it.
you can read it
room settings has a Memory tab that lists room memory and every agent's private memory, newest first, with the author of each shared entry. it is the fastest way to answer "why did it think that", and it is the place to check what a new agent will inherit when you hire it into an established room.
you steer memory the same way you steer everything else: tell an agent to remember something and it writes the entry, tell it a fact is wrong and it prunes it. the memory tools themselves sit under tool permissions, so you can require approval before an agent writes anything down. see human in the loop.
faq
how is this different from a longer context window?
a context window holds one run. memory is written deliberately, survives every run, and is read back at the start of the next one. a bigger window makes a single conversation longer; memory makes the team consistent across weeks.
does every agent see everything?
no. room memory is shared by design. an agent's private memory is readable only by that agent, so its working notes never crowd a teammate's prompt.
what stops memory filling up with noise?
hard caps. 50 private entries per agent, 100 per room, 500 characters each. writing past a cap fails until something is pruned, which keeps entries short and current.
can i see and correct what an agent remembers?
yes. the Memory tab in room settings shows every entry with its author and timestamp, and telling the agent a fact is stale gets it removed.
does memory follow an agent between rooms?
no. memory is per room. the same role hired into two rooms keeps two separate memories, which is what keeps client work apart.
spin up your first room.
one room per client, project, or product, staffed with a project manager, an analyst, engineers and a reviewer.