Tools
Connect MCP tool servers or write hosted ones, review every tool a server offers before an agent can call it, and grant servers to the organizations that may use them
A tool is something an agent can call in another system — search a corpus, look up a ticket, post a message. Admin → Tools is where an administrator connects the servers that offer those tools and decides, one tool at a time, which of them an agent is allowed to call. Open it with the Admin control in the top navigation bar, then choose Tools under Capabilities.
Connecting and reviewing tool servers takes Manage tools; View tools opens this page read-only, with every server's tools, releases and calls, and Sync, Test, edits and deletes held. Granting a connected server to an agent needs no permission: administrators connect servers and decide which organizations may use them, and the people with Write access to an agent's project choose which of those it may call.

A new tenant has no tool servers. Nothing is connected until an administrator connects it.
Three kinds of server
| Tab | What it holds |
|---|---|
| MCP Servers | Tool servers this tenant connects by URL and credential. Every tool one offers is held for review before an agent can bind it. |
| Builtin | Tools the platform authors, such as SQL connections and Mailboxes, added as many times as you need, each with its own settings. Their tools arrive already approved, because there is no third-party text for an administrator to read. |
| Hosted | Servers whose code you write here and the platform builds and runs for this tenant: see Hosted servers. |
Each tab reads its servers afresh when you open it, so a tab always shows that kind's current list.
The Builtin tab shows a card for each kind of platform tool, with the connections you added listed beneath it. Today those are SQL database, see SQL connections, and Mailbox archives, see Mailboxes.

Each card lists its connections; Add connection adds another.
Connect an MCP server
Choose Connect a tool server.
Leave Kind on MCP Server, then give the server a Name and a Description.
Enter the URL of its MCP endpoint.
Tick the Organizations that may use it. You can change this later on the Organizations tab.
Choose an Authentication method and fill in what it needs.
Choose Connect. The handshake runs immediately, so the sheet that opens is already showing what the server offered.

The notice above Authentication is the most important sentence on the form — see below.
Authentication
| Method | What it sends | What it needs |
|---|---|---|
| No authentication | Nothing. | — |
| Header token | A secret in a request header. | Header name (required), an optional prefix such as Bearer , and the Token. |
| OAuth client credentials | A token fetched with a client ID and secret. | Client ID (required), the Client secret, optional Scopes, and where the credentials are sent at the token endpoint. |
One server, one credential, shared by everyone. Every agent, in every organization granted this server, calls it as this one connected account — there are no per-agent credentials. Granting a server to an agent is granting that agent the right to act as that account.
For OAuth, where the client ID and secret are sent is asked rather than negotiated. A server that accepts only the request body answers a correctly-formed Basic header with invalid_client — the same error it returns for a wrong secret — so no status code can tell the two apart. Set it to match what your server expects.
An OAuth server's authorization server must publish its metadata (RFC 8414, or an OpenID discovery document), naming the token endpoint the secret is sent to. Without it the secret is sent nowhere — never to a /token guessed on the server's own host — agents' calls to the server fail, and Sync tools and Test connection fail with no OAuth authorization-server metadata could be read for this server.
A credential is write-only: the stored value never comes back, and the form shows only whether one is set. Sending a new value rotates it, one field at a time.

A connected server's card is a summary of everything that decides whether its tools are reachable: its status, when it last synced, how many organizations hold it, and how it authenticates.
Every tool is held for review
This is the property the whole feature is built around. A tool's title, description and schemas are text a third party wrote, and an agent follows them. So nothing a server offers is callable until an administrator has read it and accepted it under their own name.

Three tools discovered, none of them approvable yet — the page approval counts only rows whose text has been on screen.
A row joins the page approval only after its schemas have been opened. That is not a formality: the input schemas are not on the row, so a bulk approval that promoted them unread would put an administrator's name on text nobody saw. There is deliberately no control that marks rows read without showing them.

Opening one row's schemas admits that row and no other. Show what approving all N accepts opens the rest — a shortcut through the gate, never around it.
Open the server and go to its Tools tab.
Read each tool. Use Show the schemas on a row, or Show what approving all N accepts to open every held-back row at once.
Choose Approve N on this page.
Approval is per page of the listing, and the button's label carries the count — Approve 0 on this page and Approve 3 on this page are the same control. If tools on another page are still waiting, the tab says so.

