You had an agent write a report and the result came out too casual. You left a comment under the card saying "we write emails in a formal tone", and the agent fixed it. The real question starts after that. When you hand the same job to another card next week, does the casual tone come back?
In Orbi it does not. As the run closes, that correction is distilled into a short note, and at the start of the next run the agent is reminded of it on its own. You do not have to file it anywhere or tick a box.
That does not mean the agent remembers everything. What survives is not the past itself but the lesson drawn from it.
What it learns on its own
As a run ends, the agent distills any lasting learning by itself. The system also watches for strong signals in the background, things like revision feedback and phrases that start with "from now on". That evaluation runs on a local model on the server, so it does not spend your API keys.
The same happens in chat. The moment you give an explicit instruction such as "write reports as bullet points from now on", a note is saved. Even without the word "remember", something lasting you mention in passing gets evaluated in the background once the conversation settles and turns into a note. Language makes no difference, since detection looks at intent rather than at a pattern.
You can also write notes by hand. Admins manage workspace and project notes from the Memory tab under Settings, and everyone adds and edits their personal notes from the Memory tab in their profile.
Some things are left out. Passing states and sensitive subjects such as health do not enter memory unless you ask for it. Secrets like API keys or passwords are refused outright.
Why not the whole past
Notes are short and their limits are deliberately tight. A note holds at most 500 characters and a workspace keeps at most 200 active notes. Once that number fills up, existing notes get updated instead of new ones piling on.
Carrying every card from last week instead sounds smarter, but it creates two separate problems.
The first one raises the cost. As context grows without limit, every run gets more expensive and slower.
The second one lowers the quality. The more irrelevant old information you hand a model, the less it focuses on the job in front of it. A detail from last month's project starts bleeding into today's work and the output drifts without anyone noticing.
Distilling solves both. Memory works less like a notebook and more like a store of lessons.
The rest of the context comes from mentions
When you want an agent to look at a particular document or record, you name it inside the card. A collection, another card or a file gets pointed to this way.
The content of what you mention is not copied into the context automatically. The agent only learns that such a thing exists and what it is called, then pulls the content with its own tool when it needs it.
The reason comes back to context economy. If mentioning a collection with hundreds of records copied all of them in, the cost would climb and the model would lose the actual job in the crowd. This way the agent reads only the part it needs.
What an agent actually sees
When a run starts, what sits in front of the agent is well defined.
The workspace description and the project description
Today's date
The card's title, description, priority, label and state
The list of collections in the workspace
The current state of the checklist
On long jobs, a distilled summary of the earlier rounds
Every comment written on the card
All memory notes in scope
Two of those lines look unnecessary at first. Without today's date, models take their own training date for today and miscalculate phrases like "last quarter". The collection list does a similar job, since it stops the agent from opening a second collection for a purpose the first one already serves.
The biggest loss in that list comes from leaving the project description empty. That is where the agent learns who the work is for and within what frame.
Where a note applies
Notes come in three scopes. A note in workspace scope applies to everyone's runs. A note in project scope only works in runs inside that project. A note in personal scope loads only in runs you start, and nobody else can see it, admins included.
Preferences like "give me a short summary" stay in personal scope. The agent reflects them in its own behavior but does not carry them into shared output. When the system cannot be sure, it picks personal scope, because applying one person's preference to everyone is more uncomfortable than leaving a shared rule personal.
What a human says wins
A note you add or edit by hand is pinned automatically. When you say "never forget this" in chat, the note the agent saves is born pinned as well, because the words are yours and the agent is only the scribe.
Neither agents nor the automatic distiller can touch a pinned note again. Even as memory grows, pinned notes stay in the run's context in full.
When an agent runs into a new learning that contradicts a pinned note, it does not change the note. It raises a flag on it and leaves the decision to you. A note an agent deletes actually moves to the archive and can be brought back, and permanent deletion happens only through the interface.
Notes have a limit on the authority side too. A note steers what an agent does but cannot grant it a new permission, and the current instruction on the card always outranks a note.
Lessons carry, data does not
The distinction shows itself most clearly in work that runs on a schedule. A job that runs every morning brings its learned rules along but has no idea what it produced yesterday.
If you want continuity in the data, the road goes through a collection. The job writes its output into a collection and the next run reads it and picks up where it left off. There is a second benefit here, because writing into a collection lets you check whether a similar record went in before.
Where each kind of knowledge goes
There are four separate places for lasting knowledge, and which one you pick changes the result.
Rules that hold for every run go into the project description. Brand voice, audience and things to avoid belong there. Behavior and output format an agent should always follow live in that agent's job description. Data that needs to accumulate and be queried, such as past output and decisions, goes into a collection. A memory note is for the short lessons that fit into none of those three.
What the team builds up together
Notes belong to the workspace rather than to a person. A lesson learned in a teammate's run is recalled in yours too. Clients connected from outside join the same pool, so a coding agent you connect to the board and Orbi's own agents share the same lessons.
The limits on notes, the scope rules and how they are managed are covered in more detail in Workspace memory in the help center. If you are curious about exactly what an agent sees while it works, see Memory and context.
If you want to try it, you can open a free account and write your first note yourself.