Deploy an API in 2 Minutes, From Your Terminal or From an AI Agent

Deployment is changing. A year ago, "deploy my API" meant a human clicking buttons in a dashboard. Today it increasingly means an AI agent calling a tool, mid-conversation, because the human said "ship it" in plain English. Both users deserve the same thing: a single command that works, every time, with zero configuration surface.

This post shows you how to deploy a real HTTP API to production in under two minutes using the CreateOS CLI. The CLI is agent-native by design. Every command works non-interactively for CI and scripts, authentication works with API tokens as well as browser OAuth, and the same platform is also available as a hosted MCP server at https://api-createos.nodeops.network/mcp. That MCP server exposes 75+ deployment tools that Claude Code, Cursor, Claude.ai, ChatGPT, and any other MCP-compatible client can call directly. Whether you type createos deploy yourself or an agent calls the deployment tool over MCP, the outcome is the same: a live HTTPS endpoint.

Who this is for

• Developers who want to stop context-switching into a browser for every deploy.
• AI agents (and the developers building with them) that need a deployment primitive they can call as a tool, without wrapping a dashboard in scraping glue.
• Anyone building agentic workflows where "the agent deploys its own code" is a first-class step, not a manual handoff.

What you'll build

A Node.js Express API, deployed to CreateOS, with:

