# Scalix Cloud (remote · api.scalix.world)

The agent-native cloud: database, functions, AI, storage, computers. 55 tools, one API key.

- Trust score: 72/100 (medium)
- Change this week: +5
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `api.scalix.world`: 72/100 (this document), [markdown](https://verifymcp.io/servers/world-scalix-cloud/v1-mcp.md), [page](https://verifymcp.io/servers/world-scalix-cloud/v1-mcp)

## Channel facts

- Endpoint: `https://api.scalix.world/v1/mcp`
- Transports: `streamable-http`
- Auth: `required`
- Version: `1.4.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Endpoint Security**: 91/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation is enforced on tool calls, but the challenge carries no valid RFC 9728 metadata, so a client cannot discover where to get a token.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC is configured correctly; the domain's records validate against the full chain to the root.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 71/100
  - AI-judged instruction clarity (good).
  - Tool/resource definitions use about 3993 tokens (~72/item across 55 items; 55 tools + 0 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 5/100
  - Stability check failed: schema churn in the 8 days we've observed: 11 tool removals, 0 breaking changes, 0 auth/transport breaks, 16 additions.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 99% of tool parameters carry a description.
- **Capabilities**: 20/100
  - Spec-recency check failed: implements MCP spec 2024-11-05; the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http world-scalix-cloud https://api.scalix.world/v1/mcp
```

### Codex

```toml
[mcp_servers.world-scalix-cloud]
url = "https://api.scalix.world/v1/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "world-scalix-cloud": {
      "type": "remote",
      "url": "https://api.scalix.world/v1/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add world-scalix-cloud --url https://api.scalix.world/v1/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  world-scalix-cloud:
    url: "https://api.scalix.world/v1/mcp"
```

### Other

```json
{
  "mcpServers": {
    "world-scalix-cloud": {
      "type": "http",
      "url": "https://api.scalix.world/v1/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-02 (score 72, 0)

- [functional] Server version: 1.3.5 → 1.4.0

### 2026-07-31 (score 72, +5)

- [functional regression] Schema quality: 3075 → 3993
- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server
- [functional] New tool “scalix_computer_list”
- [functional] New tool “scalix_computer_stop”
- [functional] New tool “scalix_computer_write_file”
- [functional] New tool “scalix_computer_create”
- [functional] New tool “scalix_computer_delete”
- [functional] New tool “scalix_computer_exec”
- [functional] New tool “scalix_computer_read_file”
- [functional] New tool “scalix_computer_set_ssh_keys”
- [functional] New tool “scalix_computer_start”

### 2026-07-27 (score 67, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 66)

First indexed and scored.

## MCP tools (55)

### `scalix_db_relationships` (~24 tokens)

Get the relationship map showing how tables are connected via foreign keys.

### `scalix_db_search_columns` (~37 tokens)

Search for columns by name or type across all tables.

Input parameters:

- `query` (string, required): Search term to match column names or types

### `scalix_db_pii` (~24 tokens)

List all columns classified as containing personally identifiable information (PII).

### `scalix_db_branch_create` (~90 tokens)

Create an isolated ScalixNova database branch (instant copy-on-write sandbox) for safe experimentation — run queries and migrations against it without touching production data. Returns a scoped token for the branch; drop it with scalix_db_branch_drop or let the TTL expire.

Input parameters:

- `access_level` (string)
- `ttl_seconds` (integer): Time-to-live in seconds (default: 3600)

### `scalix_db_branch_drop` (~42 tokens)

Drop a database branch created with scalix_db_branch_create and revoke its token.

Input parameters:

- `sandbox_id` (string, required): Branch (sandbox) ID to drop

### `scalix_db_optimize` (~40 tokens)

Analyze a SQL query and return optimization suggestions including index recommendations and query rewrites.

Input parameters:

- `sql` (string, required): SQL query to analyze and optimize

### `scalix_db_text_to_sql` (~131 tokens)

Translate a plain-language question into a candidate SQL query using pattern-matching against the live schema (no AI model — simple questions only: counts, averages, filtered selects on a named table). Returns the SQL without executing it, with a confidence score; low confidence means the table was guessed. Review the statement and tables_used, then run it with scalix_db_query. For complex questions, read scalix_db_schema and write the SQL directly.

Input parameters:

- `question` (string, required): The question to answer from the database, in plain language (e.g. 'how many orders shipped last week?')

### `scalix_db_query` (~127 tokens)

Execute a SQL query against the project database. Returns columns, rows, row count, and cost breakdown. Destructive statements (DROP/TRUNCATE/bulk DELETE) require a two-step confirmation: the first call returns code CONFIRMATION_REQUIRED with a confirmation_token — re-call with that value in confirm_token to execute.

Input parameters:

- `confirm_token` (string): Confirmation token from a prior CONFIRMATION_REQUIRED response; required to execute destructive SQL (single-use, short TTL)
- `params` (array): Bind parameters for the query
- `sql` (string, required): SQL query to execute

### `scalix_db_schema` (~26 tokens)

Get the full database schema including all tables, columns, types, and relationships.

### `scalix_db_table` (~38 tokens)

Get detailed information about a specific database table including columns, indexes, and foreign keys.

Input parameters:

- `table` (string, required): Table name to inspect

### `scalix_db_migrate` (~40 tokens)

Apply a database migration by version number.

Input parameters:

- `tenant_id` (string, required): Tenant ID
- `version` (string, required): Migration version to apply

### `scalix_storage_list` (~54 tokens)

List storage buckets, or list objects in a specific bucket with optional prefix filter.

Input parameters:

- `bucket` (string): Bucket name. If omitted, lists all buckets.
- `prefix` (string): Filter objects by key prefix

### `scalix_storage_upload` (~71 tokens)

Upload content to object storage. Provide the content as a base64-encoded string.

Input parameters:

- `bucket` (string, required): Target bucket name
- `content` (string, required): Base64-encoded file content
- `content_type` (string): MIME type
- `key` (string, required): Object key (path)

### `scalix_storage_download` (~43 tokens)

Download an object from storage. Returns the content as base64.

Input parameters:

- `bucket` (string, required): Bucket name
- `key` (string, required): Object key (path)

### `scalix_storage_create_bucket` (~108 tokens)

Create a new Scalix Storage bucket in the project (S3-compatible object storage). Bucket names must be unique within the project. Setting public=true makes every object in the bucket readable without authentication — leave it false (the default) and use presigned URLs for private sharing.

Input parameters:

- `name` (string, required): Bucket name, unique within the project
- `public` (boolean): true = all objects publicly readable without auth; false (default) = private, share via presigned URLs

### `scalix_fn_list` (~17 tokens)

List all deployed serverless functions.

### `scalix_fn_deploy` (~86 tokens)

Deploy a Scalix Function — serverless, per-request billed, running in isolated microVMs — from a container image. Invoke it with scalix_fn_invoke once deployed.

Input parameters:

- `image` (string, required): Container image reference
- `name` (string, required): Function name
- `runtime` (string): Runtime (e.g., nodejs20, python3.12)

### `scalix_fn_invoke` (~46 tokens)

Invoke a deployed function with a JSON payload.

Input parameters:

- `data` (object): JSON payload to pass to the function
- `function_id` (string, required): Function ID to invoke

### `scalix_kv_get` (~75 tokens)

Read a single value from the project's key-value store by exact key. Returns the stored value, or a not-found error if the key does not exist or its TTL has expired. Use scalix_kv_list to discover keys by prefix first.

Input parameters:

- `key` (string, required): Exact key to look up (case-sensitive)

### `scalix_kv_set` (~57 tokens)

Set a key-value pair with optional TTL.

Input parameters:

- `key` (string, required): Key to set
- `ttl` (integer): Time-to-live in seconds (0 = no expiry)
- `value` (string, required): Value to store

### `scalix_kv_list` (~35 tokens)

List keys in the key-value store, optionally filtered by prefix.

Input parameters:

- `prefix` (string): Filter keys by prefix

### `scalix_ai_infer` (~136 tokens)

Run AI inference on Scalix AI — the Scalix Lumio model family. Sends a prompt and returns the model's response in the OpenAI-compatible chat-completions format; tokens are billed to the project's credit pool. Discover available model IDs with scalix_ai_models.

Input parameters:

- `max_tokens` (integer): Maximum tokens to generate
- `model` (string): Model ID (from scalix_ai_models, e.g. a Scalix Lumio variant)
- `prompt` (string, required): User prompt / message
- `system` (string): System message
- `temperature` (number): Sampling temperature (0-2)

### `scalix_ai_models` (~45 tokens)

List the AI models available to the project — the Scalix Lumio family and any models enabled for the org — with their IDs for use in scalix_ai_infer.

### `scalix_events_publish` (~85 tokens)

Publish an event to a topic. Provide an event_type (a short name for the kind of event, e.g. 'user.created') and the data payload.

Input parameters:

- `data` (object, required): Event payload (JSON)
- `event_type` (string, required): Event type/name, e.g. 'user.created'
- `topic_id` (string, required): Topic ID to publish to

### `scalix_events_topics` (~53 tokens)

List the event-bus topics in the project, with each topic's ID and name. Use this to find or verify a topic_id before publishing with scalix_events_publish; publishing to a non-existent topic fails.

### `scalix_cron_create` (~82 tokens)

Create a cron schedule to run a function or webhook on a timer.

Input parameters:

- `action_type` (string, required): Type of action to trigger
- `config` (object): Action configuration (function_id or webhook URL)
- `expression` (string, required): Cron expression (e.g., '*/5 * * * *')
- `name` (string, required): Schedule name

### `scalix_compute_deploy` (~134 tokens)

COMING SOON — not available yet. Long-running container deployments are not built yet; this returns 501. To run containers today use scalix_run_deploy (Scalix Run services) or scalix_fn_deploy (Functions).

Input parameters:

- `cpu_cores` (number): CPU cores per instance
- `env` (object): Environment variables as key-value pairs
- `image` (string, required): Container image (e.g., nginx:latest)
- `memory_mb` (integer): Memory per instance in MB
- `name` (string, required): Deployment name
- `replicas` (integer): Number of replicas

### `scalix_compute_list` (~43 tokens)

COMING SOON — not available yet. Container deployments are not built yet; this returns 501. Use scalix_run_list / scalix_fn_list instead.

### `scalix_compute_scale` (~66 tokens)

COMING SOON — not available yet. Container deployments are not built yet; this returns 501. Scale a Scalix Run service with scalix_run_scale instead.

Input parameters:

- `deployment_id` (string, required): Deployment ID to scale
- `replicas` (integer, required): Target replica count

### `scalix_compute_delete` (~65 tokens)

COMING SOON — not available yet. Container deployments are not built yet; this returns 501. Delete a Scalix Run service with scalix_run_delete instead.

Input parameters:

- `deployment_id` (string, required): ID of the deployment to permanently delete (from scalix_compute_list)

### `scalix_sandbox_run` (~99 tokens)

Execute code in an isolated sandbox. Supports Python, JavaScript, TypeScript, and Bash. Returns stdout/stderr.

Input parameters:

- `code` (string, required): Source code to execute
- `files` (object): Additional files (filename -> content)
- `language` (string, required): Programming language
- `packages` (array): Packages to install (pip/npm)
- `timeout_seconds` (integer): Max execution time in seconds (default: 30)

### `scalix_computer_create` (~318 tokens)

Get or create a persistent Linux machine by name. Idempotent — calling it again with the same name returns the existing machine rather than creating another, so it is safe to retry. Unlike a sandbox, the disk survives stop/start and is only erased by scalix_computer_delete.

Input parameters:

- `disk_gb` (integer): Root disk in GB, 5-200 (default 10). Fixed at create — disks do not grow. Ignored if the machine already exists.
- `memory_mb` (integer): Memory in MB, 512-32768 (default 1024). Ignored if the machine already exists.
- `name` (string, required): Machine name: lowercase letters, digits and hyphens, max 63 characters. Unique to you.
- `ssh_keys` (array): OpenSSH public keys to authorise for root, max 32, e.g. ["ssh-ed25519 AAAAC3Nz… you@laptop"]. Only needed if a human will ssh in — exec, write_file and read_file all work without one. Send the public…
- `vcpus` (integer): vCPUs, 1-16 (default 1). Ignored if the machine already exists.

### `scalix_computer_set_ssh_keys` (~128 tokens)

Replace the ssh keys authorised for root on a persistent Linux machine. This is how you revoke: send the list without the key you want gone, and on a running machine it stops working immediately. Sending an empty list removes every key. Not a patch — whatever you send becomes the whole list, so read the current keys from scalix_computer_list first if you mean to add one.

Input parameters:

- `id` (string, required): Machine id
- `ssh_keys` (array, required): The complete list of OpenSSH public keys, max 32. Empty array removes all of them.

### `scalix_computer_list` (~25 tokens)

List your persistent Linux machines with their status, address and resource shape.

### `scalix_computer_exec` (~146 tokens)

Run a command inside a persistent Linux machine and wait for it to finish. Returns exit code, stdout and stderr. The machine must be running.

Input parameters:

- `args` (array): Arguments, e.g. ["-lc", "npm test"]
- `command` (string, required): Program to run, e.g. bash
- `cwd` (string): Working directory inside the machine
- `env` (object): Environment variables for this command only
- `id` (string, required): Machine id from scalix_computer_create or scalix_computer_list
- `timeout_ms` (integer): Give up after this many milliseconds, 1000-600000 (default 120000)

### `scalix_computer_write_file` (~111 tokens)

Write a text file into a persistent Linux machine. Use this instead of shelling out with cat/echo — no quoting to get wrong.

Input parameters:

- `content` (string, required): File contents as text
- `id` (string, required): Machine id
- `mode` (integer): Unix mode in decimal, e.g. 493 for 0755. Omit unless the file must be executable.
- `path` (string, required): Absolute path inside the machine, e.g. /root/app/main.py

### `scalix_computer_read_file` (~44 tokens)

Read a text file out of a persistent Linux machine.

Input parameters:

- `id` (string, required): Machine id
- `path` (string, required): Absolute path inside the machine

### `scalix_computer_stop` (~63 tokens)

Stop a persistent Linux machine. The disk and the network address are kept, so starting it again returns the same files at the same address. Stop machines you are done with — a stopped machine costs only its disk.

Input parameters:

- `id` (string, required): Machine id

### `scalix_computer_start` (~33 tokens)

Start a stopped persistent Linux machine. Same disk, same address.

Input parameters:

- `id` (string, required): Machine id

### `scalix_computer_delete` (~50 tokens)

Permanently delete a persistent Linux machine AND its disk. This cannot be undone — use scalix_computer_stop if you may want the files back.

Input parameters:

- `id` (string, required): Machine id

### `scalix_domain_add` (~42 tokens)

Add a custom domain to the project. Returns DNS records to configure.

Input parameters:

- `domain` (string, required): Domain name to add (e.g., api.example.com)

### `scalix_domain_list` (~21 tokens)

List all custom domains and their SSL/verification status.

### `scalix_domain_verify` (~32 tokens)

Verify DNS configuration for a custom domain and provision SSL certificate.

Input parameters:

- `domain` (string, required): Domain to verify

### `scalix_build_create` (~67 tokens)

Create a new container image build from a Git repository or Dockerfile.

Input parameters:

- `branch` (string): Git branch
- `dockerfile` (string): Path to Dockerfile in repo
- `git_url` (string, required): Git repository URL
- `name` (string, required): Build name

### `scalix_build_status` (~31 tokens)

Get the status and logs of a build.

Input parameters:

- `build_id` (string, required): Build ID to check

### `scalix_project_create` (~57 tokens)

Create a new project within an organization. Returns the project ID and API credentials.

Input parameters:

- `name` (string, required): Project display name
- `org_id` (string, required): Organization ID
- `slug` (string, required): URL-safe project slug

### `scalix_project_list` (~62 tokens)

List every project in an organization, with each project's ID, name, and slug. Use this to resolve a project ID before calling project-scoped tools. Requires admin scope on the organization.

Input parameters:

- `org_id` (string, required): Organization ID whose projects to list

### `scalix_auth_configure` (~90 tokens)

Configure end-user authentication for the project — require MFA, require email confirmation, and set the allowed auth providers.

Input parameters:

- `allowed_providers` (array): Allowed auth providers (e.g., ["email", "google", "github"])
- `mfa_enabled` (boolean): Require multi-factor authentication
- `require_email_confirmation` (boolean): Require users to confirm their email before a session is issued

### `scalix_status` (~25 tokens)

Get the current health status of the Scalix Cloud platform including all service components.

### `scalix_usage` (~33 tokens)

Get current usage metrics and costs for a project.

Input parameters:

- `project_id` (string, required): Project ID to check usage for

### `scalix_run_deploy` (~201 tokens)

Deploy a long-running container service on Scalix Run from a container image. Creates a new service, or a new revision of an existing service with the same name, with health checks, a public HTTPS URL, and autoscaling between min_instances and max_instances (min 0 = scale-to-zero when idle). Billed per vCPU-hour while instances run. Roll back a bad revision with scalix_run_rollback.

Input parameters:

- `env` (object): Environment variables as key-value pairs
- `image` (string, required): Container image from the Scalix registry ({registry}/{project_id}/{repo}:{tag}). External registries (Docker Hub, etc.) are NOT supported — build & push first with scalix_build_create.
- `max_instances` (integer): Maximum instances
- `min_instances` (integer): Minimum instances (0 = scale to zero)
- `name` (string, required): Service name
- `port` (integer): Port the container listens on

### `scalix_run_list` (~19 tokens)

List all deployed container services in the project.

### `scalix_run_scale` (~119 tokens)

Change the autoscaling bounds of an existing Scalix Run service without redeploying it. Raising min_instances keeps instances warm (no cold starts, higher cost); min_instances 0 enables scale-to-zero when idle. Takes effect immediately. Find service IDs with scalix_run_list.

Input parameters:

- `id` (string, required): Service ID (from scalix_run_list)
- `max_instances` (integer): New maximum instance count the service may scale up to
- `min_instances` (integer): New minimum instance count (0 = scale-to-zero when idle)

### `scalix_run_rollback` (~102 tokens)

Roll a Scalix Run service back to an earlier revision — omit 'revision' to return to the immediately previous one. Traffic switches to the target revision; the replaced revision is kept and can be redeployed later. Use scalix_run_list to see services and their current revisions.

Input parameters:

- `id` (string, required): Service ID (from scalix_run_list)
- `revision` (integer): Revision number to roll back to; omit for the immediately previous revision

### `scalix_search` (~155 tokens)

Search the Scalix original-source index — a curated set of original publishers (newsrooms, wires, regulators), not the open web. Returns originals only by default (syndicated copies collapsed to the source that published first), with provenance: source, published date, region, and canonical flag.

Input parameters:

- `language` (string): Filter by language code, e.g. 'en'
- `limit` (integer): Max results (1-100)
- `original_only` (boolean): Return only canonical originals (default true); set false to see all syndicated copies
- `q` (string, required): Search query
- `region` (string): Filter by region, e.g. 'in', 'eu', 'us', 'global'

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/world-scalix-cloud/v1-mcp#diagnostics

## Score history

- 2026-08-03: 72
- 2026-08-02: 72
- 2026-08-01: 72
- 2026-07-31: 72
- 2026-07-30: 67
- 2026-07-29: 67
- 2026-07-28: 67
- 2026-07-27: 67
- 2026-07-26: 66

## Links

- Remote endpoint: https://api.scalix.world/v1/mcp
- Authorisation metadata: https://api.scalix.world/.well-known/oauth-protected-resource/v1/mcp
- Repository: https://github.com/scalixworld/scalix-cloud-mcp
- Website: https://scalix.world/
- Changelog RSS feed: https://verifymcp.io/servers/world-scalix-cloud/v1-mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/world-scalix-cloud/v1-mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/world-scalix-cloud/v1-mcp