> For the complete documentation index, see [llms.txt](https://docs.beefree.io/beefree-sdk/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.beefree.io/beefree-sdk/ai-and-mcp/ai-co-pilot.md).

# AI Co-Pilot

{% hint style="info" %}
Beefree SDK's AI Co-Pilot is freely accessible to all customers on a paid plan. You just need to activate it in your Developer Console and add your LLM provider API key to make it available for your end-users.
{% endhint %}

Beefree SDK's AI Co-Pilot is the out-of-the-box AI agent that your user can prompt to create email designs, edit layouts, generate variations, and review templates. You install it in the Developer Console, choose a supported provider, and configure your model to make it available for your end users. Hosts can also persist chat history to continue guided sessions across visits and future revisions.&#x20;

### Overview

Beefree SDK's AI Co-Pilot is installed as a Partner AddOn — part of the same family of ready-to-install extensions available through the [Beefree SDK Partner AddOns directory](https://docs.beefree.io/beefree-sdk/builder-addons/partner-addons/partner-addons-directory).&#x20;

It is installed and configured directly from the Beefree SDK Developer Console, without any changes to your integration code. For a general walkthrough of how Partner AddOns work, see [Installing Partner AddOns](https://docs.beefree.io/beefree-sdk/builder-addons/partner-addons/installing-partner-addons).

<figure><img src="https://806400411-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F8c7XIQHfAtM23Dp3ozIC%2Fuploads%2FJQeGPjG7MkAxnsAkPblG%2Fedit-with-ai-blank.png?alt=media&amp;token=262f9631-7ce5-4a82-b8d8-31d5e3d9f74c" alt=""><figcaption></figcaption></figure>

The AI Co-Pilot is a ready-made conversational agent that enables advanced workflows in the Beefree SDK email builder. Your users can prompt the agent to:

* **create full** **email designs** from scratch
* **edit existing designs**, for example by adding a content block, changing the structure, or switching the color palette
* **generate content variations** while preserving core brand elements
* **check an existing template** for quality or accessibility issues, for example missing image links or alt text

If you'd like the Co-Pilot to follow specific brand guardrails, you can work with [Brand Rules](#using-brand-rules-with-the-ai-co-pilot) to ensure the Co-Pilot's output matches your users' brand.&#x20;

Unlike the [AI Writing Assistant](https://docs.beefree.io/beefree-sdk/builder-addons/partner-addons/ai-writing-assistant), which targets individual content blocks, the AI Co-Pilot surfaces a "Create with AI" panel. Thanks to this, your users can generate, iterate on, and apply content across their design in a guided chat experience within the Beefree email builder embedded in your application.

End users can always manually edit any design the agent generates. That keeps the workflow collaborative: AI helps your users move faster, while they stay in control as creative directors, shaping the final result to match their vision.

Inside the builder, your users can:

* **open the Co-Pilot** from the floating button on the stage, or from the **Edit with AI** (sparkle) action on the toolbar of the selected row or content block. When opened from a toolbar, the Co-Pilot keeps that row or block selected and uses it as the context of the conversation.
* **start from a prompt starter**: when the conversation is empty, the panel shows a short list of suggested prompts. Clicking one fills the prompt input, so the user can complete it before sending. You can replace them with your own using [`promptStarters`](#settings-reference).
* **copy an answer** of the agent to the clipboard, as plain text, with the copy button under the answer.

<figure><img src="https://806400411-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F8c7XIQHfAtM23Dp3ozIC%2Fuploads%2Fl4D5HtiUFq47qyjX9wGm%2Fpopulated-prompt.png?alt=media&amp;token=7dc67457-3d17-4394-9242-ffd2a52f2169" alt=""><figcaption></figcaption></figure>

AI Co-Pilot is registered as `ai-agent` in the standard `addOns` array passed to `BeePlugin.create()`. Message history is surfaced through the existing `onInfo` callback.

### Activation

You can configure AI Co-Pilot through the Beefree SDK Developer Console under **AddOns → AI Co-Pilot.**

<figure><img src="https://806400411-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F8c7XIQHfAtM23Dp3ozIC%2Fuploads%2FiUuTN4IIBnJrdlzY5x7O%2FAI%20Co-Pilot.png?alt=media&amp;token=79c64700-96a2-4936-a0eb-e35070c4f392" alt=""><figcaption></figcaption></figure>

#### Prerequisites

* An API key from one of the [supported AI providers](#supported-providers).

#### Configure in the Developer Console

1. Log in to the [Beefree SDK Developer Console](https://developers.beefree.io).
2. Navigate to your application, then open the AddOns section.
3. Click on Browse AddOns and select **AI Co-Pilot**.
4. Click Install. You will then see the AI Co-Pilot available in the installed AddOn section.
5. Set up your AI Co-Pilot:
   * Select your provider.
   * Select your model.
   * Enter your API key.

Once you’ve completed the setup, toggle on Enable, then click Save.

### Supported providers

Three providers are currently supported: Anthropic, OpenAI, and Gemini. Each provider offers a range of models, from faster and more economical options to higher-capability ones that produce stronger output at higher cost and latency. The [Developer Console](https://developers.beefree.io/login?from=website_menu) shows a recommended default for each provider and flags any models that've been deprecated or retired. You'll always find current availability and status there, rather than on this page.

#### Anthropic

[Anthropic](https://docs.anthropic.com/en/docs/welcome)'s Claude models prioritize safety, alignment, and high-quality conversational output — making them well-suited for creative and editorial workflows inside the builder.

#### OpenAI

[OpenAI](https://platform.openai.com/docs/concepts)'s GPT models offer broad language coverage and advanced text generation capabilities across a wide range of writing styles and use cases.

#### Gemini

[Gemini](https://ai.google.dev/) models from Google DeepMind offer multimodal capabilities and competitive performance on text generation tasks.

### AI Co-Pilot configuration

Add an entry with `id: 'ai-agent'` to `beeConfig.addOns`. All `settings` fields are optional.

```
const beeConfig = {
  // ...your standard config
  addOns: [
    {
      id: 'ai-agent',
      settings: {
        initialMessages,  // seed the chat on open — same shape returned by onInfo
        systemPrompt,     // string — appended to every chat request
        maxIterations,    // number — auto-continue cap (default: 10)
        loadingPhrases,   // string[] — overrides default cycling loader text
        brandRules,       // brandRules object
        reusableRows,     // { entries: [...] } — saved rows the Co-Pilot can place
        fileManager,      // { readPaths, uploadPaths, deletePaths } — File Manager folders the Co-Pilot can use
      },
    },
  ],
}

```

#### Custom System Prompt

Customizing the system prompt lets you control how the AI Co-Pilot behaves in your application. Use it to define tone of voice, brand guidelines, and the kind of content the assistant should favor or avoid, so generated design and copy stays consistent with your product and your users’ expectations.

{% hint style="info" %}
System Prompt customization is only available for Superpowers and Enterprise plans.
{% endhint %}

#### Settings reference

| Field             | Type                 | Required | Description                                                                                                                                                                                                                                                          |
| ----------------- | -------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `initialMessages` | message array        | No       | Loads a previous conversation at panel mount. Pass back exactly what you received from `onInfo` as `detail.messages` — the shape is identical. Persist that array (e.g. in `localStorage`) and replay it here on the next session. Pass `[]` or omit to start blank. |
| `systemPrompt`    | `string`             | No       | Forwarded verbatim with every chat request. Use it to inject role, tone, or brand voice instructions.                                                                                                                                                                |
| `maxIterations`   | `number`             | No       | Caps the agent's auto-continue loop on tool-call turns. Defaults to `10`. Lower it to control cost and latency.                                                                                                                                                      |
| `loadingPhrases`  | `string[]`           | No       | Replaces the default cycling phrases shown under the loader (e.g. `"Sending request"`, `"Working"`). Phrases cycle per auto-continue turn and are announced via `aria-live`.                                                                                         |
| `brandRules`      | `brandRules` object  | No       | Brand Rules the Co-Pilot must follow (presets, permissions, limits). See the [Brand Rules](https://docs.beefree.io/beefree-sdk/ai-and-mcp/brand-rules.md) page for the full schema and logic.                                                                        |
| `reusableRows`    | `{ entries: [...] }` | No       | A library of your users' saved rows the Co-Pilot can search and place instead of building them from scratch. Core plan and above. See [Reusable Rows for AI](https://docs.beefree.io/beefree-sdk/ai-and-mcp/reusable-rows-for-ai.md) for the row shape and limits.   |
| `fileManager`     | `fileManager` object | No       | The folders of your user's File Manager the Co-Pilot can list and search, save files to, and delete files from. See [Using the File Manager with the AI Co-Pilot](#using-the-file-manager-with-the-ai-co-pilot).                                                     |

#### Receiving message updates (`onInfo`)

The panel's chat history is broadcast through the SDK's top-level `onInfo` callback. Filter by `code` and `detail.handle`:

```
const beeConfig = {
  // ...
  onInfo(data) {
    if (data?.code === 1010 && data?.detail?.handle === 'ai-agent') {
      // data.detail.messages — full conversation so far.
      // Persist it and pass it back next session as initialMessages.
      persistAiAgentMessages(data.detail.messages)
    }
  },
}

```

#### Event shape

| <h4>Field</h4>  | <h4>Value</h4>                                          |
| --------------- | ------------------------------------------------------- |
| `code`          | `1010`                                                  |
| `message`       | `"Messages changed for addon handle: ai-agent"`         |
| `detail.handle` | `"ai-agent"`                                            |
| detail.messages | Complete chat history — same shape as `initialMessages` |

#### When it fires

* After each auto-continue turn (partial progress is preserved if the user closes the panel mid-iteration).
* When the model finishes its full response.
* When the user clicks **Stop** or closes the panel during active generation.

The initial emission caused by seeding the store from `initialMessages` is not echoed back — only real changes trigger the callback.

#### Opening and closing the panel programmatically

By default, end users open the AI Co-Pilot panel by clicking its icon in the builder. You can also open or close the panel programmatically using the `toggleAgent` Frontend Command, without requiring a click.

```javascript
beeInstance.execCommand('toggleAgent');
```

Each call toggles the panel's current state: calling it while the panel is closed opens it, and calling it while it's open closes it. See the [Frontend Commands page](https://docs.beefree.io/beefree-sdk/other-customizations/frontend-commands.md) for the full reference.

### Tracking token usage (`onInfo` code `1000`) <a href="#tracking-token-usage-oninfo-code-1000" id="tracking-token-usage-oninfo-code-1000"></a>

The Co-Pilot reports the tokens it uses through the same `onInfo` callback, with code `1000`, the code the [AI Writing Assistant](https://docs.beefree.io/beefree-sdk/builder-addons/partner-addons/ai-writing-assistant) uses for its usage reports. Use it to monitor consumption or to bill your users.

A single prompt can result in several requests to the AI provider: when the agent edits the design, it keeps working in more steps until it answers (up to `maxIterations`). The Co-Pilot sends one `1000` event for each request, and all the events of the same prompt share the same `promptId`. Add them up to get the usage of a prompt; don't keep only one event per `promptId`, or you lose part of the usage.

```javascript
const usageByPrompt = {}

const beeConfig = {
  // ...
  onInfo(data) {
    if (data?.code === 1000 && data?.detail?.handle === 'ai-agent') {
      const { promptId, usage } = data.detail
      usageByPrompt[promptId] = (usageByPrompt[promptId] ?? 0) + (usage.totalTokens ?? 0)
    }
  },
}
```

#### Usage event shape

| Field             | Value                                                  |
| ----------------- | ------------------------------------------------------ |
| `code`            | `1000`                                                 |
| `message`         | `"Token usage for addon handle: ai-agent"`             |
| `detail.handle`   | `"ai-agent"`                                           |
| `detail.promptId` | `string` — the same for all the requests of one prompt |
| `detail.usage`    | Token usage of this request (see below)                |

#### `detail.usage`

| Field                                | Type     | Description                           |
| ------------------------------------ | -------- | ------------------------------------- |
| `inputTokens`                        | `number` | Input (prompt) tokens.                |
| `inputTokenDetails.noCacheTokens`    | `number` | Input tokens not read from the cache. |
| `inputTokenDetails.cacheReadTokens`  | `number` | Input tokens read from the cache.     |
| `inputTokenDetails.cacheWriteTokens` | `number` | Input tokens written to the cache.    |
| `outputTokens`                       | `number` | Output (completion) tokens.           |
| `outputTokenDetails.textTokens`      | `number` | Output tokens of text.                |
| `outputTokenDetails.reasoningTokens` | `number` | Output tokens used for reasoning.     |
| `totalTokens`                        | `number` | Total tokens of the request.          |

Not every provider and model reports every field: a field can be missing or `undefined`, so treat it as `0`.

{% hint style="info" %}
The `usage` object of the Co-Pilot has a different shape from the AI Writing Assistant's (for example, `totalTokens` instead of `total_tokens`). If you use both AddOns, check `detail.handle` before reading it. Token usage is not included in the messages of the `1010` event.
{% endhint %}

### Checking prompts before they are sent (`aiAgentBeforeSend`) <a href="#checking-prompts-before-they-are-sent-aiagentbeforesend" id="checking-prompts-before-they-are-sent-aiagentbeforesend"></a>

With the `aiAgentBeforeSend` hook, your application can check every prompt before it leaves the browser, and allow it or block it. Use it, for example, to run a DLP (data loss prevention) check on your server and keep personal or sensitive data away from Beefree and the AI provider.

Declare the hook in `beeConfig.hooks`. When it's configured, each time the user sends a prompt the Co-Pilot calls your handler first. Nothing reaches any Beefree backend or the AI provider until your handler allows it.

```javascript
const beeConfig = {
  // ...your standard config
  hooks: {
    aiAgentBeforeSend: {
      handler: async (resolve, reject, { promptText }) => {
        try {
          const verdict = await myDlpService.check(promptText) // your own server
          if (verdict.ok) {
            resolve({ allowed: true })
          } else {
            resolve({ allowed: false, message: 'Remove patient data before sending this prompt.' })
          }
        } catch (err) {
          reject() // the prompt is not sent
        }
      },
    },
  },
}
```

#### Payload

| Field        | Type     | Description                          |
| ------------ | -------- | ------------------------------------ |
| `promptText` | `string` | The text the user typed in the chat. |

#### Response

Call `resolve` with an object:

| Field     | Type      | Required | Description                                                                                                           |
| --------- | --------- | -------- | --------------------------------------------------------------------------------------------------------------------- |
| `allowed` | `boolean` | Yes      | `true` sends the prompt. `false` blocks it.                                                                           |
| `message` | `string`  | No       | Shown to the user when `allowed` is `false`, as plain text (up to 500 characters). Omit it to show a default message. |

#### What the user sees

* **Allowed**: the prompt is sent as usual.
* **Blocked** (`allowed: false`): the chat shows your `message`, or a default message if you didn't provide one. The prompt stays in the input, so the user can edit it and send it again.
* **Check failed**: the prompt is not sent and the chat shows an error with a **Retry** button. Retry asks your handler again. This happens when your handler calls `reject()`, resolves with a response that doesn't match the shape above, or doesn't answer within `beforeSendTimeout` (30 seconds by default). A malformed response is also reported through `onError`.

The check is fail-closed: if your handler can't give a verdict, the prompt is never sent.

{% hint style="warning" %}
The hook checks only the text the user types. While it works, the Co-Pilot still reads the template content, including the selected element, and sends it to the AI provider. If your policy covers template content too, check it separately.
{% endhint %}

If the hook isn't configured, the Co-Pilot sends prompts directly, without any extra round trip.

### Persisting chat history

The SDK does not store the conversation itself — persistence is the host application's responsibility. The simplest approach uses `localStorage`:

```
const STORAGE_KEY = 'aiAgent.messages'

function getInitialMessages() {
  try {
    const raw = localStorage.getItem(STORAGE_KEY)
    return raw ? JSON.parse(raw) : []
  } catch { return [] }
}

function persistMessages(messages) {
  try { localStorage.setItem(STORAGE_KEY, JSON.stringify(messages)) }
  catch (err) { console.warn('[aiAgent] persist failed', err) }
}

const beeConfig = {
  addOns: [{ id: 'ai-agent', settings: { initialMessages: getInitialMessages() } }],
  onInfo(data) {
    if (data?.code === 1010 && data?.detail?.handle === 'ai-agent') {
      persistMessages(data.detail.messages)
    }
  },
}

```

This produces a conversation that survives page reloads and follows the user across sessions.

### Full configuration example

```javascript
const STORAGE_KEY = 'aiAgent.messages'

const beeConfig = {
  client,
  uid,
  // ...standard config
  addOns: [
    {
      id: 'ai-agent',
      settings: {
        initialMessages: JSON.parse(localStorage.getItem(STORAGE_KEY) || '[]'),
        systemPrompt:    "You write in the brand's friendly, concise voice.",
        maxIterations:   8,
        loadingPhrases:  ['Drafting', 'Tweaking copy', 'Polishing'],
        promptStarters:  ['Create a newsletter for our spring sale', 'Make this email more concise'],
        submitOnEnterKey: true,
        brandRules: {
          presets: {
            blocks: {
              button: {
                'brand-cta': {
                  description: 'Mandatory brand CTA button style',
                  properties: {
                    backgroundColor: '#7747FF',
                    color: '#FFFFFF',
                    borderRadius: '24px',
                  },
                },
              },
            },
          },
          permissions: {
            blocks: {
              noAdd: ['video'],
              noDelete: ['menu'],
            },
          },
          limits: {
            rows: { max: 12 },
          },
        },
      },
    },
  ],
  onInfo(data) {
    if (data?.code === 1010 && data?.detail?.handle === 'ai-agent') {
      try {
        localStorage.setItem(STORAGE_KEY, JSON.stringify(data.detail.messages))
      } catch (err) { /* noop */ }
    }
    if (data?.code === 1000 && data?.detail?.handle === 'ai-agent') {
      trackTokenUsage(data.detail.promptId, data.detail.usage) // your own function
    }
    // ...handle other onInfo codes here
  },
}

BeePlugin.create(token, beeConfig, (instance) => {
  // editor ready
})
```

### Using Brand Rules with the AI Co-Pilot

With [Brand Rules](https://docs.beefree.io/beefree-sdk/ai-and-mcp/brand-rules.md), you can attach a `brandRules` object when starting an AI editing session. Brand Rules act as guardrails that the Co-Pilot must work within so that the output it generates matches your (or your end users') brand.&#x20;

Please check out the [Brand Rules page](https://docs.beefree.io/beefree-sdk/ai-and-mcp/brand-rules.md) for a full overview of the different types of Brand Rules you can set and to access the full JSON Schema for Brand Rules.&#x20;

To make the Co-Pilot work with Brand Rules, you simply pass the `brandRules` object in the AI Agent `settings` section of your config file when starting an AI editing session. Check out the [example above ](#full-configuration-example)to see what that can look like.

{% hint style="info" %}
Tip: You can use the [Brand Rules validation endpoint](https://docs.beefree.io/beefree-sdk/ai-and-mcp/brand-rules.md#testing-and-validating-your-brand-rules) to validate your Brand Rules JSON before starting an AI editing session with the Co-Pilot.
{% endhint %}

### Using Reusable Rows with the AI Co-Pilot

With [Reusable Rows](https://docs.beefree.io/beefree-sdk/ai-and-mcp/reusable-rows-for-ai.md), you can hand the Co-Pilot a library of your users' saved rows: like brand headers, footers with legal text, signatures. When prompted to find a saved row, the Co-Pilot searches the library and places the approved row instead of generating a new one.

To enable it, pass the library as `reusableRows` in the AI Agent `settings`:

```javascript
addOns: [
  {
    id: 'ai-agent',
    settings: {
      reusableRows: {
        entries: [
          {
            metadata: { name: 'Brand footer', category: 'Footers', tags: ['legal'] },
            columns: [ /* the row's columns, as saved from onSaveRow */ ],
            synced: true,
          },
        ],
      },
    },
  },
]
```

* The Co-Pilot starts a new MCP session for every prompt and attaches the library to each of them, so a change to `reusableRows` applies from the next prompt.
* On Core plans and above, the Co-Pilot is also told how to use the library: search before building, place rows by id, never edit a synced row.
* If you set your own `systemPrompt`, it replaces the default instructions, including the ones about reusable rows. The library and its tools are still available, but you need to describe how to use them in your own prompt.
* If the library is too large, it's trimmed, and the editor reports it through `onWarning` with code `1770`. If a row is invalid, the session doesn't start and the Co-Pilot shows the error. See [Reusable Rows for AI](https://docs.beefree.io/beefree-sdk/ai-and-mcp/reusable-rows-for-ai.md#what-happens-when-a-library-does-not-fit).

{% hint style="info" %}
Tip: You can use the [validation endpoint](https://docs.beefree.io/beefree-sdk/ai-and-mcp/reusable-rows-for-ai.md#validate-a-library-before-starting-a-session) to check your `reusableRows` payload before starting the Co-Pilot.
{% endhint %}

### Using the File Manager with the AI Co-Pilot

With [File Manager for AI](https://docs.beefree.io/beefree-sdk/ai-and-mcp/file-manager-for-ai.md), the Co-Pilot can find, save, and delete files in your user's File Manager, only in the folders you allow. Pass the folders as `fileManager` in the AI Agent `settings`:

```typescript
// Exported by @beefree.io/sdk as McpFileManager
interface McpFileManager {
  readPaths?: string[]   // folders the Co-Pilot can list and search, subfolders included
  uploadPaths?: string[] // folders it can save files to
  deletePaths?: string[] // folders it can delete files from, subfolders included
}
// A list you leave out defaults to ['/AI Generated Images']; [] turns that operation off.
// Without fileManager, the Co-Pilot has no file tools.
```

```javascript
addOns: [
  {
    id: 'ai-agent',
    settings: {
      fileManager: {
        readPaths: ['/'],
        uploadPaths: ['/AI Generated Images'],
        deletePaths: [],
      },
    },
  },
]
```

* The Co-Pilot works in the File Manager of the `uid` the editor was started with.
* The folders apply to the MCP session the Co-Pilot starts for a prompt. If a session is still open, or the editor joined one with `bee.join()`, the prompt runs in that session, with that session's own `fileManager`.
* An invalid `fileManager` keeps the session from starting, and the Co-Pilot shows an error with a Retry button. Check it with the [validation endpoint](https://docs.beefree.io/beefree-sdk/ai-and-mcp/file-manager-for-ai.md#validate-a-configuration-before-starting-a-session), adding the editor's `uid`: the endpoint requires one.

See [File Manager for AI](https://docs.beefree.io/beefree-sdk/ai-and-mcp/file-manager-for-ai.md) for path rules, limits, and [choosing folders for the agent](https://docs.beefree.io/beefree-sdk/ai-and-mcp/file-manager-for-ai.md#choosing-folders-for-the-agent).

### Disable the AI Co-Pilot per user

To disable the AI Co-Pilot for a specific user, set `enabled: false` on the AddOn entry. To re-enable it, change the value to `true`.

```
const beeConfig = {
  uid: 'inactive-user',
  addOns: [
    {
      id: 'ai-agent',
      enabled: false,
    },
  ],
}
```

### Additional considerations

* Only one provider can be active per application at a time. You can switch providers at any time from the Developer Console without code changes.
* The `systemPrompt` field is a powerful lever for brand alignment — use it to enforce tone, language, and content guardrails across all end-user sessions.
* Lowering `maxIterations` from the default of `10` is recommended in cost-sensitive environments, especially when using larger models such as Claude Opus or GPT-5.4.
* To monitor the tokens your users consume, listen to the [token usage events](#tracking-token-usage-oninfo-code-1000) (`onInfo` code `1000`).
* To inspect or block prompts before they are sent (for example, for DLP), use the [`aiAgentBeforeSend` hook](#checking-prompts-before-they-are-sent-aiagentbeforesend).
* For data security and privacy information, refer to the [AI Providers and Data Security](https://docs.beefree.io/beefree-sdk/builder-addons/partner-addons/ai-writing-assistant/data-security) page.

### Related resources

* [AI Writing Assistant AddOn](https://docs.beefree.io/beefree-sdk/builder-addons/partner-addons/ai-writing-assistant) — block-level AI writing, configured separately.
* [Available Providers — AI Writing Assistant](https://docs.beefree.io/beefree-sdk/builder-addons/partner-addons/ai-writing-assistant/available-providers)
* [Configuration Reload](https://docs.beefree.io/beefree-sdk/getting-started/readme/installation/configuration-parameters/configuration-reload) — update AddOn settings in real time via `bee.loadConfig()`.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.beefree.io/beefree-sdk/ai-and-mcp/ai-co-pilot.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
