Koskamo

Scalix Cloud MCP

An official Model Context Protocol server provided by Scalix World that exposes 51 tools for AI agents to interact with the Scalix neocloud platform. It allows agents to manage Postgres-compatible databases, deploy serverless functions, run isolated microVMs, handle storage, authentication, and billing using a single API key.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

Scalix Cloud MCP logo, by Scalix WorldVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-06Operated by Scalix World
You need:Bearer API key
MCP endpoint (Streamable HTTP)
https://api.scalix.world/v1/mcp
Vendor documentation

What its tools do

53 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

Read-only (23)

Can change data (30)

53 of 53 have a description · 53 of 53 declare behavior hints · 42 of 42 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Passed Official MCP Registry namespace is tied to scalix.world ·
  • Passed Endpoint is on the registry namespace domain ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Provision and manage serverless Postgres databases
  • Deploy and host applications via Scalix Run
  • Execute serverless functions on microVMs
  • Manage AI inference and storage resources

Source and maintenance

Vendor evidenceRegistry 1.5.0
mcp-registry: world.scalix/cloud@1.5.0Source repositoryProject website
Maintenance checked

Protocol and capabilities

Server
scalix-cloud 1.5.0
MCP protocol negotiated in check
2025-06-18
Tools
53 advertised
Resources
2 advertised
Resource templates
1 advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": false
  },
  "resources": {
    "subscribe": false,
    "listChanged": false
  }
}

Tools

53 advertised

scalix_db_relationships
Advertised by the server during the last successful anonymous check.
Advertised read-only

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

scalix_db_relationships input schema
{
  "type": "object",
  "properties": {}
}
scalix_db_relationships annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_db_search_columns
Advertised by the server during the last successful anonymous check.
Advertised read-only

Search for columns by name or type across all tables.

scalix_db_search_columns input schema
{
  "type": "object",
  "required": [
    "query"
  ],
  "properties": {
    "query": {
      "type": "string",
      "description": "Search term to match column names or types"
    }
  }
}
scalix_db_search_columns annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_db_pii
Advertised by the server during the last successful anonymous check.
Advertised read-only

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

scalix_db_pii input schema
{
  "type": "object",
  "properties": {}
}
scalix_db_pii annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_db_optimize
Advertised by the server during the last successful anonymous check.
Advertised read-only

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

scalix_db_optimize input schema
{
  "type": "object",
  "required": [
    "sql"
  ],
  "properties": {
    "sql": {
      "type": "string",
      "description": "SQL query to analyze and optimize"
    }
  }
}
scalix_db_optimize annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_db_text_to_sql
Advertised by the server during the last successful anonymous check.
Advertised read-only

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.

scalix_db_text_to_sql input schema
{
  "type": "object",
  "required": [
    "question"
  ],
  "properties": {
    "question": {
      "type": "string",
      "description": "The question to answer from the database, in plain language (e.g. 'how many orders shipped last week?')"
    }
  }
}
scalix_db_text_to_sql annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_db_query
Advertised by the server during the last successful anonymous check.
Advertised destructive

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.

scalix_db_query input schema
{
  "type": "object",
  "required": [
    "sql"
  ],
  "properties": {
    "sql": {
      "type": "string",
      "description": "SQL query to execute"
    },
    "params": {
      "type": "array",
      "items": {},
      "description": "Bind parameters for the query"
    },
    "timeline_id": {
      "type": "string",
      "description": "F17: run the query against a BRANCH timeline of this project instead of the primary. Takes the timeline_id returned by scalix_db_branch_create (or its db_<timeline_id> form). A timeline that is not a branch of this project fails the call — it never falls back to the primary. Omit for the primary."
    },
    "confirm_token": {
      "type": "string",
      "description": "Confirmation token from a prior CONFIRMATION_REQUIRED response; required to execute destructive SQL (single-use, short TTL)"
    }
  }
}
scalix_db_query annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
scalix_db_schema
Advertised by the server during the last successful anonymous check.
Advertised read-only

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