Approving accepts a tool. It does not switch it on — those are two decisions.
Approve, enable, effect
Each row carries three things, and all three must line up before an agent can call the tool:
| Control | Meaning |
|---|---|
| Approval | An administrator has read this version of the tool and accepted it. |
| Enable | This tool is offered to agents at all. Approving an MCP server's tool never switches it on. |
| Effect | Read only or Side effecting. A side-effecting tool changes something in the outside world, so a beat spends an action budget slot on it and an agent at manual autonomy may not call it at all. |
A tool binds to an agent only when it is approved, enabled, and still offered by the server.
The effect is an administrator's decision — nothing is inferred from the tool's name. The default it starts from does come from the server, though: a tool declaring readOnlyHint arrives marked Read only, which costs no action budget and is exempt from the manual-approval gate. Check it rather than accept it, since the server is a third party. It is what the runtime reads when it decides whether a call costs an action and whether approval is required — see Policies.
When a server changes underneath you
Sync tools re-reads what the server offers. Anything that changed lands as pending, and the row is pulled back into review: the tool keeps running for agents at the text that was approved, while the new text waits for someone to read it.

A rewritten description is shown in plain sight, labelled as not yet accepted, and the approval gate is closed again.
The rewritten text is on the row rather than hidden behind the disclosure, because that is what an administrator has to read before deciding. Approving replaces the approved title and description with the pending ones; the disclosure holds the comparison, so you can see exactly what you are accepting and what you are discarding.
Until then, agents keep binding the approved snapshot. A description rewritten upstream does not reach an agent on its own.
Test connection runs the same handshake and writes nothing — use it to check a URL or a credential without touching the catalog.
Moving a connected server to a different URL deletes every tool it has offered and drops the server back to inactive and not synced, so each tool has to be discovered and approved again — including the decisions about what each one is allowed to do. The form asks you to confirm before it does that.
Switching a server on and off
Switched on is the administrator's own decision about whether the server should run, separate from the status the last handshake reported. A server that is switched off binds to no agent, whatever organizations it is granted to.
A server can only be switched on once a sync has succeeded against it — until then it is offered to no agent, and the control says so rather than failing silently.
Simulated systems
Switch on Simulated system when a server stands in for a real one, such as a demo's stub. Its card is marked Simulated, and so is each call an agent makes to it while it is marked, on its project's Activity tab. Calls made before you switch it on stay unmarked, and those made while it was on keep the mark. It is a label only: the server binds, runs and is governed as any other.
Organizations
An MCP server is connected once for the tenant and then granted to the organizations that may use it. Agents in those organizations' projects can be given the server; an organization removed here loses it immediately.

The checklist is the complete set. Saving with nothing ticked revokes the server everywhere, and the confirmation says so.
The Agents tab answers the other half of that question — which agents currently hold a grant to this server, and therefore what a revoke or a delete would take away. It is a read, so it has a tab of its own rather than only appearing when you start to destroy something.
Hosted servers
A hosted server is a tool server whose code the platform builds and runs, rather than one you connect by URL. Its code runs in an isolated sandbox that belongs to that one server, and one project's calls never share a running environment with another project's.
You write a hosted server's code here and publish it, the platform builds and checks each release, and an administrator reviews and approves it before any agent can call its tools. Its tools are approved with the release that carries them, so its tool list has no approve control.
Write a hosted server
There is nothing to install: a hosted server is written, published and run from the console.
On the Hosted tab, choose New hosted server. Give it a Name, pick its Runtime, Node.js 24 or Python 3.14, and a Template to start from, then choose Create.
The server opens on its Source tab. Edit its files, its dependencies, its Memory (MB) and its Timeout (seconds), and choose Save. The entry file, server.mjs or server.py, is an ordinary MCP server written with the official SDK, which the platform installs for you.
Each file opens in a code editor that highlights Python and JavaScript, numbers its lines, indents as you type and closes brackets. Completions appear as you type, or when you press Ctrl+Space: the language's keywords, the names the file defines, and the platform's askrai helpers, each with a line on what it does. Ctrl+F (⌘F on a Mac) searches the file. Tab indents; press Escape and then Tab to move on from the editor.
Choose Publish. The platform builds the saved source into a new release, and the Releases tab shows it move: Building, Built, Staging, then Staged, with the tools it offers listed as Pending approval.
Choose Review release, read what the release changes, and choose Approve release: see Review and approve a release.

