Knowledge
The facts, methods, and reference material agents can use across work, and the controls that decide where each belongs.
A Customer Success agent preparing a renewal brief should not need the same setup every time. It can remember how leadership wants risk framed, follow the team's account-review method, and open the customer history and usage table when the work calls for them. Knowledge is the material that lets an agent begin from what your team has already established.
Knowledge gives future work a better starting point
Preserve the facts, methods, and reference material worth using again. The next thread can retrieve the right context without carrying every prior conversation with it.
Three kinds of knowledge
Memories: facts worth carrying forward
Preferences, decisions, definitions, relationships, and other standing context the agent should be able to recall in future work.
Skills: methods worth following again
Repeatable ways of doing work: the checklist, format, decision rules, scripts, and when-to-use guidance behind a reliable result.
Documents and tables: material worth maintaining
Written material and structured records the agent reads, updates, and reuses across threads, such as a brand guide, research brief, account tracker, or dataset.
Knowledge is what you give an agent to work from
Knowledge is the material an agent begins from instead of rediscovering: a memory it recalls, a skill it follows, a document or table it reads. Some of it you lift out of real runs, a fact you corrected or a method that worked. Just as much of it you bring in from outside: upload a brand guide, write a memory by hand, attach a dataset the agent should treat as ground truth. Either way, giving an agent knowledge is deliberate.
That is also the property that separates knowledge from a thread's own history. A thread keeps the conversation and tool results for one piece of work, and the next thread does not inherit them. Knowledge is what you deliberately keep or provide so the next run can use it, there for work that hasn't started yet.
Work creates knowledge, and you decide what lasts
A run often reveals something worth keeping: a fact you corrected, a method that worked, reference material worth keeping current. The agent proposes a memory, skill, or prompt improvement, and nothing becomes standing knowledge until you accept it, unless you've allowed a trusted agent to save that kind on its own. Documents and tables the agent builds are editable outputs that live in the Library. See Learning for how proposals are raised and reviewed.
The agent loads only what a run needs
Saved knowledge is not poured into every run. A small amount of pinned context arrives up front; the rest surfaces or is fetched when the conversation makes it relevant, so the context window stays free for the work itself. This is why what an agent can reach and what it loads on a given run are different things. See How context gets into a thread.
Choose the right home
Match what you are preserving to the question it answers. This keeps one fact from becoming a document, one process from becoming a memory, and one run's temporary state from leaking into every future job.
| You need to preserve | Put it here | Example |
|---|---|---|
| A standing fact, preference, correction, or relationship | A memory | “Renewal briefs should lead with risk and next action.” |
| A repeatable process or quality standard | A skill | “How to prepare and review a renewal brief.” |
| Written material the agent reads or maintains | A document | A living customer brief or brand guide. |
| Structured records with reusable columns | A table | Account health, owners, renewal dates, and status. |
| Facts, corrections, decisions, and plan details for this conversation | Thread Context Document | “For this run, use the corrected renewal date of October 12.” |
| Data that already belongs in another system | Keep it in the connected system | Current CRM fields, support tickets, or calendar events the agent can retrieve when needed. |
Control who can use and change knowledge
Set what the agent may use
Knowledge and learning controls which memories the agent can read, whether it can discover skills, which context files travel with it, and where new learning is saved.
Review what the agent wants to keep
Learning collects proposed memories, skills, prompt improvements, and configuration changes. Review the suggestion before it becomes lasting knowledge, or allow trusted personal agents to save selected types automatically.