Changelog

What's new in Alien

Dead-letter queues

A message that always fails used to behave differently on each cloud: retried until SQS retention ended, retried for days on Pub/Sub, parked in a Service Bus subqueue nothing read, or retried forever locally. Now a Queue can name another Queue as its dead-letter target:

alien.ts
const failed = new alien.Queue("tasks-failed").build()
const tasks = new alien.Queue("tasks").deadLetter(failed, { maxAttempts: 5 }).build()

After maxAttempts failed deliveries (5 to 100, default 5), the message moves to tasks-failed with its payload. The target is a normal Queue: link it, receive from it, or trigger a Worker from it.

  • Approximate count: SQS counts every receive and Pub/Sub is best-effort, so a message can move a little early or late
  • No redrive call: to retry a message, send it to the original queue again
  • Frozen queues: adding it to an existing queue needs a setup rerun, which updates the same queue in place and keeps its messages
  • attempt on Google Cloud: receive and a Worker's queue trigger report Pub/Sub's delivery attempt for a queue with a dead-letter queue
  • alien.toml: dead-letter = { queue = "tasks-failed", max-attempts = 5 }

Read the docs →

Managed custom domains on AWS, Google Cloud, and Azure

Managed custom domains now work on AWS, Google Cloud, and Azure. Alien issues and renews the certificate for Containers and Daemons there while the customer keeps their own DNS:

alien domains add app.customer-1.example --dns customer
alien deployments set-domains customer-1/us-east-1 --resource viewer \
  --endpoint viewer=app.customer-1.example

The customer creates the _acme-challenge CNAME that alien domains add prints, then points the hostname at the endpoint.

  • One certificate per resource: a resource switches to the custom certificate only once it covers every endpoint
  • WAF or CDN: a new guide puts Cloudflare or CloudFront in front, with the origin presenting a certificate for the public name
  • Domains on Alien DNS: a failed name server check keeps a verified domain attached for up to 7 days and shows DNS changed in the dashboard

Read the docs →

Startup timeout for daemons on machines

A daemon update on machines now fails when the new version doesn't pass its health check within the startup timeout, 10 minutes by default:

alien.ts
const agent = new alien.Daemon("agent")
  .code({ type: "image", image: "ghcr.io/acme/agent:2.0.0" })
  .healthCheck({ path: "/health", startupTimeoutSeconds: 900 })
  .build()

The error names the machine and the timeout. The rollout stops on that machine, and the machines after it keep running the previous release.

  • Rollback: promote the previous release. The machine that failed gets it at once, and its process has at most 30 seconds to stop
  • Limits: up to 24 hours, on machines only

Read the docs →

Machines clear unused images when the disk fills

Machines now clean up container images on their own. When the disk that holds images is 85% full, the machine agent removes the deployment's unused images, least recently used first, until the disk is back at 80%. It also removes data left by image downloads it stopped, for example when a newer release replaced them.

It never removes an image a container uses, running or stopped. A new release's download stops before the disk is full, so the current release keeps serving, and is retried once cleanup has made room.

It reaches machines through the machine agent's automatic update, with nothing to change in your stack. See Compute cluster for the details.

Fixes and improvements, mid November

Fixes and smaller improvements shipped in the middle of November.

  • Inside a deployment, a resource updates only after the resources it links to run the new release. If one fails, the resources that depend on it stay on the previous release. Update order
  • On AWS, the management role can launch instances and create security groups, load balancers, and Auto Scaling groups only in the stack's own VPC and subnets. Existing stacks get the limit on their next stack update. Management role
  • A customer-managed key now also encrypts Postgres and Container volumes on Google Cloud and Azure. Customer-managed keys
  • Azure AI Foundry serves gpt-5.5 and gpt-5.6-sol on OpenAI Responses, and text-embedding-3-large for embeddings. Each model deployment asks for 50,000 tokens per minute, capped to the subscription's free quota. AI models
  • A Private Alien Instance holds the secrets and environment variables entered on a setup link until a deployment is created from it. Setup link values
  • On AWS, a Private Alien Instance takes a Deployment regions parameter, so Lambda functions in other regions can pull their images. Deployment regions
  • On Azure, initial setup picks the first VM series with free quota for a compute pool, and runs it without zones when the subscription allows none. Disks and Postgres use only allowed zones.
  • Azure Postgres rounds storage up to a size Azure accepts, and allows the btree_gin extension.
  • On Google Cloud, public HTTP endpoints keep requests open for up to an hour instead of 30 seconds, so WebSockets and streamed responses last. New container volumes use pd-balanced disks.
  • Endpoint DNS for machines drops a machine about a minute after it stops reporting, with a 30-second record TTL. Machines
  • A Lambda release waits for its image to replicate to the function's region instead of failing.
  • Generated Terraform modules work on Terraform 1.9 and later. A module for an existing EKS cluster no longer creates a network.
  • A sandbox agent that refuses a session for its egress check says which check failed and why.
  • On Azure, runInteractive answers at once for a program that prints nothing until it reads input.
  • On Azure, get finds a sandbox by the key you passed to getOrCreate, including a key that isn't a GUID.

Join commands for 100 machines, and machine recovery

A machines join command now works on up to 100 machines for 7 days. Run the same command on each machine, at the same time if you like. After 7 days, or once 100 machines have joined, generate a new one.

curl -fsSL '<install-url>' | sudo bash -s -- join --token '<join-token>'
  • Older join commands: tokens created before this change keep working until you revoke them
  • Recovery: a machine offline for more than about 8 days can't renew its credentials. A workspace admin chooses Recover, then Create recovery command, and runs it on the machine within 1 hour. The machine keeps its ID and workloads

Read the docs →

Sandboxes on EKS with AWS Nitro Sandboxes

Sandboxes on EKS now run in AWS Nitro Sandboxes, the isolated-sandbox RuntimeClass of EKS Auto Mode. Untrusted code your app starts, such as an agent's tool calls or a customer's script, gets its own sandboxed runtime instead of the node's ordinary container runtime.

Your code doesn't change. The Sandbox you declare in alien.ts and the calls in your workload are the same on every platform:

api/src/run.ts
import { sandbox } from "@alienplatform/sdk"

const box = sandbox("agent")
const { sandbox: agent } = await box.getOrCreate("task-42", {
  egress: { allow: ["api.example.com"] },
})

for await (const frame of box.runCommand(agent.sandboxId, "python3", { args: ["job.py"] })) {
  if (frame.kind === "stdout") process.stdout.write(frame.data)
}

The chart picks the runtime from the cluster's Kubernetes version:

ClusterRuntime
EKSAWS Nitro Sandboxes (isolated-sandbox)
GKEgVisor (gvisor)
AKSKata VM isolation. Set sandbox.runtimeClassName: kata-vm-isolation.
On-premisesThe gVisor or Kata class your administrator installed. Set sandbox.runtimeClassName.
  • Requirements: EKS Auto Mode on Kubernetes 1.36 or later. EKS clusters Alien creates start on 1.36.
  • Argo CD: Argo CD renders the chart without the cluster version, so set sandbox.runtimeClassName: isolated-sandbox in your values.
  • Boundary: the Alien Operator refuses a RuntimeClass that isn't sandboxed. Sandbox pods get no service account token, and a sandbox starts only after its NetworkPolicy is proven in force.
  • Sessions: getOrCreate with your own id, reconnecting from another process, long interactive commands, preview, and "none", "internet", or allowlist egress all work as on the other platforms.

Read the docs →

Fewer long-lived keys

CloudFormation stacks, Helm values, and machines no longer hold a key that never expires. Each gets a code that expires, and what runs in the environment trades it for its own short-lived key and renews that key itself.

  • AWS CloudFormation: a new stack holds a deployment ID and a one-use code, never a token. An older stack moves over with one update from the portal's update link.
  • Kubernetes: values.yaml holds a one-use, one-hour enrollment code. The Operator trades it for its own key on first start, so a later helm upgrade with the expired code is fine.
  • Kubernetes with Terraform: for a new install on EKS, GKE, or AKS, TF_VAR_token is a one-use setup key that expires after two hours. The admin issues a new one in the portal with Issue a new setup key before each later apply.
  • Deploy CLI reruns on Kubernetes: the admin runs the same command again without a token. The CLI gets a 15-minute key from the Operator through kubectl exec, and never saves it.
  • Machines: cloud machines use one-hour sessions. Machines you run yourself join with a join command, then keep a key they replace every day.
  • Containers on machines get their commands credential from the machine's session instead of a deployment token.

Read the docs →

One Helm install for Helm, Flux and Argo CD

Install with Flux or Argo CD: the Helm chart installs the same way with helm, Flux and Argo CD, with the manager URL, the enrollment code and the infrastructure JSON.

  • Operator-owned secrets: the Operator creates its encryption key, log collector token and Postgres passwords once, in <release>-operator, and never replaces them.
  • Pull credentials: the Operator keeps its refreshed registry credential in its own Secret, so an Argo CD sync can't overwrite it.
  • Self-update off: runtime.image.selfUpdate defaults to false. A new chart version upgrades the Operator.
  • Remote Operator: it needs Helm release history, so install it with Helm or Flux.

Read the docs →

AWS sandbox image versions cleaned up

On AWS, Alien now retires sandbox image versions that a release replaced, so an image stays under AWS's limit of 50 versions per image.

  • Retire: a replaced version stays active for at least 60 minutes, and the most recent one always stays. Then no new sandbox starts on it, while running and suspended sandboxes keep going.
  • Delete: a retired version is deleted 8.5 hours later.
  • Permission: retiring needs lambda:UpdateMicrovmImageVersion, now part of sandbox/provision. A stack set up before it keeps every version and logs a warning every 6 hours. After 50 versions, its next sandbox image update fails. The customer's admin reruns initial setup to add the permission.

Read the docs →

Sandbox preview on Google Cloud

Sandbox preview works on Google Cloud, next to AWS, Azure, Kubernetes and Local. Your own bearer token goes in the header the preview names, and the service receives it as Authorization, over HTTP and WebSocket:

const preview = await box.preview(sandboxId, 8080)
await fetch(preview.endpoint, {
  headers: { ...preview.headers, [preview.callerAuthorizationHeader]: `Bearer ${token}` },
})
  • Who can preview: on Google Cloud, preview access equals command access. Only a caller that can run commands in the sandbox gets a preview, and a declaration with preview ports that no permission profile can run commands in is refused at plan time.
  • Credentials: last at most 5 minutes. Call preview again for a fresh one.
  • WebSocket: offer preview.subprotocols after your own, and send the headers too. Open it from server code.
  • Needs: the Alien CLI and SDK 3.3.68 or later. Initial setup creates one signing identity per sandbox resource with preview ports.

Read the docs →

Sandbox preview on Azure and Kubernetes

Sandbox preview now works on Azure and Kubernetes, next to AWS and local. A preview link carries an Alien capability in X-Alien-Preview-Capability, so your own Authorization header reaches the service unchanged, over HTTP and WebSocket:

