Installation

Prerequisites

For the default installer, you need:

• curl or wget
• tar

If you plan to build from source, you also need:

• Rust 1.93+: install via rustup if you don't have it
• A C linker (included with Xcode Command Line Tools on macOS, or build-essential on Debian/Ubuntu)

Install with curl

This downloads the matching release archive for your OS and CPU, verifies its SHA-256 checksum, and installs chio into /usr/local/bin:

$ curl -fsSL https://www.chio.world/install.sh | sh

To install into a user-writable directory:

$ curl -fsSL https://www.chio.world/install.sh | CHIO_INSTALL_DIR="$HOME/.local/bin" sh

Pin a version or point the installer at a private mirror:

$ curl -fsSL https://www.chio.world/install.sh | CHIO_VERSION=0.1.0 sh
$ curl -fsSL https://www.chio.world/install.sh | \
    CHIO_RELEASE_BASE_URL=https://mirror.example.com/chio/releases/v0.1.0 sh

Install via Cargo

If you already have a Rust toolchain:

$ cargo install chio

Homebrew

On macOS and Linuxbrew, install the release formula directly:

$ curl -fsSL https://www.chio.world/releases/chio/latest/chio.rb -o /tmp/chio.rb \
    && brew install --formula /tmp/chio.rb

Prebuilt Binaries

The installer downloads the same release archives directly. Builds are available for these targets:

$ VERSION=0.1.0
$ TARGET=aarch64-apple-darwin
$ ARCHIVE="chio-$VERSION-$TARGET.tar.gz"
$ BASE="https://www.chio.world/releases/chio/v$VERSION"
$ curl -fL "$BASE/$ARCHIVE" -o "$ARCHIVE"
$ curl -fL "$BASE/$ARCHIVE.sha256" -o "$ARCHIVE.sha256"
$ shasum -a 256 -c "$ARCHIVE.sha256"
$ tar -xzf "$ARCHIVE"
$ sudo install -m 0755 "chio-$VERSION-$TARGET/chio" /usr/local/bin/chio

Docker

Run the Chio kernel in a container for CI runners, temporary build agents, or environments where installing a native binary is impractical.

$ docker pull ghcr.io/backbay-labs/chio-sidecar:latest

Run a governed MCP server inside the container:

$ docker run --rm -v ./policy.yaml:/policy.yaml \
    ghcr.io/backbay-labs/chio-sidecar:latest \
    mcp serve --policy /policy.yaml --server-id srv-files \
    -- npx -y @modelcontextprotocol/server-filesystem /workspace

The image is Alpine-based and runs as the non-root user chio (UID 10001), with tini as PID 1 for correct signal handling. Sidecar state is persisted under /var/lib/chio; mount a volume there to keep receipts across restarts. With no command supplied the container defaults to chio --help, so pass an explicit subcommand (run, mcp serve-http, and the like) to start the kernel.

SDK Installation

To embed Chio governance directly in your application instead of running the CLI as a sidecar, use one of the language SDKs.

TypeScript

$ npm install @chio-protocol/sdk

Or with your preferred package manager:

$ yarn add @chio-protocol/sdk
$ pnpm add @chio-protocol/sdk
$ bun add @chio-protocol/sdk

Python

$ pip install chio-sdk

Go

$ go get github.com/backbay-labs/chio/sdks/go/chio-go

Framework adapters

Framework integrations connect Chio to an existing application stack. In Python, install an adapter alongside chio-sdk:

$ pip install chio-fastapi     # FastAPI / ASGI
$ pip install chio-django      # Django
$ pip install chio-langgraph   # LangGraph
$ pip install chio-temporal    # Temporal workflows

Further Python adapters cover chio-langchain, chio-crewai, chio-autogen, chio-llamaindex, chio-prefect, chio-dagster, chio-airflow, and chio-ray. On TypeScript, the core @chio-protocol/sdk is paired with per-framework packages:

$ npm install @chio-protocol/express
$ npm install @chio-protocol/fastify
$ npm install @chio-protocol/elysia
$ npm install @chio-protocol/node-http
$ npm install @chio-protocol/ai-sdk

Other languages

Chio also ships host SDKs beyond TypeScript, Python, and Go. The JVM surface includes chio-sdk-jvm, chio-spring-boot, and chio-streaming-flink; .NET is served by ChioMiddleware; C++ by chio-cpp and the Drogon middleware chio-drogon. For infrastructure, there is a Kubernetes controller with CRDs and admission webhooks, an AWS Lambda extension (chio-lambda-extension), and a Swift SDK with App Attest support.

Verify release signatures

Each release archive ships with a detached Sigstore keyless signature: a .sig (cosign signature) and a .pem (Fulcio short-lived certificate) produced by the GitHub Actions release workflow under its OIDC identity. Verify a downloaded archive with cosign, pinning both the certificate identity and the OIDC issuer:

$ ARCHIVE=chio-0.1.0-aarch64-apple-darwin.tar.gz
$ cosign verify-blob \
    --signature   "$ARCHIVE.sig" \
    --certificate "$ARCHIVE.pem" \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    --certificate-identity-regexp \
        '^https://github.com/backbay-labs/chio/.github/workflows/.+@refs/tags/.+$' \
    "$ARCHIVE"

The verification fails closed if the signature does not match the bytes, the Fulcio certificate does not chain to the trust root, the certificate identity does not match, the issuer is wrong, or the Rekor transparency-log inclusion proof is missing. If the CLI is already installed, chio attest verify wraps the same trust root and identity contract without a separate cosign install. Releases also publish SLSA provenance and an SBOM alongside the signed archives.

Verify Installation

Confirm the CLI is installed and reachable:

$ chio --version
chio-cli 0.1.0

If you see a version string, you're ready. If you get a command not found error, ensure the install directory is in your PATH.

Next Steps

With the CLI installed, explore the system architecture or jump straight into writing policies:

• Architecture: understand the kernel, guard pipeline, and trust boundaries
• Capabilities: how authority is scoped, delegated, and revoked
• Policy Schema: full guard configuration options