> ## Documentation Index
> Fetch the complete documentation index at: https://docs.prisme.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Agent Capabilities

> Extend your agent with tools, knowledge bases, and integrations

Capabilities give your agent the ability to do more than just chat. Connect tools to call APIs, knowledge bases to search documents, and integrations to interact with external systems. Every capability is built on the shared foundation, so what you wire up once, a tool, a knowledge base, an MCP connector, can be reused across any agent rather than rebuilt per project.

## The Capabilities Page

Open any agent and go to the **Capabilities** section. You'll see:

* **Added capabilities** - Tools and knowledge already attached to this agent
* **Add button** - Opens the capability catalog
* **Configure** - Adjust settings for each capability

## Types of Capabilities

### Knowledge Bases

Connect document stores so your agent can search and retrieve information.

| Type | Description |
| - | - |
| **Knowledge Base** | Search documents uploaded to Knowledges |
| **File Search** | Search files attached to conversations; auto-created the first time a user uploads a file |

When you add a knowledge base:

1. Click **Add Capability**
2. Select **Knowledge** category
3. Choose the knowledge base to connect
4. Save

Your agent can now search that knowledge base when answering questions. You can attach **as many knowledge bases as you want**: each one becomes a separate tool the LLM can call, and the model uses each tool's description to pick which one to query for a given question.

<Tip>
  After adding a knowledge base, update your Instructions to tell the agent when and how to use it. For multi-KB setups, make the tool descriptions explicit about which corpus each one covers.
</Tip>

For the full picture (how vector stores are scoped, what happens when a user uploads a file mid-conversation, and how to migrate to a new embedding model without losing data), see [Knowledge & RAG Architecture](./knowledge-architecture).

### Tools

Give your agent the ability to take actions and retrieve data.

| Type | Description |
| - | - |
| **Custom Function** | Wire any HTTP endpoint (typically a [Builder automation](/products/ai-builder/automations)) as a tool. See [Custom Tools](./custom-tools). |
| **MCP Servers** | Connect to Model Context Protocol servers. For OAuth-protected MCP servers, see [MCP Connections & OAuth](/products/ai-securechat/mcp-connections). |
| **System Tools** | Built-in capabilities like web search |
| **Skills** | Pre-built capability bundles from the catalog, loaded on demand via progressive disclosure. Example: [Deck Designer](./slides): turn a brief into an editable PPTX/PDF deck (skill + Slides MCP + canvas). |

Common tools include:

* **Web Search** - Search the internet for current information
* **Code Interpreter** - Execute Python code for calculations
* **Calendar** - Check schedules and availability
* **Email** - Send and read emails

<Note>
  **Why some tools need configuration**: System tools like Web Search are pre-configured and work immediately. Custom Functions and MCP servers connect to endpoints outside the agent, so they need URLs and (for external services) credentials. The agent discovers available tools from descriptions you provide, then decides when to use each tool based on the user's request.
</Note>

<Tip>
  The fastest way to give your agent a brand-new capability is to write a [Builder automation](/products/ai-builder/automations) and expose it as a [Custom Function](./custom-tools). You stay inside Prisme.ai (RBAC, secrets, audit) and only need to fill the URL + JSON-Schema for parameters.
</Tip>

### Guardrails

Add safety controls to your agent:

* **Input guardrails** - Filter or modify user messages before processing
* **Output guardrails** - Check and filter agent responses before sending
* **Action approval** - Require human approval before sensitive tools run. See [Tool Permissions](./tool-permissions) for the full configuration model (default policy, per-tool overrides, conditions, designated approvers).

### Hooks

Intercept the agent's runtime pipeline at lifecycle events to inspect, modify, allow or block messages, files and LLM calls.

| Type | Description |
| - | - |
| **HTTP / Workspace hook** | Call an external endpoint or a [Builder automation](/products/ai-builder/automations) at events like `before_message`, `before_llm`, `after_llm`, `before_file_ingest`: for PII redaction, toxicity blocking, antivirus, citation enforcement. |
| **Client file gate** | A declarative, browser-side policy that blocks a file before upload based on its metadata (e.g. classification markings). |

See [Hooks](./hooks) for events, targets (HTTP / workspace / client), execution modes, fail-open vs fail-closed, and org/platform-level enforcement.

## Adding Capabilities

1. Click **Add Capability** in the Capabilities page
2. Browse or search the catalog
3. Select a capability
4. Configure required settings (if any)
5. Click **Add**

Some capabilities require configuration:

* **Knowledge Base** - Select which knowledge base to connect
* **API Tool** - Provide the endpoint URL and authentication
* **MCP Server** - Enter the server URL and any required headers

## Configuring Capabilities

To change settings for an existing capability:

1. Find it in your capabilities list
2. Click the **Configure** button (gear icon)
3. Update the settings
4. Save

Common configuration options:

| Setting | Description |
| - | - |
| **Name** | Display name for the tool |
| **Description** | What the tool does (helps the agent decide when to use it) |
| **Parameters** | Input fields the tool accepts |
| **Authentication** | API keys or tokens for external services |

### MCP servers with a self-signed certificate

By default the platform validates a custom MCP server's TLS certificate and refuses to connect if it can't be verified against a trusted CA. For an **internal MCP server presenting a self-signed certificate**, enable **Allow self-signed certificate** in the MCP server's configuration to skip that check.

<Warning>
  Disabling TLS verification removes protection against man-in-the-middle attacks. Only enable it for a trusted internal server you control on a private network — never for a public endpoint.
</Warning>

## Removing Capabilities

To remove a capability:

1. Find it in your capabilities list
2. Click the **Remove** button (trash icon)
3. Confirm removal

<Warning>
  Removing a capability may break your agent if the instructions reference it. Update your instructions after removing capabilities.