const preview = await box.preview(sandboxId, 8080)
await fetch(preview.endpoint, { headers: preview.headers })
  • Azure: preview and jobs on agent images. A preview capability lasts at most 15 minutes. maxLifetimeSeconds and timeoutMs set a deadline, after which Alien deletes the sandbox. getOrCreate with an id returns one sandbox, even under concurrent calls.
  • Kubernetes: images whose USER is root run on amd64 nodes with "internet" or "none" egress. Preview is reachable from inside the cluster. A sandbox starts only after its network policy is proven in force.
  • Google Cloud: a disk above 10Gi, "internet" egress, and idle pause are refused when you build, not at run time. A template that exits at start fails at once with its cause. The agent port moved to 8971, so your workload can use 8080.

Read the docs →

Bare metal & on-prem

Alien now installs and updates your product on bare metal and on-prem machines, yours or your customers'. You get releases, rollbacks, health, and logs for every machine, with no Ansible, SSH, or VPN.

Run one command on a machine and it joins the deployment:

On each machine
curl -fsSL 'https://pkg.alien.dev/acme/bare-metal-worker/install.sh?version=1.0.0' | sudo bash -s -- join --token 'aj1_…'

The token can be revoked from the dashboard. Machines connect out to Alien over HTTPS, so there's no inbound port, VPN, or SSH access to set up. Machines in the same deployment reach each other over an encrypted mesh.

Releases

Every alien release reaches every joined machine on its own. A release can go to a staging channel first, then to production. At Islo, a release is running in a median of 1.2 minutes.

When a release or a drain stops a process, the process gets up to the limit you set, as long as 24 hours, to finish its work.

Rollbacks

Roll back by promoting an earlier release. Its artifacts are reused, so nothing is rebuilt:

alien releases promote <release-id> --channel production

You can also pin one deployment to a known release while you debug.

Health and logs

Health, versions, and logs for every machine are in the dashboard, including machines behind a customer's firewall. If a machine loses its connection to Alien, it keeps running its last release.

What runs

Daemons run one process per machine, and can have full host access for hypervisors, network agents, and other software that needs the machine to itself. Stateless containers run alongside them. Each deployment gets its own domain, and Alien issues and renews the TLS certificates.

The same stack also deploys to AWS, Google Cloud, and Azure accounts, so moving a customer from their own machines to their cloud is a change of configuration.

In production at Islo

Islo runs agent computers on its own bare metal, in customers' AWS accounts, and on machines in customers' data centers, all from one release. A release reaches a machine in a median of 1.2 minutes, down from about eight with Ansible.

Read how Islo ships to all of them, why we built this in Bringing the web workflow to bare metal and on-prem, or start with the quickstart.

alien.toml

A stack can now live in alien.toml, for Rust, Go, and Python teams that don't want TypeScript in their repo:

alien.toml
name = "acme-jobs"
platforms = ["machines"]

[pool.workers]
cpu = 2
memory = "4Gi"

[daemon.job-worker]
build = { toolchain = "rust", binary-name = "job-worker" }
pool = "workers"
stop-grace-period = "1h"

alien build and alien release read it when the directory has no alien.ts. The CLI parses it itself, so release CI needs no Node, Bun, or package manager, and loading the stack runs no code from the branch.

It describes the same stack as alien.ts. Every resource type is available, along with inputs, pools, and permissions.

  • Strict: an unknown key is an error with a did-you-mean hint, and every error points at the line and column
  • Short forms: sizes like "512Mi", durations like "2m", health-check, autoscaling, and env values taken from inputs

Read the docs →

Browser uploads to Storage

A browser can now upload straight to a Storage bucket through a signed URL, without the file passing through your backend. Name the origins that may upload:

alien.ts
const uploads = new alien.Storage("uploads")
  .corsUploadOrigins(["https://app.acme.com"])
  .build()

Your backend signs a PUT URL, and the page uploads to it:

src/upload.ts
const upload = await storage("uploads").signedUrl({
  method: "PUT",
  path: `avatars/${userId}.png`,
  expiresIn: 900,
})
// Send upload.url, upload.method and upload.headers to the page.
app/upload.ts
await fetch(upload.url, { method: upload.method, headers: upload.headers, body: file })

Alien adds an upload CORS rule next to the read rule from .corsAllowedOrigins(), with the headers each cloud's signed uploads send.

  • Clouds: AWS, Google Cloud, and Azure, in every setup method
  • Single-request uploads only: a presigned or SAS URL, or one multipart part. Uploads that start with a POST aren't covered
  • Checked at build: an origin a browser would never send is refused with STORAGE_CORS_INVALID

Read the docs →

Fixes and improvements, early November

Fixes and smaller improvements shipped in the first part of November.

  • A release of a one-replica container on machines keeps the old replica serving until the new one is healthy. When the pool can grow, Alien adds a machine first. Machines a release leaves empty are returned.
  • When a container on machines exits on its own, its events show the exit and its code, instead of a scale-down. The deployment page shows these events under Runtime events.
  • Logs from containers Alien adds to a deployment, such as the sandbox egress gateway, are labeled as system output and hidden by default.
  • A failed automatic update reads Update failed while the previous release keeps serving, a retried update shows as queued until it's picked up, and containers no longer read Degraded while an update runs or Not reporting right after a long one.
  • When an update waits for initial setup, the deployment says Action required with numbered steps for its setup method, and a customer-installed deployment offers Send to customer. Optional features that need initial setup say auto-updates continue either way.
  • A release that replaces a failing update is applied, instead of waiting behind it.
  • A daemon can update while its cluster replaces machines, a roll never drains a daemon's last healthy load balancer target, a failed roll cancels its drains, and rolls and scale-in keep zones balanced.
  • The deploy page and setup links offer only the platforms a release was built for, and subaccounts only on those clouds.
  • Secret inputs keep their line breaks, and a PEM value pasted as one line is refused. Running initial setup again can replace an old input value the release no longer accepts.
  • A Private Alien Instance's custom domain gets its TLS certificate, and is released when the instance is uninstalled. Deleting an instance revokes its setup links.
  • On AWS, ai/invoke can list Bedrock inference profiles and Bedrock Mantle models, so model discovery works where invoking already did.
  • AWS image pushes go through the registry proxy in chunks, so large images upload reliably.
  • TypeScript containers keep requests that stay silent for more than 10 seconds, and entry files that use import.meta.main compile.
  • alien dev creates its deployment with stack inputs, and a container can use a linked Sandbox.
  • Air-gapped sites receive every image layer after their registry changes.
  • The CLI says who approves an access request, and a debug session ends when its access is revoked.
  • Errors from AWS KMS, SSM, and Secrets Manager no longer include secret values.

Redis

You can now add Redis to a stack. Alien creates a Redis-compatible server on a private network in your customer's cloud, and your code connects with the client it already uses: ioredis, node-redis, redis-py, or BullMQ.

alien.ts
const cache = new alien.Redis("cache")
  .memory("4Gi")
  .evictionPolicy("allkeys-lru")
  .build()

const api = new alien.Container("api")
  .code({ type: "image", image: "ghcr.io/acme/api:1.4.0" })
  .link(cache)
  .permissions("execution")
  .build()

export default new alien.Stack("acme")
  .add(cache, "frozen")
  .add(api, "live")
  .permissions({ profiles: { execution: { cache: ["redis/data-access"] } } })
  .build()
src/cache.ts
import { redis } from "@alienplatform/sdk"
import { Redis } from "ioredis"

const conn = await redis("cache").connection()
const client = new Redis({
  host: conn.host,
  port: conn.port,
  username: conn.username,
  password: conn.password,
  tls: conn.tls || undefined,
})

The server has no public endpoint, and TLS and a password are always on. connection() reads the password with the workload's own identity, so it never sits in an environment variable.

PlatformServer
AWSElastiCache for Valkey
Google CloudMemorystore for Valkey, through Private Service Connect
AzureAzure Managed Redis, through a private endpoint
Kubernetes, MachinesA server the customer provides, through an external binding
alien devValkey in Docker
  • Options: memory, eviction policy, persistence, a replica in another zone with automatic failover, and a customer-managed encryption key
  • One endpoint: Lua scripts, MULTI/EXEC, streams, pub/sub, and blocking commands work as on a plain Redis server
  • Python and Rust: the same connection(), and in Python redis.Redis(**conn.redis_kwargs())

Read the docs →

Helm upgrades finish setup updates

A release that adds a frozen Kubernetes object, such as a service account, used to stop a Helm deployment with no way forward. Now the customer's admin upgrades the chart, and the update finishes:

helm upgrade <release> <chart> --version <version> -n <namespace> --reset-then-reuse-values

The deployment page shows that command with the release name, namespace, and chart version filled in. Argo CD, Flux, and Terraform work the same way: set the chart version and apply as usual.

The upgraded chart tells Alien which setup it carries. Alien accepts it only when the chart matches the waiting release and the change stays inside Kubernetes objects the chart creates.

  • Cloud resources: a release that also needs a new bucket or permission asks for the cloud part of initial setup first
  • Older Helm: --reset-then-reuse-values needs Helm 3.14 or later. The page also shows the two commands for older versions
  • Declined charts: helm upgrade still succeeds, the current release keeps running, and the page says why

Read the docs →

Machine OS updates

Machines in a compute cluster now move onto each new stable release of their operating system, with its kernel and security fixes. Alien replaces them one at a time: it starts a new machine, drains the old one, and removes it once its workloads are healthy elsewhere. An update to the machine agent alone still applies in place, without replacing machines.

The deployment page has a Machine OS row:

StatusMeaning
Rolling 1/2Machines are being replaced
DoneEvery machine runs the current release
Held: <reason>The roll is waiting, and the reason says why

A drain waits as long as a workload's stop grace period allows. A machine that can't drain, for example because a volume has no machine in its zone, stops the roll, and the error names the workload. Machines that were starting or not reporting when the roll began are replaced too.

This works on AWS, Google Cloud, and Azure.

Approve access in Slack

Access requests now ask for approval on a Slack card. In the Slack Connect channel you share with a customer, they select Approve for 6 hours or Deny, and their click decides. The card shows who asked, why, the deployment, the access, and when the request expires.

Each deployment group has a Who approves access requests setting:

  • Customer (the default): the customer approves on the Slack card, or with kubectl on Kubernetes. The dashboard, CLI, and API can't approve for them.
  • Team: a verified member of your Alien workspace approves on the card, or a teammate approves in the dashboard or CLI.

On a Customer group, Alien refuses clicks from your own Slack workspace, from members of your Alien workspace, and from bots and guests, so your team can't approve a customer's request by mistake.

Cards come from the Alien Slack app, or from your own Slack app with your name on it.

Read the docs →

Private Alien Instances

Private managers are now called Private Alien Instances. A Private Alien Instance runs the Alien manager in your own AWS, Google Cloud, or Azure account, so your customers' deployment traffic stays in your cloud.

More of that traffic now stays there, and never reaches Alien's hosted API:

  • Logs: log bodies no longer pass through Alien's hosted API.
  • Commands: the parameters and results of commands and Remote Operator operations stay in the instance.
  • Values: with a values key, secret inputs, environment variables, and dynamic container secrets are sealed with a key in your account. Alien keeps only metadata, such as the name and when it changed. The dashboard and CLI send each value straight to the instance.

