# Kuiper

> Kuiper is a deployment platform for AI agents, the way Vercel is for Next.js apps. It builds, runs and keeps alive Glove Foundry apps, Station daemons and other Node services, with persistent disks, managed Postgres, Redis and object storage, secrets, custom domains, logs and rollbacks. Made by Cradle Research (cradleresearch.io). Kuiper is in early access.

Facts an agent working with Kuiper needs:

- The CLI is `kuiper`. Install it with `curl -fsSL https://kuiper.sh/install | sh` (macOS and Linux, x86-64 and arm64; prebuilt binaries only, the source is not public), then sign in with `kuiper login`, which opens the dashboard to approve a short code.
- In CI or on a server, sign in with an API token instead: `kuiper login --token <token>`, or the `KUIPER_TOKEN` environment variable. Tokens start with `kpr_` and act for a whole organisation. Never commit or print one.
- The dashboard and API are at https://app.kuiper.sh. Every deployed unit gets an HTTPS address under `kiprsh.app`, and custom domains point a CNAME at `cname.kiprsh.app`.
- The words: an organisation owns projects; a project groups units and owns secrets, databases, buckets and domains; a unit is one deployed agent or service (`agent`, `station` or `service`); each deploy of a unit is a numbered deployment, and one is live at a time.
- Glove Foundry apps and Station daemons deploy with no Dockerfile and no config: Kuiper detects them and picks the build, the start command and the port. Other Node apps need a start command and a port, and a repository with a Dockerfile is built from it. `kuiper.json` changes what Kuiper detects.
- Variables are templates of the form `${{<name>.<OUTPUT>}}`: `${{secrets.NAME}}` reads a project secret, `${{shared.NAME}}` a shared project variable, and `${{main.DATABASE_URL}}` an output of the database, bucket, unit or external resource whose slug is `main`.
- Foundry and Station units keep state on a persistent disk at `/data`, and logs survive crashes and redeploys.
- Kuiper runs browsers and sandboxes for agents on its gateway, `https://gateway.kuiper.sh`. Browsers speak Steel's API at `/browsers` (Steel's SDKs work with `baseURL` changed; connect with Playwright or Puppeteer over CDP). Sandboxes are at `/sandboxes/v1/sandboxes`, from images such as `kuiper/coding`. Both take a gateway key, `kgw_…`, never an API token. A unit gets its own with `${{browsers.API_KEY}}`, `${{browsers.BASE_URL}}`, `${{sandboxes.API_KEY}}` and `${{sandboxes.BASE_URL}}`; elsewhere, create one with `kuiper keys create NAME -p PROJECT`.
- Kuiper's model gateway is at `https://gateway.kuiper.sh/models` and serves each provider's own API: OpenAI's (Chat Completions, Responses, Embeddings, images, audio), Anthropic's Messages and Google's Gemini API. Glove's `createAdapter({ provider, model, baseURL, apiKey })` and OpenAI's SDK take `/models/v1` as their base URL (`${{models.BASE_URL}}`); Anthropic's SDK and Glove's `anthropic` provider take `/models` (`${{models.ANTHROPIC_BASE_URL}}`), and so does Google's Gen AI SDK (`${{models.GEMINI_BASE_URL}}`); the key is a gateway key (`${{models.API_KEY}}`). Calls go to the organisation's own provider keys (`kuiper providers add openai --key -`): `name/model` picks a key, and a provider's own model names (`gpt-…`, `claude-…`, `gemini-…`, `kimi-…`, `glm-…`, `MiniMax-…`, `mimo-…`) go to that provider. Kuiper adds no charge; `kuiper models calls` and `kuiper models usage` show every call's tokens and estimated provider cost.
- In TypeScript, `@kuiper-sh/sdk` (npm) wraps all three: `new Kuiper({ apiKey })` gives `kuiper.models.chat()` and `.stream()`, `kuiper.browsers.create()` (a session's `websocketUrl` takes Playwright or Puppeteer), and `kuiper.sandboxes.create()` (then `sandbox.exec()`, `sandbox.files`, `sandbox.terminal()`, `sandbox.ports`). `kuiper.models.openai()`, `anthropic()`, `google()`, `glove(provider)` and `aiSdk.*` give those clients the right base URL and key. `@kuiper-sh/models`, `@kuiper-sh/browsers` and `@kuiper-sh/sandboxes` are the services one by one. Failures are `KuiperError` with the gateway's `code`.
- Kuiper is an MCP server at `https://app.kuiper.sh/mcp` (Streamable HTTP, OAuth sign-in approved in the dashboard). An agent connected to it can read projects, logs, network logs and usage and, with write access, deploy and change configuration; secret values are never returned. Add it to Claude Code with `claude mcp add --transport http kuiper https://app.kuiper.sh/mcp`.

## Get started

- [Overview and quickstart](https://kuiper.sh/docs/index.md): Kuiper deploys Glove Foundry and Station agents. Install the CLI, sign in, deploy an agent and watch it come up.
- [Install and sign in](https://kuiper.sh/docs/install.md): Install the kuiper CLI on macOS or Linux, sign in from a terminal, a server or CI, and add a passkey to the dashboard.

## Dashboard

- [Dashboard tour](https://kuiper.sh/docs/dashboard.md): Every page of the Kuiper dashboard and what it is for, from the project overview to logs, usage and the Inspect cards.
- [Finding things](https://kuiper.sh/docs/finding.md): Jump to any unit, deployment, domain or variable with Ctrl-K, search a project from the CLI, and filter logs with @level:error. The full reference for the search language.
- [Connect an agent (MCP)](https://kuiper.sh/docs/mcp.md): Let Claude Code, Claude Desktop, claude.ai, Cursor, VS Code or any MCP client see your Kuiper dashboard and, if you allow it, deploy, restart and change configuration. It signs in with OAuth and you can disconnect it at any time.

## Deploy

- [Deploying](https://kuiper.sh/docs/deploying.md): Deploy from a Git repository, from a folder or from an image, and use kuiper.json when you need to change what Kuiper detects.
- [Variables and secrets](https://kuiper.sh/docs/variables.md): Give a unit its settings. Values are templates that can point at a secret, a database or another unit, and a restart applies them.
- [Databases, Redis and buckets](https://kuiper.sh/docs/databases.md): Run Postgres and Redis next to your units, store files in S3-compatible buckets, and keep state on a volume. All of it is private to the project.
- [Domains](https://kuiper.sh/docs/domains.md): Every unit has an address on kiprsh.app. Add your own domain, create the DNS records Kuiper shows you, and HTTPS follows on its own.
- [Environments](https://kuiper.sh/docs/environments.md): Run production, staging and experiments of the same project, each from its own git branch with its own variables, databases and URLs.

## Agents

- [Station units](https://kuiper.sh/docs/station.md): Deploy a Station daemon with no Dockerfile, sign in to its dashboard, inspect signals, runs and beacons from Kuiper, and mint API keys for other services.
- [Glove Foundry units](https://kuiper.sh/docs/foundry.md): Deploy a Foundry app with no Dockerfile, protect it with an authorizer, give browsers a login and read its runs from the dashboard.
- [Example: ops-lab](https://kuiper.sh/docs/example.md): One project with a Station headquarters and workers, a service that drives them and a Foundry agent that reads them. Shipped with a single script.

## Agent services

- [TypeScript SDK](https://kuiper.sh/docs/sdk.md): Kuiper's SDK for models, browsers and sandboxes. One gateway key, typed methods for everything the gateway does, ready settings for OpenAI's, Anthropic's, Google's, Glove's, the AI SDK's and Steel's clients, and errors you can act on.
- [Models](https://kuiper.sh/docs/models.md): Call OpenAI, Anthropic, Google, Kimi, GLM, MiniMax and more through one gateway with your own provider keys, each provider in its own API. Kuiper routes, limits and records every call, can keep what each call said, and adds no charge.
- [Browsers](https://kuiper.sh/docs/browsers.md): Give your agents real Chrome browsers through a Steel-compatible API. Connect with Playwright or Puppeteer, hold a session for later, keep logins in profiles, replay recordings, or run sessions on your own Steel, Browserbase, Kernel, Hyperbrowser, Anchor or Browser Use account.
- [Sandboxes](https://kuiper.sh/docs/sandboxes.md): Give an agent a remote computer to run code in. Create a sandbox from a ready-made image, run commands, open a terminal, move files, serve a dev server at its own URL and hibernate it for later.
- [Sandbox images](https://kuiper.sh/docs/sandbox-images.md): Start a sandbox from Kuiper's ready-made images for documents, coding, coding agents, video and data by name, without building, publishing or allowlisting an image.
- [Gateway keys](https://kuiper.sh/docs/gateway-keys.md): The keys that open Kuiper's models, browsers and sandboxes. Units on Kuiper get theirs from a variable; agents and scripts elsewhere use keys you create and revoke.

## Operate

- [Logs, deployments and rollbacks](https://kuiper.sh/docs/operations.md): Read what a unit printed, follow a deploy, restart a unit, go back to an earlier deployment and move a unit to another region.
- [Network logs](https://kuiper.sh/docs/network.md): See every request your units answer, every name they look up and every connection they make, and search all of it. Nothing to install or configure; it works for every unit.
- [Usage and billing](https://kuiper.sh/docs/usage.md): See what your organisation used and what it cost, by day, by resource, by project and by unit, and how each amount is worked out.
- [Budgets and limits](https://kuiper.sh/docs/budgets.md): Cap or watch what your organisation, a project or a gateway key spends on browsers and sandboxes each month, and the limits on concurrent sessions and requests.
- [Teams, roles and tokens](https://kuiper.sh/docs/teams.md): Invite people, give them a role, create API tokens for the CLI and CI, and manage the Git credentials and registries your builds use.

## Reference

- [CLI reference](https://kuiper.sh/docs/cli.md): Every kuiper command and subcommand with what it does and the flags it takes.

## Optional

- [All of the docs in one file](https://kuiper.sh/llms-full.txt): every page listed above, in order, as Markdown.
- [From Proxima to Kuiper](https://kuiper.sh/blog/from-proxima-to-kuiper/): why Kuiper exists and what it grew out of.
- [Glove](https://glove.dterminal.net): the framework Glove Foundry apps are built with.
- [Station](https://station.dterminal.net): background jobs and long-running processes for TypeScript.