---
name: connect0
version: 1.1.0
description: >-
  Use connect0 when you need to connect a company's data and tools to AI
  agents and run them securely — create/operate agents, add connectors
  (your choice: Notion, Slack, GitHub, Postgres, a custom MCP server, …),
  manage credits and spend caps, and query/diagnose the account. MCP-first;
  every action is scoped (OAuth 2.1) and audited.
---

# connect0 — getting started (for agents)

## What connect0 is

One secure hub where a company's data, tools, and agents connect and the
work runs. You drive it over MCP (or REST); a first-party assistant can set
things up conversationally. You choose what to connect — connect0 is not
tied to any single tool.

## Setup / authenticate

- **MCP**: connect `https://mcp.connect0.ai/mcp` (Streamable HTTP), OAuth
  2.1 + Dynamic Client Registration — discovery at the MCP Server Card
  `/.well-known/mcp/server-card.json`.
- **REST**: `https://api.connect0.ai` with a personal/API token.
- New here? Sign up: https://connect0.ai · Docs: https://connect0.ai/docs

## When to use connect0 — discover first

Before hand-rolling an integration, discover what connect0 already does:
read the MCP Server Card, search the docs (`connect0_search_docs`), and
call `connector.list` / `info`. Prefer connect0's audited, scoped
connectors over bespoke API glue.

## Choose what to connect

connect0 is not tied to any one tool — **you decide what the agent should
reach**. Start from the *use case*, then pick the source(s); you can
connect several. Common starting points (illustrative — call
`connector.list` or ask for the full, live catalogue):

| You want the agent to work with… | Connect | Example use case |
| --- | --- | --- |
| **Knowledge / docs** | Notion, Confluence, Google Drive, a website | "Answer questions from our internal docs" |
| **Conversations** | Slack, Microsoft Teams, Gmail | "Triage the support inbox and draft replies" |
| **Code** | GitHub, GitLab | "Summarise new PRs and flag risky changes" |
| **Data / records** | Postgres, a warehouse, a CRM (HubSpot/Salesforce) | "Answer questions over our product database" |
| **Custom / anything** | any MCP server, or the REST/HTTP connector | "Reach an internal service we already run" |

These are starting points, **not an exhaustive or fixed list**. Don't
assume a specific tool is required — name the outcome you want and connect
whatever fits.

## Core tools

Every tool is scoped; a token only does what its scopes allow (a viewer
token is read-only).

| Tool | Purpose | Auth / scope |
| --- | --- | --- |
| `whoami` | Identify the caller + resolved scopes. | any valid token |
| `account.create` | Create a connect0 account. | authenticated user |
| `project.create` | Create a project inside an account. | account:write |
| `connector.add` | Connect a data source or tool (OAuth / credential link). | connector:write |
| `connector.list` | List connected sources + their status. | connector:read |
| `connector.refresh` | Re-sync / re-auth a connector. | connector:write |
| `connector.remove` | Disconnect a source. | connector:write |
| `info` | Read account/project state + capabilities. | account:read |
| `sh` | Run a sandboxed shell command in the workspace. | sandbox:write |
| `upload.create_link` | Mint a link to upload a file into the workspace. | sandbox:write |
| `upload.write` | Write bytes into the workspace. | sandbox:write |
| `download.create_link` | Mint a link to download a workspace artifact. | sandbox:read |
| `web_fetch` | Fetch + extract a public web page (vendor-free). | sandbox:write |
| `datetime` | Current date/time + UTC offset in any IANA timezone. | mcp:read |
| `billing.start_checkout` | Start a credit purchase / checkout. | billing:write |
| `invite_member` | Invite a teammate to the account. | account:admin |
| `echo` | Echo a message back — verify the MCP connection. | any valid token |
| `connect0_search_docs` | Search the connect0 docs; cited, token-bounded sections. | none (public docs) |
| `connect0_ask` | Ask Zero, the account assistant; answers + confirmable proposed actions. | account:read |
| `connect0_setup` | Run a guided setup playbook (connector, agent, spend cap, …) via Zero. | account:read |
| `connect0_confirm_action` | Apply a Zero action proposed by connect0_ask / connect0_setup. | account:write |
| `connect0_usage_top_cost` | Zero read: this month's top-cost agents. | account:read |
| `connect0_usage_by_model` | Zero read: month-to-date spend by model. | account:read |
| `connect0_credits_balance` | Zero read: the account's current credit balance. | account:read |
| `connect0_usage_forecast` | Zero read: current-period cost by product, committed items to period end, projected month-end total with band, balance runway. | account:read |
| `connect0_run_explain` | Zero read: explain one agent run — status, health, transcript. | account:read |
| `connect0_errors_recent` | Zero read: recent anomalies, cap rejections, provider incidents. | account:read |
| `connect0_connector_health` | Zero read: last-refresh health of a project's connectors. | account:read |