Settings → Private Alien Instances lists every instance in the workspace with its cloud, region, status, and how many deployments it manages. For each project, choose which instance receives new deployments on each platform. Existing deployments keep their instance. Each deployment's page shows which instance manages it.

  • Values key: an instance set up before the key existed needs its initial setup to run again with InputValuesKey set to true. Values set before then stay with Alien
  • Older CLIs: an instance with a values key refuses values from a CLI that sends them to Alien. Run alien upgrade
  • Plan: Private Alien Instances need the Pro plan

Read the docs →

Setup links name who can open them

A setup link used to open the deployment portal for anyone who had the URL, including a forwarded email or a chat log. Now it opens only for the people you name:

alien onboard customer-1 \
  --allow admin@customer-1.com \
  --allow @customer-1.com

The admin opens the link, enters their work email, and types the 6-digit code Alien sends them. The portal session lasts 12 hours. The installer gets its own short-lived key and never sees the session.

In the dashboard, enter the list under Who can open the link.

  • Entries: an email address or an @domain, up to 100 per link
  • Scripts: with --json, or outside a terminal, alien onboard exits with an error until you pass --allow
  • Older CLIs: the platform refuses setup links from a CLI that can't pass --allow. Run alien upgrade

Read the docs →

AWS compliance defaults

What Alien creates in a customer's AWS account now meets the checks their security tools run, such as AWS Security Hub and CIS, with no change to your stack:

  • Alarms: CloudWatch alarms on each load balancer (unhealthy hosts, response time, 5xx), each Aurora writer (CPU, memory, disk queue), and each Auto Scaling group (CPU). They have no actions, so they never page anyone or change anything.
  • VPC flow logs: every VPC Alien creates records its traffic to a CloudWatch log group. Default VPCs and VPCs you bring are left alone.
  • Logs kept a year: CloudWatch log groups keep 365 days.
  • DynamoDB: point-in-time recovery is on for every table.
  • S3: every bucket aborts multipart uploads left incomplete for 7 days. Stored objects are never expired, moved, or deleted.
  • TLS: HTTPS listeners use a FIPS policy with TLS 1.2 or later, and HTTP redirects to HTTPS on container and daemon load balancers.
  • Aurora Postgres: pgaudit is loaded, the text of failing statements stays out of the logs, and snapshots carry the cluster's tags.

New deployments get all of these. Existing deployments get the ones Alien manages at runtime with their next release, and the ones initial setup creates, such as flow logs on a setup-created VPC, when initial setup runs again. Until then, a missing permission shows as a warning and the deployment keeps running.

Data disks and larger machines

A compute pool can now attach a data disk on AWS, Google Cloud, and Azure, not only on Machines. Give a range, and each deployment picks its own size, the same way it picks its machine type and count:

alien.ts
const compute = new alien.ComputeCluster("runtime")
  .pool("general", {
    requirements: {
      cpu: 4,
      memory: "16Gi",
      dataDisk: { size: { min: "50Gi", default: "200Gi", max: "4Ti" } },
    },
    scale: { type: "autoscale", min: 1, max: 10 },
  })
  .build()

A fixed size: "200Gi" still works. With a default of 0Gi, the pool has no data disk unless the deployment picks one. The size is chosen in initial setup and changed later in Change compute.

The machine catalog now comes from the AWS, Google Cloud, and Azure APIs and grows from 99 to 365 types, including current families such as c8i, m8i, and r8i up to 96xlarge with nested virtualization. The machine picker shows suggested machines first, then families, then each family's sizes, and only offers machines that can run the pool. Initial setup checks that the region offers the machine and that the quota covers it.

  • Changing the disk size replaces every machine in the pool, and data on the old disks isn't kept. The dashboard warns before it does this
  • Limits: 65,536 GiB on AWS and Google Cloud, 32,767 GiB on Azure. Kubernetes doesn't support data disks
  • Automatic selection picks from the same machines as before, so no existing deployment changes machines

Read the docs →

Deployment actions in the CLI

Actions that needed the dashboard now have CLI commands. Each takes a deployment ID or <group>/<name>, prints --json, and asks before a destructive change (--yes skips the prompt):

alien deployments set-compute customer-1/us-east-1 --pool general --min 2 --max 6
alien deployments set-inputs customer-1/us-east-1 --secret-input-file tlsCertificate=./tls.pem
alien deployments drain-machine customer-1/on-prem <machine-id> --deadline 10m
alien access-requests approve <request-id> --duration 1h
  • Deployments: set-compute, set-env, inputs, set-inputs, check, and pin, which now also takes <group>/<name>
  • Secret inputs from a file: --secret-input-file ID=PATH reads the value from a file, or from stdin with -, so it stays out of shell history and keeps its line breaks
  • Machines: drain-machine, cancel-machine-drain, remove-machine, and join-tokens list|create|rotate|revoke
  • Access requests: approve and deny
  • Private Alien Instances: alien instances update, provision, and set-domain. alien managers still works
  • Malformed IDs are refused before any API call, with the expected format

Read the docs →

New project overview and deployment pages

The dashboard's project overview and deployment pages are rebuilt.

A new project opens on Get started: ship your app into customers' clouds, or operate what they already run, with the steps for each. Add-ons such as customer-managed keys and local AI models are one row each, and show On once they're on.

On the overview, type a customer's name and select Create link. The setup link appears in the card, ready to copy, using the link page's defaults. When a value has no default, such as a required input, the button reads Continue and opens the link page.

The deployments list, deployment page, and group view share one layout, with status explanations, release, activity, properties, and actions. They read the same on a phone. More API actions are in the UI: change a pool's machine type, switch between fixed and autoscaling, restore a volume from a snapshot, and update or retry a Private Alien Instance.

AWS permissions boundary

On AWS, initial setup now creates a permissions boundary for each deployment. Every IAM role Alien's management identity creates or changes must carry it, so management access stays limited to the deployment's own resources.

The boundary caps those roles at non-IAM actions on the deployment's own resources, plus a few account-level actions the deployment needs. It denies sharing and public exposure: bucket policies and ACLs, snapshot and image sharing, resource shares, and resource policies on Lambda, SQS, SNS, and other services.

The management identity can't edit the boundary or remove it. Even a role it creates with an admin policy attached stays inside the boundary. To see the boundary your stack produces:

alien render --format cloudformation --stack .alien/build/aws/stack.json > template.yaml

It's the ManagementPermissionsBoundary resource.

  • Every setup method: CloudFormation, Terraform, and the setup CLI all create it
  • Existing deployments: keep working unchanged, and get the boundary when the customer's admin reruns initial setup

Read the docs →

Customer-managed keys

You can now add BYOK (bring your own key) to your product. Each customer holds the key to their data in their own AWS KMS, Google Cloud KMS, or Azure Key Vault, and can revoke it at any time.

If they disable the key, their data in your storage stays ciphertext, unreadable to you and to anyone holding a leaked database password or a copied snapshot.

Encrypt/Decrypt API

For values your app stores and reads back by ID, such as message bodies, documents, or tokens, call encryption.alien.dev with the customer's ID. Alien caches each customer's encryption root for 5 minutes, so a request doesn't wait on the customer's cloud. This works with a shared database.

AWS Virtual Keys

To put a whole database on the customer's key, give each customer their own database and point it at an AWS Virtual Key: an ordinary KMS key in your AWS account, backed by the customer's key. Aurora, S3, DynamoDB, and EBS work unchanged:

main.tf
module "customer_key" {
  source  = "pkg.alien.dev/alien/virtual-key/aws"
  version = "0.1.0"

  deployment_id = "dep_0c29fq4a2yjb7kx3smwdgxlc" # customer-1's key
  alias         = "customer-1-documents"
}

resource "aws_rds_cluster" "main" {
  engine            = "aurora-postgresql"
  storage_encrypted = true
  kms_key_id        = module.customer_key.kms_key_arn 
}

The customer's key can live in any cloud, so a customer on Azure Key Vault can govern the Aurora database you run for them. AWS sends Alien only encrypted data keys through External Key Store, so plaintext never reaches Alien.

Setup and revocation

The customer connects their key in your branded deployment portal. When they revoke it, the Encrypt/Decrypt API stops working for them within 5 minutes, and an Aurora database on a Virtual Key is stopped. Restoring access makes the data readable again.

Deployments in the customer's own cloud take the key natively: add alien.Key to alien.ts, and buckets, Postgres, and volumes encrypt with it.

Read why multi-tenant SaaS needs this, and how we built it, or go straight to the docs.

Storage notifications

Storage can now put an event into a Queue every time an object is created or overwritten. Each .notify() call adds a rule with an optional prefix and suffix:

alien.ts
const work = new alien.Queue("work").build()

const objects = new alien.Storage("objects")
  .notify(work, { prefix: "uploads/", suffix: ".json" })
  .notify(work, { prefix: "uploads/", suffix: ".csv" })
  .build()

Consume the queue with a Worker's queue trigger, batched or not, or with queue.receive(). storageEventFromMessage returns the same StorageEvent on every cloud, with the bucket, key, and timestamp.

S3 delivers straight to SQS, Cloud Storage publishes to Pub/Sub, and Azure routes Blob Storage events through Event Grid into Service Bus. Under alien dev, each rule keeps a cursor, so a restart doesn't replay objects already delivered.

On a frozen bucket, the rules belong to initial setup, so changing one needs the customer's admin to rerun initial setup. On a live bucket, Alien updates the rules on every release and touches only its own entries.

  • Rules: up to 10 per Storage, and no two rules may match the same key
  • Python and Rust: storage_event_from_message
  • Storage triggers: on AWS, updating or removing a Worker storage trigger no longer clears other entries in the bucket's notification configuration

Read the docs →

Fixes and improvements, October

