Memory

Tell your agents how you work once, and let them remember what they learn. Marshal adds two documents to every space you launch. My context holds your standing instructions, and you write it. Memory holds what your agents have learned, and they write it. Both reach the agent when the space starts, so you never repeat yourself in a task.

What you can do with it

Set your house rules once. Write “Use conventional commits. Run make verify before every push.” in My context. Every agent in every space you launch follows it from the first command.
Stop re-explaining your repo. The first agent that works out how your monorepo builds writes it to Memory. The next agent starts with that knowledge instead of finding it again.
Give a deputy its own playbook. A nightly dependency-bump deputy keeps its own context (“open one PR per package”) and its own memory of what broke last time, separate from any person’s.

See it end to end: Nightly dependency upgrades.

How it works

	My context	Memory
Who writes it	You	Your agents, and you
What it holds	Standing instructions, such as how you like commits written	What agents learned while they worked, such as how your repo builds
How the agent treats it	Agents are told it outranks guidance that comes with packages	Agents read it and update it as they work
Where it applies	Every space you launch	Every space you launch

Each document belongs to one person. A deputy has its own pair. See Deputies.

Before and after: a context file

A first draft is often long and general:


# My context
 
I am a backend developer. I care a lot about code quality and I like
clean code. Please try to write good tests and be careful with changes.

A good context file is short, specific and easy to check:


# My context
 
- Use conventional commits (feat:, fix:, docs:).
- Run `make verify` before every push. Do not push if it fails.
- Wrap errors with context. Never log an error and return it too.
- Open pull requests as drafts.

Both documents use context in every task, so each line should earn its place. The editor shows a rough token count as you type.

Edit your documents

Open the page

Select your avatar at the bottom of the sidebar, then Personal settings, then Context & memory.

Choose a tab

Select My context or Memory.

Write and save

Edit the text, then select Save.

What you should see: a message such as “Saved · version 3”. The next space you launch uses the new text.

Memory starts empty, and agents add to it as they work. Read it from time to time, because what an agent writes reaches every space you launch after that. Agents read all of the text in both documents, so keep secrets out of them.

History and restore

Every save keeps the earlier text as a version. The Recent changes panel lists them. Each older version has Compare, which shows it next to the current text, and Restore, which brings it back as a new version. Nothing is lost. Marshal keeps the newest 15 versions of each document.

When an agent saves while you edit

An agent can save to Memory while you have it open. A banner then says someone else saved and shows the new version number. Select Load their version to take theirs, or Save mine anyway to keep your text.

Every write to these documents, including writes by agents, is recorded in the audit log.

Configure it

A manifest can leave out your context, your memory, or both. The choice applies to that manifest only.

Open the manifest in the editor.
Select the Agent context card. It lists everything Marshal adds to the agent at the start, grouped by who added it, with a token estimate.
Clear the box next to your context or memory.
Save the manifest.

New spaces from that manifest start without that document. A space from that manifest that is already running stops using memory too.

An admin can lock an item in a stack so every manifest from it keeps the item. A locked item shows a lock label. See Manifests and stacks.

Deputies

A deputy has its own context and memory. Open the deputy and select Context & memory.

The deputy’s Context is its standing instructions. People write it. Every run the deputy starts gets it.
The deputy’s Memory is what it learned from its own runs. It reads it at the start of every run and may update it as it works. You can edit it or roll it back.

A deputy’s runs use only the deputy’s documents. No person’s own context or memory reaches them, whoever owns the deputy or started the run. Whoever can launch the deputy can read its documents. See Deputies.

Edge cases

Your documents follow you, not the space. A change reaches the next space you launch.
Restoring an old version saves it as the newest version, so you can always undo a restore.

Try it

Open Personal settings > Context & memory, add one line to My context, such as “Run the tests before you commit”, and launch a space. Ask the agent what your standing instructions are.