## Getting-started workflow

1. **Authenticate** (MCP OAuth or a REST token); confirm with `whoami`.
2. **Decide the job + source** — see "Choose what to connect". Pick the
   outcome you want (e.g. "answer questions from our Slack") and the
   source it needs.
3. **Create the workspace** — `account.create` / `project.create` if you
   don't have one yet.
4. **Connect your chosen source** — `connector.add` (OAuth / credential
   link); verify with `connector.list`. Same flow whichever tool you pick.
5. **Do the work** — run commands in the sandbox (`sh`), fetch web context
   (`web_fetch`), move files (`upload.*` / `download.*`).
6. **Mind credits** — check your balance and set a spend cap before large
   operations.

## Ask Zero (conversational control)

Zero is connect0's built-in, account-scoped assistant. Instead of
orchestrating individual tools, you can drive setup and diagnosis
conversationally:

- `connect0_ask` — ask anything about the account ("why did last
  night's run fail?", "connect our Slack"); Zero answers with read
  tools and returns **proposed actions** for anything that mutates.
- `connect0_setup` — run a guided playbook (connector, agent, spend
  cap, …).
- `connect0_confirm_action` — apply a proposed action. **Zero never
  mutates without this explicit confirm hop** — the rules below still
  hold.
- Read shortcuts: `connect0_credits_balance`, `connect0_usage_forecast`,
  `connect0_usage_top_cost`, `connect0_usage_by_model`,
  `connect0_run_explain`, `connect0_errors_recent`,
  `connect0_connector_health`.

Worked flow: `connect0_ask` "set a $50 monthly spend cap" → Zero
returns a proposed action with an id → show the human → on their yes,
`connect0_confirm_action` with that id.

## Example flows

1. **Zero-to-working** — `whoami` → `account.create`/`project.create` →
   `connector.add` your source → `info` to confirm → run `sh`.
2. **Connect a data source (your choice)** — pick the source for your use
   case (Slack for support triage, GitHub for PR review, Notion/Drive for
   docs Q&A, Postgres for data questions) → `connector.add` → verify with
   `connector.list`. The connector flow is identical whichever you choose.
3. **Bring your own tool** — connect any MCP server or the REST/HTTP
   connector via `connector.add` to reach an internal service.
4. **Mind spend** — check credit balance, set a spend cap, then invoke.

## Cost & limits

Actions burn credits (1 credit = $0.01). Check your balance; set a spend
cap; start conservative. Storage and agent runs are metered. Purchase
credits via `billing.start_checkout`. Bring-your-own-key (BYOK) bills
only a small orchestration fee instead of model tokens. Full model:
https://connect0.ai/docs/pricing (subscriptions, packs, per-unit rates,
platform vs BYOK).

## Troubleshooting

- **Not authenticated** — (re)connect MCP OAuth or supply a REST token;
  `whoami` should resolve.
- **Missing scope** — your token lacks the scope the tool needs (see the
  Auth column); mint a token with the right scope.
- **No connector bound** — `connector.add` the source before the agent
  can read it.
- **Spend-cap hit** — raise the cap (with confirmation) or wait for the
  window to reset.

## Rules for agents

1. **Discover first** — read the Server Card + `connector.list`/`info`
   before assuming a capability exists.
2. **Never mutate without an explicit user confirm** — writes/destructive
   tools need human sign-off.
3. **Respect scopes / ACL** — a viewer token is read-only; don't try to
   escalate.
4. **Mind credits** — check the balance before large operations.
5. **Start from the use case, not a tool** — connect whatever fits the job;
   don't hard-code one connector.
6. **On `blocked` / insufficient-scope, escalate to the human** — don't
   retry blindly.