Fixes and smaller improvements shipped in October.

  • Containers on machines with persistent volumes are replaced with their own volume, handed off during machine drain, keep retrying while a volume is still attaching, and grow their filesystem when the disk grows, including on Azure.
  • Machines keep serving traffic through updates: load balancer targets stay healthy during drain and deregistration, rollouts wait for ALB target health, and DNS keeps answering across restarts.
  • A failed machine agent update now rolls back, and heartbeats and exec keep working while an update downloads.
  • AWS compute clusters that hit a capacity shortage keep running instead of failing, scale-in no longer drains healthy machines, and Google Cloud and Azure clusters keep reconciling through shortages.
  • alien destroy finds a deployment by ID or by group and name in the right project, even when it is not tracked locally, and alien deployments delete --forget removes a deployment whose cloud is gone.
  • CLI errors now name each failed resource, show the manager's own error and S3's rejection reason, and report the cause of a failed teardown.
  • --json output and exit behavior are consistent across CLI commands.
  • The CLI prompts for deployer secrets securely, alien vault commands accept deployment IDs and reach the right manager, and deployer secrets moved to the deployment actions menu in the dashboard.
  • Management identities on AWS, Google Cloud, and Azure can no longer read deployment secrets or decrypt with the deployment key, and the Azure management identity can no longer grant itself roles.
  • Alien never adopts or deletes an AWS bucket, build project, or registry role that the deployment did not create, and volume backups only snapshot the stack's own volumes.
  • On Azure, initial setup grants each management role only at the scope it names and covers the permissions needed for scale sets, gateway subnets, public IPs, and disk snapshots.
  • Google Cloud deployments reuse and clean up only their own custom roles, workers on a network without NAT can reach the internet, and Cloud Run IAM and storage lifecycle rules apply correctly.
  • Workers return application HTTP redirects instead of following them, report their URL from the first public endpoint, support custom domains, and renew certificates without a full update.
  • Lambda workers export application logs before the function freezes, and a slow log endpoint no longer delays invocations.
  • Custom domains keep serving the last issued certificate until its replacement is ready, and renewal keeps retrying.
  • Log search supports quoted phrases, runs faster, keeps pagination and the time window stable across pages, and the Logs page shows loading after a filter change and runs one search.
  • The dashboard's deployment and release pages load without layout jumps, show correct compute status and ready-replica counts, hide completed installation panels, and stop rendering after a deployment is deleted.
  • CLI commands copied from the dashboard include the workspace, and the CLI uses the linked project's workspace in a linked directory.
  • CLI sign-in now finish for signed-out users, and approved users land in their workspace after signup.
  • Rerunning initial setup with an older setup link no longer rolls a deployment back, new CloudFormation stacks get unique names, a second stack for the same deployment is refused, CloudFormation stack updates from a rerun can always roll back, and first deployments show initial setup and provisioning progress.
  • Existing Kubernetes deployments keep working across Operator upgrades, Kubernetes quota failures are shown, and teardown removes vault-owned Kubernetes secrets.
  • Air-gapped sites verify downloads reliably, receive configuration changes on the same release, get bundles built for their architecture, and show offline reports in the deployment portal.
  • alien dev passes deploy inputs to the local deployment, recovers interrupted sessions, honors the selected Docker context, and runs local Postgres and non-root containers correctly.
  • Remote Sandboxes honor env and cwd, run commands as the image's non-root user, replace a terminated sandbox in getOrCreate, and keep egress open when one gateway replica stops answering.
  • Transient credential errors are retried instead of failing the deployment, and every service trusts the updated CA bundles.

Subaccounts

Subaccounts are now available in every workspace. Alien creates an AWS account, a Google Cloud project, or an Azure resource group in your cloud, requests the quotas it needs, and deploys your stack into it.

A separate account per customer is the strongest isolation a cloud offers: separate permissions, quotas, and bills. Before, you created each account by hand and ran initial setup in it.

Once you Connect a cloud, a new customer takes one form:

  1. Open Deployments, choose Deploy release, then Deploy to your environment.
  2. Enter the Environment name, for example customer-1.
  3. Under Where, choose New AWS subaccount, New Google Cloud subaccount, or New Azure subaccount.
  4. Pick the Region and choose Deploy.

No one runs CloudFormation or Terraform. Alien keeps the account current on every release, like any other deployment.

  • Any region: one customer's subaccount can hold deployments in several regions
  • Warm pools: keep accounts ready so a new customer deploys at once
  • Quotas: the deployment shows Waiting for quota while an increase is pending

Read the docs →

Managed custom domains

Endpoints can now use a custom domain with a certificate Alien issues and renews, while the customer keeps their own DNS:

alien domains add api.customer-1.example --dns customer
alien deployments set-domains customer-1/us-east-1 --resource api \
  --endpoint default=api.customer-1.example

alien domains add prints the DNS records to create: an _acme-challenge CNAME that lets Alien prove control of the name, and a CNAME that points traffic at the deployment. Once the records exist, the domain verifies, and the certificate is issued and renewed with no further steps.

With --dns alien, the zone is delegated to Alien and the records are created for you. --clear returns an endpoint to its generated domain.

  • Uninterrupted renewal: the last issued certificate keeps serving until its replacement is ready
  • Second certificate authority: issuance fails over to another ACME provider
  • Customer-supplied certificates: an ACM, Certificate Manager, Key Vault, or TLS Secret certificate still works, and Alien never sees the private key
  • Domains in the dashboard: a verified domain can be offered to a project from its settings

Read the docs →

Generated and conditional inputs

Stack inputs can now be generated, and they can depend on another answer. generate creates a random secret once per deployment:

alien.ts
signingSecret: alien.secret({
  providedBy: "developer",
  required: true,
  label: "Signing secret",
  generate: { length: 64 },
  env: "ACME_SIGNING_SECRET",
}),

The value is reused across every update. Use it for values nobody should type, like a signing key shared between the deployment and your backend. A value you provide replaces it.

when asks a question only when a yes or no input says so:

alien.ts
snapshotsBucket: alien.string({
  providedBy: "deployer",
  required: true,
  label: "Snapshots bucket",
  when: { input: "snapshotsEnabled", equals: true },
}),

An inactive input is skipped: it isn't required, isn't validated, and sets no environment variable. The setup page, the CLI, CloudFormation, Terraform, and Helm all follow the same rule.

  • Inputs at registration: a deployment set up with the CLI can answer inputs when it registers
  • Terraform: conditional inputs need Terraform 1.9 or newer

Read the docs →

Deployment portal updates

The deployment portal can now be branded from the CLI. alien projects portal set changes only the fields you pass:

alien projects portal set docproc \
  --title Acme \
  --subtitle "Document processing in your cloud" \
  --accent-color blue \
  --avatar-url https://acme.com/logo.png \
  --favicon-url https://acme.com/favicon.png

alien projects portal domain sets the portal's own domain, and alien projects portal get prints the appearance, the domain status, and the Google sign-in settings.

Setup links can also send the admin back to your product. returnUrl adds a Back to link to the top of the portal. refreshUrl is where an admin lands after opening an expired or revoked link, so your product can sign them in and create a new one.

alien onboard customer-1 \
  --return-url https://app.acme.com/settings/byoc \
  --refresh-url https://app.acme.com/settings/byoc/refresh
  • Resources by category: the portal groups a deployment's resources into categories, closed by default and opened on progress or failure
  • Favicon: set in Settings → Deployment Portal or with --favicon-url
  • Display names: resources added by setup checks have readable names

Read the docs →

Your own setup screen

You can now build the whole initial setup into your product. One API call creates the deployment and returns the setup step for the cloud and method the customer picked:

lib/create-deployment.ts
const customer = new Alien({ apiKey: setupToken }) // acts for this one customer

const deployment = await customer.deployments.create({
  name, project: PROJECT, platform: "aws", setupItem: "deployment",
  setupMethod: "cloudformation", setupHandoff: "await-registration",
  installation: { region: "us-east-1" },
})

The response's installation object holds what your screen shows. For CloudFormation, it's a launchUrl that opens the AWS console with every parameter filled in. For Terraform, it's the main.tf to save. For Helm, it's the values.yaml and the install command. For the setup CLI, it's the configuration and command.

The deployment exists from the first call. Your product saves its ID and reads its status from then on, and the customer never sees the deployment portal.

Read the docs →

Webhooks

Alien now sends webhooks. Your endpoint gets a signed POST when a deployment changes, so your product hears about it without polling:

{
  "id": "evt_6f1c2b9e-3a4d-4e8f-9b7a-2c5d8e1f0a3b",
  "type": "deployment.failed",
  "occurredAt": "2026-10-25T14:03:11.482Z",
  "data": {
    "deploymentId": "dep_7h3k9m2x5q8v1c4n6b0z2t7r9w3y",
    "name": "us-east-1",
    "status": "provisioning-failed"
  }
}

Open Settings → Webhooks and select Add webhook. Pick all projects or specific ones, clear the events your receiver doesn't handle, and enter an HTTPS URL.

Use them to update your product, page your team, or start a workflow.

  • Events: deployment.created, deployment.running, deployment.failed, deployment.update_applied, deployment.update_blocked, deployment.teardown_required, deployment.heartbeat_lost, deployment.heartbeat_restored, deployment.deleted
  • Signed: every request carries a signature your endpoint verifies
  • Retries: failed deliveries are retried

Read the docs →

Per-customer ExternalId

AWS deployments now use a per-customer ExternalId on their management roles. Alien generates one for each deployment group, and the portal fills it in. To require it on CloudFormation packages:

alien projects packages update --file - <<'JSON'
{ "cloudformation": { "requireManagementExternalId": true } }
JSON

Alien's managing role serves many customers. The ExternalId makes sure one customer's registration can't name another customer's role, the confused-deputy problem. Every AssumeRole call sends it.

Require AWS External ID is on by default for new projects, under Settings → Artifacts → CloudFormation. In Terraform, it's the management_external_id variable.

  • Google Cloud: initial setup creates workload identity federation in the customer's own project, and management credentials renew through it
  • One role per deployment: each deployment is reached through the managing role its stack trusts
  • Neutral names: resources Alien creates at runtime carry a neutral prefix, not Alien's name

Read the docs →

Queue batching

Queues now send and receive in batches. sendBatch uses the cloud's own batch API and returns one outcome per message, in input order:

src/enqueue.ts
const results = await tasks.sendBatch(images.map(id => ({ type: "resize", imageId: id })))

results.forEach((result, i) => {
  if (result.status === "rejected") console.error(images[i], result.code)
})

A message that's too large is rejected on its own, without failing the others. An unknown outcome means the message may have been accepted, so retrying can duplicate it.

On the consuming side, add batch: { maxMessages, maxWindowSeconds } to a Worker's queue trigger and register onQueueBatch. It returns success or retry per delivery, and retrying one doesn't affect the others.

  • Remote queues: your backend can send into a customer's queue through a remote binding, with send, sendText, sendBatch, and sendBatchText
  • Remote KV: KV is available as a remote binding too
  • Python: send_batch and on_queue_batch

Read the docs →

Initial setup recovery

When initial setup fails, rerunning it now resumes the failed attempt. The customer's admin fixes the cause, like a missing cloud role, and runs the same command again:

acmectl deploy --config deployment.toml

Before, the admin had to retry the deployment first, and the retry didn't start anything on its own. Now the rerun is the retry.

Initial setup with CloudFormation or Terraform also survives a closed tab. The portal reserves the deployment when the admin launches, so a refresh or another browser opens the same deployment with its original settings and credentials.

  • Stack started: CloudFormation reports the moment the stack starts, before it registers
  • Review before launch: the admin sees the stack's domain and what it creates before launching
  • Who acts next: a failed deployment says whether it's waiting on your team or the customer's admin

Read the docs →

Sandboxes

The Sandbox resource now runs on AWS, Google Cloud, Azure, and Kubernetes. Your app creates isolated environments at runtime and runs code it doesn't trust inside them:

alien.ts
const agent = new alien.Sandbox("agent")
  .code({ type: "image", image: "ubuntu:24.04" })
  .limits({ cpu: "1", memory: "2Gi", disk: "8Gi" })
  .egress("internet")
  .lifecycle({ maxLifetimeSeconds: 3600 })
  .build()