scalix_db_schema input schema
{
  "type": "object",
  "properties": {}
}
scalix_db_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_db_table
Advertised by the server during the last successful anonymous check.
Advertised read-only

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

scalix_db_table input schema
{
  "type": "object",
  "required": [
    "table"
  ],
  "properties": {
    "table": {
      "type": "string",
      "description": "Table name to inspect"
    }
  }
}
scalix_db_table annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_db_migrate
Advertised by the server during the last successful anonymous check.
Advertised destructive

Apply a database migration by version number.

scalix_db_migrate input schema
{
  "type": "object",
  "required": [
    "tenant_id",
    "version"
  ],
  "properties": {
    "version": {
      "type": "string",
      "description": "Migration version to apply"
    },
    "tenant_id": {
      "type": "string",
      "description": "Tenant ID"
    }
  }
}
scalix_db_migrate annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
scalix_storage_list
Advertised by the server during the last successful anonymous check.
Advertised read-only

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

scalix_storage_list input schema
{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "Alias of bucket — accepted for symmetry with create/delete"
    },
    "bucket": {
      "type": "string",
      "description": "Bucket name (aliases: name). If omitted, lists all buckets."
    },
    "prefix": {
      "type": "string",
      "description": "Filter objects by key prefix"
    }
  }
}
scalix_storage_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_storage_upload
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

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

scalix_storage_upload input schema
{
  "type": "object",
  "required": [
    "bucket",
    "key",
    "content"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "Object key (path)"
    },
    "name": {
      "type": "string",
      "description": "Alias of bucket — accepted for symmetry with create/delete"
    },
    "bucket": {
      "type": "string",
      "description": "Target bucket name"
    },
    "content": {
      "type": "string",
      "description": "Base64-encoded file content"
    },
    "content_type": {
      "type": "string",
      "default": "application/octet-stream",
      "description": "MIME type"
    }
  }
}
scalix_storage_upload annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": true
}
scalix_storage_download
Advertised by the server during the last successful anonymous check.
Advertised read-only

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

scalix_storage_download input schema
{
  "type": "object",
  "required": [
    "bucket",
    "key"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "Object key (path)"
    },
    "name": {
      "type": "string",
      "description": "Alias of bucket — accepted for symmetry with create/delete"
    },
    "bucket": {
      "type": "string",
      "description": "Bucket name"
    }
  }
}
scalix_storage_download annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_storage_create_bucket
Advertised by the server during the last successful anonymous check.
Open-world

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. Public buckets double as static websites: upload index.html and serve it from the project's store subdomain at https://{slug}.store.scalix.world/buckets/{bucket}/objects/ (directory requests serve index.html; a 404.html object is served as the error page).

scalix_storage_create_bucket input schema
{
  "type": "object",
  "required": [
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Bucket name, unique within the project (aliases: bucket)"
    },
    "bucket": {
      "type": "string",
      "description": "Alias of name — accepted for symmetry with the object tools"
    },
    "public": {
      "type": "boolean",
      "default": false,
      "description": "true = all objects publicly readable without auth (also serves as a static website on {slug}.store.scalix.world); false (default) = private, share via presigned URLs"
    }
  }
}
scalix_storage_create_bucket annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_storage_delete_object
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

Permanently delete an object (key) from a storage bucket. Irreversible.

scalix_storage_delete_object input schema
{
  "type": "object",
  "required": [
    "bucket",
    "key"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "Object key (path) to delete"
    },
    "name": {
      "type": "string",
      "description": "Alias of bucket"
    },
    "bucket": {
      "type": "string",
      "description": "Bucket name (aliases: name)"
    }
  }
}
scalix_storage_delete_object annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": true
}
scalix_storage_delete_bucket
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

Permanently delete a storage bucket and every object in it. Irreversible.

