Skip to main content
An agent is a saved, versioned configuration that runs on a single knowledge base. Where an ad-hoc chat starts fresh each time, an agent bundles everything the assistant needs to behave the same way on every run: a goal, instructions, a model, the tools and connected apps it may use, its skills, and — optionally — a schedule. Because all of that is captured in one place, an agent is repeatable. Point it at a task once, and it will approach that task the same way whether a teammate runs it from the dashboard, your application calls it through the API, or the scheduler triggers it overnight.

Configure an agent

Set the goal, instructions, model, and the tools and skills it can use.

Deploy & version

Each configuration deploy creates an auditable numbered snapshot.

Schedule runs

Run an agent automatically — daily, weekly, monthly, or on a custom cadence.

Delegate to other agents

Let an agent ask another specialized agent for answers outside its knowledge.

​
What an agent bundles

A clear statement of what the agent is for, plus instructions on how it should behave. These shape every run so the agent stays on task.
The model the agent reasons with. It’s saved with the configuration, so runs stay consistent until you change it and deploy again.
The integrations, custom tools, and tool servers the agent is allowed to use — enabled explicitly so behavior stays predictable.
Reusable authored procedures the agent can follow, attached so they load every run or only when relevant.
An optional cadence that runs the agent automatically. See Scheduling.

​
Where an agent lives

Every agent belongs to exactly one knowledge base and one tenant, and it draws its grounded answers from that knowledge base’s documents and connected data. The knowledge base is chosen when you create the agent and stays fixed for the life of that agent — a design that keeps each agent’s grounding stable and predictable. To build on a different knowledge base, use Copy (fork) to create a new agent. See Deploying & versioning.
Agents are versioned. Creating an agent is its first version, and every later configuration deploy creates a numbered snapshot. Name and status edits do not create versions, and there is no rollback or version-selection operation. See Deploying & versioning.

​
Agents always run in Deep mode

Every agent run uses Deep mode — the more thorough, multi-step reasoning mode. Deep mode lets the agent plan, retrieve from your knowledge base, call tools, and combine results across several steps before answering, which is exactly what a saved, goal-driven configuration is built for.
You don’t need to select a mode for an agent — Deep mode is applied automatically on every run. To compare reasoning modes for interactive chat, see Chat modes.

​
Three ways to run an agent

Interactively

Run it from the dashboard and watch the response stream in real time.

Through the API

Call the agent from your own product. See the agent lifecycle.

On a schedule

Let the scheduler trigger background runs on a cadence you choose.
Each run produces a chat you can open and review, kept alongside the agent’s run history. See Running & run history.

​
Next steps

Configure your first agent

Set its goal, instructions, model, tools, and skills.

Learn the core concepts

See how agents relate to knowledge bases, chat, and memory.