The code inside gets no cloud credentials, so it can't reach other resources in the stack. Network access goes through an egress gateway that enforces the sandbox's policy.

PlatformRuns on
AWSLambda MicroVMs
Google CloudAgent Platform sandboxes
AzureContainer Apps sandboxes
KubernetesPods with gVisor or Kata
  • Files and jobs: writeFiles, readFile, and long commands that outlive the call that started them
  • Preview ports: reach a port inside a sandbox from the Python and Node SDKs
  • Pause and resume: on platforms that support it, with egress policy changes applied on resume
  • Images: build a sandbox from a Dockerfile or a private base image, cached in each region on first use
  • Image users and boot commands: the image's USER and entrypoint are honored

Read the docs →

Private endpoints and internet egress

Container endpoints on AWS can now stay inside the customer's network. The admin picks private endpoint access at initial setup:

acmectl deploy --config deployment.toml --endpoint-access private

In CloudFormation, it's the EndpointAccess parameter. Endpoints then use internal load balancers, reachable only from the VPC and the networks routed to it. With a custom domain in internal DNS, the hostname stays private too.

Containers can also get internet access without reaching anything else in the customer's network:

alien.ts
const fetcher = new alien.Container("fetcher")
  .code({ type: "image", image: "ghcr.io/acme/fetcher:1.0" })
  .security({ profile: "restricted" })
  .egress("internet")
  .build()
  • Outbound IPs: the deployment page lists the public addresses traffic leaves from, for services that allowlist by IP
  • Availability zones: the admin can pick the zones for a new AWS network on the setup page
  • Links: linked Containers stay reachable over private addresses

Read the docs →

Infrastructure updates in your own cloud

Deployments in your own cloud now apply infrastructure changes on their own. A release that adds, changes, or removes a frozen resource, like a bucket, rolls out like any other release, without rerunning initial setup.

In a customer's cloud, frozen resources stay with the customer's admin: a release that changes one waits for them to rerun initial setup. That split exists because the admin owns the account. In your own cloud, you are the admin, so initial setup grants Alien's management identity the rights to manage them too.

alien deploy --platform aws --automatic-setup

--automatic-setup grants these rights for a new deployment in your own AWS, Google Cloud, or Azure environment. A deployment set up without it keeps the manual behavior.

Read the docs →

Quota checks

Initial setup now checks the cloud quotas a stack needs before it creates anything. A shortfall stops initial setup with the quota, the current usage, and a link to request an increase:

alien render --format cloudformation --stack .alien/build/aws/stack.json --check-quotas

On AWS, the checks cover EC2 vCPUs, VPCs, Elastic IPs, NAT gateways per Availability Zone, and Lambda concurrency. On Google Cloud, regional CPUs, custom IAM roles, and service accounts. On Azure, compute quotas and SKU restrictions in the region.

Before, a missing quota surfaced halfway through provisioning as a cloud error. Now the customer's admin sees it before the first resource exists.

  • IAM limits: generated policies are checked against AWS policy and template size limits
  • Overrides: --quota-warning-override L-1216C47A accepts a known shortfall for one deployment
  • Missing read access: a quota the admin's credentials can't read is reported as a warning
  • Clearer errors: deployment errors say who acts next, your team or the customer's admin

Read the docs →

Customer keys for databases and volumes

Postgres and persistent container volumes can now be encrypted with a customer-managed key:

alien.ts
const key = new alien.Key("customer-key").build()

const db = new alien.Postgres("db").encryptionKey(key).build()

const search = new alien.Container("search")
  .code({ type: "image", image: "ghcr.io/acme/search:2.1" })
  .persistentStorage("200Gi", { mountPath: "/data", encryptionKey: key })
  .build()

On AWS, the key encrypts Aurora storage, snapshots, and Performance Insights data, and EBS volumes and their snapshots. Storage buckets already supported .encryptionKey() on AWS, Google Cloud, and Azure.

The key on a resource can't change after the resource exists. A stack that uses a key on a platform that doesn't support it fails the build, not the deployment.

Hosted AWS deployments in your own cloud can use the customer's key too, so a single-tenant deployment keeps data encrypted with a key the customer holds.

Read the docs →

Deployment sizes

Deployments can now choose container CPU and memory within the ranges your release declares, and Alien picks the machines. Change a running deployment from your product:

lib/resize.ts
const res = await alien.deployments.updateCompute(deploymentId, {
  compute: { containers: { worker: { cpu: 2, memory: "4Gi", volumeSizeGib: 100 } } },
})

Initial setup defaults to Automatic machine sizing. The admin can pin a machine type instead, and clearing the pin returns to automatic. Your product can map its own Small, Medium, and Large sizes to these values without naming provider machine types.

On AWS, a pool's machine type can change at runtime to another type with the same CPU architecture. Alien rolls the existing machines over to it.

  • Graviton4: c8g machines are in the AWS catalog
  • Machine inventory: alien deployments machines <deployment> lists the hosts on every deployment
  • Capacity shortages: initial AWS placement retries when a zone runs out of a machine type

Read the docs →

Simpler Platform API SDK

@alienplatform/platform-api now takes request bodies directly. Methods with one ID take (id, body):

lib/alien.ts
// before
await alien.deploymentGroups.createDeploymentGroupToken({
  id, createDeploymentGroupTokenRequest: body,
})

// after
await alien.deploymentGroups.createToken(id, body)

This is a new major version. The HTTP API and the model types didn't change, so only call sites move. Larger requests and query-only calls keep their named request objects.

Setup links got simpler too. The workspace comes from the API key, and creating a link again with the same external ID returns the same deployment group with a new link, so a second click in your product is safe.

  • Project admin keys: alien api-keys create --for project-admin creates a key that manages one project, including its webhooks and deletion
  • Deployment group moves: the SDK and alien deployments move move a deployment to another group

Read the docs →

Release now, ship later

alien release can now create a release without moving any channel:

alien release --no-promote --title "Fix checkout"
alien releases promote rel_7x2kq9 --channel production

The first command prints the release ID. Nothing updates until you promote it, from the CLI or with Promote this exact release on the release page. Use it for an urgent fix you want to review first, or for a CI job that builds and a reviewed workflow that ships.

Releases also have titles now. --title names the release in the dashboard, in Slack reports, and in rollout notifications.

  • Safe promotion: alien releases promote fails if someone promoted another release in between
  • Move a deployment: alien deployments move puts a Machines deployment into another deployment group, with --dry-run to check first

Read the docs →

Volume backups

Persistent container volumes now have backups. They're on by default: a snapshot every 24 hours, kept for 7 days, in the customer's account and in the volume's region.

alien.ts
const db = new alien.Container("db")
  .code({ type: "image", image: "postgres:17" })
  .persistentStorage("500Gi", {
    mountPath: "/var/lib/postgresql/data",
    backups: { intervalHours: 4, retentionDays: 14 },
  })
  .build()

To restore one replica's volume:

alien deployments volumes customer-1/us-east-1
alien deployments restore-volume customer-1/us-east-1 --resource db --ordinal 0 --snapshot <snapshot-id>

Volume size can also differ per deployment. Set compute.containers.<id>.volumeSizeGib at initial setup or later. An existing volume can grow on AWS, Google Cloud, and Azure, and its filesystem grows with it. It can't shrink.

Read the docs →

Log forwarding

Projects can now forward their logs to the tool your on-call already watches. Open Settings → Integrations and choose Datadog, Coralogix, Axiom, or Custom OTLP.

Each project has one log destination, and it applies to all its deployments. The endpoint must be HTTPS, and Send test log checks the connection. Pause forwarding stops delivery without losing the configuration.

Logs are also easier to read. Alien parses each stdout and stderr line, and a JSON line from a common logger becomes a readable message with its level and fields. This works for Pino, Winston, Bunyan, Rust tracing-subscriber, Go hclog, python-json-logger, structlog, and Loguru, with no configuration.

  • Kubernetes: collect logs through the Kubernetes API or a Fluent Bit DaemonSet
  • Metrics history: CPU and memory per replica, from the last hour to the last 30 days

Read the docs →

Deployer secrets

A secret input the customer's admin provides is now written into their own secret store, never sent to Alien:

alien.ts
ocrLicenseKey: alien.secret({
  providedBy: "deployer",
  required: true,
  label: "OCR license key",
  env: "OCR_LICENSE_KEY",
}),

The value lives in the deployment's deployer-secrets vault: SSM Parameter Store on AWS, Secret Manager on Google Cloud, Key Vault on Azure, or a Kubernetes Secret. Initial setup shows the secret's name in that store and the command to write it.

Alien checks only whether the secret exists. Until a required one does, the deployment waits in WaitingForSecrets and the workloads don't start. Workloads read the value at start with their own identity.

  • Local development: alien dev vault set deployer-secrets ocr-license-key --stdin
  • Delete: alien vault delete removes a secret from a deployment's vault
  • Not readable by management: the identity Alien uses to manage a deployment can't read its secrets

Read the docs →

Air-gapped sites

You can now deploy to air-gapped Kubernetes sites. Releases go in, and status and logs come back, in one folder the site's admin carries across the gap:

alien onboard customer-4 --platforms kubernetes --airgapped

On a machine that can reach your manager, the admin downloads the update. Inside the site, the same command applies it:

# online
alien-deploy sync --token <sync-token> --manager <manager-url>

# inside the site
alien-deploy sync --registry registry.internal/acme -f values.yaml \
  --trusted-key ed25519:<bundle-key>

sync verifies your manager's signature and every file's checksum, pushes the images to the site's registry, installs the chart, and writes a report. Once the report reaches your manager, the site's status and logs show up like any other deployment's.

  • Small updates: only image layers the site doesn't have yet
  • Rollback: alien-deploy rollback returns to the release before the last sync
  • Preview: alien-deploy sync --dry-run shows what an update would change
  • Branded: the site's admin runs your CLI, like acmectl sync
  • Sync status: the dashboard shows when each site last synced

Read the docs →

Fixes and improvements, September

