Agent Tools (MCP)

Scalix is an agent-operable cloud: 50 platform tools for AI agents over a standard MCP endpoint, plus a plain-HTTP tool surface, with the same auth and metering as any API key

Listed on the official MCP Registry as world.scalix/cloud — registry-aware MCP clients can discover and connect to Scalix directly (remote server https://api.scalix.world/v1/mcp, Bearer auth with your API key). Client configs, the Antigravity plugin, and one-click install links live in scalixworld/scalix-cloud-mcp on GitHub.

Overview

Scalix World is an agent-operable cloud: the same control plane a human uses in the console is available to an AI agent as tools. An agent with one scoped API key can provision a database, deploy a service, manage storage and DNS, and read back its own usage, without a human clicking anything.

Every Scalix service is exposed to AI agents as tools: 50 tools across database, storage, functions, services, computers, KV, events, cron, domains, builds, auth, search, and more. There are two ways in:

• Standard MCP — point any MCP-capable client or agent framework at https://api.scalix.world/v1/mcp (JSON-RPC 2.0 over HTTP). Scalix implements the open Model Context Protocol, so it works with any compliant client — Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, Antigravity, Cline, Continue, Zed, and custom/framework agents alike. It is not tied to any single vendor's agent.
• Plain HTTP — list tools with GET /api/v1/mcp, call them with POST /api/v1/mcp/call. No MCP client required — any language that can make an HTTP request works.

Every tool call runs with the permissions, metering, and audit trail of the API key that makes it — agent usage is governed exactly like human usage.

Authentication

Discovery is open, actions are authenticated. The MCP handshake — initialize, ping, tools/list, resources/list — works without credentials, so any client, registry, or health checker can browse the tool catalog (names, descriptions, and input schemas only). tools/call and resources/read require credentials; a missing or invalid one returns 401 with a WWW-Authenticate challenge (RFC 6750) that also carries a resource_metadata pointer for clients that can negotiate OAuth.

Two credential types are accepted:

• An API key, as Authorization: Bearer <key>. Create one in the console (API Keys). Best for your own scripts and CI. Examples below use $SCALIX_API_KEY.
• An OAuth grant, for a third-party app asking on your behalf — no secret to paste, scoped to one project, revocable by name. See Connect an app.

Spec-compliant clients discover the OAuth path on their own; pointing them at the server URL is enough.

Protocol version

The server speaks MCP 2025-06-18 and negotiates down. A client that requests 2024-11-05 or 2025-03-26 is answered in its own version rather than being forced to upgrade, so older builds keep working. MCP-Protocol-Version is validated when sent; omitting it is not an error.

Both tools and resources capabilities are advertised. Resources are the database schema, a per-table view and the relationship map, addressed as scalix://schema, scalix://schema/{table} and scalix://relationships; reading one requires the same credentials and scopes as the equivalent tool.

Connect an MCP client

Clients that support remote HTTP servers

Most modern clients connect directly to the HTTP endpoint. The config shape is the same everywhere — a server named scalix, an HTTP URL, and a Bearer header.

Claude Code:

claude mcp add --transport http scalix https://api.scalix.world/v1/mcp \
  --header 'Authorization: Bearer ${SCALIX_API_KEY}'

Note the single quotes: they stop your shell from expanding the variable, so the stored config holds the reference ${SCALIX_API_KEY} — which Claude Code expands from your environment at read time — instead of the raw key. A config file that never contains the secret is safe to sync and commit.

Cursor, VS Code, Windsurf, and other config-file clients — add to the client's MCP config (Cursor mcp.json, VS Code .vscode/mcp.json, etc.):

{
  "mcpServers": {
    "scalix": {
      "type": "http",
      "url": "https://api.scalix.world/v1/mcp",
      "headers": { "Authorization": "Bearer ${SCALIX_API_KEY}" }
    }
  }
}

Environment-reference syntax varies by client — Claude Code's .mcp.json expands ${VAR}, VS Code's config uses ${env:VAR} — check yours, and if a client only takes a literal string (Claude Desktop's config does not expand variables), keep the key in a secret manager and paste it only there. Prefer a scoped or read-only key per agent: scopes are enforced identically through MCP and REST, so an exploration agent can hold a key that cannot mutate anything.

VS Code one-click: skip the config file — Install Scalix in VS Code registers the server in Copilot agent mode and reads the key from your environment as ${SCALIX_API_KEY}.

Antigravity (Google) uses a different key for remote servers — serverUrl (it rejects url and httpUrl). Add to ~/.gemini/config/mcp_config.json (global), .agents/mcp_config.json (workspace), or type /mcp in Antigravity CLI for the interactive manager:

{
  "mcpServers": {
    "scalix": {
      "serverUrl": "https://api.scalix.world/v1/mcp",
      "headers": { "Authorization": "Bearer YOUR_SCALIX_API_KEY" }
    }
  }
}

Or install it as an Antigravity plugin in one command — the plugin is auto-discovered on restart:

git clone https://github.com/scalixworld/scalix-cloud-mcp ~/.gemini/config/plugins/scalix

Then replace YOUR_SCALIX_API_KEY inside the plugin's mcp_config.json. Antigravity doesn't document environment-variable expansion in headers, so the key lives in the file — use a scoped or read-only key there, never a full-access one.

Any MCP client (universal stdio bridge)

Clients that only speak stdio to a local process — Claude Desktop, Cline, Continue, older MCP clients — reach the remote endpoint through the standard mcp-remote bridge. This works with every MCP client, so it's the fallback when a client has no native HTTP transport:

{
  "mcpServers": {
    "scalix": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote",
        "https://api.scalix.world/v1/mcp",
        "--header", "Authorization: Bearer YOUR_SCALIX_API_KEY"
      ]
    }
  }
}