A hosted server starts from a template on one runtime.

The Source tab holds everything a release is built from.
Each template is a small working server you can publish as it is:
| Template | What its tool does | Dependencies |
|---|---|---|
| Word count | Counts the words in a block of text | none |
| Spreadsheet to CSV | Turns one sheet of an .xlsx file, sent as base64, into CSV text | openpyxl (Python), exceljs (Node.js) |
| Spreadsheet summary (Python only) | Reads an .xlsx file from the calling project's Workspace tab and summarizes each sheet in Markdown: its size and first rows | openpyxl, reading the file as Reading files describes |
| Chart | Draws a bar chart of labelled values as a PNG image | matplotlib (Python), sharp (Node.js) |
| REST call with a secret | Calls an HTTP API with a token from the server's secrets | none |
| Web screenshot (Node.js only) | Opens a public web page in Chromium and saves a PNG of it to the calling project's Workspace tab | puppeteer-core, on the browser layer |
Every Node.js template also declares zod, which its tools' input schemas are written in. A tool receives what it works on as its arguments, and reads a file of the project's Workspace tab the agent passes it (see Reading files). An image it returns is not shown to the model.
Saving files
A tool saves a file into the calling project's Workspace tab with askrai.file(), and returns what that gives back as part of its result:
const link = await askrai.file(ctx, png, 'image/png', 'chart.png')
return { content: [{ type: 'text', text: 'Chart drawn' }, link] }link = askrai.file(ctx, png, "image/png", "chart.png")
return [TextContent(type="text", text="Chart drawn"), link]- A call saves up to 5 files of at most 25 MB each, within the time the call has left. Python's
askrai.file()waits for its upload, so anasynctool calls it throughasyncio.to_thread. - A file appears under tool-outputs › the server's slug once the agent's beat completes, and the agent is told its name, type and size. A name already taken there gets the call's id added.
- Only a file the tool returns is kept; one it uploads but leaves out of its result is deleted within about nine days, and counts against your tenant's file storage allowance until its kept copy expires 30 days after that. Once the allowance is used up,
askrai.file()fails and the tool's error says so, and the agent is told the call saved no file even if the tool hides that error. - A test run saves its files apart from every project, for a day.
Reading files
An agent names a file of its project's Workspace tab by its askrai-workspace: link, which it reads from the files it lists or a tool's earlier result. When it passes that link among a hosted tool's arguments, the tool reads the file's bytes with askrai.read():
const bytes = await askrai.read(ctx, file)data = askrai.read(ctx, file)- A call reads up to 5 files, each as its current version stood when the call began, and only files the agent itself may read: its workspace access decides, as it does for the agent's own reads. A link to any other file, or a sixth one, gets nothing, and the agent is told which links the tool could not read and why. A file a tool saves can be passed on from the agent's next heartbeat, once it has landed in the Workspace tab.
askrai.read()fails for a link the call was given nothing for, and when the file does not arrive within the time the call has left. Reading a file twice is fine.askrai.downloads(ctx)lists the files a call may read, each with its link, name, type and size. Python'saskrai.read()waits for the file, so anasynctool calls it throughasyncio.to_thread.- A link anywhere among the arguments counts, in a list or inside a sentence. A server you connect over MCP is never given a file: a link reaches it as text.
- A release reaches
askrai.read()once it runs on helpers that have it: a release published before needs publishing again, or a platform update.
The browser layer
A Node.js server can drive a web browser. Tick Browser layer under Layers on its Source tab, declare puppeteer-core among its dependencies, and start Chromium with askrai.browser.launch():
const browser = await askrai.browser.launch(ctx)
const page = await browser.newPage()- Its pages reach public addresses only. A request, redirect, embedded resource or WebSocket to a private, loopback or link-local address is refused, and so is any scheme but
httpandhttps, such asfile:, besides a page's owndata:andblob:URLs. - Open every page in the browser's default context, with
browser.newPage(). Chromium runs as a single process here, and a second browser context,browser.createBrowserContext(), ends it. - Nothing outlasts the call. The browser is closed and its profile removed when the call ends, whatever the code left open.
- It brings fonts for Chinese, Japanese and Korean text and for emoji, and gives the server 2 GB of temporary storage.
- A release keeps the browser it was built with. Each release uses the browser layer's version that was current when its build started, and its review shows that version.
The Web screenshot template is a working example. It waits for the page to load until 3 seconds before the call runs out of time, then captures what has rendered, and its result says when the page had not finished loading. A page that fails to load, or that has not begun to arrive by then, is an error the agent is told the reason for, and nothing is saved.
What a hosted server can be
| Limit | Value |
|---|---|
| Runtime | Node.js 24 or Python 3.14 |
| Files | At most 100 text files, 512 KB together. A path stays inside the server and may not be a file a package manager reads, such as package.json, .npmrc, pyproject.toml or requirements.txt |
| Dependencies | At most 50 packages from npm or PyPI, each at an exact version, such as 3.1.5. No ranges, git or URL dependencies |
| Packages | Installed with install scripts off and from prebuilt binaries only, for Linux on arm64. A version published less than two days ago is not installed yet |
| Size | The built server, with what it installs and the browser layer if it uses it, at most 250 MB |
| Memory | 512 to 3008 MB |
| Timeout | 2 to 27 seconds a call |
| Network | Internet access, or none: see Network access |
| State | None between calls: each call may run in a fresh environment |
The MCP SDK and the platform's own helpers are provided, so a server may not declare them, nor any package in the @askrai/ or askrai- namespaces. A tenant holds at most 25 hosted servers, unless AskRAI has raised its limit.
Network access
The Source tab's Egress sets what the server's code can reach, and each release keeps the choice it was published with. Two modes are available today:
| Egress | The server's code reaches |
|---|---|
| Internet | Any host on the internet, as the code itself chooses |
| No network access | Nothing on the internet: it can neither connect to a host nor look up a name. The files a call saves with askrai.file() still reach the project's Workspace tab |
A third mode, Allowlisted hosts only, is coming soon. Egress lists it, marked Coming soon, but it cannot be chosen yet.
Choose No network access for a server that only works on what its call carries, such as Word count, Spreadsheet to CSV or Chart. Changing it is a source change like any other: it takes effect when you publish and approve a release, and the release review shows it under Settings. A server with no network access that no agent has called for 14 days can answer its next call as unavailable, at no cost, while it reconnects; the calls after it go through.
Secrets
The Secrets tab holds the server's secrets, each under a name you choose, such as API_TOKEN. Add one, rotate its value or remove it, one at a time; a value is never shown again once saved. Every call carries all of them, and the code reads one by its name: askrai.secrets(ctx)["API_TOKEN"].
Whoever can publish this server can use its secrets: publishing runs code with them. Secrets are removed from everything the platform keeps or shows, but the server's own code holds them during a call.
Publish a release
Each Publish builds the saved source in an environment of its own:
- Packages are checked before anything runs. A dependency that a security advisory marks as malicious fails the release. Any other advisory is shown on the release as a warning.
- The platform checks what it built against your source before it stages it.
- A newer publish replaces an earlier one that is not yet live, which shows as Superseded.
- Builds wait their turn. A tenant builds one release at a time, so a release can stay Building while another is built. A tenant publishes at most 20 times an hour.
A release that fails says whose the failure is. Your source means the build or the server itself refused it: a dependency that does not exist at that version or has no prebuilt binary, a malicious package, a size over the limit, or code that fails as it starts or cannot list its tools. Platform means it failed on our side, and publishing again later is safe. The release shows its build log either way.