Fixes and smaller improvements shipped between August 24 and September 30.

  • A deployment whose initial setup or provisioning failed now picks up the next corrective release, and alien refreshes setup before retrying a failed update instead of repeating the same failure.
  • Container rollouts on machines now wait for the new replicas to be healthy before an update is marked ready, and old or stale replicas no longer count toward readiness.
  • Machines whose credentials were rejected can rejoin, and a join token can no longer be reused for a machine ID that already exists.
  • CLI errors now keep the server's error details, list every failed preflight check, and print --json command failures on stderr.
  • Structured log messages render as readable text in the CLI and the dashboard instead of raw JSON.
  • Log delivery from containers and the manager retries transient failures instead of dropping lines, and log search bounds its queries and reports failed responses.
  • Deploying into a fresh AWS account no longer fails on a missing autoscaling service role or an exhausted Elastic IP quota, which is now checked before the network is created.
  • Postgres on AWS works in the default VPC, and initial setup asks for explicit subnets instead of guessing.
  • Unknown permission sets are rejected before deployment, generated AWS and Azure permission documents resolve their scopes correctly, and explicit permissions on links are kept.
  • Remote Operator Kubernetes RBAC now grants only what the enabled operations need, and Remote Operator setup tokens expire and resume the exact installation they were created for.
  • Teardown no longer hangs on AWS when a Lambda execution role still holds network interfaces, and Azure teardown keeps track of partially created resources.
  • alien destroy works without a local tracking file, retries a failed teardown, and deployments that failed before provisioning can be deleted.
  • Helm installs keep their runtime identity across upgrades, EKS uses a proper Kubernetes exec auth block, and wildcard hosts in Kubernetes endpoint routes are preserved.
  • On Google Cloud, initial setup resolves default networks and shared vaults, and completes the handoff of compute and PostgreSQL to the runtime.
  • Azure Container Apps names stay within Azure's length limit, managed certificates get enough time to issue, and storage lifecycle rules apply only to their own container.
  • Remote Sandboxes on Azure now work end to end, and AWS sandbox images are read and deleted by ARN so rebuilds and cleanup succeed.
  • The CLI keeps waiting through transient deployment read errors and manager hiccups, and retries transient registry uploads.
  • Local builds and alien dev no longer stall on verbose output, enforce container health checks, and reject worker images built for the wrong architecture.
  • Deployment input secrets are write-only and are redacted from diagnostics.
  • Containers on machines receive their entrypoint arguments, and ingress keeps working on Google Cloud machines that share a host port.
  • The AI gateway sends valid requests when translating to Anthropic, routes Databricks models correctly, and accepts reasoning effort none.
  • Dashboard sign-in now shows OAuth failures, workspace invitations survive the OAuth redirect, and viewers can no longer make changes.
  • alien vault --deployment works when the flag comes after the subcommand, and setting telemetry off is honored by the manager's logs.

Dynamic containers

Running deployments can now host dynamic containers: containers your backend creates through the API, separate from releases. Use them for per-tenant workers, jobs, or anything you start on demand.

The stack decides what's allowed. It approves the image repositories and picks the compute pool, so a caller can't run an arbitrary image or choose where it lands.

The API puts, gets, lists, and deletes containers, and reads their logs. The typed methods are in the Platform API SDK. Dynamic containers have their own lifecycle, separate from the resources a release manages.

  • Restricted by default: on Kubernetes, they run with restricted security settings and namespace-scoped permissions

Read the docs →

Remote Sandboxes

Remote Sandboxes run the code your product executes for a customer, like an agent's tool calls or a user's script, in sandboxes inside the customer's own cloud. Your product stays hosted. Only the sandboxes run there.

alien projects capabilities enable remote-sandbox --max-session-lifetime-seconds 3600
alien api-keys create --for remote-sandbox --description production

Your backend calls the Sandbox Gateway at https://sandbox.alien.dev and names the customer by the ID you already know them by. The customer's admin connects their account once through a setup link with the sandbox item.

Sandboxes run on AWS, Google Cloud, and Azure. Without an image, they use Alien's default image, which ships a general agent toolchain. To use your own:

alien projects capabilities enable remote-sandbox --image public.ecr.aws/acme/analysis:v1
alien projects capabilities enable remote-sandbox --src ./sandbox
  • --src: builds a Dockerfile and pushes it to the project's private repository on each cloud
  • New images reach existing customers: no need to rerun initial setup when you change the image
  • Logs and usage: Remote Sandbox requests show up in alien logs and in project usage

Read the docs →

Kubernetes deployments

Stacks can now target Kubernetes. A deployment runs your stack as pods in one namespace of the customer's cluster, on-prem or in EKS, GKE, or AKS:

alien onboard customer-2 --platforms kubernetes

The customer's admin installs one Helm chart from the deployment portal. It runs the Operator, which connects out to Alien and applies every release after that. Nobody runs helm upgrade, and nothing in the cluster accepts inbound connections.

Frozen resources map to infrastructure the customer already runs. The admin binds them in values.yaml:

values.yaml
infrastructure:
  files:
    type: storage
    service: s3
    bucketName: customer-2-files
  • New clusters: the portal can create an EKS cluster with CloudFormation or Terraform, or a GKE or AKS cluster with Terraform
  • PostgreSQL and named endpoints: bind any PostgreSQL the customer provides, and expose named endpoints
  • Existing nodes: compute pools schedule onto the cluster's own capacity by CPU architecture
  • Logs: logCollector.mode reads Pod logs through the Kubernetes API or runs a Fluent Bit DaemonSet
  • Registration: each deployment reports its Helm release name

Read the docs →

Remote Operator for existing products

Remote Operator can now join a product you already ship with your own Helm chart or Amazon ECS service. How you release doesn't change. The dashboard generates the chart or template, and the install ends with one command:

helm install operator-<installation-id> ./remote-operator \
  --namespace checkout --kube-context customer-1-staging \
  --values operator-values.yaml --replace --atomic --wait --timeout 5m

Remote Operator is one container that runs next to your application. It only connects out, so the customer's security team has no inbound access to review. Through it, your team runs operations, opens debug sessions, and rolls out upgrades.

Open Set up Remote operator in a project and choose Existing Kubernetes or Amazon ECS Fargate. Before installing, you review the image, the RBAC or IAM it grants, and which Pods it collects logs from.

  • Installations: each customer environment shows status, the exact image it runs, and whether its permissions are out of date
  • Releases for software Alien didn't ship: record the version each installation runs, see drift, and roll back
  • Key rotation: rotate an installation's connection key without reinstalling
  • Inside your chart: ship it as a dedicated release or as part of your product's own release

Read the docs →

Sign in with email

You can now sign in to Alien with your email address, without a password. Choose Continue with Email, enter your address, and type the six-digit code Alien sends you.

It works for new accounts too, alongside GitHub and Google. The sign-in page also remembers which method you used last and marks it, so returning teammates pick the right one.

Python SDK

Python workloads now have their own SDK. alienplatform gives async access to the resources a workload links to:

app.py
import asyncio
from alienplatform import kv, storage

async def main() -> None:
    await storage("files").put("reports/2026-10.json", b"{}")
    await kv("cache").put("status", b"ready", ttl_seconds=60)

asyncio.run(main())

The package wraps the same Rust core as the TypeScript SDK, so bindings behave the same on every platform. Build Python workloads with the python toolchain in alien.ts.

pip install alienplatform
pip install "alienplatform[worker]"   # queue handlers for a Python Worker

Requires Python 3.10 or newer. Remote bindings and sandbox previews work from Python too.

Read the docs →

Slack app

The Alien Slack app now reports rollouts and investigates deployments. Connect it in Settings → Integrations → Slack, then ask:

@Alien why is customer-1/us-east-1 not reporting?
@Alien did rel_7x2kq9 roll out to every production deployment?

The agent reads deployment status, logs, events, and inventory, and runs the read-only operations your policy allows. When a fix needs more, it proposes an access request instead of acting.

Every release and deployment gets one message that updates as the rollout progresses. When something keeps failing, the agent replies once with the cause and a next step. Large rollouts group failures instead of posting one message per deployment.

  • Monitor Reports Channel: pick where rollout reports go, or turn them off
  • Investigate: a message shortcut that starts an investigation on any message
  • Workspace members only: actions that run something are accepted only from Slack users in your Alien workspace

Read the docs →

Custom operations

You can now build your own operations plugins for Remote Operator. A plugin is a Rust program that exposes named operations, like a health check against your application's admin API:

alien operations init acme-admin     # scaffold with one read-only operation
cd acme-admin
alien operations check               # validate the typed operations
alien operations permissions --cloud aws   # preview the IAM grants, offline
alien operations package
alien operations publish ./acme-admin-0.1.0.zip

Each operation has a name, a risk tier, typed parameters, a typed result, and the permissions it needs. Alien generates the AWS, Google Cloud, and Kubernetes permissions from the plugins a release declares, so the customer grants only what the enabled operations use.

Declare plugins and their approval rules on the stack:

alien.ts
export default new alien.Stack("acme")
  .operations({
    kubernetes: {
      approval: { "*": "auto", "restart-pod": "manual", scale: "manual" },
    },
    cloudwatch: { approval: { "*": "auto" } },
  })
  .build()
  • Built-in catalog: read-only operations for Kubernetes, Postgres, Redis, Kafka, ClickHouse, Elasticsearch, and AWS and Google Cloud services
  • Risk tiers: read-only, mutating, and destructive
  • Permission preview: the dashboard shows which grants a plugin change adds or removes before you release

Read the docs →

Access requests

You can now request time-boxed access to a customer deployment from the CLI, the dashboard, or Slack:

alien access-requests create --deployment customer-1/us-east-1 \
  --operation 'kubernetes/*' --max-risk read-only \
  --debug-tool kubectl --debug-namespace checkout \
  --duration 2h --reason "Checkout pods restarting"

alien access-requests wait ar_5k2m8q

One approved request covers a whole fix for up to 6 hours, so nobody approves each step. The requester can't approve their own request.

A request can cover one exact operation with its parameters, every operation in a plugin up to a risk cap, or a debug session with kubectl, aws, gcloud, or az. The approver sees the commands and the reason before deciding.

  • Approve in Slack: the approval card has Approve for 6 hours and Deny, and can go to a channel you share with the customer
  • Approve with kubectl: on Kubernetes, the customer can approve with one kubectl patch command
  • Run and wait: alien operations invoke --request-access creates the request, waits for approval, and runs
  • Revoke: alien access-requests revoke ends a grant early
  • Remote debugging: alien debug sessions use the same requests

Read the docs →

CLI upgrades

The Alien CLI now upgrades itself:

alien upgrade            # latest stable release
alien upgrade --canary   # latest canary build, for standalone installs
alien upgrade --dry-run  # show what would be installed

It uses the same method you installed with. If a command fails with a JSON parse error like unknown field, the CLI is older than the API: run alien upgrade and repeat the command.

A new account can also start from the terminal. alien login signs you in, and alien workspaces create <name> creates the workspace.

  • ALIEN_PROJECT: selects the project without --project, useful for a separate staging project in CI
  • alien deployments events <deployment>: recent lifecycle events for one deployment
  • alien projects delete: remove a project from the CLI

Read the docs →

AI Gateway

AI Gateway lets you route inference requests to the customer's AI provider. The prompts, the quota, and the bill stay with them, and your backend keeps one integration. The difference is a prefix on the model ID:

src/ai.ts
const ai = new OpenAI({
  baseURL: "https://ai.alien.dev/v1",
  apiKey: process.env.ALIEN_AI_KEY,
  defaultHeaders: { "X-Alien-External-ID": customer.id },
})

await ai.chat.completions.create({
  model: "byo/claude-opus-5", 
  messages,
})

byo/ says the model runs in the customer's own account. The gateway removes the prefix and calls whichever provider they connected:

byo/claude-opus-5
├── connected AWS           → Claude on Bedrock, in their account and region
├── connected Google Cloud  → Claude on Vertex AI, in their project
├── connected Azure         → Claude on AI Foundry, in their subscription
├── pasted an Anthropic key → Claude on the Anthropic API
└── connected Databricks    → Claude in their Databricks workspace

