Ink is Live

What is Ink?

Ink is cloud infrastructure built from the ground up for AI agents. Instead of clicking through dashboards or writing CI/CD pipelines, your AI coding agent — Claude, Cursor, Codex, or any MCP-compatible client — gets direct control over compute, databases, domains, and billing through the Model Context Protocol.

One command takes code from a git repo to a running service at {name}.ml.ink in about 60 seconds.

Deploy Anything

Ink auto-detects your framework, language, and build system. No Dockerfiles, no CI pipelines, no infrastructure config required. Just point it at a repo and it works.

Supported frameworks and languages:

• Frontend — React, Next.js, SvelteKit, Remix, Nuxt, Astro, Vite, Angular
• Backend — Express, FastAPI, Flask, Django, Go, Rust, Ruby on Rails
• Other — Static sites, Docker containers, WebSocket servers, background workers, cron jobs

That's 29+ frameworks detected automatically. If we don't detect yours, you can always use a Dockerfile.

MCP-native — Your Agent Deploys Full-stack Apps

Every feature in Ink is exposed as an MCP tool. To show what that means in practice, here's exactly what your agent does to deploy a full-stack app with a Next.js frontend, a Flask API, and a Supabase database.

Step 1 — Create repos and push code

The agent creates two repos on Ink's built-in git hosting, then pushes your code:

The agent pushes the Next.js frontend to acme-web and the Flask API to acme-api.

Step 2 — Deploy the Flask API with Supabase

The API gets the Supabase connection string and key as environment variables:

Ink detects Python + Flask automatically, installs dependencies, and starts the server. The API is live at acme-api.ml.ink, connected to the existing Supabase Postgres database.

Step 3 — Deploy the Next.js frontend

Step 4 — Verify everything is running

That's it. Four tool calls and your agent just deployed a full-stack Next.js + Flask app connected to an existing Supabase database — two different languages, zero configuration. Every subsequent git push triggers an automatic redeploy.

If something fails, the agent reads the build or runtime logs with get_service, fixes the code, pushes again, and calls update_service to redeploy — all without you intervening.

Built-in Git Hosting

You don't need GitHub to use Ink. Every workspace gets built-in git hosting. Create a repo, push code, deploy — all without leaving your agent's workflow.

The typical flow:

1. create_repo — creates a private repo on Ink
2. Push your code using the returned authenticated git remote
3. create_service — deploys from the repo
4. Auto-redeploy happens on every subsequent push

GitHub repos are also fully supported with our GitHub App integration for automatic deploys on push.

Managed Databases

Provision managed SQLite databases (powered by Turso) with a single MCP call. You get back a connection URL and auth token, ready to inject as environment variables into your services.

Currently only SQLite is supported as a managed database, but we're actively working to offer managed Postgres as well.

That said, nothing stops you from using your existing databases with Ink. Services deployed on Ink connect to external databases like Neon, Supabase, PlanetScale, or any other provider — just pass the connection string as an environment variable.

Real-time Metrics

Monitor your services with per-minute granularity across CPU, memory, and network I/O. Your agent can query metrics directly through get_service to make scaling decisions autonomously — but we also built a beautiful dashboard for when you want to check in yourself:

Structured Logs

Access build logs and runtime logs directly through the get_service tool — your agent can self-debug deployment failures without you lifting a finger. Logs are color-coded by level and support structured queries with level filtering (@level:error, @level:warn) and full-text search.

Custom Domains & DNS

Every service you deploy gets a default URL at {name}.ml.ink, but you can bring your own domain with automatic SSL. Here's how it works:

1. Delegate your zone — Go to the DNS page in your dashboard, add your domain (e.g. acme.dev), and point your NS records to ns1.ml.ink and ns2.ml.ink at your registrar. Add the TXT verification record Ink gives you.

2. Attach a subdomain to a service — Once the zone is active, use the add_custom_domain tool (or the dashboard) to attach any subdomain to a service. For example:

• api.acme.dev → your FastAPI backend
• app.acme.dev → your Next.js frontend
• docs.acme.dev → your documentation site

SSL certificates are provisioned automatically — no configuration needed.

3. Manage DNS records — Ink gives you full control over your zone. Create A, AAAA, CNAME, MX, TXT, and CAA records with the add_dns_record tool. Set up email routing with MX records, verify your domain with TXT records for services like Google Workspace, or point subdomains to external services:

• mail.acme.dev → MX record pointing to your email provider
• _acme-challenge.acme.dev → TXT record for domain verification
• status.acme.dev → CNAME to an external status page

Your agent can manage all of this programmatically — no need to log into a separate DNS provider.

We'll publish a detailed write-up on how DNS delegation and custom domains work under the hood in a future blog post.

Workspaces & Teams

Organize your infrastructure with workspace-based team collaboration. Invite members, assign roles (owner, admin, member), and scope all resources — services, databases, domains — to a workspace.

Per-minute Billing — Pay Only for What You Use

There are no fixed instance sizes or hourly minimums. Ink bills per minute based on exactly what your services consume:

• CPU — billed per vCPU-minute of actual usage
• Memory — billed per GB-minute allocated to your service
• Egress — billed per GB of outbound network traffic

If your service runs for 3 minutes and uses 0.25 vCPU and 256 MB of memory, you pay for exactly that — not for rounding up to the nearest hour or paying for an idle instance. Services that are stopped cost nothing.

You can set spending limits and alert thresholds per workspace so you're never surprised. Your agent can even call account_status to check its remaining balance before deploying, making cost-aware decisions autonomously.

What's Next

This is just the beginning. We're shipping new features every week — follow this changelog to stay up to date.