• A public HTTPS URL on a *.nodeops.app subdomain
• TLS and routing handled automatically
• Build logs streaming to your terminal (or your agent's context)
• Runtime logs one command away (createos deployments logs -f)

Total time: two minutes.

Prerequisites

• Node.js 18 or later (for the example, not the CLI)
• A CreateOS account
• If you're an agent: an API key from Profile Settings → API Keys in the CreateOS dashboard

No Docker. No Kubernetes. No cloud account anywhere else.

Step 1: Install the CreateOS CLI

macOS with Homebrew:

brew tap nodeops-app/tap
brew install createos

macOS or Linux without Homebrew:

curl -sfL https://raw.githubusercontent.com/NodeOps-app/createos-cli/main/install.sh | sh -

Verify:

createos version

The CLI is a single Go binary with no runtime dependencies. It starts instantly, which matters when an agent is orchestrating dozens of calls.

Step 2: Authenticate

Human: browser login

createos login

Opens your default browser for OAuth sign-in. The CLI stores the session and auto-refreshes it, so you rarely need to re-authenticate.

Agent or CI: API token

createos login --token

This prompts you to paste an API key. Generate one in the CreateOS dashboard under Profile Settings → API Keys. Tokens are scoped and revocable. In a headless environment, pipe the key in via echo $CREATEOS_TOKEN | createos login --token.

Verify:

createos whoami

Step 3: Write the API

mkdir hello-api && cd hello-api
npm init -y
npm install express

Save as index.js:

const express = require("express");
const app = express();

app.get("/", (req, res) => {
  res.json({ message: "Hello from CreateOS!", time: new Date().toISOString() });
});

app.get("/health", (req, res) => {
  res.json({ status: "ok" });
});

const port = process.env.PORT || 3000;
app.listen(port, () => {
  console.log(`API listening on ${port}`);
});

Read the port from process.env.PORT. CreateOS assigns the port at runtime. Hardcoding will work locally and fail in production.

Add a start script to package.json:

{
  "scripts": {
    "start": "node index.js"
  }
}

Step 4: Link the project

createos init

This lists your CreateOS projects, lets you pick one (or create a new one), and writes a .createos.json file into the directory. Every subsequent createos command auto-detects the project from that file. .createos.json is automatically added to .gitignore.

If you already know the project ID:

createos init --project <project-id>

Step 5: Deploy

createos deploy

That's the whole command. The CLI detects the project type (Node.js here), uploads the code, streams build logs to your terminal, and prints the live URL.

A typical run:

Building v1...

Step 1/4: Installing dependencies...
Step 2/4: Building application...
Step 3/4: Packaging container...
Step 4/4: Starting service...

✓ Deployed (v1)

ℹ Live at: https://hello-api.nodeops.app

Useful deploy flags

# Deploy a specific branch (GitHub-linked projects)
createos deploy --branch staging

# Deploy a pre-built Docker image
createos deploy --image myapp:v1.0

# Explicit project ID (skip .createos.json auto-detection, useful in CI)
createos deploy --project <project-id>

Step 6: Hit the API

curl https://hello-api.nodeops.app

{ "message": "Hello from CreateOS!", "time": "2026-04-15T10:23:17.312Z" }

Live on HTTPS, signed certificate, globally routable.

Agent mode: let Claude Code, Cursor, or ChatGPT deploy for you

Everything above works great if you're typing. But the real unlock for agentic workflows is letting the AI do it directly. CreateOS exposes the same platform over MCP, so any MCP-compatible agent can deploy, manage env vars, provision databases, tail logs, and more, without touching a terminal.

Install the MCP server in Claude Code

claude mcp add createos-mcp \
  --transport http \
  https://api-createos.nodeops.network/mcp \
  --header "X-API-Key: YOUR_CREATEOS_API_KEY"

Install in any MCP client (Cursor, Claude Desktop, Windsurf, ChatGPT, Antigravity)

Add this to your MCP config:

{
  "mcpServers": {
    "createos-mcp": {
      "url": "https://api-createos.nodeops.network/mcp",
      "transport": "http",
      "headers": {
        "X-API-Key": "YOUR_CREATEOS_API_KEY"
      }
    }
  }
}

Once installed, the agent gets 75+ deployment tools in its toolbox. Ask it to "deploy this API to CreateOS" and it calls the right MCP tool, handles the flow, and hands you back the URL. Ask it to "provision a Postgres database and wire the connection string into the deployment" and it does that too, in a single conversation turn.

Full MCP integration docs:

• Claude Code
• Claude.ai
• ChatGPT
• Antigravity

Environment variables without the web form

# Set one (or many)
createos env set DATABASE_URL=postgres://...
createos env set API_KEY=sk_live_xxx SECRET=abc NODE_ENV=production

# Push the local .env to the remote environment
createos env push

# Pull remote vars into a local .env.<environment> file
createos env pull

# List (values shown in full, use --hide to mask)
createos env list
createos env list --hide

# Remove
createos env rm API_KEY

Agents manage env vars via the equivalent MCP tools (env_set, env_list, etc.), so the same flow works from a natural-language prompt.

Logs you can tail

# Deployment status at a glance
createos status

# Tail runtime logs
createos deployments logs -f

# Open your project in the browser
createos open

createos status shows current deployment health. createos deployments logs -f streams live runtime logs, the equivalent of tail -f. Both work the same way in a CI script or in an agent tool call.

Redeploys

After any change:

createos deploy

Connected to GitHub? Push to your deploy branch and CreateOS auto-deploys. Uploading directly? Re-running createos deploy re-uploads the current directory. Pick whichever flow matches your repo.

Human vs agent vs traditional platform

Every row collapses to a single primitive that works identically whether a human or an agent is the caller.

Non-Node.js stacks

Same flow for Python, Go, Rust, Bun, and any Dockerfile:

# Python (reads pyproject.toml or requirements.txt)
createos deploy

# Go (reads go.mod)
createos deploy

# Any Dockerfile
createos deploy

# Existing Docker image
createos deploy --image ghcr.io/you/your-api:latest

Runtime is detected from your files. Agents benefit from the same detection logic, so "deploy whatever is in this repo" is one tool call regardless of language.

Troubleshooting

Build fails with "port already in use": You're hardcoding the port. Read from process.env.PORT (Node), os.Getenv("PORT") (Go), or os.environ["PORT"] (Python).

"createos: command not found": Restart your shell or run source ~/.zshrc.

Upload hangs on large projects: The upload path is meant for small codebases. For larger projects, connect via GitHub (VCS mode) or push a pre-built Docker image.

Agent reports "authentication required": API key missing or expired. Check the X-API-Key header in the MCP config, or re-run createos login --token for the CLI.

Why agent-native matters

"Agent-native" isn't a marketing label. It's a measurable property: can a well-designed AI agent accomplish the task end-to-end without any step breaking on interactive prompts, ambiguous output, or browser-only flows? For most deployment platforms today, the answer is no. The agent gets halfway through, hits a login page, and gives up.

CreateOS runs every command as a non-interactive flow, ships a hosted MCP server with 75+ tools, and treats the agent as a first-class user. Shipping software end-to-end without leaving the conversation is the unlock, not a nice-to-have.

And the same properties that make the platform good for agents make it good for humans. Non-interactive mode is what your CI pipeline needs. A hosted MCP server is what your AI editor needs. Zero config is what you need on a Tuesday at 11 PM when something breaks.

Try it in two minutes

Human path:

brew tap nodeops-app/tap
brew install createos
createos login
createos init
createos deploy

Agent path (Claude Code shown, works in any MCP client):

claude mcp add createos-mcp \
  --transport http \
  https://api-createos.nodeops.network/mcp \
  --header "X-API-Key: YOUR_CREATEOS_API_KEY"

Either way, two minutes from now you'll have an API in production.

---

Next in this series: Managing cron jobs and env vars, for you and your agents →

Try it: Install the CreateOS CLI · Docs · GitHub · MCP server