One model ID, one request body, five different companies' bills. Your backend never holds an AWS role, a Google credential, an Azure credential, or a provider API key. The model publisher and the service running the model are not the same thing, and the customer picks the second one.

Choose the models your product calls in Infrastructure → Models. The catalog carries 54 models from 11 publishers across Bedrock, Vertex AI, AI Foundry, Anthropic, OpenAI, and Databricks. Customers then connect through a link you create for the ID you already know them by:

alien onboard "Acme" --external-id org_123 --setup-items models

A connected account does not mean every model is ready. Availability belongs to the connection, and some models need a one-time activation, like accepting the Marketplace terms for Claude in the Foundry portal.

  • Keep your client API: OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages
  • Diagnostics without the contents: alien logs --source ai-gateway records routing and outcome, never prompts or responses
  • Usage as a privacy-safe aggregate: alien usage ai --range 7d for counts, tokens, estimated cost, and latency

Read the docs →

Alon GubkinItamar ZandDan Lilienblum
Alon +2

Remote bindings

Remote bindings let your hosted backend read and write a resource that lives in the customer's cloud. Until now, using a customer-owned bucket or key meant running your code next to it. Now you can publish one resource and reach it from the backend you already operate.

Publish the resource in the stack:

alien.ts
const uploads = new alien.Storage("uploads").build()

export default new alien.Stack("customer-storage")
  .add(uploads, "frozen", { remoteAccess: true })
  .build()

remoteAccess: true publishes that one resource. Nothing else in the stack becomes reachable.

Then resolve the customer from your backend by the same external ID you used when you created their setup link:

import { Bindings } from "@alienplatform/bindings"

const bindings = await Bindings.forRemoteCustomer({
  project: "my-project",
  externalId: customer.id,
  token: process.env.ALIEN_API_TOKEN!,
})

const uploads = bindings.storage("uploads")
await uploads.put("report.txt", Buffer.from("hello"))

Storage, Key, and AI are the resources you can publish today. Credentials are minted per call and scoped to the deployment, so nothing long-lived sits in your environment.

  • One resource, not the stack: remoteAccess is per resource and off by default
  • No deployment required: your backend stays where it is
  • Short-lived, deployment-scoped credentials: minted behind the handle, never handed to you

The request still crosses environments. Review what you send and receive exactly as you would for any hosted API integration.

Read the docs →

Alon GubkinDan Lilienblum
Alon & Dan

Release channels

Projects now have release channels: named streams of releases, like staging and production, and every deployment follows one. Until now every release went to every deployment; channels let parts of your install base move at different speeds, like an internal staging deployment, a cautious enterprise customer, or a region you roll last:

# CI publishes every build to staging
alien release --channel staging

# When it's proven, promote the exact same artifacts to production
alien releases promote rel_8f3ka92 --channel production

Promotion doesn't rebuild anything, so production runs the exact bytes staging tested. It's also how you roll back: promote an earlier release and the channel's deployments follow. Every project gets a production channel automatically, and alien release with no flags advances it, so if you never think about channels, nothing changes.

Every release also has a detail page now: each deployment classified as updated, updating, failed, pending, or pinned, with rollout durations, failures sorted first, and a live view while the rollout is in flight.

  • Channels are groupings, not environments: staging, regions, one nervous enterprise account
  • Rollback is a promotion: point the channel at an earlier release
  • Nothing hides: pinned and failed deployments stay visible instead of becoming version drift

Read the docs →

Dan LilienblumAlon Gubkin
Dan & Alon

Versioned KV

KV now supports atomic conditional writes: create a key only if it doesn't exist, or update and delete a key only if it hasn't changed since you read it.

It works through versions. Every read returns the entry's current version. Pass it back as ifVersion and the write only happens if the key is still at that version. Pass ifVersion: null and the write only happens if the key doesn't exist yet:

const jobs = kv("jobs")

// Exactly one worker can create the key
const claimed = await jobs.setJson(jobId, { worker: workerId }, {
  ifVersion: null, // only write if the key doesn't exist
  ttl: 300,
})

if (!claimed) return // another worker already claimed it

When the condition fails, the write returns false instead of throwing. That is all you need for locks, counters, and idempotency keys that stay correct when two workers race.

Under the hood each cloud's native primitive does the work: DynamoDB condition expressions, Firestore preconditions, Azure Table Storage ETags, and an atomic upsert in local dev. Identical semantics everywhere, in TypeScript and Rust.

Read the docs →

Itamar Zand
Itamar

Storage object metadata

Storage put now accepts object attributes, and get and head return them: content type, cache control, content disposition, custom key-value metadata, plus the provider's ETag and version. No more keeping a file's content type in a separate database next to the file:

const assets = storage("assets")

await assets.put("reports/q1.pdf", pdfBytes, {
  attributes: {
    contentType: "application/pdf",
    cacheControl: "public, max-age=3600",
    metadata: { quarter: "q1" },
  },
})

// Serve it back with the headers it was stored with
const { data, attributes } = await assets.get("reports/q1.pdf")
res.type(attributes.contentType!).send(data)

Reads also return the provider's ETag and version; a head is enough to answer an If-None-Match with a 304 without downloading the object. The same model works on S3, Google Cloud Storage, and Azure Blob, and writes a provider can't honor fail before any bytes land, so an object never exists with silently dropped attributes.

Read the docs →

Dan LilienblumItamar Zand
Dan & Itamar

AI

Alien now provisions AI inference as a resource. Your product's AI features run on the model service already inside the customer's cloud — Bedrock on AWS, Vertex AI on GCP, AI Foundry on Azure — so the prompts, the data, and the bill all stay with them.

const llm = new alien.AI("assistant").build()

The model is an argument on each request, not a decision in the stack, so one stack file works across three clouds whose model menus differ:

const llm = ai("assistant")

// Model menus differ per cloud, so take one this deployment actually has.
const [model] = await llm.getAvailableModels()

const answer = await llm.chat.completions.create({
  model: model.id,
  messages: [{ role: "user", content: "Summarize this support thread." }],
})
  • Prompts and data never leave their account — inference runs where the workload runs
  • No API keys — calls run under the workload's own cloud identity
  • AWS Bedrock, Google Vertex AI and Azure Foundry — from one line of stack code
  • Claude, GPT, Gemini, Mistral, Qwen, DeepSeek and dozens more — whatever that cloud serves
  • The provider's real API, not a translation layer

That makes AI features shippable into regulated environments: their cloud, their models, their bill.

Some models need a one-time activation in the customer's cloud account before they can be called — Claude on all three clouds.

Read the docs →

Itamar Zand
Itamar

Rollout progress

After you publish a release, the question is always the same: is it running everywhere yet? The releases table now answers it at a glance. A release in flight shows live progress — how many deployments have picked it up out of how many. A finished release shows how long the rollout took.

The releases table showing per-release rollout duration and deployment counts, with a tooltip reading "Rolled out to 2 deployments · avg 12s from release to deployed"

The number next to each release is the average time from publishing the release to it running in a deployment, with the count of deployments it reached. Each deployment's timeline also shows its own number — "Release updated · 4m 32s after release" — so a straggler stands out immediately.

Failed rollouts got the same attention. A deployment that failed mid-rollout no longer needs special-case surgery: fix the problem, release again, and it converges through the same desired-state reconciliation as everything else. Auto-updating and pinned deployments both find their way back on their own.

  • Live progress — see a release land deployment by deployment
  • Time to deploy — per-release average and per-deployment timing
  • Recovery is just another release — failed rollouts converge, no manual repair path

Read the docs →

Alon Gubkin
Alon

Offline-first

Software you deploy with Alien no longer depends on Alien being up.

Every machine in a deployment now keeps the last accepted deployment plan and supervises it locally. If the control plane becomes unreachable — our outage, their network partition, an air-gap window — nothing changes for the workloads. They keep serving. They keep restarting on failure. A machine can reboot during the outage and come back with its workloads running, restored entirely from the local plan.

Stateful workloads are handled with more care: rather than guessing during a partition, they hold further changes until the control plane is back and fresh authority is confirmed — no split-brain, no double-writes.

Operators aren't blind in the meantime. A local status command inspects what's actually running on a machine, read-only and offline. And the dashboard now separates "we can't reach this machine" from "this workload is down", so a management-plane gap doesn't page anyone about healthy software.

When connectivity returns, machines report what happened and reconcile back to the desired state.

  • Workloads survive outages — serving, restarts, and recovery continue with no control plane
  • Reboot-safe — machines restore their full workload set from the locally cached plan
  • No split-brain — stateful workloads wait for fresh authority instead of guessing
  • Honest status — management reachability and workload health are reported separately

If you sell software that runs in your customer's environment, this is the guarantee they ask about: your vendor's control plane is not in their critical path.

Read the docs →

Alon Gubkin
Alon

Team invitations

You can now bring your team into a workspace two ways: invite someone directly by email, or share an invite link.

An email invitation waits for its recipient — whether they already have an account or sign up later, they land in the right workspace with the right role on their first login. Pending invitations show up in a dedicated tab on the members table, where you can resend, copy, or revoke them.

For onboarding several people at once, generate an invite link instead: pick a role, share the link, and anyone who opens it can request to join. Links expire, and joins are confirmed by an admin, so a link that leaks doesn't become a backdoor.

Seat limits are enforced at acceptance time, atomically — two people accepting the last seat at the same moment can't both get in.

  • Email invitations — persistent, resendable, revocable, for registered and unregistered recipients
  • Invite links — reusable, role-scoped, expiring, admin-confirmed
  • Seats enforced — acceptance is atomic against your workspace's seat count
Alon Gubkin
Alon

Optional resources

Not every customer needs every part of your stack. Resources can now be gated on a boolean deployment input with .enabled(), so the admin who sets up the deployment decides what gets provisioned:

const inputs = alien.inputs({
  cacheEnabled: alien.boolean({
    providedBy: "deployer",
    required: true,
    label: "Enable the cache",
    description: "Provision a key-value store for response caching.",
  }),
})

const cache = new alien.Kv("cache")
  .enabled(inputs.cacheEnabled)
  .build()

A disabled resource isn't hidden — it doesn't exist. Nothing is provisioned, no IAM grants are emitted for it, and it's absent from the generated CloudFormation and Terraform. The setup template a security team reviews contains exactly what that customer turned on.

The gate follows the resource's lifecycle. For frozen resources, the answer is part of initial setup and fixed for the deployment's lifetime. For live resources, it can change later: enabling provisions the resource, disabling deletes it — data included, deliberately, because that's what "turn this off" means to the person paying for it.

  • Real absence — disabled means no infrastructure, no permissions, no cost
  • Per-customer stacks — one alien.ts, different footprints per deployment
  • Asked like any input — the toggle shows up in the dashboard, portal, CLI, and IaC

Read the docs →

Itamar Zand
Itamar

Email

Alien now provisions email infrastructure as a resource. Your product can send and receive mail on domains your customer owns, from inside their own cloud account — their sending reputation, their DKIM keys, their data.

const inbound = new alien.Storage("inbound").build()
const events = new alien.Queue("email-events").build()