scalix_storage_delete_bucket input schema
{
  "type": "object",
  "required": [
    "bucket"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Alias of bucket"
    },
    "bucket": {
      "type": "string",
      "description": "Bucket name (aliases: name)"
    }
  }
}
scalix_storage_delete_bucket annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": true
}
scalix_fn_list
Advertised by the server during the last successful anonymous check.
Advertised read-only

List all deployed serverless functions.

scalix_fn_list input schema
{
  "type": "object",
  "properties": {}
}
scalix_fn_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_fn_deploy
Advertised by the server during the last successful anonymous check.
Open-world

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

scalix_fn_deploy input schema
{
  "type": "object",
  "required": [
    "name",
    "image"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Function name"
    },
    "image": {
      "type": "string",
      "description": "Container image reference"
    },
    "runtime": {
      "type": "string",
      "description": "Runtime — `node` or `python` (exactly what the functions orchestrator accepts)"
    }
  }
}
scalix_fn_deploy annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
scalix_fn_invoke
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

Invoke a deployed function with a JSON payload.

scalix_fn_invoke input schema
{
  "type": "object",
  "required": [
    "function_id"
  ],
  "properties": {
    "data": {
      "type": "object",
      "description": "JSON payload to pass to the function"
    },
    "function_id": {
      "type": "string",
      "description": "Function ID to invoke"
    }
  }
}
scalix_fn_invoke annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}
scalix_kv_get
Advertised by the server during the last successful anonymous check.
Advertised read-only

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.

scalix_kv_get input schema
{
  "type": "object",
  "required": [
    "key"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "Exact key to look up (case-sensitive)"
    }
  }
}
scalix_kv_get annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_kv_set
Advertised by the server during the last successful anonymous check.
Advertised destructive

Set a key-value pair with optional TTL.

scalix_kv_set input schema
{
  "type": "object",
  "required": [
    "key",
    "value"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "Key to set"
    },
    "ttl": {
      "type": "integer",
      "description": "Time-to-live in seconds (0 = no expiry)"
    },
    "value": {
      "type": "string",
      "description": "Value to store"
    }
  }
}
scalix_kv_set annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
scalix_kv_list
Advertised by the server during the last successful anonymous check.
Advertised read-only

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

scalix_kv_list input schema
{
  "type": "object",
  "properties": {
    "prefix": {
      "type": "string",
      "description": "Filter keys by prefix"
    }
  }
}
scalix_kv_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_ai_infer
Advertised by the server during the last successful anonymous check.

Run AI inference on Scalix AI. 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.

scalix_ai_infer input schema
{
  "type": "object",
  "required": [
    "prompt"
  ],
  "properties": {
    "model": {
      "type": "string",
      "description": "Model ID (from scalix_ai_models — a scalix-auto/* tier or a scalix-gw/<vendor>/<model> catalog id)"
    },
    "prompt": {
      "type": "string",
      "description": "User prompt / message"
    },
    "system": {
      "type": "string",
      "description": "System message"
    },
    "max_tokens": {
      "type": "integer",
      "default": 1024,
      "description": "Maximum tokens to generate"
    },
    "temperature": {
      "type": "number",
      "default": 0.7,
      "description": "Sampling temperature (0-2)"
    }
  }
}
scalix_ai_infer annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
scalix_ai_models
Advertised by the server during the last successful anonymous check.
Advertised read-only

List the AI models available to the project — virtual tiers and the pass-through catalog model IDs — for use in scalix_ai_infer.

scalix_ai_models input schema
{
  "type": "object",
  "properties": {}
}
scalix_ai_models annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_events_publish
Advertised by the server during the last successful anonymous check.
Open-world

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.

scalix_events_publish input schema
{
  "type": "object",
  "required": [
    "topic_id",
    "event_type",
    "data"
  ],
  "properties": {
    "data": {
      "type": "object",
      "description": "Event payload (JSON)"
    },
    "topic_id": {
      "type": "string",
      "description": "Topic ID to publish to"
    },
    "event_type": {
      "type": "string",
      "description": "Event type/name, e.g. 'user.created'"
    }
  }
}
scalix_events_publish annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
scalix_events_topics
Advertised by the server during the last successful anonymous check.
Advertised read-only

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_events_topics input schema
{
  "type": "object",
  "properties": {}
}
scalix_events_topics annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_cron_create
Advertised by the server during the last successful anonymous check.
Open-world

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

