Connect your AI to Bool

Bool runs a remote MCP server — one endpoint that any Model Context Protocol  client can connect to. Once it’s connected, your AI can create Bool projects, deploy websites, and check on what’s live, all on your behalf.

You only need two things:

• Server URL: https://bool.com/api/mcp
• Transport: Streamable HTTP (remote)

That’s it. How you add those depends on your client — pick yours below.

The fast way: just ask

Most modern AI clients can add an MCP server themselves. Before hunting through settings, try simply telling your AI:

Add the Bool MCP server at https://bool.com/api/mcp as a connector.

If your client supports it, it’ll walk you through connecting and then sign you in (see Signing in below). If that doesn’t work, use the per-client steps below.

Signing in

Bool needs to know it’s really you. There are two ways to authenticate, and you usually don’t have to think about it — the client picks one for you:

• Sign in with Bool (recommended). Clients that support connectors (Claude, ChatGPT) pop open a Bool login the first time you use the server. Log in, approve access, and you’re done — no keys to copy.
• Personal access token. Clients that connect by config file (Cursor, VS Code, and most others) authenticate with a token. Create one at Settings → API tokens, click New token, and copy the value (it starts with bool_live_). Treat it like a password — anyone with it has your access to that workspace. Each token is scoped to a single workspace.

By default the AI can see projects across all the workspaces you belong to (personal and shared), and it respects the same permissions you have. Ask it to target a specific workspace — or use list_workspaces to see them and pass a workspace_id — to narrow things down. A token is the exception: it’s bound to a single workspace and only ever acts there.

Connect your client

Claude (desktop or web)

1. Open Settings → Connectors and click Add custom connector.
2. Paste the server URL: https://bool.com/api/mcp.
3. Save, then click Connect — a Bool login opens. Sign in and approve.

Bool’s tools now show up in the chat’s tools menu.

ChatGPT

1. In a workspace that allows custom connectors, go to Settings → Connectors → Add.
2. Paste https://bool.com/api/mcp and choose OAuth for authentication.
3. Connect, sign in to Bool, and approve access.

Cursor

Add Bool to your MCP config (Settings → Tools & MCP, or edit ~/.cursor/mcp.json directly):

{
  "mcpServers": {
    "bool": {
      "url": "https://bool.com/api/mcp",
      "headers": {
        "Authorization": "Bearer bool_live_your_token_here"
      }
    }
  }
}

Replace bool_live_your_token_here with a token from Settings → API tokens.

VS Code (Copilot agent mode)

Add a server to .vscode/mcp.json in your workspace (or your global mcp.json):

{
  "servers": {
    "bool": {
      "type": "http",
      "url": "https://bool.com/api/mcp",
      "headers": {
        "Authorization": "Bearer bool_live_your_token_here"
      }
    }
  }
}

Any other MCP client

The pattern is the same everywhere — point the client at the remote server and give it your token:

• URL: https://bool.com/api/mcp
• Transport: Streamable HTTP (sometimes labeled “HTTP” or “remote”)
• Auth: an Authorization: Bearer bool_live_… header, or the client’s OAuth flow if it has one

Two worth naming, since neither appears in a marketplace yet:

• Poke — Settings, Connections, New Integration, paste the URL. Poke runs the OAuth flow for you, so no token to paste.
• Grok — grok.com/connectors, New Connector, add it as a custom MCP server.

What your AI can do

Once connected, these tools are available.

Projects and deploying

Building the code yourself

Your AI can write a project’s code itself instead of asking the Bool AI. It uses the same tools and follows the same rules as the Bool AI does, so the app builds and runs the same way.

The build guide is also available as a resource (bool://projects/{project_id}/build-guide) and as a prompt (build_bool_app), for clients that let you attach context or start from a slash command.

Your data model

Your app’s records

These read and write your app’s real data as the project admin, so they see and change every row — including every end-user’s rows on a private entity.

Developing locally

You don’t call any of these directly — you just describe what you want, and your AI runs the steps (creating a project from a prompt, then polling until the deploy is live). For example:

Create a Bool project for this idea and give me the live URL.

List my Bool projects and tell me which ones are live.

Add a due_date to my tasks model, then show me every overdue task.

The record and entity tools act with full admin access to a project’s data. Deletes are permanent, and a connected AI can read every end-user’s rows. Only connect clients you trust, and prefer a workspace-scoped access token so the connection can only ever touch that workspace.

Agent workflow examples

With the lifecycle tools, an agent can build and ship apps without touching the Bool UI.

Iterate on an existing project

Add a testimonials section to my landing-page project and keep the same live URL.

The AI calls prompt_project on the existing project; it runs a headless turn, publishes the result, and the URL stays the same.

Build a new app

Make me a tip splitter app on Bool.

The AI calls create_project, reads get_build_guide, writes the app with create_file and edit_file, runs build_app until it passes, and saves it with save_version. No Bool AI turn runs, so this uses no Bool credits.

Remix and customize a project

Remix my “streamline-landing” project into a Spanish version and update the copy to say “Agiliza”.

The AI calls fork_project, then prompt_project to edit the copy.

Clean up experiments

Delete every non-live project whose name starts with “draft-”.

The AI calls list_projects, filters by deployed: false, then calls delete_project for each match.

The data-model and record tools need a project on Bool’s current app runtime. Older projects don’t expose them — if your AI reports that a project has no entities, rebuild it as a new project.

Controlling who can see your app

Every project has a visibility setting that controls who can view the deployed app:

• link — anyone with the URL, no login (fully public).
• workspace — only members of the project’s workspace.
• restricted — only you, plus anyone you explicitly share it with.

New projects use the workspace default (public for a personal workspace, members-only for a shared one). You can set a different visibility when you deploy — just ask, e.g.:

Deploy this and keep it private to just me.

To change an existing project’s visibility, ask your AI to update it (it uses get_project under the hood):

Make my landing-page project public.

A few rules apply: making an app restricted or workspace may require a paid plan, and only the project’s owner can change its visibility. If a change isn’t allowed, the tool returns a clear message explaining why.

Your data, and revoking access

Connecting sends your assistant through Bool’s OAuth consent screen. The token it gets back is scoped to your account and bound to https://bool.com/api/mcp, so it cannot be replayed against anything else.

Bool only ever sees the arguments a tool is called with, never your conversation with the assistant. What a tool returns, on the other hand, lands in that conversation and is then held by the assistant’s vendor under their policy, not ours. That matters most for the record tools, which can return rows from your app’s database.

Bool does not train models on anything that arrives through the connector.

Settings → Tokens lists every client you have authorized and revokes any of them in one click. Revoking takes effect immediately. The full detail is in the privacy policy, section 6.

Troubleshooting

• “Unauthorized” or a login loop. Your token is wrong, expired, or revoked. Create a fresh one at Settings → API tokens and update your config. For OAuth clients, disconnect and reconnect the server.

• “Rate limit exceeded.” The server limits requests per minute per token. Wait the few seconds it suggests and retry; higher plans get higher limits.

• Tools don’t appear. Confirm the URL is exactly https://bool.com/api/mcp and that your client is set to a remote / HTTP server, not a local command.