const email = new alien.Email("email")
  .domains(["mail.acme.com"])
  .inbound(inbound)
  .events(events)
  .build()

Declared domains are verified with DKIM set up automatically. Inbound mail lands in the linked storage bucket, ready for your workload to parse. Delivery, bounce, and complaint events flow into the linked queue, so suppression lists and deliverability monitoring are ordinary queue consumers.

Domains don't have to be fixed at initial setup. With the email/manage-identities grant, your workload can create and remove domain identities at runtime — the flow a multi-tenant product needs when each of its users brings their own domain.

  • Customer-owned — identities, reputation, and mail live in their account, not a shared sender
  • Send and receive — outbound with email/send, inbound to a bucket you control
  • Runtime domains — add and remove verified domains from your app, not from IaC
  • Event stream — bounces and complaints as queue messages

The Email resource is currently available only on AWS, backed by SES.

Read the docs →

Alon Gubkin
Alon

Containers without a runtime

Until now, every Container and Daemon ran under a small Alien runtime — a Rust process that started your app, supervised it, and brokered access to bindings and commands. That layer is gone. Your entrypoint is now PID 1: what runs in the customer's cloud is exactly what's in your Dockerfile, with nothing in front of it.

Bindings moved in-process to make that possible. Instead of talking to the runtime, your app imports a library, resolves a resource once, and calls it:

import { kv, queue, container } from "@alienplatform/bindings"

const index = kv("index")
const jobs = queue("jobs")

await index.setJson("user:42", { plan: "pro" })
await jobs.send({ type: "welcome-email", userId: 42 })

const db = container("postgres")
const url = await db.getInternalUrl()

The library is a native binding over the same Rust core on every language, so behavior is identical across Node, Bun, and Rust. Credentials are minted short-lived and refreshed behind the handle — nothing long-lived sits in your environment.

Commands got the same treatment. A container registers named handlers, with optional schema validation using any Standard Schema library (Zod, Valibot, ArkType), and your control plane invokes them without any inbound port:

import { createCommandReceiver } from "@alienplatform/commands"
import * as z from "zod"

const receiver = createCommandReceiver()

receiver.command("reindex", z.object({ tenant: z.string() }), async input => {
  return { started: true, tenant: input.tenant }
})

await receiver.run()

Validated commands infer their input types; handleRaw is there when you want the raw payload.

  • No wrapper — your process runs directly, smaller images, one less thing between you and your app
  • In-process bindings — resolve once, call like a library; queue and KV APIs no longer take a name on every call
  • Typed commands — schema-validated input in Rust and TypeScript

Read the docs →

Dan LilienblumAlon Gubkin
Dan & Alon

Stateful workloads

Containers can now keep state. Give a container persistent storage and each replica gets its own durable volume, mounted where you say:

const db = new alien.Container("db")
  .code({ type: "image", image: "ghcr.io/acme/db:v1" })
  .replicas(3)
  .persistentStorage("20Gi", { mountPath: "/var/lib/data" })
  .port(5432)
  .permissions("execution")
  .build()

Each replica has a stable identity — db-0, db-1, db-2 — and its volume follows that identity. Restarts, upgrades, and machine replacement all reattach the same disk to the same replica. Peers find each other by name, so clustered software that expects stable members just works.

Replicas are placed across availability zones, and each volume is provisioned in the right zone for its replica. Losing a zone loses one member, not the dataset.

This is the capability that databases, queues, and durable-execution engines need — the class of software that previously meant hand-rolled StatefulSets, PVCs, and an operator per product. We've been running a distributed durable-execution engine and a Postgres connection pooler on it in real customer-style deployments: journals survive restarts, in-flight work completes through rolling updates.

  • Durable volumes — EBS and equivalents on each cloud, kept through every kind of replacement
  • Stable ordinals — predictable names for clustering and peer discovery
  • Zone-aware placement — replicas and their disks spread across failure domains

Read the docs →

Alon Gubkin
Alon

TCP endpoints

Public endpoints now speak raw TCP, not just HTTP. If your product talks the Postgres wire protocol, Redis, MQTT, or anything else over a socket, you can expose it from a customer deployment the same way you expose an API.

const pooler = new alien.Container("pooler")
  .code({ type: "image", image: "ghcr.io/acme/pooler:v1" })
  .port(6432)
  .publicEndpoint("db", 6432, "tcp")
  .permissions("execution")
  .build()

Alien creates the network load balancer, DNS, and TLS inside the customer's cloud, on AWS, GCP, Azure, and plain machines. Clients get one stable address per deployment and connect with their normal drivers — psql, redis-cli, whatever they already use.

The hard part of TCP is deploys. Database connections live for hours, and a rollout that cuts them is an incident. So Alien drains: during a release, each replica is taken out of the load balancer, waits for its open connections to finish, and only then gets replaced.

  • Any protocol — if it runs over TCP, you can expose it
  • Connection draining — rolling updates wait for open connections instead of cutting them
  • Same declaration everywhere — one alien.ts line works on every cloud and locally in alien dev

Read the docs →

Alon Gubkin
Alon

Public endpoints

Workers, Containers, and Daemons can now expose named HTTPS endpoints, declared in alien.ts next to the resource they serve.

Alien creates the DNS, TLS, and load balancing inside the customer's cloud. The customer's network decides who can reach each endpoint:

  • Behind the customer's VPN, for dashboards and admin tools their employees use
  • Internal only, for APIs that other services in the environment call
  • On the public internet, for webhook receivers and public APIs
const server = new alien.Container("server")
  .code({ type: "image", image: "ghcr.io/acme/server:v1" })
  .port(8080)
  .publicEndpoint("api", 8080, { protocol: "http", hostLabel: "@" })
  .publicEndpoint("app", 8080, {
    protocol: "http",
    hostLabel: "app",
    wildcardSubdomains: true,
  })
  .permissions("execution")
  .build()

Each deployment gets its own domain, and every endpoint becomes a hostname on it. In the example above, api is served at the domain itself, and app also covers *.app.<domain>, so one declaration handles per-customer subdomains. Your control plane reads the resolved URLs from the manager API instead of constructing them.

TLS works per deployment: every deployment runs in a different cloud account, so there is no shared certificate. Alien issues one for each deployment, imports it into the customer's cloud (ACM on AWS, Certificate Manager on GCP, Key Vault on Azure), and renews it automatically. Customers who manage their own certificates can bring their own domain instead; Alien never sees the private key.

Read the docs →

Alon Gubkin
Alon

Daemons

Daemons let you run a managed process on every machine in a customer deployment.

Use them for the work that should live on the machine: observability collectors, node agents, and host-level control loops.

const agent = new alien.Daemon("agent")
  .code({ type: "image", image: "ghcr.io/acme/agent:v1" })
  .commandsEnabled(true)
  .permissions("execution")
  .build()

You define the daemon in alien.ts and ship it with the rest of your stack. Alien handles placement, release rollouts, rollback, health, logs, deployment inputs, linked resources, and command-receiver configuration.

Daemons are private by default and can expose HTTP endpoints when they need a public surface. For remote commands, the Daemon application starts an explicit receiver from @alienplatform/commands or alien-commands; Alien injects its target identity and credentials, but does not add a runtime or polling sidecar.

Read the docs →

Dan LilienblumItamar Zand
Dan & Itamar

Postgres

Alien now provisions a managed Postgres database directly in your customer's cloud. Declare it once in alien.ts, and Alien creates and operates it on AWS, GCP, and Azure.

const db = new alien.Postgres("orders")
  .version("17")
  .cpu("2")
  .memory("8Gi")
  .build()

The connection is injected into your workload, and the password never lands in state, logs, or generated infrastructure. Like every Alien resource, it runs the same locally for development and during alien dev.

  • Private by default, with no public IP on any cloud
  • One declaration, provisioned on AWS, GCP, and Azure (and embedded locally)
  • pgvector out of the box for embeddings, semantic search, and RAG
  • In-place day-2 resize of cpu and memory, with your data kept

Read the docs →

Itamar ZandAlon Gubkin
Itamar & Alon

Deployment inputs

When your software runs inside your customer's cloud, it needs real values to start: endpoints, connection strings, API keys. Some of them are yours. Some only the customer's admin has.

Deployment inputs let you declare every one of them in alien.ts. Each input says what it is, how it's validated, and who provides it.

const inputs = alien.inputs({
  databaseUrl: alien.string({
    providedBy: "deployer",
    required: true,
    label: "Database URL",
    description: "Postgres connection string inside the customer's network.",
    pattern: "^postgres://",
    env: "DATABASE_URL",
  }),
  controlPlaneApiKey: alien.secret({
    providedBy: "developer",
    required: true,
    label: "Control plane API key",
    description: "Authorizes this deployment with your control plane.",
    env: "CONTROL_PLANE_API_KEY",
  }),
})

The important part is providedBy, which decides who gets asked:

  • developer values are collected on your side, and the customer never sees them.
  • deployer values are asked of the customer's admin at initial setup, because they're specific to their own environment.

From that one declaration, Alien validates each value and collects it everywhere initial setup happens: the dashboard, deployment portal, CLI, CloudFormation, Terraform, and Helm. Types cover strings, secrets, numbers, integers, booleans, enums, and lists, and secrets stay masked, encrypted at rest, and out of generated IaC and logs.

Read the docs →

Alon GubkinDan Lilienblum
Alon & Dan

Remote debugging

Debug remotely with the new alien debug command. It opens a secure channel into your customer's cloud and lets you run the CLIs you already use against it, so a remote environment behaves like another region in your own.

  • Secure channel into your customer's cloud
  • No open ports or inbound networking
  • Works with aws, gcloud, az, and kubectl
  • Least-privilege management permissions only
  • Optional approvals from the customer's admins

Read the docs →

Itamar ZandAlon Gubkin
Itamar & Alon

Live log viewer

Alien now collects logs from all your remote BYOC deployments into an object storage bucket you own. Stream them live and search history from the dashboard, the same across AWS, GCP, Azure, and Kubernetes.

The hardest part of BYOC usually isn't the deployment. It's everything after it.

Observability docs →

Dan LilienblumItamar ZandAlon Gubkin
Dan +2

Introducing the Alien Platform

Today we're launching the Alien Platform: deploy your software into your customers' clouds and operate it from one place, with updates, monitoring, and remote debugging.

You define what runs in a customer's environment once. Alien generates white-labeled deployment options (CloudFormation, Login with Google, Terraform, Helm, bring-your-own Kubernetes, airgapped), installable through a deployment portal on your own domain. Updates roll out to every deployment automatically across AWS, GCP, Azure, and on-prem.

We also raised a $5M seed from Basis Set, Jibe, and angels at OpenAI, Google, and Databricks.

Read the docs →

Alon Gubkin
Alon

Introducing Alien

We're happy to announce the first version of Alien, an open-source platform for deploying your software into your customers' own environments and keeping it fully managed. Still very early.

The software runs in the customer's environment, so their data stays private, but you keep operating it: deployments, updates, monitoring, and debugging stay centralized. Targets AWS, GCP, and Azure.

Alon Gubkin
Alon