scalix_cron_create input schema
{
  "type": "object",
  "required": [
    "name",
    "expression",
    "action_type"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Schedule name"
    },
    "config": {
      "type": "object",
      "description": "Action configuration (function_id or webhook URL)"
    },
    "expression": {
      "type": "string",
      "description": "Cron expression (e.g., '*/5 * * * *')"
    },
    "action_type": {
      "enum": [
        "function",
        "webhook"
      ],
      "type": "string",
      "description": "Type of action to trigger"
    }
  }
}
scalix_cron_create annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
scalix_sandbox_run
Advertised by the server during the last successful anonymous check.
Open-world

Execute code in an isolated sandbox. Supports Python, JavaScript, TypeScript, and Bash. Returns stdout/stderr, the probed interpreter version, and any files the code wrote (base64, under size/count caps).

scalix_sandbox_run input schema
{
  "type": "object",
  "required": [
    "language",
    "code"
  ],
  "properties": {
    "code": {
      "type": "string",
      "description": "Source code to execute"
    },
    "files": {
      "type": "object",
      "description": "Additional files (filename -> content)"
    },
    "language": {
      "enum": [
        "python",
        "javascript",
        "typescript",
        "bash"
      ],
      "type": "string",
      "description": "Programming language"
    },
    "packages": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Packages to install (pip/npm)"
    },
    "timeout_seconds": {
      "type": "integer",
      "description": "Max execution time in seconds (default: 30)"
    }
  }
}
scalix_sandbox_run annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
scalix_computer_create
Advertised by the server during the last successful anonymous check.

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.

scalix_computer_create input schema
{
  "type": "object",
  "required": [
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Machine name: lowercase letters, digits and hyphens, max 63 characters. Unique to you."
    },
    "vcpus": {
      "type": "integer",
      "description": "vCPUs, 1-16 (default 1). Ignored if the machine already exists."
    },
    "disk_gb": {
      "type": "integer",
      "description": "Root disk in GB, 5-200 (default 10). Fixed at create — disks do not grow. Ignored if the machine already exists."
    },
    "ssh_keys": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "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 half only; a private key is rejected. Ignored if the machine already exists — use scalix_computer_set_ssh_keys to change them. Supplying this needs the sandbox:execute scope on top of sandbox:create, because a key is a root shell; omit it and sandbox:create alone is enough."
    },
    "memory_mb": {
      "type": "integer",
      "description": "Memory in MB, 512-32768 (default 1024). Ignored if the machine already exists."
    }
  }
}
scalix_computer_create annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_computer_set_ssh_keys
Advertised by the server during the last successful anonymous check.
Advertised destructive

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.

scalix_computer_set_ssh_keys input schema
{
  "type": "object",
  "required": [
    "id",
    "ssh_keys"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Machine id"
    },
    "ssh_keys": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The complete list of OpenSSH public keys, max 32. Empty array removes all of them."
    }
  }
}
scalix_computer_set_ssh_keys annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
scalix_computer_list
Advertised by the server during the last successful anonymous check.
Advertised read-only

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

scalix_computer_list input schema
{
  "type": "object",
  "properties": {}
}
scalix_computer_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_computer_exec
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

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.

