> For the complete documentation index, see [llms.txt](https://docs.bito.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.bito.ai/governor/set-up-bito-governor-bito-hosted.md).

# Set up Bito Governor (Bito-hosted)

[Bito Governor](/governor/overview.md) runs either on Bito's infrastructure or inside your own network. This page covers the Bito-hosted deployment. To run Governor inside your own network, see [Set up Bito Governor (self-hosted)](/governor/set-up-bito-governor-self-hosted-with-docker.md).

With Bito-hosted Governor, Bito operates the infrastructure and there is nothing for you to install. You configure your workspace in the Bito Governor admin UI at <https://gateway.bito.ai/admin/>, then point your AI coding tools at it.

Setup has four parts:

|      Setup parts     | Description                                                                                                                                         |
| :------------------: | --------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Provider account** | Stores an API key for an LLM provider. Add an account for every provider you use.                                                                   |
|       **Route**      | <p>Which provider and model serve each request.</p><p></p><p>Maps a model alias your tools request to a provider account and an upstream model.</p> |
|    **Gateway key**   | Authenticates a coding tool to Governor.                                                                                                            |
|      **Feature**     | A server-side capability that runs inside a request, such as [Bito's AI Architect](/ai-architect/overview.md). Optional.                            |

## Prerequisites

You need the following:

* **Admin Token.** Contact <support@bito.ai> to set up Governor for the first time. Bito creates your account and sends you an Admin Token.
* **An API key for each LLM provider you use,** such as Anthropic, OpenAI, Groq, or Google. Governor sends requests to your own provider accounts.
* **The model names your coding tools request,** such as `claude-opus-4-8`. Model names are case sensitive.
* **AI Architect MCP URL and access token,** if you enable AI Architect. Both are available in your [Bito account](https://alpha.bito.ai/).

## Sign in

1. Go to <https://gateway.bito.ai/admin/>.
2. Enter your Admin Token.

The workspace opens on the **Dashboard**. The left sidebar contains the following pages: Dashboard, Documentation, Reports, Keys, Members, Accounts, Routes, Features, Limits, Prices, Test, and Audit.

Your Admin Token grants access to your own workspace only.

Most configuration pages contain a form at the top and a table of existing entries below it.

## Step 1: Add a provider account

A provider account stores one API key. Add an account for every provider you use, such as Anthropic, OpenAI, Groq, Fireworks, OpenRouter, Together, or Google. Add more than one account for the same provider when you hold several keys, for example one per team or environment.

1. In the left sidebar, click **Accounts**.
2. In the **Add account** form, complete the following fields:

| Field    | Description                                                                                                                                     |
| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| provider | The provider you are connecting.                                                                                                                |
| name     | A name for this account, for example `prod` or `my-vllm`. The name appears in routes, reports, and prices.                                      |
| key      | Your provider API key. Governor stores it envelope encrypted.                                                                                   |
| base url | The provider endpoint. The default is filled in for each provider. Override it for a proxy, a regional endpoint, or a self-hosted model server. |

3. Click **Add**.

The account appears in the **Accounts** table with the actions **edit**, **test**, **reveal**, and **remove**.

4. Click **test** on the new account. **test** checks the connection to the provider to verify the key and endpoint.

{% hint style="info" %}
To forward the credential supplied by the caller, leave the **key** field blank. This is passthrough mode.

Azure accounts can authenticate with an Entra ID service principal instead of an API key.
{% endhint %}

{% hint style="info" %}
**reveal** displays a stored provider key. Every use is recorded in the audit log.
{% endhint %}

#### Examples

<details>

<summary><strong>Expand to view examples</strong></summary>

Each example states a goal, then the values to enter in the **Add account** form.

#### Connect a provider

Add your organization's Anthropic key.

| provider  | name             | key                    | base url                  |
| --------- | ---------------- | ---------------------- | ------------------------- |
| anthropic | `prod-anthropic` | your Anthropic API key | leave the prefilled value |

Governor fills in **base url** when you select a provider. Change it only for a proxy, a regional endpoint, or a server you host yourself.

#### Separate production and staging spend

Bill staging traffic to a different key from production.

| provider  | name                | key                 | base url                  |
| --------- | ------------------- | ------------------- | ------------------------- |
| anthropic | `prod-anthropic`    | your production key | leave the prefilled value |
| anthropic | `staging-anthropic` | your staging key    | leave the prefilled value |

Add the provider twice under different names. Routes select an account by name, and reports show which account served each request, so spend separates cleanly.

#### Connect a model you host yourself

Send requests to a model running on your own inference server.

| provider | name      | key                                                | base url                      |
| -------- | --------- | -------------------------------------------------- | ----------------------------- |
| openai   | `my-vllm` | your server's key, or leave empty if it needs none | your inference server address |

Any server that implements the OpenAI API works here.

#### Forward the caller's own key

Apply routing and reporting to traffic without storing provider keys centrally.

| provider | name                 | key         | base url                  |
| -------- | -------------------- | ----------- | ------------------------- |
| openai   | `passthrough-openai` | leave empty | leave the prefilled value |

An account with no key runs in passthrough mode, where Governor forwards the credential the caller supplied.

</details>

## Step 2: Add a route

A route maps a model alias your coding tool requests to a provider account and an upstream model.

1. In the left sidebar, click **Routes**.
2. In the **Add route** form, complete the following fields:

<table data-search="false"><thead><tr><th>Field</th><th>Description</th></tr></thead><tbody><tr><td>alias</td><td>The model name your coding tool requests, for example <code>claude-opus-4-8</code> or <code>claude-*</code>. Enter <code>*</code> to match any model.</td></tr><tr><td>provider</td><td>The provider that serves the request.</td></tr><tr><td>account</td><td>The provider account used.</td></tr><tr><td>model (or *)</td><td>The upstream model sent to the provider. Enter <code>*</code> to forward the model name the tool requested.</td></tr><tr><td>api</td><td>The API dialect. Leave it on <strong>auto</strong> to follow the caller.</td></tr><tr><td>priority</td><td>The failover tier. Lower numbers are used first. Default <code>0</code>.</td></tr><tr><td>weight</td><td>The share of traffic within a tier. Default <code>1</code>.</td></tr><tr><td>retries</td><td>Retry attempts for this target. Leave blank to use the gateway default.</td></tr></tbody></table>

3. Click **Add route**.

Routes are grouped by alias in the table below the form. Each group lists its targets with provider, model, account, priority, weight, retries, an enable toggle, and a health state. Priority, weight, and retries are editable inline.

A target marked **cooling** is in a cooldown period after repeated failures. Governor sends its traffic to the next available target until it recovers.

#### Wildcard and exact aliases

An alias can be an exact model name such as `claude-opus-4-8`, or a wildcard such as `claude-sonnet-*` or `*`.

A route with `*` as both the alias and the upstream model passes every request through to the selected account unchanged.

Exact aliases take precedence over wildcards. A route for `claude-opus-4-8` is used instead of a `claude-*` route, and a `claude-*` route is used instead of `*`. This lets you run one catch-all route so that every model reaches a provider, then override selectively for the models you care about.

#### Failover and load balancing

Add the same alias again with a different provider account.

* Governor uses the lowest priority tier first.
* Within a tier, traffic is distributed by weight.
* Targets with the same priority receive requests in turn.
* If a provider returns errors, Governor sends the request to the next available target.

#### Examples

<details>

<summary><strong>Expand to view examples</strong></summary>

Each example states a goal, then the values to enter in the **Add route** form.

#### Route every model to one provider

Send all traffic to a single account, without naming each model.

| alias | provider  | account          | model | priority |
| ----- | --------- | ---------------- | ----- | -------- |
| `*`   | anthropic | `prod-anthropic` | `*`   | 0        |

Type the asterisk in both fields. `*` in the alias matches any model, and `*` in the model field forwards the model name your tool sent. Add this route first, so that every request reaches a provider while you configure the rest.

#### Route a model family to one account

Send every version of Sonnet to an Azure account.

| alias             | provider | account      | model | priority |
| ----------------- | -------- | ------------ | ----- | -------- |
| `claude-sonnet-*` | azure    | `azure-prod` | `*`   | 0        |

The wildcard matches `claude-sonnet-5`, `claude-sonnet-4-5`, and later versions, so new releases need no new route. This alias is more specific than `*`, so it overrides the catch-all.

#### Fail over to a second provider

Serve Opus 5 from Anthropic, and switch to Azure while Anthropic is unavailable.

| alias           | provider  | account          | model           | priority |
| --------------- | --------- | ---------------- | --------------- | -------- |
| `claude-opus-5` | anthropic | `prod-anthropic` | `claude-opus-5` | 0        |
| `claude-opus-5` | azure     | `azure-prod`     | `claude-opus-5` | 1        |

Add the alias once per account. Priority `0` takes all traffic. When those requests fail, Governor moves them to priority `1` until the primary account recovers.

#### Split traffic across two accounts

Spread Opus 5 traffic so that neither account reaches its rate limit.

| alias           | provider  | account          | model           | priority | weight |
| --------------- | --------- | ---------------- | --------------- | -------- | ------ |
| `claude-opus-5` | anthropic | `prod-anthropic` | `claude-opus-5` | 0        | 3      |
| `claude-opus-5` | azure     | `azure-prod`     | `claude-opus-5` | 0        | 1      |

Equal priorities put both targets in the same tier, and the weights send three requests to Anthropic for every one to Azure. Set both weights to `1` for an even split.

#### Serve a request with a different model

Serve Opus 5 requests with a lower-cost model, with no change on any developer machine.

| alias           | provider  | account          | model             | priority |
| --------------- | --------- | ---------------- | ----------------- | -------- |
| `claude-opus-5` | anthropic | `prod-anthropic` | `claude-sonnet-5` | 0        |

The alias is the model your tool requests. The model is what serves the request. Your tools continue to request Opus 5, and Governor serves those requests with Sonnet 5. Edit the route to reverse it.

</details>

{% hint style="info" %}
Before applying a model substitution across your workspace, run it against a representative set of your own tasks and compare results as well as cost.
{% endhint %}

## Step 3: Create a gateway key

A gateway key authenticates a coding tool to Governor. Provider keys stay in the Bito UI.

1. In the left sidebar, click **Keys**.
2. In the **Create key** form, enter a **name** that identifies the team or tool that will use the key.
3. Click **Create**.
4. Copy the key.

The key starts with `gw_sk_` and is displayed once. Governor stores keys hashed and cannot display them again.

The **Keys** table lists each key by ID, prefix, name, enabled status, and a **revoke** action.

{% hint style="info" %}
Create one key per team or tool so that you can revoke one without affecting the others.
{% endhint %}

## Step 4: Enable features

Features are server-side capabilities that Governor runs inside a request. Two features are available, and both are optional.

The **Features** table lists each enabled feature with its alias, state, whether a token is stored, and its MCP URL, with **edit**, **test connection**, and **disable** actions. Enabled features also appear as badges against each alias on the **Routes** page.

#### AI Architect

AI Architect serves system context from a live knowledge graph of your engineering system, covering code, business context, and tribal knowledge. Governor applies it inside each request, so your coding tools receive that context as they work.

1. In the left sidebar, click **Features**.
2. In the **Configure feature** form, select `ai_architect` from the **feature** list.
3. Complete the following fields:

<table data-search="false"><thead><tr><th>Field</th><th>Description</th></tr></thead><tbody><tr><td>alias</td><td>Leave blank to enable the feature across the workspace, or enter a route alias such as <code>claude-*</code> to scope it to that alias.</td></tr><tr><td>MCP URL</td><td>Your AI Architect MCP endpoint. If left empty, Governor falls back to a built-in stub.</td></tr><tr><td>Steering text</td><td>Overrides the default instructions Governor sends with AI Architect. Leave blank to use the default.</td></tr><tr><td>Tool allowlist</td><td>Restricts which AI Architect tools the model may call, one tool name per line. Leave empty to allow all.</td></tr><tr><td>Max hops</td><td>The hop budget for a single AI Architect lookup. Default <code>16</code>. See <a href="#max-hops">Max hops</a> below for more details.</td></tr><tr><td>Max hops per request</td><td>The combined hop budget across every AI Architect lookup in one request. Leave blank to use the gateway default.</td></tr><tr><td>Prompt-cache injection</td><td>Caches what Governor sends with AI Architect on Anthropic, so repeat hops bill at the cache-read rate. Leave on <strong>Use default</strong> to follow the gateway-wide setting.</td></tr><tr><td>Architect model (sub-agent)</td><td>Runs the AI Architect lookups on a cheaper route alias while the route model writes the answer, for example <code>gemini-3.1-flash-lite</code> or <code>gpt-5.6-luna</code>. Leave blank to run them on the request's own route model.</td></tr><tr><td>Run Architect in-loop (legacy)</td><td>Runs the AI Architect tools inline on the route model instead of the default sub-agent mode. Ignored when an Architect model is set.</td></tr><tr><td>Quality mode</td><td><p>Sets how deeply AI Architect researches a question.<br><br>Choose one of the following:</p><ul><li><strong>Use default:</strong> follows the gateway-wide setting.</li><li><strong>Normal:</strong> uses the standard prompts and hop budget. This is the default.</li><li><strong>High quality:</strong> researches deeper and more thoroughly, at roughly twice the AI Architect cost.</li></ul></td></tr><tr><td>MCP token</td><td>Your AI Architect access token. Leave blank to keep the token already stored.</td></tr></tbody></table>

4. Click **Enable**.

Changes apply to the next request. Users take no action.

{% hint style="info" %}
Setting **Architect model (sub-agent)** to a cheaper alias moves the AI Architect lookups off your main model while the route model still writes the answer. This reduces the cost of a request that takes several hops.
{% endhint %}

#### Max hops

Some questions require several passes to answer. A question about how your repositories connect requires Governor to retrieve the repository list, then look up the dependencies of each repository. Each pass is a hop.

Two settings cap this work, and both apply at the same time.

| Setting              | Scope                                               |
| -------------------- | --------------------------------------------------- |
| Max hops             | One AI Architect lookup.                            |
| Max hops per request | Every AI Architect lookup in one request, combined. |

A single request can trigger more than one lookup, so **Max hops per request** is what stops a complex request from running up cost through repeated lookups that each stay within their own limit.

Governor stops as soon as it has an answer, so both values are ceilings rather than fixed costs.

| Max hops     | Use                                                                                               |
| ------------ | ------------------------------------------------------------------------------------------------- |
| 16           | Default. Suitable for most workspaces.                                                            |
| 30 or higher | Workspaces with several hundred repositories, or teams that ask broad cross-repository questions. |

Raise **Max hops** if answers come back incomplete. Leave **Max hops per request** blank to use the gateway default, and set it when you want a firm ceiling on how much AI Architect work a single request can do. Each hop consumes tokens.

#### Reasoning downgrade

`reasoning_downgrade` lowers the reasoning effort of a request by exactly one level. Reasoning tokens bill at the output rate, so a lower level reduces the cost of the request.

1. In the left sidebar, click **Features**.
2. In the **Configure feature** form, select `reasoning_downgrade` from the **feature** list.
3. Leave **alias** blank to apply the feature across the workspace, or enter a route alias such as `claude-*` to scope it to that alias.
4. Click **Enable**.

Apart from **alias**, the `reasoning_downgrade` feature has no settings.

Governor leaves a request unchanged when it already uses the lowest or second-lowest reasoning level, or when it sends no reasoning at all.

## Step 5: Connect a coding tool

In the left sidebar, click **Documentation**. Your base URL is displayed at the top of the page, and the links below it jump to the four sections on the page.

| Section        | Contents                                                                                     |
| -------------- | -------------------------------------------------------------------------------------------- |
| Get started    | Your base URL, a field for your gateway key, and how to authenticate.                        |
| Use it         | Ready-made curl, Python, and JavaScript requests, and **Try it** for sending a live request. |
| Connect a tool | Copy-paste setup for each supported coding tool.                                             |
| Reference      | Endpoints, your route aliases, and how usage and cost are reported.                          |

To connect a coding tool:

1. In the **Get started** section, paste a gateway key into the key field. Every example on the page fills in with your base URL and key. To generate a key here, click **+ Create test key**.
2. In the **Connect a tool** section, select your tool.

Setup is provided for Claude Code, Cursor, Cline (VS Code), Continue (VS Code / JetBrains), Aider, Codex CLI, GitHub Copilot CLI, Windsurf, Zed, and any OpenAI-compatible or Anthropic-compatible tool.

For Claude Code, set two environment variables and start the tool:

```bash
export ANTHROPIC_BASE_URL="https://gateway.bito.ai"
export ANTHROPIC_AUTH_TOKEN="gw_sk_..."
claude
```

To configure a team, distribute these two variables using your existing developer environment tooling. If your traffic already passes through a central gateway, set them there instead.

Governor accepts requests on three endpoints:

| Path                   | Dialect                 | Used by                             |
| ---------------------- | ----------------------- | ----------------------------------- |
| `/v1/messages`         | Anthropic Messages      | Claude Code, Anthropic SDKs         |
| `/v1/chat/completions` | OpenAI Chat Completions | Codex, most OpenAI-compatible tools |
| `/v1/responses`        | OpenAI Responses        | OpenAI Responses API clients        |

Authenticate with `Authorization: Bearer <GATEWAY_KEY>` or `X-Api-Key: <GATEWAY_KEY>`. The same gateway key works for all three dialects.

{% hint style="info" %}
Claude Code reports that its connectors are disabled when it runs through Governor, because the session authenticates against Governor rather than a Claude account. This message is expected. AI Architect continues to work, because Governor serves it from the server side.
{% endhint %}

## Operate the Bito Governor

### Verify the configuration

1. **Check route selection.** In the left sidebar, click **Test**. Enter a model alias and click **Test**. Governor returns the route, provider, account, and lane it would use. No request is sent, so this costs nothing.
2. **Send a request.** In the left sidebar, click **Documentation**. In the **Use it** section, go to **Try it**. Paste a gateway key, select a model, type a prompt in the message box, and click **Run**. This sends a real, billable request to your provider.
3. **Query your own system.** From your coding tool, ask a question that requires knowledge of your repositories. A response naming your own services confirms AI Architect is active.
4. **Check the report.** In the left sidebar, click **Reports** and confirm the requests appear.

{% hint style="info" %}
For a wildcard alias such as `claude-*`, enter a concrete model that matches it, for example `claude-opus-4-8`.
{% endhint %}

### Set prices

Token prices produce the cost figures on the **Dashboard** and in **Reports**. Prices are expressed in `$/Mtok`, meaning US dollars per million tokens.

Global defaults are maintained by your gateway operator. Set a price here to override the default for your workspace, or to record a negotiated rate for one account. Governor resolves prices in this order: account, then workspace, then global.

1. In the left sidebar, click **Prices**.
2. In the **Set price** form, select the **vendor**.
3. Select an **account** to apply the price to that account only, or leave it on **all accounts** to apply the vendor rate across your workspace.
4. Enter the **model** name.
5. Enter **in**, **out**, and optionally **cache-read** and **cache-write** prices, all in `$/Mtok`.
6. Click **Set**.

The **Prices** table lists each price with its scope, vendor, model, rates, and source.

A model with no price reports token counts and a cost of zero. The **Dashboard** shows the number of unpriced requests per model in the **UNPRICED** column.

### Set limits

Limits are applied per gateway key.

1. In the left sidebar, click **Limits**.
2. In the **Set limits** form, select a **key**.
3. Complete any of the following fields:

| Field            | Description                                   |
| ---------------- | --------------------------------------------- |
| rpm              | Maximum requests per minute.                  |
| tpm              | Maximum tokens per minute.                    |
| budget ($/month) | Monthly spend cap. Requires prices to be set. |
| max\_concurrency | Maximum concurrent requests.                  |

4. Click **Set**.

Leave a field blank to leave it unchanged. Enter `0` to remove a cap, which makes that limit unlimited.

{% hint style="info" %}
Setting a limit to `0` removes the cap rather than blocking the key. To stop a key entirely, disable it on the **Keys** page.
{% endhint %}

### Monitor usage and cost

#### Dashboard

The **Dashboard** shows spend and request volume for the last 30 days, with totals for requests, input tokens, output tokens, and cost. Use **Group by** to break the numbers down by model, alias, key, provider, account, detail, or feature.

The table below the chart lists requests, token counts, cost, and unpriced request count per model.

#### Reports

**Reports** is the raw event log, with one row per request, updated in near real time. Filter the log and export it with **Download CSV**.

Token counts are split into four buckets:

| Bucket   | Description                                                             |
| -------- | ----------------------------------------------------------------------- |
| in       | Fresh prompt tokens, excluding anything served from cache.              |
| cached   | Prompt tokens read from cache, billed at a lower rate.                  |
| cache\_w | Tokens written to the cache. On Anthropic this carries a small premium. |
| out      | All generated tokens, including reasoning tokens.                       |

The full prompt your tool sent is `in + cached + cache_w`. The buckets do not overlap, so nothing is counted twice.

Features make hidden calls inside a request and are reported separately. The base columns show the answer the caller received, and the feature columns show the feature's own usage. A request's total is base plus feature. Expand a row to see the split.

#### Measure the effect of AI Architect

Governor does not currently report savings against a baseline. To measure the effect:

1. Select a set of tasks your team runs regularly.
2. Disable AI Architect, run the tasks, and record cost per task from **Reports**.
3. Enable AI Architect and run the same tasks with the same tool and model.
4. Compare cost per task and confirm the tasks still complete correctly.

### Add members

1. In the left sidebar, click **Members**.
2. In the **Add team member** form, enter a **name** and select a **role**.
3. Click **Create**.

Each member signs in to the Bito UI with the token generated for them.

| Role            | Permissions                                                                                   |
| --------------- | --------------------------------------------------------------------------------------------- |
| Member          | Manages their own gateway keys and views their own usage.                                     |
| Workspace admin | Full configuration access to the workspace, including routes, accounts, features, and limits. |

You can disable a member from the **Team** table. To change or disable a workspace admin, contact <support@bito.ai>.

### View the audit log

**Audit** records every configuration change and every secret reveal in your workspace, with the admin who performed it and a timestamp. The log is read only.

Give each person their own member token, so that the log identifies who made each change.

## Troubleshooting

<table data-search="false"><thead><tr><th>Symptom</th><th>Cause</th><th>Resolution</th></tr></thead><tbody><tr><td><code>401</code> from Governor</td><td>The gateway key is invalid or revoked.</td><td>Create a new key on <strong>Keys</strong> and update the tool configuration.</td></tr><tr><td><code>404</code> for a model</td><td>No route matches the requested alias.</td><td>Add a route for the exact model name, or add a <code>*</code> route.</td></tr><tr><td>Requests reach an unexpected model</td><td>An exact alias takes precedence over the <code>*</code> route.</td><td>Open <strong>Routes</strong>. Exact aliases override wildcards.</td></tr><tr><td>A route shows <strong>cooling</strong></td><td>The target failed repeatedly and is in a cooldown.</td><td>Check the provider account with <strong>test</strong> on the <strong>Accounts</strong> page. Traffic uses the next target until it recovers.</td></tr><tr><td>Cost column shows zero, or UNPRICED is high</td><td>The model has no price set.</td><td>Add prices for that model on <strong>Prices</strong>.</td></tr><tr><td>Budget limit has no effect</td><td>The model has no price set, or the limit is <code>0</code>.</td><td>Set prices, then set a positive budget. <code>0</code> means unlimited.</td></tr><tr><td>A key still works after setting limits to <code>0</code></td><td><code>0</code> removes the cap rather than blocking the key.</td><td>Disable the key on <strong>Keys</strong>.</td></tr><tr><td>AI Architect responses lack system context</td><td>The feature is disabled, scoped to a different alias, or the MCP URL is empty.</td><td>Open <strong>Features</strong> and check the alias, MCP URL, and token. An empty MCP URL falls back to a built-in stub.</td></tr><tr><td>Broad questions return incomplete answers</td><td>Governor reached the max hops budget.</td><td>Increase <strong>Max hops</strong> and repeat the question.</td></tr><tr><td>Repeated <code>429</code> or <code>5xx</code></td><td>One provider account is rate limited or unavailable.</td><td>Add a second target on the same alias to enable failover.</td></tr></tbody></table>

## What's next

* [Governor overview](/governor/overview.md)
* [Deploy Governor (self-hosted)](/governor/set-up-bito-governor-self-hosted-with-docker.md)
* Contact <support@bito.ai> for configuration assistance.


---

# 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 dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.bito.ai/governor/set-up-bito-governor-bito-hosted.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.