For Claude Desktop, put this in claude_desktop_config.json (Settings → Developer → Edit Config) and restart the app.

Custom and framework agents

Agents built with your own code or a framework (LangChain, LlamaIndex, the OpenAI/Anthropic SDKs, etc.) can speak MCP JSON-RPC directly, or skip MCP and use the plain-HTTP tool surface below. Raw JSON-RPC handshake:

# browse the catalog — no credentials needed
curl -X POST https://api.scalix.world/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
 
# call a tool — API key required
curl -X POST https://api.scalix.world/v1/mcp \
  -H "Authorization: Bearer $SCALIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"scalix_status","arguments":{}}}'

The endpoint implements initialize, ping, tools/list, resources/list, and tools/call over streamable HTTP (POST). It does not maintain SSE streams — a GET returns 405, which spec-compliant clients handle by using plain POST responses.

Calling convention (plain HTTP)

List every tool available to your key:

curl https://api.scalix.world/api/v1/mcp \
  -H "Authorization: Bearer $SCALIX_API_KEY"

Each definition carries the tool name, a description, and a JSON-Schema input_schema. Call a tool by POSTing its name and arguments:

curl -X POST https://api.scalix.world/api/v1/mcp/call \
  -H "Authorization: Bearer $SCALIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "scalix_db_query",
    "arguments": { "sql": "SELECT count(*) FROM orders" }
  }'

SQL through scalix_db_query executes on the same metered, scope-checked path as the SQL API (POST /api/v1/sql) — use whichever surface fits your agent.

Tool catalog

Platform tools (scalix_*), by family:

Database-native tools served in-process by the gateway (relationship maps, column search, PII scan, query optimization, NL-to-SQL) are also in the catalog: scalix_db_relationships, scalix_db_search_columns, scalix_db_pii, scalix_db_optimize, scalix_db_text_to_sql. The legacy bare names (get_schema, nl_to_sql, …) still dispatch as hidden aliases, so existing agent configs keep working.

Database branching (scalix_db_branch_create / scalix_db_branch_drop) is not currently offered as a tool. The branch machinery is not finished, and a tool that reports an isolated branch while statements still reach the primary is worse than no tool at all, so both names are withheld from the catalog and refused if called. They will return when branching is real.

Permissions and read-only keys

Tool calls are authorized by the calling key's scopes — a key without functions:write cannot deploy a function through a tool call any more than it could through the REST API. Read-only keys are refused every tool that mutates state (deploys, uploads, creates, deletes, scaling, rollbacks, sandbox creation, and anything that can reach a shell — scalix_computer_exec and scalix_computer_set_ssh_keys included); reads (scalix_db_query, listings, status, search) work normally.

Discovery for agents

• GET /v1/me — capability discovery for the current token: identity (org and project), effective scopes, the tools those scopes unlock, and plan limits including the rate limit.
• Live OpenAPI 3.1 spec at https://api.scalix.world/openapi.json — fetch it at runtime for tool synthesis or code generation.
• API reference — every REST endpoint, with auth and error semantics.

Errors everywhere carry a stable machine-readable code, a human-readable error, and a request_id; responses carry X-RateLimit-* headers so agents can pace themselves.

Example: an agent shipping a change

1. GET /v1/me                    → discover identity, scopes, and rate limits
2. scalix_db_schema              → learn the data model
3. scalix_db_optimize            → check the statement before anything runs
4. scalix_db_migrate             → apply the schema change
5. scalix_fn_deploy              → ship the function
6. scalix_run_rollback           → roll back if the revision misbehaves