What does an AI agent remember between tasks?
Where an agent's memory lives, what it keeps between runs, and how Nebula, Claude Tag and Slack differ on scope, sharing and deletion.
An AI agent remembers only what its product gives it somewhere to write down. In Nebula, each agent you create has its own Agent Storage, files that survive across runs, threads, channels and devices, plus a Memory list you can read and prune. A weekly task can compare this week against last week instead of starting from nothing. Conversation history alone cannot do that: it records what was said, not the state of the work.
Almost every question about agent memory is really a question about where the writing goes and who can read it. A chat transcript answers “what did we say last Tuesday”. It does not answer “what invoice number did you stop at”, and on a free plan it may not survive long enough to be asked.
This page takes memory apart: the four things teams mean by it, what Nebula stores and where, what Claude Tag and Slack publish about their own models, and what to check before you assume an agent will pick up where it left off. Where a vendor publishes nothing, this page says so.
Four different things people mean by “remembers”
- Does it remember this conversation? What you asked and what it already tried. This is the cheapest kind and the most common.
- Does it remember the last time it did this job? Yesterday’s run, last week’s table, the invoice number it stopped at. This is state, and it needs a place to live outside the conversation.
- Does it remember in a different channel? You brief a research agent in one channel and tag it in another. Does the second channel know what the first one taught it?
- Does it remember on a different computer? The laptop was asleep last night and the work ran in the cloud. Does the agent find its own notes when it moves back?
Only the first is a model-quality question. The other three are product design, and they decide whether an agent can hold a job down for months rather than for an afternoon. That is the difference an agent-native workspace is built around.
How the three compare
| Nebula | Claude Tag | Slack | |
|---|---|---|---|
| Where the agent’s own state lives | Agent Storage, “a persistent set of files that survives across runs, threads and devices”, plus a Memory list in the agent window | Channel notes and workspace notes, held by Claude per Slack workspace | Message history. Free keeps 90 days; paid plans advertise unlimited history |
| Scope: whose memory is it? | “Storage belongs to the agent, not to a channel or a device.” It follows the agent into every channel it joins | “Claude Tag memory belongs to the channel, not to you.” Workspace notes saved from a public channel are read in every channel | Per workspace, per conversation. No per-agent store is published |
| What deletes it | Deleting the agent. A single memory can be removed with one click | An Owner disconnecting the workspace | History ageing out on Free |
| Best fit | An agent that holds a job across weeks, channels and machines, with files you can open and prune | Per-channel notes with workspace-wide conventions, inside Slack | Searchable history of the conversation itself |
Nebula’s memory follows the agent; Claude Tag’s follows the channel; Slack’s follows the workspace and conversation. None of the three is wrong. The one you need depends on whether your work is “keep a running job” or “keep a room informed”. Pricing for all three is on the comparison hub; Nebula is $25 per seat per month with a 7-day trial.
What Nebula keeps
Each agent you create has its own persistent files. The documentation’s own example is the clearest statement of why the feature exists:
You: @Market Analyst, keep each week’s competitor pricing table so you can tell me what changed next Monday.
Market Analyst: Saved this week’s table as pricing/2026-10-26.csv in my storage. Next Monday I’ll compare the new prices against it and list every change.
A transcript holds the table if you scroll back far enough. A stored file holds it as an input the next run can open and diff against.
The documentation lists four things agents keep there: working notes (“what a research agent has already checked, so it doesn’t repeat itself”), state between scheduled runs (“the last invoice number a weekly job processed”), generated reports (“each month’s summary, kept so the next one can compare”), and caches and datasets (“a cleaned customer list it reuses instead of rebuilding”). Agents are told to keep the store findable: a short README.md at the top, files grouped by purpose (state/, reports/, cache/), and anything stale deleted.
How an agent reaches it
There is no setup. Each agent ships with a built-in storage skill and picks one of two routes depending on the file:
| Route | Good for | Limits | What you see |
|---|---|---|---|
| Storage tools | Notes, JSON state, Markdown | Text files up to 256 KiB; storing replaces the whole file at that path | List Stored Files, Read Stored File, Store File, Delete Stored File in the task’s activity log |
nebula-storage on a device |
Binary or large files, and anything the agent makes on a computer | Up to 100 MiB per file | ls, get, put, rm commands the agent runs |
Paths are relative to the agent’s own storage, like reports/2026-10.csv. The command-line route works only inside commands the agent runs; a terminal you open on the same device can’t use it, so ask the agent to move the file instead. Because the files belong to the agent and not the machine, it makes no difference whether the run happened on a cloud device or your own computer.
Where you look at it
On desktop, open the agent and go to Instructions → Files → View files to preview or download what it stored, and, if you can edit the agent, delete files. The mobile app has no such screen yet, so there you ask the agent to list its storage, read a file back to you, or copy one onto a device you can open.
Who shares it, and what deletes it
An agent’s storage is shared by everyone who runs that agent. The files are not split per person: “Everyone who can run the agent reads and writes the same files”. The documentation turns that into a warning: don’t ask an agent to store passwords, tokens or one person’s private details unless everyone who uses that agent should have them. Account access belongs in Connections and sign-ins in a password manager.
Deleting an agent deletes its files. Taking an agent off a channel’s team keeps the agent, so its storage stays too. Deletion cannot be undone, so if a store has become the record of a running job, export it first.
Which agents don’t have it
App agents and website agents are limited to the tool for their one job plus a few read-only helpers such as web search, so they have no storage. Coding agents such as Claude Code and Codex run on their own runtime and don’t use it either; see running coding agents in your channels for how their state works.
Files, Memory and Skills are three different things
Nebula keeps three things apart in the agent window:
- Instructions → Files → View files shows the files the agent keeps between runs: Agent Storage.
- Instructions → Memory shows what it has learned from you. Each person sees only their own memories for the agent, and clicking the X on one makes the agent forget it immediately.
- Identity → Agent skills lists what the agent knows how to do. Open one to read its full instructions, or edit it if you can edit the agent.
Files are for state a task reads and writes: a CSV, a JSON cursor, a report. Memory is what the agent has picked up from you about how you work. Skills are what it does. When an agent keeps getting something wrong, the documentation’s own escalation is: steer it in the thread, make it forget the memory, fix the skill, and only then take it off the team. A corrected skill is usually a better fix than another memory entry.
What Claude Tag keeps, in its own words
Anthropic publishes a memory model for Claude Tag, and it is the closest thing in the market to what Nebula’s storage does. The page notes that Claude Tag is in public beta and may change.
The first line is the design: “Claude Tag memory belongs to the channel, not to you.” Each channel, public or private, has its own notes, and channel memory “isn’t organized by person”. From a public channel Claude can also save workspace notes, which it reads in every channel in the workspace.
| Where Claude is working | Reads from | Saves to |
|---|---|---|
| Public channel | That channel’s notes and the workspace notes | That channel’s notes, or the workspace notes for something that applies across the workspace |
| Private channel | That channel’s notes, plus the workspace notes (read-only) | That channel’s notes only |
| Group DM | That group DM’s notes only | That group DM’s notes only |
Three details in that model matter for anyone designing agent memory:
- Stable facts, not a log. Anthropic’s advice is to keep saved instructions short: “Long entries crowd out everything else; memory works best holding stable facts, not a running log of events”.
- Past sessions are readable but not searchable. Claude “can read past sessions” when you ask it to look back, but “it can’t full-text search across them, so name a timeframe or topic”.
- Anyone in the channel can correct it. “Anyone in the channel can save, read, and correct memory by talking to Claude directly in the channel”, and the page recommends pruning what your work has outgrown. Notes are deleted “when an Owner disconnects the workspace, not when you disconnect your own Claude account in Slack”.
Claude Tag is available on Claude’s Team and Enterprise plans; @Claude is not on the individual Free, Pro, Max or Ultra plans.
What Slack keeps
Slack does not publish a memory model for its AI features, and this page will not invent one. What its pricing page does publish is the boundary of recall, and that boundary is the plan: Free gets “90 days of message history”, while paid plans advertise “unlimited message history” that is “saved and fully searchable”. Slackbot on paid tiers is described as “your personal AI agent that understands conversations, files, and projects in Slack. Plan limits apply”.
So for Slack the memory is the history, and the history is priced. Nothing on the page describes per-agent persistence, sharing rules for a stored artefact, or size limits for one; treat those as unpublished rather than absent. For how Nebula compares with Slack more broadly, including where Slack is the better fit, see the comparison page or how an agent works in your Slack channels.
Will next Monday’s run know what last Monday’s run did?
Strip the phrasing away and that is the buyer’s question. It has five failure modes:
- The conversation closed. The state lived in a thread nobody has opened since, so the next run starts from zero.
- The channel changed. The agent worked in
#researchlast week and was added to#analyticsthis week. Channel-scoped memory does not follow it; agent-scoped memory does. - The machine changed. The laptop was shut, so the run happened on a cloud device. Notes written to a folder on the laptop are invisible there.
- The plan changed. A downgrade or expired trial shortened the history window.
- The agent changed. It was deleted or replaced, and its storage went with it.
Nebula’s design answers 1, 2 and 3 by construction, because the files belong to the agent rather than to a conversation, a channel or a machine. It answers 5 in the strict direction: files are deleted with the agent, which is the right default for shared storage but means a departing agent takes its working record unless someone exported it first. Claude Tag answers 1, and handles 2 by scope rules: workspace notes cross public channels and are read-only in private ones, while channel notes stay put. Slack’s answer to all five is the plan’s history window.
Which is why “does it remember?” is the wrong first question. The right one is “what does it write it down in, and who else can read that?”
What memory should not hold
- Not credentials. Shared storage means shared secrets. Passwords go in a password manager; account access goes in Connections. The same logic applies to any product with a shared memory surface.
- Not one person’s private context in a shared scope. Nebula shares an agent’s stored files with everyone who runs it, and Claude Tag shares memory per channel and workspace. If a note is about a person rather than the work, it belongs somewhere else.
- Not a running log. A store with a
state/cursor and areports/folder is a system. A store with a thousand dated notes and no index is a liability.
What to check before you assume an agent remembers
- Is there a store that isn’t the chat? Ask to see a file the agent kept. Not a summary of one, the file.
- Does it follow the agent or the room? Add the agent to a second channel and ask what it remembers.
- Does it follow the machine? Run the same job once on a laptop and once in the cloud, and see whether the second run finds the first one’s state.
- Who else can read it? If a colleague using the same agent can read and change what you taught it, that is a shared surface and should be treated like one.
- What deletes it? An agent deletion, a plan downgrade, an owner disconnecting the workspace, a 90-day window. Know which event wipes the record before it happens.
Where the others fit better
If your team already lives in Slack and the job is keeping a room informed, Slack’s searchable history and Claude Tag’s per-channel notes are a good fit, and neither requires a second workspace. Nebula does not match Slack on enterprise compliance, Microsoft 365 integration or app-directory size. The claim this page makes is narrower: an agent’s memory should live in files the agent owns, follow it across channels and devices, and be visible enough that you can prune it. Nebula builds that. Claude Tag builds a version of it around channels. Slack sells it as history.
Frequently asked questions
Does an AI agent remember between tasks?
Only if the product gives it a persistent store that isn’t the conversation. In Nebula, each agent you create has Agent Storage, files that survive across runs, threads, channels and devices, so a scheduled task can open last week’s file and compare. Products without one fall back on conversation history, which is bounded by the plan.
Where does Nebula keep an agent’s memory?
In the agent’s own Agent Storage, plus a separate Memory list on the agent window’s Instructions tab. Text files up to 256 KiB go through storage tools; larger or binary files up to 100 MiB are moved with the nebula-storage command on a device. On desktop you view them under Instructions, then Files, then View files.
Can I see and delete what an agent remembers?
Yes. On desktop, open the agent and use Files, then View files, to preview or download stored files (and delete them if you can edit the agent), and Instructions, then Memory, to see what it has learned from you. Clicking the X on a memory makes the agent forget it immediately. The mobile app has no file browser yet, so ask the agent to list its storage instead.
Does one agent’s memory follow it into other channels?
Yes. The files belong to the agent within the workspace, so it reaches the same storage from every channel it works in and from any device it runs commands on. Channel-scoped memory, as in Claude Tag, stays with the channel instead.
What happens to memory when an agent is deleted?
The files are deleted with it. Taking an agent off a channel’s team keeps the agent, so its storage stays. Deleting the agent is permanent, so export anything you need first.
Do coding agents like Claude Code and Codex use Agent Storage?
No. Coding agents run on their own runtime and don’t use it, and neither do app agents or website agents, which are limited to the tool for their one job plus a few read-only helpers. Agent Storage belongs to the agents you create in Nebula.
Sources (6)
- Nebula docs, Agent Storage: files your agents keep between runs, checked 16 Nov 2026
- Nebula docs, Agents and your channel’s team, checked 16 Nov 2026
- Claude documentation, What Claude Tag remembers, checked 16 Nov 2026
- Anthropic, Pricing, checked 6 Nov 2026
- Slack, Pricing plans, checked 6 Nov 2026
- Nebula, Pricing, checked 16 Nov 2026
