Memory and knowledge

The four layers

The first two are always in play and therefore cost something on every turn; the second two are looked up on demand and cost nothing until used. That difference is the whole reason to be deliberate about where things live.

Conversation memory

Each conversation is a durable thread. Close the browser, come back next week, reopen it from the Chat rail - the agent still has the context. Conversations are listed newest-first with a readable label, the channel they came from, their message count and their running cost.

A long conversation does not fall over: as it approaches the model's limit, older turns are compacted in place so the thread keeps going rather than forking. The context bar in the chat header shows how full the conversation currently is, and the /context command opens a breakdown card - how much room the system prompt, tools, memory files, skills and messages are each taking, and how much free space is left.

Two commands matter here. /new starts a fresh conversation, which is the right move whenever you change subject - a clean thread is cheaper and sharper than a long one carrying unrelated history. /compact asks for a compaction now rather than waiting for the limit.

Long-term memory

The Memory section is a direct view of the agent's long-term memory document, which is injected into its instructions on every single turn. Three read modes are available: Outline (sections and facts, filterable and collapsible), Read (rendered) and Raw (the markdown source). Copy and Download do what they say.

You can write to it two ways. The quick-add form appends a single fact: choose a section and it lands in long-term memory; leave the section blank and it goes into today's daily log instead. The Edit button opens the whole document for editing - Save overwrites the file in one atomic write.

The agent also maintains this itself. A background loop distils recent conversations into a dated daily log, and periodically folds the durable parts of those logs up into the main memory document. That is why memory grows on its own without anyone typing into it.

Keep long-term memory short. It is read on every turn, so it should hold stable things - who the customers are, what the house style is, which supplier is preferred - not a transcript of last Tuesday.

Your knowledge base

The Knowledge section builds a searchable collection from documents and web pages you supply. Add individual files, add URLs, create named stores so different bodies of material stay separate, sync a whole directory, list what has been indexed, and remove sources you no longer want. Search runs across the knowledge base, the agent's workspace, its memory, or a custom store.

This is where product manuals, price lists, policies, past proposals and reference PDFs belong. The agent does not carry any of it in its head; it searches when a question calls for it and quotes what it finds. That keeps answers grounded in your material rather than in the model's general training, and it keeps the cost of holding a large corpus at zero until it is actually needed.

Files uploaded through the chat composer land in the agent's workspace and are visible in the Files section under uploads/. Anything the agent produces - a generated image, a report, a screenshot - lands there too, which makes Files the place to look when you want the artefact rather than the conversation about it.

Notes

The Notes section is a linked markdown wiki the agent reads and writes. Each note has a title, tags, aliases and sources, and notes link to each other; the reader pane shows both directions of that link graph as Links to and Referenced by chips, so you can walk the neighbourhood of an idea. A search box runs keyword search across the collection.

One flag is worth knowing: auto-inject. A note marked auto-inject has its snippet pushed into the agent's context every turn, like long-term memory - useful for a standing instruction that deserves its own document, and limited to the five most recent such notes so it cannot quietly balloon. Everything else is looked up on demand.

Skills

A skill is a taught procedure: a folder containing written instructions and, optionally, scripts to run. Where the system prompt says who the agent is, a skill says how a particular job is done - the steps, the format, the checks. The agent picks the relevant one up when the task matches, and you enable or disable them per agent from the Skills tab of the agent's detail page.

Skills come from three places: the ones bundled with the platform, ones written for your deployment, and ones the agent learns for itself through Cortex (see chapter 7). Type /skills in chat to list what the current agent actually has, grouped by category. If a skill has been held back by the security audit, it is listed there too with the reason, rather than silently disappearing.

Skills are the right home for anything with steps. "Draft the weekly client update by pulling last week's tasks, grouping them by account, and matching this template" is a skill; trying to encode it as a system-prompt paragraph makes the prompt worse at everything else.

Which one should this go in?

• A fact that should shape every reply - our office hours, the CEO's name, the tone we use - goes in long-term memory.
• A document someone might ask about - the 40-page policy, the catalogue, last year's report - goes in the knowledge base.
• A repeatable method - how we qualify a lead, how we format the digest - goes in a skill.
• Something relevant only to this thread - just say it in the conversation. It is remembered for as long as that conversation lives.

The common mistake is pouring documents into long-term memory. It works for a week, then every reply is slower, costlier and more confused, because the agent is carrying a filing cabinet into every conversation. Put documents where documents go.