Knowledge for Agents

#Overview

A knowledge base only earns its keep when the work actually runs on it. This page is about that last step: how the documents, files, and shared context in Knowledge become the grounding context an agent works from.

The mechanism is simple, and it is the same one people use. Knowledge reaches agents through spaces. Add files and folders to a space, and the agents operating in that space can retrieve and ingest that content while they work — answering a question in a thread, running a task overnight, carrying out a step in a flow. Nothing is copied into the agent, and nothing needs to be pasted into a prompt. The agent goes and gets what it needs, from the same place a colleague would look.

Two things follow from that, and they are what make this worth understanding.

The first is that agents both read and write. As part of its work, an agent can create a new document or edit an existing one, so the knowledge base is something your digital workforce maintains as well as consumes — under the same review and publishing controls that apply to everyone else.

The second is that format is handled for you. Different models accept different kinds of input. When an agent retrieves a file, Opal routes it in the form that agent's model can actually use: natively where the model supports the format, and as a text equivalent — a transcription, for instance — where it does not. You add the file once; matching it to each agent's model is not your job.

#Key Capabilities

• Ground agents through spaces. Add files and folders to a space, and every agent working in that space can retrieve and use them — configured once, at the space level, rather than agent by agent.
• Retrieval wherever work happens. Agents draw on space knowledge in threads, in tasks, and across the steps of a flow, in the moment the work calls for it.
• Agents contribute back. An agent can create new documents and edit existing ones as part of its work, keeping the knowledge base current instead of letting it age.
• The reviewed version is the one that gets used. Agents work from published content, and agent-authored changes go through the same draft-to-published lifecycle as anyone else's.
• Automatic format routing by model modality. Opal passes a retrieved file to the agent's model natively when the model supports that input modality, and supplies a text equivalent when it does not.
• Optimized for retrieval at scale. Behind the scenes, Opal optimizes files for agent retrieval — including caching and token reduction — so agents can draw on a large knowledge base without unnecessary overhead.

#How it Works

1. Add the knowledge to a space. Files and folders added to a space become available to everything in it: every agent there, and every thread, task, and flow run there. This is the whole of the setup. There is no separate step for attaching knowledge to an individual agent, and no prompt to maintain listing what the agent should know. Spaces covers how a space is assembled.

2. Agents retrieve what they need, while they work. Grounding is not a one-off load at setup time — an agent reaches for content when the work calls for it:

• In a thread, an agent answering a question pulls the relevant procedure or reference document into its response.
• In a task running unattended at 3am, the agent works from the current published version of the material it depends on.
• In a flow, each step's assignee draws on the same shared knowledge, so a hand-off between agents does not mean a hand-off of context.

3. Opal delivers each file in a form the agent's model can use. Models differ in the input modalities they accept — text, images, audio, video, files. When an agent retrieves a file, Opal checks what its model supports and routes accordingly:

• If the model supports the file's format natively, Opal confirms compatibility and passes the file directly.
• If it does not — an audio recording retrieved by a model with no native audio support, say — Opal supplies a text-based equivalent instead, such as the transcription produced when the file was processed.

The practical effect is that a mixed knowledge base of documents, images, and recordings works across agents on different models, without anyone converting files by hand or keeping track of which agent can read what. See Models for what each model accepts, and File Processing for how text equivalents such as transcriptions are produced in the first place.

4. Agents write back, and the work is reviewed. When an agent drafts a new document or updates an existing one, that change enters the same lifecycle as a person's: it is a draft until it is published, and where your organization has the publishing workflow turned on, a member with the required permissions reviews it first. Agents keep the knowledge base current; people stay in control of what becomes official.

5. Efficiency is handled underneath. Opal optimizes retrieved files for agent use, including caching and token reduction, so drawing on a substantial knowledge base does not carry unnecessary overhead. There is nothing to configure.

#Additional Notes

• The space is the boundary. An agent can retrieve only what has been added to the space it is working in. If an agent is missing something it should have, the first question is whether that content is in its space — not how the agent is configured.
• Agents read the published version. Work in progress stays in draft. That is what stops a half-finished revision quietly becoming the instruction an agent acts on tonight. See Viewing & Editing Files.
• Knowledge is not the same as skills. Skills package reusable instructions and procedures that shape how an agent performs a kind of work; knowledge is the shared reference content it draws on to know about your business. They are complementary — skills supply the method, knowledge supplies the material — and both can be added at the space level. See Skills.
• Format routing depends on the model, not the file. The same file can reach one agent natively and another as a text equivalent, because the two agents run on different models. Nothing about the file changes.
• Processing pays off here. A recording that has been transcribed, or a scan that has been digitized, is usable by any agent on any model. Files left unprocessed limit which agents can act on them.
• Curate what goes into a space. Everything added to a space is available to the agents working there, so a tidy, current, reviewed set of content produces better-grounded work than an unfiltered dump of everything the team has ever written.
• Short definitions of the terms used here are in one place: Glossary.

#Related Features

• Spaces — The operational environment knowledge is added to; an agent works from the content in its space. Spaces
• Agents — The digital workers that retrieve knowledge as grounding context, and create and edit documents as part of their work. Agents
• Models — The model powering an agent, and the input modalities it supports, which determine how a retrieved file is delivered. Models
• Skills — Reusable packaged expertise that shapes how an agent performs work, complementing the reference content knowledge supplies. Skills
• Threads — Real-time conversations where agents retrieve, create, and edit knowledge alongside people. Threads
• Tasks — Work an agent runs on its own, grounded in the published content of its space. Tasks
• Flows — Multi-step processes whose steps draw on the same shared knowledge as they hand work along. Flows
• File Processing — How raw uploads become content agents can act on, including the transcriptions used as text equivalents. File Processing
• Knowledge Overview — How the knowledge system fits together, and where grounding sits within it. Knowledge Overview
• Access & Permissions — The full access model behind plans, role permissions, and per-resource permissions. Access & Permissions