# INK Full Reference

> Infrastructure for AI agents and developers. Deploy services, templates, databases, domains, and production workloads through the CLI, Agent Skills, MCP, or dashboard.

INK lets AI coding agents operate application infrastructure directly. Agents can create repositories, deploy services, inspect logs and metrics, configure environment variables, attach persistent volumes, deploy database templates, manage domains and DNS, coordinate through workspace chat, and review action logs.

## Canonical URLs

- Website: https://deployink.com
- Documentation: https://docs.deployink.com
- Pricing: https://deployink.com/pricing
- Templates: https://deployink.com/deploy
- Dashboard: https://deployink.com
- MCP endpoint: https://mcp.deployink.com
- GraphQL API: https://api.deployink.com/graphql

## Positioning

INK is built for agent-operated infrastructure. The platform supports four first-class control paths:

1. Agent Skill: prompt-guided, uses the INK CLI under the hood.
2. CLI: direct terminal interface for agents, humans, scripts, and CI.
3. MCP: hosted Streamable HTTP tool-calling endpoint.
4. Dashboard: human-visible control and observability.

INK supports MCP, CLI, Skills, and dashboard workflows as first-class control paths.

## Install And Connect

### CLI

```bash
npm install -g @mldotink/cli
brew install mldotink/tap/ink
ink login
ink whoami
```

### Skill

```bash
npx skills add mldotink/ink-skill
```

The Skill teaches an agent the INK CLI workflow. It is the simplest path for Claude Code and other AgentSkills-compatible clients because no MCP server configuration is required.

### MCP

- URL: `https://mcp.deployink.com`
- Transport: Streamable HTTP
- Auth: OAuth browser flow or `Authorization: Bearer <api-key>`
- Clients: Claude Code, Cursor, VS Code, Codex, Gemini CLI, Windsurf, Goose, Kimi Code, Open Code, Cline, KiloCode, Antigravity, and any MCP-compatible client.

## Core Concepts

- Workspace: billable scope for members, billing, usage, DNS, settings, and projects.
- Project: group of related services and template deployments.
- Service: deployed container or application. Services have ports, env vars, resources, logs, metrics, deployments, volumes, and settings.
- Template: preconfigured service stack that can create one or more normal INK services.
- Persistent volume: durable storage attached to a service.
- Domain: custom hostname attached to a service, backed by DNS records under delegated zones.

## Supported Workloads

INK supports Docker images, Dockerfiles, Docker Compose, static sites, and Railpack auto-detection for common app frameworks and languages.

Common stacks include Node.js, React, Next.js, Vue, Svelte, Astro, Python, FastAPI, Django, Flask, Go, Rust, Ruby on Rails, PHP/Laravel, Java/Spring Boot, .NET/C#, Elixir, Bun, Deno, Streamlit, Gradio, Haskell, Zig, and static HTML.

## Deployments

Agents can deploy from:

- INK-managed git repositories created by `repo_create` or `ink repo create`
- GitHub repositories when GitHub integration is connected
- Prebuilt Docker images with `source="image"`

Default service resources are `256Mi` memory and `0.25` vCPU unless overridden. Resource limits are subject to the active workspace plan.

Service ports use the current `ports` array schema:

```json
[
  { "name": "http", "port": 3000, "protocol": "http", "visibility": "public" }
]
```

Workers that do not listen on a port can pass `ports: []`.

Environment variables use an array of key/value pairs:

```json
[
  { "key": "DATABASE_URL", "value": "postgresql://..." },
  { "key": "NODE_ENV", "value": "production" }
]
```

## Templates And Databases

Templates deploy preconfigured service stacks. A template deployment creates normal INK services with generated credentials, endpoints, outputs, and persistent volumes when the template defines them.

Seed database templates:

| Slug | Engine | Default resources | Volume |
|---|---|---|---|
| `postgres` | PostgreSQL 17 | 512 Mi memory, 0.5 vCPU | 10 Gi default |
| `postgres-pgvector` | PostgreSQL 17 + pgvector | 512 Mi memory, 0.5 vCPU | 10 Gi default |
| `redis` | Redis 7 with password auth | 512 Mi memory, 0.5 vCPU | 10 Gi default |
| `mysql` | MySQL 8 | 512 Mi memory, 0.5 vCPU | 10 Gi default |
| `mongodb` | MongoDB 7 | 512 Mi memory, 0.5 vCPU | 10 Gi default |

Database templates are self-hosted container services on INK. They are not a separate managed-database product with automatic backups, failover, or managed upgrades unless a template explicitly documents those capabilities.

Any database with a container image can be provisioned as a normal INK service. Use `service_create` with `source="image"`, the database image, an internal TCP port, required environment variables, and a persistent volume at the database data directory. Templates provide repeatable one-command provisioning and generated outputs for common engines, but they do not limit which database engines can run on INK.

