Skip to main content
Live now: connect your AI tools to BuildOS

Connect your agents to BuildOS

BuildOS is not another agent. BuildOS is where the project lives so every human and agent can work from the same memory.

Give Claude Code, Cursor, Claude Desktop, ChatGPT, or any HTTP-capable tool a scoped read/write into it.

Generate a key How it works
Per-project scope Per-op write whitelist Audit log Rotate or revoke any time

Works with Anthropic, OpenAI, and OpenClaw

Same key. Same scope. Different tools. Anything that can call HTTP can connect.

Works with
Anthropic · Claude OpenAI · ChatGPT OpenClaw

Anthropic (Claude / Claude Code / Claude Desktop) and OpenAI (ChatGPT / Codex) connect today with the same env block. The OpenClaw connector is in progress — same key will work once it ships.

Claude Code

Works today

CLI for engineering and writing. Paste the env into your config file, ask Claude to dial BuildOS.

Cursor

Works today

IDE-native AI. Drop the env into agent settings, then prompt Cursor to list your projects.

Claude Desktop

Works today

Chat with file access. Configure the connector with the env block and ask Claude to connect.

ChatGPT (Custom GPT)

Works today

Wire BuildOS into a Custom GPT’s actions with the bearer token from the env block.

Custom HTTP / scripts

Works today

Any tool that can make an HTTP request works. The bootstrap URL gives you the env block.

OpenClaw

In progress

The original integration. Use this surface once the OpenClaw connector ships.

Status: the agent-key gateway is live. Read access is included by default, write ops appear only when explicitly granted. Manage keys in Profile > Agent Keys.

Your projects, your tools, one place

Your AI tools forget every session. BuildOS doesn’t. Your projects live here. Your tools read off them — not from your last copy-paste.

BuildOS is the system of record for your projects, tasks, docs, and decisions.

Your tools never get direct database access. They go through a scoped session.

BuildOS verifies the caller before any tool runs. Per-project, per-op, per-key.

No vendor SDK. No OAuth dance. No retraining your agents on your context every session.

One key per tool

Each tool installation gets its own BuildOS-issued key. The secret is shown once on generate — BuildOS only stores a hash.

Scope each key to specific projects. Whitelist which write ops it can perform. Rotate or revoke from your profile any time. Audit log shows every tool call, every write, every error.

Manage keys here
/profile?tab=agent-keys

How it works

Four steps from cold install to your agent reading your projects. Same flow for every tool — the only thing that changes is where you paste the env.

Step 1

Generate a key in BuildOS

Go to Profile > Agent Keys. Pick which projects the key can see and whether it can read or also write.

BuildOS shows a one-time token plus an env block you can paste directly into your tool. The full secret is shown once — BuildOS only stores a hash.

Step 2

Paste the env block into your tool

Drop the values into your tool’s config file or secret store — Claude Code config, Cursor settings, ChatGPT Custom GPT actions, your own script’s env.

Never paste the token into chat input or have the agent read it from a chat message. It belongs in env, not memory.

Step 3

Tell your agent to dial BuildOS

Say something like “connect to BuildOS, list my projects.” Your tool calls the BuildOS gateway and opens a scoped session.

BuildOS verifies the caller and the scope before any tools are exposed. Per-project, per-op, per-key.

Step 4

Work off the same sheet of paper

Your agent can list projects, read tasks and docs, and — if the key allows — write back to them. Same project state every session.

Surfaced tools: skill_load, tool_search, tool_schema, plus direct ops like list_onto_projects, list_onto_tasks, create_onto_task, and update_onto_task.

The trust model

Think of it like a phone call: caller identity first, tool access second.

Your BuildOS workspace

Each user has an internal BuildOS agent identity. Your tool dials this when it wants to read or write your projects.

Agent key

Each tool gets its own BuildOS-issued bearer token. BuildOS stores only the hash. Rotate or revoke any time.

Scoped session

The tool does not impersonate your browser session. It opens a separate, scoped call session that BuildOS can accept or reject.

Per-op tool access

Read access is included by default. Write ops appear only when the key explicitly grants them.

Available in v1

What your tools can do today

A small, explicit tool surface. Tools are only exposed after the call is accepted, and write ops only when the key explicitly grants them.

skill_load

Load a BuildOS skill playbook when the workflow is multi-step, stateful, or easy to get wrong.

tool_search

Discover candidate BuildOS tools when the exact direct tool is not already clear.

tool_schema

Inspect the exact arguments for one canonical BuildOS op before calling the returned direct tool.

direct tools

Execute scoped BuildOS actions directly, such as list_onto_projects, list_onto_tasks, create_onto_task, or update_onto_task.

Quick start

What you paste into your tool

BuildOS generates the env block. Your tool stores it in a secret store or config file and uses it when calling the gateway. Same block, every tool.

Env snippet

BuildOS gives you these values from the Agent Keys screen.

BUILDOS_BASE_URL=https://build-os.com
BUILDOS_AGENT_TOKEN=boca_your_one_time_secret
BUILDOS_CALLEE_HANDLE=buildos:user:YOUR_USER_ID
BUILDOS_CALLER_KEY=your-tool:install:your-handle

Gateway request flow

Your tool dials BuildOS, lists what it can call, then calls tools by name.

POST /api/agent-call/buildos
Authorization: Bearer <BUILDOS_AGENT_TOKEN>
Content-Type: application/json

{
  "method": "call.dial",
  "params": {
    "callee_handle": "buildos:user:YOUR_USER_ID",
    "requested_scope": {
      "mode": "read_only"
    },
    "client": {
      "provider": "claude-code",
      "caller_key": "your-tool:install:your-handle"
    }
  }
}

// then:
// 1. tools/list
// 2. tools/call name=list_onto_projects arguments={}
// 3. tools/call name=tool_schema arguments={ "op": "onto.task.update", "include_schema": true }
// 4. tools/call name=update_onto_task arguments={ "task_id": "...", "state_key": "done" }
// 5. call.hangup

Current boundaries

The current integration is intentionally narrow. That is by design.

Your tool gets a BuildOS-issued key, never your browser session.

Calls are user-scoped. A caller cannot dial another user’s BuildOS workspace.

Project scoping is enforced before any tool runs.

Read access is included by default. Write ops appear only when the key explicitly grants them.

Keys can be rotated or revoked from Profile > Agent Keys.

Stop re-explaining your projects to every chat

Generate your first key, paste it into the tool you use most, and let your agents read off the same sheet of paper as you.

Generate your first key Ask a question

Signed in already? Go straight to /profile?tab=agent-keys.