A staged release lists the tools it offers, which no agent can call until the release is approved.
Review and approve a release
A release is approved as one unit: its code, its dependencies and every tool it offers. On the Releases tab, a Staged release has Review release, which sets it beside the release live now, so you read what approving it would change. For a server's first release, everything is new.
| Section | What it shows |
|---|---|
| Tools | Every tool either release lists, marked Added, Removed, Changed or Unchanged, with a changed description or input schema shown against the live one. Each tool the release lists has an Effect choice, Read only or Side effecting, and Test run (see Test-run a tool). |
| Test runs | The release's own test runs, newest first. |
| Settings | The runtime, memory, timeout and egress, with what each was if it changed. |
| Dependencies | The packages added, removed or moved to another version. |
| Lockfile | The changed lines of the exact package versions the release installs. |
| Warnings | The security advisories against those packages. |
| Source | Each changed file, line by line. |
Back to releases leaves the review without approving.

A release is reviewed beside the live one, and each tool's effect is set before it is approved.
Each tool's effect starts from what its code declares: a tool annotated readOnlyHint starts as Read only, any other as Side effecting. On a server with internet access every tool starts as Side effecting whatever it declares, because a request to an address the model chose can carry the project's data out. On a server with no network access each tool starts from what it declares. Check each one: the effect you approve is what the agent's autonomy and action budget read (see Approve, enable, effect), and you can change it later on the server's Tools tab, as for any tool.
Approve release puts the release live in one step. Agents call its tools from their next beat, and a beat already running finishes on the release it started with. A tool the live release already offered keeps whether it was switched on; a new tool arrives switched on, because approving the release was the decision. The release shows as Live, and the one it replaced as Retired. A server an administrator switched off stays off.
If someone publishes, approves or reverts this server's releases while you are reviewing, the approval is refused and the review reads the release again. Check what it holds now, then approve again.
Anyone who can manage tools can approve a release, including the person who published it. When you approve a release you published, the review says so before you choose Approve release, and the approval is recorded as a self-approval: the release is marked Self-approved, and so is the server while that release is live, on its card and as Approval on its Connection tab, and so is the audit record of every call to its tools. It is a record, not a block: no setting requires a second approver.
Revert a release
When the live release replaced an earlier one, the Releases tab shows Revert to previous release. Confirm with Revert, and the release the live one replaced goes live again in one step: its code and its tools as they were approved, from each agent's next beat. Each tool keeps whether it is switched on now, so a tool you switched off stays off. The reverted release shows as Retired, and the restored one as Live again.
A revert goes back one step only, and afterwards there is nothing further to revert to until the next release is approved. The release a live one replaced is the only earlier release kept to return to.
Platform updates
AskRAI keeps what a hosted server runs on patched: the platform layers, such as the browser layer, and the MCP SDK and helpers it provides. To move a live release onto a newer version of one, AskRAI makes a new release of the same code, files and installed packages, checks them again, and lists its tools. A newer MCP SDK replaces the one the release installed, and every other package it still needs stays at its version. The release shows as a Platform rebase, and nothing about it counts toward your hourly publish limit.
- Its tools and installed packages are unchanged: AskRAI puts it live, and the release says so beside Approved. Each tool keeps its effect and whether it is switched on, and a self-approved release stays marked Self-approved. You can revert it as any release.
- Its tools changed, or a newer MCP SDK changed its installed packages: it waits as Staged for your review, and the release asks you to approve it by a date. Review and approve it as any release: the review shows what changed in the lockfile.
- The update is not yet tried on live servers: it waits as Staged for your review even with its tools and installed packages unchanged, and the release asks you to approve it by a date.
- Its code no longer builds or lists its tools on the update: it shows as Failed, with the reason or the server's output in its build log, and asks you to publish and approve a release by a date. A newer MCP SDK that needs another version of a package the release installed is one such reason: publishing again installs them together.
Either way, everyone who can manage tools is notified, and reminded three days before the date, unless it asked you within those three days. An update to the browser layer, which carries Chromium's security fixes, is due 14 days after AskRAI published the first one your live release lacks, and any other 30 days after it asks you. Until you act, your agents keep calling the live release, past the date too: nothing changes on its own, and AskRAI follows up with you, since that release goes without the update. A server held for a malicious package is never moved, and neither is one with a release of its own being built or awaiting review.
AskRAI moves servers onto an update a few at a time, and can withdraw the update. A Platform rebase it put live is then reverted to the release before it, which lists the same tools (unless that release can no longer be restored, as one held for a malicious package cannot), and one waiting for your review shows as Superseded, asking nothing more of you. A platform rebase you approved stays live.
Test-run a tool
A test run calls one tool of a release yourself, without an agent: try it before you approve the release, or find out why a live one fails. Choose Test run beside the tool, in a Staged release's review or under Show details of a Staged or Live release on the Releases tab.
The dialog has a field for each argument the tool takes, marked (required) where the tool needs it. When an argument is a list or an object the form cannot show, switch on Edit as JSON and write the arguments as one JSON object. A test run's arguments come to at most 1,048,576 bytes (1 MiB) as JSON.
Choose Run. A run takes at most the server's timeout, and a little longer when the server has not been called for a few minutes.
The Result says whether the tool answered or failed, and shows how long it took, its billed duration and memory, and its estimated cost. Output is what an agent would read, and Log tail is the last 64 KB the code printed.