</Warning>

## System Capabilities

Some capabilities are added automatically from your agent's profile, starting with **Memory**. Its settings live in its **Parameters (JSON)** field, and they are reset to the profile's values whenever the profile changes.

### Memory Types

Agents have access to different memory types depending on their profile:

| Memory Type | Description | Available From |
| - | - | - |
| **Working Memory** | The current conversation: its past turns are reloaded at each message | All profiles |
| **Session Memory** | A summary of the user's past conversations with this agent, carried into new ones | Workflow+ |
| **Long-term Memory** | Facts and preferences the agent explicitly saves, kept across sessions | Full Agent+ |

**Working Memory** is the conversation itself: what the user said earlier in this conversation, reloaded at each message.

**Session Memory** links separate conversations: an LLM-written summary of the user's earlier conversations with this agent, built from the first exchange of each conversation, is added to the agent's instructions in the user's later conversations. It lasts as long as the user's login session.

**Long-term Memory** persists between sessions. If you tell the agent your preferences today, it can remember them next week.

<Tip>
  Long-term memory requires the Full Agent or Orchestrator profile. Workflow and Light Agent still carry a session summary from one conversation to the next: to keep conversations strictly isolated, see [Turn off cross-conversation memory](./memory#turn-off-cross-conversation-memory).
</Tip>

<Warning>
  Don't remove the Memory capability to turn memory off: depending on the agent's other capabilities, this either changes nothing or also turns off working memory. Edit its **Parameters (JSON)** instead.
</Warning>

### System Tools by Profile

Depending on the agent profile, the following system tools are available:

| Tool | Description | Available From |
| - | - | - |
| `memory` | Working memory (all profiles), session memory (workflow+), long-term memory (agent\_full+) | All profiles |
| `budget_get_remaining` | Check remaining token/cost budget | All profiles |
| `knowledge_search` | Search the agent's configured knowledge sources | All profiles (when knowledge configured) |
| `todo_write` | Create and manage task lists | Agent Light+ |
| `activate_skill` | Activate a specialized skill for the current task | Agent Light+ |
| `planning_create_plan` | Create step-by-step plans | Agent Full+ |
| `reflection_evaluate` | Self-evaluate progress and quality | Agent Full+ |
| `human_request_approval` | Request human approval for actions | Agent Full+ |
| `human_ask_clarification` | Ask the user for clarification | Agent Full+ |
| `agent_delegate` | Delegate subtasks to other agents | Orchestrator |
| `agent_list_available` | Discover available agents | Orchestrator |

### Asking the user for clarification

When an agent calls `human_ask_clarification`, the chat renders an interactive panel above the input rather than a plain message: numbered options to click, a free-text field, and a **Skip** action. A tool that asks several questions walks through them one at a time, showing progress and letting the user step back to a previous answer.

The question itself stays the message text, so the conversation reads normally once answered. The answer continues the same conversation, and a clarification left open survives a page refresh, so the panel is still there to answer when the user comes back.

<Note>
  System tools are never gated behind [human approval](/products/agent-factory/tool-permissions). Asking for a clarification, writing a todo or reading the remaining budget is the agent's own machinery, not an action on the outside world, so an "always ask" policy applies to the agent's real tools instead of stopping on its internal ones.
</Note>

### Planning and Reflection

Full Agents and Orchestrators have access to **planning** and **reflection** capabilities:

**Planning**: Before tackling a complex task, the agent creates a step-by-step plan. You'll see this as a "Plan" block in the conversation. The agent then executes each step.

**Reflection**: After completing steps, the agent evaluates its progress. Did the step succeed? Is the output quality good? Should it adjust the approach?

These capabilities help agents handle complex, multi-step tasks more reliably. They're not available in simpler profiles because they add overhead that isn't needed for straightforward Q\&A.

<Note>
  **How agents think**: Full Agents and Orchestrators use a **reason-act cycle**. They reason about what to do, take an action (like calling a tool), observe the result, then reason again about what to do next. This loop continues until the task is complete or the budget limit is reached. Simpler profiles respond in a single pass without this iterative reasoning, which makes them faster but less capable of handling multi-step problems.
</Note>

## Best Practices

<AccordionGroup>
  <Accordion title="Match capabilities to profile">
    Higher profiles support more capabilities. A Simple agent with many tools may not use them effectively.
  </Accordion>

  <Accordion title="Write clear descriptions">
    Tool descriptions help the agent decide when to use each capability. Be specific about what each tool does and when it's appropriate.
  </Accordion>

  <Accordion title="Update instructions">
    After adding capabilities, edit your Instructions to tell the agent how to use them. Don't assume it will figure it out.
  </Accordion>

  <Accordion title="Test incrementally">
    Add one capability at a time and test in the Playground before adding more. This makes it easier to identify issues.
  </Accordion>

  <Accordion title="Consider security">
    Tools that access external systems may expose data. Review what each tool can do before adding it to your agent.
  </Accordion>
</AccordionGroup>

## Capability Catalog

The catalog contains pre-built capabilities organized by category:

| Category | Examples |
| - | - |
| **Knowledge** | Knowledge bases, file search |
| **Communication** | Email, Slack, Teams |
| **Data** | Database queries, spreadsheet access |
| **Productivity** | Calendar, task management |
| **Development** | Code interpreter, GitHub |
| **Search** | Web search, internal search |

<Note>
  Available capabilities depend on your organization's configuration. Contact your admin to enable additional integrations.
</Note>

## Next Steps

<CardGroup cols="2">
  <Card title="Test in Playground" icon="flask" href="./playground">
    Try out your capabilities and see how the agent uses them
  </Card>

  <Card title="Create knowledge bases" icon="book" href="/products/ai-knowledge/overview">
    Build document stores to connect to your agents
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.