How CellCog agents remember across conversations: Context Trees for projects and agent roles, the private memory of AI employees, and the shared skills and canon every agent in your organization reads.
| Kind | Who it serves | Where you see it |
|---|---|---|
| Context Trees | Agents in chats: project documents, agent role memory, organization documents | Project Documents and Agent Memory tabs; Organization Documents tab |
| AI employee memory | One AI employee, across all of its shifts | The employee's own workspace, shaped through your conversations with it |
| Shared skills and canon | Every agent working for your organization (and, at the personal level, every agent working for you) | The memory/ folder of the Organization Drive and of My Drive |
The rest of this guide covers each in turn.
A Context Tree is a hierarchical document store: an organized knowledge base that both you and AI agents can read from and write to.
Context Trees are a core building block of CellCog. The same memory system is used in multiple places across the platform, and it's also exposed to external agents via the Python SDK.
| Entity | What It Stores | Who Manages It | Persistence |
|---|---|---|---|
| Project | Project-specific documents, specs, data files | You (upload via UI) + Agents (via tools) | Permanent until deleted |
| Agent Role | The role's accumulated learnings and artifacts from past sessions | Agents (when you ask) + You (via UI) | Permanent until deleted |
| Organization | Company-wide documents shared across all projects | You (upload via UI) + Agents (via tools) | Permanent until deleted |
| CellCog Support Docs | Platform documentation that agents reference to answer questions | CellCog team | Managed by CellCog |
| External (SDK) | Whatever your own agents need to remember | Your agents (via the Python SDK) | Permanent until deleted |
Key point: All document stores (project, agent role, and organization) are two-way. Both humans and agents can read from and write to them. Humans manage documents through the UI; agents manage them through their built-in context tree tools.
This is the most powerful and often misunderstood feature. Here's exactly what happens:
An agent role is a repeatable role assignment you create within a project. It has:
Agent roles serve two purposes:
When you start a chat linked to a project and an agent role, here's the lifecycle:
Context trees change only when you ask. Separately, every chat (with or without a project) may save durable facts and skills to the memory of My Drive and the Organization Drive, once, quietly, after it goes idle; see Shared Memory Across Your Organization. AI employees have their own memory system, described below.
Not everything should go into agent memory. The key distinction:
Example: In a "Mini Pirates Series" project with an "Episode Producer" agent role:
Here's a concrete example of how agent role memory works in practice:
Chat 1 (Episode 1): You create a project "Mini Pirates Series" and an agent role "Episode Producer." You describe the series concept and ask the agent to produce Episode 1. It researches pirate themes, writes the script, generates character designs, and creates scene artwork. At the end you ask it to save its work: Episode 1's script and story notes go into its memory, while the core character designs and finished episode go into project documents.
Chat 2 (Episode 2): You start a new chat with the same "Episode Producer" role. The agent loads its memory: it knows Episode 1's storyline, the characters, your feedback about pacing. You say "produce Episode 2." It picks up where it left off, maintaining continuity.
Chat 6 (Episode 6): By now, the agent has deep memory of the entire series arc: recurring characters, plot threads, your style preferences, what worked and what didn't. Each new episode builds naturally on everything before it.
You decide what goes into an agent role's memory. Every agent role may need different kinds of memories depending on the work:
You curate what gets stored by:
Think of it like managing a team member's notes: you point out what is worth keeping, and they file it in the right place.
Project documents are the foundation of team knowledge in CellCog.
When you start a chat linked to a project, all project documents are automatically available to the agents. You don't need to attach them to each chat; they're always there.
This is different from chat attachments, which only exist for that single chat.
Every CellCog account belongs to at least one organization: a personal organization, plus any company organization you create or join. Every organization has a Documents tab (go to Organization → Documents) for company-wide documents that are available across all of that organization's projects.
| Project Documents | Organization Documents | |
|---|---|---|
| Scope | One project only | All projects in the organization |
| Best for | Project-specific specs, data, assets | Company-wide brand guidelines, policies, product docs |
| Access | Project members | All organization members |
Like project documents, organization documents are a two-way store: both humans (via UI) and agents (via tools) can manage them.
AI employees remember differently from chat agents. An employee works in shifts, and to you it behaves as one continuous colleague because each shift writes down what it learned for the next one. What you see:
You shape all of this by talking to the employee: "remember that we never discount below list price", "from now on always send me the summary first", "this is how we do X". You can also ask what it remembers about a topic.
For hiring and working with employees, see the AI Employees Guide.
Some knowledge belongs to every agent in your company, not to one role or one employee. That knowledge lives in the memory/ folder of your Organization Drive (open More → Drives in the sidebar), and every agent working for any member of your organization reads it automatically.
Each drive's memory/ folder can hold a semantic.txt file of shared facts, and every agent reads it automatically:
| Level | Where | What goes there |
|---|---|---|
| Organization | Organization Drive → memory/semantic.txt | Facts true for your whole organization: how you operate, who owns what, recurring context |
| Personal | My Drive → memory/semantic.txt | Facts about you: your preferences and how you like to work |
| Employee | Inside one AI employee's own memory | Facts that matter to that employee's role alone |
Tell any chat or AI employee a preference once ("call me Sam", "keep summaries to five lines", "we are based in Toronto") and it records the fact at the level that needs it, so every other agent of yours knows it from then on. The shared files stay short (up to 40KB each), and you can read or edit them on the Drives page.
You don't have to ask. Every chat may save durable facts and skills to My Drive and the Organization Drive memory once, quietly, after it goes idle: a correction to how the agent works, a preference you stated, a method worth reusing, a decision you made. It never messages you, never saves files or other artifacts unless you asked, and often decides nothing is worth keeping.
A skill is a reusable method written as a folder with a SKILL.md file. CellCog builds some in: CellCog skills are proven skills we review and install for every user, so your agents can use them without you doing anything (today three: Anatomy, by Ryan (wheresryan22), MIT License, adapted by CellCog, for detailed interactive isometric explainer figures; diagram-design, by Cathryn Lavery, MIT License, adapted by CellCog, for branded diagrams; and UI/UX Pro Max, by Next Level Builder, MIT License, adapted by CellCog, for interface design; see Built-in Skills in the Chat Guide). You can't edit them, and a skill of your own with the same name takes their place.
The skills you and your agents write live at three levels, and the level decides who reuses them:
| Level | Where | Who follows it |
|---|---|---|
| Organization | Organization Drive → memory/skills/ | Every agent working for anyone in your organization |
| Personal | My Drive → memory/skills/ | Only agents working for you |
| Employee | Inside one AI employee's own memory | That employee alone |
Agents place a skill by asking who will reuse it, not who taught it: a company-wide method ("how we write proposals") goes to the organization level; a workflow only you use stays personal; a method tuned to one employee's role stays with that employee.
Skills are methods; canon is facts. memory/canon/ on the Organization Drive holds your organization's shared rulings: pricing, brand rules, decisions, boundaries. Each entry is a folder with a CANON.md file whose one-line description is the rule itself (for example, a pricing rule states the price and what never to quote), so an agent stays correct even before opening the full entry.
memory/ folders directly on the Drives page.memory/, memory/skills/, and memory/canon/ folders cannot be deleted, moved, or renamed. To retire a skill or canon entry, trash its folder.See the Drive Guide for how the drives work.
| You want to... | Use... |
|---|---|
| Share company brand guidelines across all projects | Organization Documents |
| Store a dataset specific to one research project | Project Documents |
| Have a chat agent remember its past work across sessions | Agent Role memory (ask the agent to save its work) |
| Attach a one-off reference file to a single chat | Chat Attachment |
| Give an agent specific process notes to follow | Agent Role Instructions (for instructions) or Agent Role Memory (for reference docs) |
| Teach every agent in your company a repeatable method | Organization skill (Organization Drive → memory/skills/) |
| Teach only your own agents a repeatable method | Personal skill (My Drive → memory/skills/) |
| Record a company-wide rule every agent must honor | Organization canon (Organization Drive → memory/canon/) |
| Tell every agent of yours a preference once | Say it in any chat; it goes to your personal facts (My Drive → memory/semantic.txt) |
| Tell every agent in your company a fact | Say it in any chat; it goes to organization facts (Organization Drive → memory/semantic.txt) |
| Tell an AI employee a fact about its own role | Tell the employee in chat; it keeps it in its own memory |
The same context tree system that powers CellCog's internal agents is available to OpenClaw agents through the Python SDK.
The SDK includes project, document, and context tree management. This means your OpenClaw agents can:
create_project, list_projects)upload_document)get_context_tree_markdown)create_chat with project_id) so CellCog agents automatically have all project documentsInstall the project-management-cellcog ClawHub skill for full context tree management:
bashopenclaw skills install @cellcog/project-management-cellcog
See the OpenClaw Integration Guide for setup details and the project-management-cellcog skill documentation for the full API.
No. When you start a chat linked to a project, all project documents are automatically available to agents. You only need to attach files for one-off references not in the project.
Go to your project → Agent Memory tab, select the role, and browse its files.
Yes. Go to the project's Agent Memory tab, find the file, and delete it. You're in full control of what agents remember.
Not always. An agent role's memory holds what you asked it to save, and the shared facts and skills a chat saves after it goes idle are its best judgment of what will matter later. Tell the agent what to remember, and review My Drive and Organization Drive memory/ folders or the Agent Memory tab to correct anything.
Instructions are static guidelines you write (for example, "always use formal tone"). Memory is a dynamic document store that grows over time as the agent works on tasks. Instructions tell the agent how to behave; memory gives the agent what to reference.
No. Each agent role has its own private context tree. However, all agent roles in a project can see the shared project documents. This is by design: project documents are the shared layer, agent memory is the private layer.
No. Instructions belong to one role in one project. A skill is a method any agent at its level can follow, in any chat: an organization skill reaches every agent in your company.
Every active member of your organization and all of their agents and AI employees. Personal skills in My Drive are read only by agents working for you.
Yes. Context Trees are a general-purpose memory system used across CellCog for projects, agent roles, organizations, and the SDK. It's the same underlying system everywhere.