Other seeded templates include Directus, OpenClaw, Grafana, Grafana + Prometheus, observability stacks, NATS, MediaWiki, PgBouncer variants, Mathesar, Temporal, and GitHub Actions runners.
User-created and community templates are coming up.

Example template deploy:

```bash
ink template info postgres
ink template deploy postgres --name my-db --var database_name=app --var storage_gi=20
```

MCP equivalent:

```json
{
  "tool": "template_deploy",
  "arguments": {
    "template": "postgres",
    "name": "my-db",
    "variables": [
      { "key": "database_name", "value": "app" },
      { "key": "storage_gi", "value": "20" }
    ]
  }
}
```

Use `template_instance_get` to retrieve persisted template outputs later. Use `template_instance_list` to list deployed template instances.

## Persistent Volumes

Persistent volumes attach durable block storage to services and templates.

| Property | Value |
|---|---|
| Size range | 1 GiB minimum, up to the workspace storage cap |
| Billing | `$0.0000035/GB/min`, about `$0.15/GB/mo` |
| Mount path | Any absolute path inside the container |
| Persistence | Survives restarts and redeploys |
| Delete behavior | Service deletion detaches volumes; detached volumes are retained for 24 hours |

Volumes can be attached through `service_create` or `service_update` with `volume_name`, `volume_mount_path`, and `volume_size_gi`. Persistent-volume services run as a single replica. `volume_resize` grows volumes only; volumes cannot be shrunk.

## MCP Tools

### Account

`account_status`

Returns user info, default workspace, GitHub App connection status, and account context.

### Projects

- `project_list`
- `project_create`
- `project_rename`
- `project_delete`

Projects organize services inside a workspace. A project is created automatically in some deploy paths when a referenced project does not exist.

### Workspaces And Members

- `workspace_list`
- `workspace_create`
- `workspace_delete`
- `workspace_invite`
- `workspace_accept_invite`
- `workspace_decline_invite`
- `workspace_revoke_invite`
- `workspace_remove_member`
- `workspace_list_members`
- `workspace_list_invites`

Workspace is the billing and access-control scope.

### Repositories

- `repo_create`
- `repo_get_token`

Use `repo_create` for INK-managed repos or GitHub repos. For INK repos, pass the returned repo name directly to `service_create`. The `ink/name` shortcut is also accepted for disambiguation.

### Services

- `service_create`
- `service_list`
- `service_get`
- `service_update`
- `service_rename`
- `service_delete`

`service_create` supports:

- `source`: `repo` or `image`
- `repo`, `host`, `branch` for git deployments
- `image` for prebuilt Docker images
- `name`, `subdomain`, `project`, `workspace`, `regions`
- `build_pack`: `railpack`, `dockerfile`, `static`, or `dockercompose`
- `ports`: array of `{ name, port, protocol, visibility }`
- `env_vars`: array of `{ key, value }`
- `memory`, `vcpus`, `replicas`
- `build_command`, `start_command`
- `publish_directory`, `root_directory`, `dockerfile_path`
- `volume_name`, `volume_mount_path`, `volume_size_gi`
- `health_path`, teardown settings, and auto-destroy timeout

`service_get` can include deployment logs, runtime logs, environment variables, metrics, custom domain state, and attached volume details.

### Templates

- `template_list`
- `template_deploy`
- `template_instance_get`
- `template_instance_list`

Templates deploy databases and other service stacks with variables, generated credentials, endpoints, and outputs.

### Volumes

- `volume_list`
- `volume_resize`
- `volume_delete`

`volume_delete` applies to detached volumes. `volume_resize` grows volumes only.

### Domains And DNS

- `domain_add`
- `domain_remove`
- `dns_list_zones`
- `dns_add_record`
- `dns_delete_record`
- `dns_list_records`

DNS record types include A, AAAA, CNAME, MX, TXT, and CAA.

### Chat And Action Log

- `chat_send`
- `chat_read`
- `action_log_list`

Workspace chat enables multi-agent coordination. Action logs provide workspace activity history.

## CLI Commands

### Services

```bash
ink deploy <name> --repo <repo> --port 3000
ink deploy <name> --repo owner/repo --host github --port 3000
ink redeploy <name>
ink services
ink service <name>
ink status <name> --runtime-logs 50 --metrics 1h
ink logs <name>
ink logs <name> --deploy
ink delete <name>
```

### Environment Variables

```bash
ink secret set <service> KEY=value
ink secret import <service> --file .env
ink secret list <service>
ink secret unset <service> KEY
ink secret delete <service> KEY1 KEY2
```

Aliases include `secrets` and `env`.