scalix_computer_exec input schema
{
  "type": "object",
  "required": [
    "id",
    "command"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Machine id from scalix_computer_create or scalix_computer_list"
    },
    "cwd": {
      "type": "string",
      "description": "Working directory inside the machine"
    },
    "env": {
      "type": "object",
      "description": "Environment variables for this command only"
    },
    "args": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Arguments passed to the program; omit when command is a shell string"
    },
    "command": {
      "type": "string",
      "description": "Either a bare program (e.g. bash, with args passed separately) OR a full shell string (e.g. \"apt-get install -y jq\") — a command containing whitespace is run via sh -lc automatically, so no manual [\"-lc\", ...] wrapping is needed"
    },
    "timeout_ms": {
      "type": "integer",
      "description": "Give up after this many milliseconds, 1000-300000 (default 120000). 300s is the platform-wide hop ceiling — a larger request is served at 300s, not rejected."
    }
  }
}
scalix_computer_exec annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}
scalix_computer_write_file
Advertised by the server during the last successful anonymous check.
Advertised destructive

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

scalix_computer_write_file input schema
{
  "type": "object",
  "required": [
    "id",
    "path",
    "content"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Machine id"
    },
    "mode": {
      "type": "integer",
      "description": "Unix mode in decimal, e.g. 493 for 0755. Omit unless the file must be executable."
    },
    "path": {
      "type": "string",
      "description": "Absolute path inside the machine, e.g. /root/app/main.py"
    },
    "content": {
      "type": "string",
      "description": "File contents as text"
    }
  }
}
scalix_computer_write_file annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
scalix_computer_read_file
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read a text file out of a persistent Linux machine.

scalix_computer_read_file input schema
{
  "type": "object",
  "required": [
    "id",
    "path"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Machine id"
    },
    "path": {
      "type": "string",
      "description": "Absolute path inside the machine"
    }
  }
}
scalix_computer_read_file annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_computer_stop
Advertised by the server during the last successful anonymous check.

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.

scalix_computer_stop input schema
{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Machine id"
    }
  }
}
scalix_computer_stop annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_computer_start
Advertised by the server during the last successful anonymous check.

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

scalix_computer_start input schema
{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Machine id"
    }
  }
}
scalix_computer_start annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_computer_delete
Advertised by the server during the last successful anonymous check.
Advertised destructive

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

scalix_computer_delete input schema
{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Machine id"
    }
  }
}
scalix_computer_delete annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
scalix_crew_list
Advertised by the server during the last successful anonymous check.
Advertised read-only

List your crews with their ids and names. A crew is a team of AI members that share a notice board; use the crew id with the board tools.

scalix_crew_list input schema
{
  "type": "object",
  "properties": {}
}
scalix_crew_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_crew_board_read
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read a crew's notice board: every pinned note plus the newest unpinned ones, current as of this call. The board is the crew's shared coordination state — read it before starting work so you act on the latest news, and post what teammates need to know with scalix_crew_board_post.

scalix_crew_board_read input schema
{
  "type": "object",
  "required": [
    "crew_id"
  ],
  "properties": {
    "crew_id": {
      "type": "string",
      "description": "Crew id from scalix_crew_list"
    }
  }
}
scalix_crew_board_read annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_crew_board_post
Advertised by the server during the last successful anonymous check.

Post a note to the crew's notice board for other members and the human to see. The board is news, not knowledge: set ttl_seconds so routine updates expire on their own, pin only what every future task must see, and set owner_member_id to hand work off to a specific member. Notes cannot be edited from here — post a correction instead.

scalix_crew_board_post input schema
{
  "type": "object",
  "required": [
    "crew_id",
    "body"
  ],
  "properties": {
    "body": {
      "type": "string",
      "description": "The note, max 8000 chars. Write for a teammate who was not watching your work."
    },
    "pinned": {
      "type": "boolean",
      "description": "Keep this in front of everyone indefinitely. Default false; most notes should expire instead."
    },
    "crew_id": {
      "type": "string",
      "description": "Crew id from scalix_crew_list"
    },
    "ttl_seconds": {
      "type": "integer",
      "description": "Seconds until the note expires, 60 to 7776000 (90 days). Omit for no expiry — usually only right for pins."
    },
    "owner_member_id": {
      "type": "string",
      "description": "Hand off: the member id now responsible for this item."
    },
    "author_member_id": {
      "type": "string",
      "description": "Your member id, so the note is attributed. Omit when posting as the human."
    }
  }
}
scalix_crew_board_post annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
scalix_domain_add
Advertised by the server during the last successful anonymous check.

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