A test run shows what the tool answered and what its code printed.
A test run is a real call to the release's code:
- It runs with the server's secrets. They are removed from everything the run shows, as on an agent's call. The run is kept apart from every project's calls.
- It is recorded. Each run appears on the server's Calls tab marked Test run, with who ran it, and a release's review lists its own under Test runs. The record keeps a failed run's log tail; the whole 64 KB is shown only in the dialog, once.
- The files it saves are kept for a day. A file the code saves with
askrai.file()is listed in the Result and on the run's record, ready to open, and lands in no project's Workspace tab. A day later it is deleted. - It reads no workspace file. A test run belongs to no project, so a link in its arguments reaches the code as text, and
askrai.read()fails. - It costs what an agent's call costs. Its compute counts toward the tenant's 250,000 GB-seconds a month, and it takes one of the 5 hosted calls the tenant may run at once.
- A tenant test-runs at most 30 times an hour, unless AskRAI has raised its limit. A run past any of these limits, or while AskRAI has suspended or paused hosted tools, is refused in the dialog with the reason: it runs nothing and costs nothing.
How its calls are governed
An agent calls a hosted server's tools as it calls any other tool's, and the same controls govern it: organizations, grants, each tool's effect, the agent's autonomy, approval requirements, the per-beat call and action budgets, egress allowlists and the audit trail. On top of those:
-
The approved code is the code that runs. Each call goes to the exact release whose tools the agent was offered, never to code published after it.
-
Secrets stay out of everything kept or shown. The server's secrets travel with each call. Before anything is stored, shown to a model or shown to you, they are removed from the result, the audit trail and the call's log, encoded copies included.
-
A call that cannot run is refused before it costs anything. A tenant runs at most 5 hosted calls at once and 250,000 GB-seconds of hosted compute a month, unless AskRAI has raised its limits, and a call that starts a new environment for its server counts that environment's charge too. A call past either limit, or one the beat no longer has time to finish, is refused before it counts against the agent's budgets, and the agent is told why. A server that cannot take the call at all is reported to the agent as unavailable, also at no cost.
-
An egress allowlist admits a hosted server by name. A server with internet access is admitted only when every allowlist in force names its pseudo-host,
<slug>.hosted.invalid. Its code reaches the internet itself, so admitting it admits traffic that no allowlist restricts downstream, and Egress allowlists labels such an entry downstream traffic unrestricted. A server with no network access is admitted under every allowlist, needs no entry, and carries no such label. An agent's Skills & Tools tab shows each hosted server's network access, and warns This agent’s egress allowlists refuse its calls, naming the pseudo-host to add, when not every allowlist in force for that agent admits it. -
AskRAI can suspend a tenant's hosted tools. If a tenant's hosted code puts the platform or other tenants at risk, AskRAI suspends its hosted tools: every agent's call to one is refused at no cost, nothing can be published, and releases already building wait. The Hosted tab says so while it lasts, and only AskRAI lifts it. AskRAI can also pause every tenant's hosted tools at once while it deals with a platform-wide problem.
-
A live release found malicious is held. Every night AskRAI checks each live release's packages again. A package newly marked malicious holds that one server:
- every agent's call to its tools is refused at no cost, and its live release never runs again;
- the administrators who manage tools are notified;
- the server shows the hold and the packages behind it, and the release is marked Held.
You can still publish, test-run and approve a new release. Approving a release without the package, published after the hold, lifts it, and the held release can no longer be restored. A release published before the hold can be neither approved nor test-run: publish again. Any other new advisory shows on the live release as a warning. If the advisory is later withdrawn, AskRAI can publish the held release again for you to approve, but cannot release a package that is still marked malicious.
The audit trail records each hosted call's billed duration and memory, the charge for a new environment it started, the redacted log of a call that failed, and whether the release it ran was self-approved.
See a server's calls
A server's Calls tab lists the calls made to its tools, newest first: its test runs, and the calls agents and assistants made from the projects shared with you. A call from a project you cannot open is neither listed nor counted. Each shows when it was made, the agent or assistant and project that made it or Test run with who ran it, the tool, whether it succeeded or which step stopped it, and how long it took. The arguments a call sent and what came back are not shown here; an agent's call shows them on its project's Activity tab, to the people who can open the project.
A hosted server's calls also show their billed duration, the memory they used, an estimated cost, the files each was handed to read and the files it saved, which open from here: an agent's from its project's Workspace tab, a test run's for a day. A failed call has Show log tail: the last of what its code printed, with the server's secrets removed. The estimated cost prices the call's billed GB-seconds, with the charge for a new environment it started, at $0.0000133334 a GB-second, plus $0.0000002 for the call itself. It is a guide for comparing calls, not a bill.