### Templates

```bash
ink template
ink template postgres
ink template info postgres
ink template deploy postgres --name my-db
ink template deploy postgres --name my-db --var database_name=app --var storage_gi=20
ink template deploy redis --name cache
```

### Repositories

```bash
ink repo create my-app
git remote add ink <remote-url>
git push ink main
```

Aliases include `repos`.

### Domains And DNS

```bash
ink domain add <service> <domain>
ink domain remove <service>
ink dns zones
ink dns records <zone>
ink dns add <zone> <name> <type> <content> --ttl 300
ink dns delete <zone> <record-id>
```

Aliases include `domains`.

### Workspaces, Projects, Chat, Config

```bash
ink workspace
ink workspace create <name> <slug>
ink workspace members <slug>
ink workspace invite <slug> <user> member
ink workspace accept-invite <id>
ink projects
ink whoami
ink config set workspace my-team
ink config show
ink chat
```

## Pricing

INK uses usage-based billing with plan credits.

### Free Trial

- `$0` forever
- `$5` one-time usage credit
- 3 services
- 0.5 total vCPU
- 512 Mi total memory
- Up to 0.25 vCPU and 256 Mi per service
- 10 Gi persistent storage
- `*.deployink.com` subdomain
- CLI, Skill, MCP, and dashboard access

### Hobby

- `$5/mo`
- `$5/mo` credit included
- 25 services
- 10 total vCPU
- 20 Gi total memory
- Up to 1 vCPU and 2 Gi per service
- 50 Gi persistent storage
- `*.deployink.com` subdomain
- Credit top-ups

### Pro

- `$20/mo`
- `$20/mo` credit included
- 200 services
- 100 total vCPU
- 80 Gi total memory
- Up to 8 vCPU and 16 Gi per service
- 250 Gi persistent storage
- Custom domains
- DNS delegation
- Team roles

### Enterprise

- Custom billing
- Everything in Pro
- OIDC / SSO integration
- Private cloud or air-gapped deployment
- Custom workspace, service, and storage limits
- Dedicated infrastructure options
- Audit logs
- Custom SLA and Slack/email support

### Usage Rates

| Resource | Rate |
|---|---|
| CPU | `$0.000393/vCPU/min` |
| Memory | `$0.000161/GB/min` |
| Storage | `$0.0000035/GB/min` |
| Egress | `$0.05/GB` |
| Ingress | Free |

Approximate monthly equivalents use a 30-day month: CPU about `$16.98/vCPU/mo`, memory about `$6.96/GB/mo`, storage about `$0.15/GB/mo`.

## Example Full-Stack Flow

1. User asks an agent to deploy a full-stack app on INK.
2. Agent deploys a PostgreSQL template:

```bash
ink template deploy postgres --name app-db --var database_name=app
```

3. Agent deploys the backend:

```json
{
  "tool": "service_create",
  "arguments": {
    "name": "backend",
    "repo": "my-app",
    "ports": [
      { "name": "http", "port": 8080, "protocol": "http", "visibility": "public" }
    ],
    "env_vars": [
      { "key": "DATABASE_URL", "value": "<connection_string from template_deploy>" }
    ],
    "memory": "512Mi",
    "vcpus": "0.5"
  }
}
```

4. Agent reads status and logs:

```json
{
  "tool": "service_get",
  "arguments": {
    "name": "backend",
    "runtime_log_lines": 100,
    "metrics": "1h"
  }
}
```

5. Agent deploys the frontend with the backend URL:

```json
{
  "tool": "service_create",
  "arguments": {
    "name": "frontend",
    "repo": "my-app",
    "root_directory": "frontend",
    "publish_directory": "dist",
    "ports": [
      { "name": "http", "port": 3000, "protocol": "http", "visibility": "public" }
    ],
    "env_vars": [
      { "key": "VITE_API_URL", "value": "https://backend.example.deployink.com" }
    ]
  }
}
```

6. Agent attaches a custom domain:

```json
{
  "tool": "domain_add",
  "arguments": {
    "name": "frontend",
    "domain": "app.example.com"
  }
}
```

## Use Cases

- SaaS apps with frontend, backend, database templates, custom domains, and DNS.
- API services with logs, metrics, env vars, and scaling.
- AI agent backends, tool servers, RAG apps, and MCP servers.
- Static sites and SPAs.
- Internal dashboards with Streamlit, Gradio, or custom React.
- Observability stacks with Grafana, Prometheus, Loki, and Tempo templates.
- CI workers through GitHub Actions runner templates.

## Legal And Contact

- Privacy Policy: https://deployink.com/privacy
- Terms of Service: https://deployink.com/terms
- Contact: contact@ml.ink
- Sales: contact@ml.ink