The runtime platform for autonomous software

Run agents and everything they build. Secure execution from the first sandbox to live production, on your cloud or ours.

Deploy now d

Codex
Claude Code
OpenCode
Pi

10,234,000 workloadsServiceDatabaseSandboxPreview

SandboxingEvery workload, isolated by default
Cloud agentsCoding agents, always on
Internal appsVibe-coded, run like production
Northflank Cloud or BYOCRun anywhere, scale on demand

Run agents, their code, and everything they ship

Ship agents and production. Sandboxed by default

Agentic and production workloads, each in its own microVM

Explore deployments

Coding agents, running in the cloud

Any harness, running remotely with persistent storage and real compute

Explore cloud agents

Vibe-coded apps, run like production

One trusted place to ship AI-built apps, behind SSO

Explore the agentic app platform

Our cloud or yours

100,000s of vCPUs on Northflank Cloud, or fully managed in your VPC

Explore bring your own cloud

Any language. Any workload

If it runs in a container, it runs on Northflank

Explore deployments

Everyone is shipping now. Give it all a trusted runtime

Engineers
Core systems
APIs, databases, and critical services.
Vibe coders
Internal apps
AI-built apps, safely behind SSO.
Coding agents
Sandboxes, PRs, and tasks
Agents running tasks and opening PRs.
AI products
Untrusted code, at scale
Your users’ code, each one isolated.

Northflank control plane

Build & deploy

From Git or any image

Release

Previews, pipelines, rollbacks

Scale

Autoscaling and networking

Secure

SSO, RBAC, secrets, audit logs

Observe

Logs, metrics, alerts, costs

Recover

Backups, HA, disaster recovery

Northflank Cloud

17+ global regions
GPUs on demand

Your cloudBYOC

AWS
Google Cloud
Azure
Oracle
CoreWeave
Nebius

Your hardware

Bare metal
OpenShift
VMware

Engineers building core systems, vibe coders shipping internal apps, coding agents creating thousands of workloads, and AI products running untrusted code all connect to the Northflank control plane, which builds, deploys, releases, scales, secures, observes, and recovers every workload on Kubernetes, across Northflank Cloud: Zero setup across 17+ global regions. Spin up 100,000s of vCPUs and GPUs on demand, cost-effectively. AWS: Run inside your own AWS account and VPC, and put your credits and commitments to work. Google Cloud: A self-service platform on GKE in your own projects, without babysitting clusters. Azure: Give teams a PaaS experience on AKS, inside your Azure subscription and network. CoreWeave: Put CoreWeave GPUs to work for training and inference, with the same workflow as your apps. Nebius: Run AI workloads on Nebius capacity, managed from the same control plane as everything else. Bare metal: Turn your own servers into a self-service cloud, on premises or air-gapped.

The primitives for what’s next

API docs

sandbox.jsSandboxes

12345678910111213const { data: sandbox } = await apiClient.create.service.deployment({
  parameters: { projectId: 'agents' },
  data: {
    name: `task-${task.id}`,
    billing: { deploymentPlan: 'nf-compute-200' },
    deployment: { instances: 1, external: { imagePath: 'python:3.12' } },
  },
});

const { stdOut } = await apiClient.exec.execServiceCommand(
  { projectId: 'agents', serviceId: sandbox.id },
  { command: ['python', '-c', task.code] },
);

Output

$ node sandbox.js
✓ microVM task-7f3a started
python -c <agent code>
42 rows processed
✓ exit 0

service.jsServices

1234567891011121314151617await apiClient.create.service.combined({
  parameters: { projectId: 'shop' },
  data: {
    name: 'checkout-api',
    billing: { deploymentPlan: 'nf-compute-100-2' },
    vcsData: {
      projectUrl: 'https://github.com/acme/checkout',
      projectType: 'github',
      projectBranch: 'main',
    },
    buildSettings: {
      dockerfile: { buildEngine: 'buildkit', dockerFilePath: '/Dockerfile', dockerWorkDir: '/' },
    },
    deployment: { instances: 3 },
    ports: [{ name: 'http', internalPort: 8080, public: true, protocol: 'HTTP' }],
  },
});

Output

$ node service.js
▸ build started main@4f2c1e9
▸ image built in 38s
▸ rolling out 3 instances
✓ checkout-api live

database.jsDatabases

1234567891011121314const { data } = await apiClient.create.addon({
  parameters: { projectId: 'shop' },
  data: {
    name: 'orders-db',
    type: 'postgresql',
    version: '16',
    billing: { deploymentPlan: 'nf-compute-50', storage: 8192, replicas: 3 },
    tlsEnabled: true,
  },
});

const creds = await apiClient.get.addon.credentials({
  parameters: { projectId: 'shop', addonId: data.id },
});