Every call to a server, an agent's or a test run, newest first.
Grant a server to an agent
Open the agent on the project's Team pane and use its Skills & Tools tab. The picker offers the servers granted to that project's organization; an agent may hold up to 100.
An agent granted a whole server may call every approved, enabled tool on it — or, if you choose Only selected tools when granting the server on the agent's Skills & Tools tab, just the ones you name. Narrowing there is the least-privilege control: the agent is offered nothing else. Each tool reaches the model under a namespaced name — the server's slug, then __, then the tool's own name — so two servers offering a search tool never collide.
Delete a server
Delete is in the sheet header. Before you can confirm, the dialog reads how many agents hold the server and states the count.
Deleting removes the server, its stored credentials, every tool it has discovered, and every agent's grant to it — across the whole tenant, not only the organizations it was granted to. If a delete fails, running it again is safe and finishes what it started.
Deleting a hosted server also stops its releases, including one still building, and deletes the code it runs: every release's build and every version the platform staged. Agents lose its tools from their next beat. If the platform cannot remove all of the code at once, the server is still deleted for you, and what is left can no longer be called by any agent.
AskRAI keeps a short record of each deleted hosted server for a year, also after your tenant is erased: the name its code ran under, your tenant's id and when the server existed. It holds none of the server's code, secrets or results, and lets AskRAI answer an abuse report about the server that arrives later.
Field reference
| Field | Notes |
|---|---|
| Kind | MCP Server (connected by URL), Builtin (added from the Builtin tab's catalog) or Hosted (code you write on the Hosted tab, which the platform runs). Cannot be changed after connecting. |
| Name | Required. At most 120 characters. |
| Description | Optional. At most 500 characters. |
| URL | The MCP endpoint. Required for an MCP server, at most 2048 characters. |
| Authentication | No authentication, Header token, or OAuth client credentials. |
| Header name / prefix | Header token only. At most 128 and 64 characters. |
| Client ID / Scopes | OAuth only. At most 256 characters; up to 64 scopes. |
| Organizations | Up to 100 organizations may be granted one server. |
| Simulated system | Off unless you switch it on. Marks the server and its calls as a stand-in for a real system. |
| Effect | Per tool: Read only or Side effecting. A hosted server's tools are given theirs when their release is approved. |
| Enable | Per tool. Off until you switch it on for an MCP server. A hosted server's new tool arrives on when its release is approved. A builtin connection's tools arrive approved and on, and a tool you switch off stays off. |
A server may offer at most 500 tools.
Troubleshooting
| Symptom | Cause |
|---|---|
| Approve N on this page says 0 and is disabled | No row on this page has had its schemas opened. Open one, or use Show what approving all N accepts. |
| A tool is approved and enabled but an agent cannot call it | The server may be switched off, not granted to that agent's organization, or not granted to the agent. All three are required. |
| Granting tools to an agent is refused with Tools cannot be granted on tool server … | The refusal names each tool that cannot be granted, grouped by why: not approved, disabled, or no longer offered by the server. An approved tool must also be enabled, and still offered by its server, to be granted. A Platform Admin can approve or enable it here; otherwise leave it out of the grant. |
| The connection fails with a credential error, and the secret is right | A required detail is missing — Header name for a header token, Client ID for OAuth. The call fails closed rather than going out unauthenticated. |
OAuth fails with invalid_client for a correct secret | The server expects the credentials in the request body, not the Basic header. Change where they are sent on the Connection tab. |
| OAuth fails with no OAuth authorization-server metadata could be read | The authorization server publishes no metadata, or answered for it with a server error. Ask the server's operator to publish metadata naming its token endpoint; the secret is not sent until it does. |
| The connection fails with the server's TLS certificate did not verify | AskRAI does not trust the certificate the server presented, and says why in parentheses. A self-signed certificate, or one AskRAI cannot trace to a public certificate authority (unable to get local issuer certificate), needs a certificate from a public authority, served with its intermediates. An expired one needs renewing. |
| The connection fails with the server's TLS certificate is not for this host | The certificate does not name the host in the server's URL. Enter the name it was issued for. |
| An approval comes back as stale | The row moved since you read it — a sync replaced it. Re-read the row and approve again. |
| An approval comes back as unmatched | The server no longer offers a tool by that name. |
| An MCP server will not switch on | No sync has succeeded against it yet. Run Sync tools first. |
| Tools disappeared after an edit | The URL was changed. Moving the endpoint deletes the catalog by design — re-sync and approve again. |
| An agent is told a hosted tool is unavailable | The server's code could not take the call just then. Nothing ran and nothing was charged, so the agent can try again on a later beat. |
| Every hosted call is refused for the rest of the month | The tenant has used its hosted compute for this month. |
| A hosted release fails with a dependency error | That version does not exist, is less than two days old, or has no prebuilt binary for Linux on arm64. Pick another exact version. |
| A hosted release stays Building | Another of the tenant's releases is being built, and this one waits its turn. |
| A browser tool fails with Target closed or Protocol error after opening a page | Its code opened a second browser context, which ends Chromium here. Open every page with browser.newPage(): see The browser layer. |
| Publish says the hourly limit is reached | The tenant has published as often as its hourly limit allows, 20 times unless AskRAI raised it. Publish again later. |
| The Hosted tab says RAI has suspended this tenant’s hosted tools | Every agent's call to a hosted tool is refused, and nothing can be published, until AskRAI lifts the suspension. Contact AskRAI support. |
| Publish says hosted tools are paused across the platform | AskRAI has paused every tenant's hosted tools for a while. Publish again later. |
| A hosted server says RAI holds this server | The nightly check found a package in its live release that is now marked malicious, so its calls are refused. Remove or replace the package, publish, and approve the new release: the approval lifts the hold. |
| Save says someone else saved this server | The source changed since you opened it. Reload it, then make your change again. |
| Approve release is refused because the release, or the live one, changed | Someone published, approved or reverted this server's releases while you were reviewing. The review has read the release again: check what it holds now and approve again. A release a newer publish replaced shows as Superseded and can no longer be approved. |
| A Platform rebase release asks you to approve it, or publish, by a date | AskRAI moved the server's code onto a platform update, and its tools or installed packages changed, the update was not yet tried on live servers, or it no longer built or listed its tools. Review and approve the release, or fix the code and publish: see Platform updates. |
| Revert to previous release is not shown | No release is live, or the live one replaced none: a server's first release, and a release just restored by a revert, have nothing to go back to. |
| An agent's Skills & Tools tab warns This agent’s egress allowlists refuse its calls | Not every egress allowlist in force for that agent names the hosted server's pseudo-host, so each call to its tools is refused. Add the <slug>.hosted.invalid host the warning names to each of them. |
Related
Skills
Author, validate, publish and version the SKILL.md instruction packs an agent can be pinned to, and adopt the ones the platform ships
SQL connections
Connect your PostgreSQL, MySQL, MariaDB, Oracle, Snowflake, SQL Server and Azure SQL databases, as many as you need, and let the agents you grant one list, describe, query and explain its tables, export a query's rows from PostgreSQL, MySQL, MariaDB, Oracle or Snowflake, and on a read-write connection change its rows within a limit you set