scalix_domain_add input schema
{
  "type": "object",
  "required": [
    "domain"
  ],
  "properties": {
    "domain": {
      "type": "string",
      "description": "Domain name to add (e.g., api.example.com)"
    }
  }
}
scalix_domain_add annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
scalix_domain_list
Advertised by the server during the last successful anonymous check.
Advertised read-only

List all custom domains and their SSL/verification status.

scalix_domain_list input schema
{
  "type": "object",
  "properties": {}
}
scalix_domain_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_domain_verify
Advertised by the server during the last successful anonymous check.
Open-world

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

scalix_domain_verify input schema
{
  "type": "object",
  "required": [
    "domain"
  ],
  "properties": {
    "domain": {
      "type": "string",
      "description": "Domain to verify"
    }
  }
}
scalix_domain_verify annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_build_create
Advertised by the server during the last successful anonymous check.
Open-world

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

scalix_build_create input schema
{
  "type": "object",
  "required": [
    "name",
    "git_url"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Build name"
    },
    "branch": {
      "type": "string",
      "default": "main",
      "description": "Git branch"
    },
    "git_url": {
      "type": "string",
      "description": "Git repository URL"
    },
    "dockerfile": {
      "type": "string",
      "default": "Dockerfile",
      "description": "Path to Dockerfile in repo"
    }
  }
}
scalix_build_create annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
scalix_build_status
Advertised by the server during the last successful anonymous check.
Advertised read-only

Get the status and logs of a build.

scalix_build_status input schema
{
  "type": "object",
  "required": [
    "build_id"
  ],
  "properties": {
    "build_id": {
      "type": "string",
      "description": "Build ID to check"
    }
  }
}
scalix_build_status annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_project_create
Advertised by the server during the last successful anonymous check.

Create a new project within an organization. Returns the project ID, name, and slug. Issue an API key for the new project separately. Needs an admin API key: organization admin scope is never delegated to a connected app, so this tool fails on an OAuth connection.

scalix_project_create input schema
{
  "type": "object",
  "required": [
    "org_id",
    "name",
    "slug"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Project display name"
    },
    "slug": {
      "type": "string",
      "description": "URL-safe project slug"
    },
    "org_id": {
      "type": "string",
      "description": "Organization ID"
    }
  }
}
scalix_project_create annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
scalix_project_list
Advertised by the server during the last successful anonymous check.
Advertised read-only

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. `org_id` is optional: omit it to list the projects of the organization the API key belongs to (resolved via GET /v1/me). Needs an admin API key: organization admin scope is never delegated to a connected app, so this tool fails on an OAuth connection.

scalix_project_list input schema
{
  "type": "object",
  "required": [],
  "properties": {
    "org_id": {
      "type": "string",
      "description": "Organization ID whose projects to list. Optional — defaults to the API key's own organization."
    }
  }
}
scalix_project_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_auth_configure
Advertised by the server during the last successful anonymous check.
Advertised destructive

Configure end-user authentication for the project — require MFA, require email confirmation, and set the allowed auth providers. Needs an admin API key: organization admin scope is never delegated to a connected app, so this tool fails on an OAuth connection.