Output

$ node database.js
▸ provisioning postgresql 16 · 3 replicas
▸ TLS enabled · backups scheduled
✓ orders-db ready
postgresql://••••••@orders-db:5432/orders

job.jsJobs

12345678910111213await apiClient.create.job({
  parameters: { projectId: 'shop' },
  data: {
    name: 'nightly-report',
    billing: { deploymentPlan: 'nf-compute-50' },
    deployment: { external: { imagePath: 'acme/reports:latest' } },
    settings: { cron: { schedule: '0 2 * * *' }, concurrencyPolicy: 'Forbid' },
  },
});

await apiClient.start.job.run({
  parameters: { projectId: 'shop', jobId: 'nightly-report' },
});

Output

$ node job.js
▸ schedule set 0 2 * * *
▸ run #1 started
wrote report-2026-10-14.csv
✓ run #1 succeeded in 12s

inference.jsGPUs

12345678910111213await apiClient.create.service.deployment({
  parameters: { projectId: 'ml' },
  data: {
    name: 'llm-inference',
    billing: { deploymentPlan: 'nf-gpu-h100-80-1g' },
    deployment: {
      instances: 2,
      external: { imagePath: 'vllm/vllm-openai:latest' },
      gpu: { enabled: true, gpuType: 'h100-80', gpuCount: 1 },
    },
    ports: [{ name: 'api', internalPort: 8000, public: true, protocol: 'HTTP' }],
  },
});

Output

$ node inference.js
▸ scheduling 2 × H100 80GB
▸ pulling vllm/vllm-openai
▸ model loaded
✓ llm-inference serving on :8000

northflank.jsonTemplating

12345678910111213141516171819202122{
  "apiVersion": "v1.2",
  "spec": {
    "kind": "Workflow",
    "spec": {
      "type": "sequential",
      "steps": [
        { "kind": "Project", "spec": { "name": "shop", "clusterId": "acme-aws-eu" } },
        { "kind": "Addon", "spec": { "name": "postgres", "type": "postgresql" } },
        { "kind": "CombinedService", "spec": {
            "name": "checkout-api",
            "vcsData": { "projectUrl": "https://github.com/acme/checkout" } } },
        { "kind": "Pipeline", "spec": {
            "name": "release",
            "stages": [
              { "name": "Staging" },
              { "name": "Production", "releaseFlow": { "kind": "ReleaseFlow" } }
            ] } }
      ]
    }
  }
}

Output

▸ synced from github.com/acme/infra
▸ project shop on acme-aws-eu (your cloud)
▸ postgres and checkout-api deployed
✓ release pipeline: staging → production

sandbox.jsSandboxes

12345678910111213const { data: sandbox } = await apiClient.create.service.deployment({
  parameters: { projectId: 'agents' },
  data: {
    name: `task-${task.id}`,
    billing: { deploymentPlan: 'nf-compute-200' },
    deployment: { instances: 1, external: { imagePath: 'python:3.12' } },
  },
});

const { stdOut } = await apiClient.exec.execServiceCommand(
  { projectId: 'agents', serviceId: sandbox.id },
  { command: ['python', '-c', task.code] },
);

Output

$ node sandbox.js
✓ microVM task-7f3a started
python -c <agent code>
42 rows processed
✓ exit 0

Drive it from

Real-time UI
API
CLI
Templates
Workflows
GitOps

The software lifecycle, on a loop

Cloud agentHarness in a microVM
Code generationYour repo, in a sandbox
PreviewLive environment per PR
StagingPromoted through your pipeline
ProductionRelease flows and rollbacks
OperationsLogs, metrics, alerts, backups
↺ Production tells agents what to fix next

The old loop

Ticket queueEnvironment requestReview backlogRelease window

On Northflank

Every step automated, nothing waiting in between

Ready for enterprise

Enterprise

Run agents, AI-built software, and core systems inside your own infrastructure, with the compliance, governance, and guarantees your organisation needs.

Deploy now

Bring your own cloudFully managed clusters in your own VPC, on AWS, Google Cloud, Azure, Oracle, or bare metal.
Forward-deployed control planeRun the control plane in your own infrastructure, air-gapped if you need it. No platform data leaves your network.
GovernanceSSO and SAML, SCIM and JIT provisioning, RBAC, and audit logs for every team and agent.
Security and isolationMicroVM sandboxing, WAF and DDoS protection, and workload identities.
99.99% SLA and supportAn uptime SLA, and a dedicated Slack channel straight to our engineers.
Volume discountsUsage discounts on Northflank Cloud and BYOC as your spend grows.

Build the future. We’ll run it

Start free on Northflank Cloud or in your own cloud account. Same platform and workflow either way.

Deploy now d

$ npm i -g @northflank/cli$ northflank login