scalix_auth_configure input schema
{
  "type": "object",
  "properties": {
    "mfa_enabled": {
      "type": "boolean",
      "description": "Require multi-factor authentication"
    },
    "allowed_providers": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Allowed auth providers (e.g., [\"email\", \"google\", \"github\"])"
    },
    "require_email_confirmation": {
      "type": "boolean",
      "description": "Require users to confirm their email before a session is issued"
    }
  }
}
scalix_auth_configure annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
scalix_status
Advertised by the server during the last successful anonymous check.
Advertised read-only

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

scalix_status input schema
{
  "type": "object",
  "properties": {}
}
scalix_status annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_run_deploy
Advertised by the server during the last successful anonymous check.
Open-world

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.

scalix_run_deploy input schema
{
  "type": "object",
  "required": [
    "name",
    "image"
  ],
  "properties": {
    "env": {
      "type": "object",
      "description": "Environment variables as key-value pairs"
    },
    "name": {
      "type": "string",
      "description": "Service name"
    },
    "port": {
      "type": "integer",
      "default": 8080,
      "description": "Port the container listens on"
    },
    "image": {
      "type": "string",
      "description": "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": {
      "type": "integer",
      "default": 10,
      "description": "Maximum instances"
    },
    "min_instances": {
      "type": "integer",
      "default": 0,
      "description": "Minimum instances (0 = scale to zero)"
    }
  }
}
scalix_run_deploy annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
scalix_run_list
Advertised by the server during the last successful anonymous check.
Advertised read-only

List all deployed container services in the project.

scalix_run_list input schema
{
  "type": "object",
  "properties": {}
}
scalix_run_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_run_scale
Advertised by the server during the last successful anonymous check.

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.

scalix_run_scale input schema
{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Service ID (from scalix_run_list)"
    },
    "max_instances": {
      "type": "integer",
      "description": "New maximum instance count the service may scale up to"
    },
    "min_instances": {
      "type": "integer",
      "description": "New minimum instance count (0 = scale-to-zero when idle)"
    }
  }
}
scalix_run_scale annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
scalix_run_rollback
Advertised by the server during the last successful anonymous check.
Open-world

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.

scalix_run_rollback input schema
{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Service ID (from scalix_run_list)"
    },
    "revision": {
      "type": "integer",
      "description": "Revision number to roll back to; omit for the immediately previous revision"
    }
  }
}
scalix_run_rollback annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
scalix_run_delete
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

Permanently delete a Scalix Run service. This cannot be undone: it stops the running instances, releases the public HTTPS URL, erases any attached volumes and discards every revision, so scalix_run_rollback cannot bring it back afterwards. To stop paying for an idle service without losing it, set min_instances to 0 with scalix_run_scale instead.

scalix_run_delete input schema
{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Service ID (from scalix_run_list)"
    }
  }
}
scalix_run_delete annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": true
}

Prompts

Not advertised

No prompt definitions available.

Resources

2 advertised

Database Schema

Advertised by the server during the last successful anonymous check.

Full database schema as structured JSON

Database Schema URI
scalix://schema

MIME type: application/json

Relationship Map

Advertised by the server during the last successful anonymous check.

Foreign key relationships between tables

Relationship Map URI
scalix://relationships

MIME type: application/json

Table Schema

Advertised by the server during the last successful anonymous check.

Schema for a specific table

Table Schema URI template
scalix://schema/{table}

MIME type: application/json

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (1 of 1 answered).

  1. 2026-11-07: 1 of 1 checks answered

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
995 ms
95th percentile latency
995 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 995 ms · metadata changed · 53 tool(s), 2 resource(s), 1 resource template(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http scalix-cloud-mcp https://api.scalix.world/v1/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add scalix-cloud-mcp --url https://api.scalix.world/v1/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable scalix-cloud-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "scalix-cloud-mcp": {
      "url": "https://api.scalix.world/v1/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "scalix-cloud-mcp": {
      "type": "streamableHttp",
      "url": "https://api.scalix.world/v1/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start scalix-cloud-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "scalix-cloud-mcp": {
      "type": "http",
      "url": "https://api.scalix.world/v1/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http scalix-cloud-mcp https://api.scalix.world/v1/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://api.scalix.world/v1/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "scalix-cloud-mcp": {
      "serverUrl": "https://api.scalix.world/v1/mcp"
    }
  }
}

Let your agent find its tools

Find servers like Scalix Cloud MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows
See all 618

Do you run Scalix Cloud MCP?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing