Skip to content

Product / Computers

Linux microVMs attached to your actors.

Start an on-demand Firecracker Linux microVM from any actor job. Each machine mounts the actor filesystem, pauses at zero compute cost when idle, and wakes with memory intact.

Akter Cloud isolates each computer in a Firecracker Linux microVM. The Local engine runs commands as child processes on your machine.

Attach a computer to a workspace. Drive it from an actor job.

import { Schema } from "effect"import { Akter } from "@akterjs/effect/contract"export const WorkspaceId = Schema.String.pipe(Schema.brand("WorkspaceId"))export const Developer = Akter.caller("user", Schema.Struct({ id: Akter.PrincipalId }))export const Idle = Schema.TaggedStruct("Idle", {})export const Verifying = Schema.TaggedStruct("Verifying", { repo: Schema.String })export const Verified = Schema.TaggedStruct("Verified", { passed: Schema.Boolean, repo: Schema.String })export const Workspace = Akter.make("Workspace", {  callers: [Developer],  commands: {    verify: Akter.command({      callers: [Developer],      errors: [],      from: [Idle, Verified],      input: Schema.Struct({ repo: Schema.String }),      output: Schema.String,      to: [Verifying],    }),  },  initial: { input: Schema.Void, to: Idle },  jobs: {    verifyBuild: Akter.job({      errors: [],      from: [Verifying],      input: Schema.Struct({ key: WorkspaceId, repo: Schema.String }),      output: Schema.Boolean,      patches: [],      to: [Verified],    }),  },  key: WorkspaceId,  parent: Akter.Root,  queries: {},  states: [Idle, Verifying, Verified],  tables: [],})
import { Effect } from "effect"import { Activity } from "effect/workflow"import { ComputerName } from "@akterjs/effect/contract/computer"import type { ComputerSpec } from "@akterjs/effect/contract/computer"import { Workspace } from "./workspace.contract.ts"const sandbox: ComputerSpec = {  egress: ["github.com", "registry.npmjs.org"],  image: "node:24",  name: ComputerName.make("ci"),  size: { memoryMib: 2048, vcpu: 2 },}export const VerifyBuildLive = Workspace.jobs.verifyBuild.toLayer(({ key, repo }) =>  Effect.gen(function* verifyBuild() {    const computers = yield* Workspace.computer(key)    yield* Activity.make({ name: "computer", execute: computers.ensure(sandbox).pipe(Effect.asVoid, Effect.orDie) })    yield* computers.step("ci", { name: "clone", command: `git clone ${repo} .` })    yield* computers.step("ci", { name: "install", command: "npm ci" })    const check = yield* computers.step("ci", { name: "test", command: "npm test" })    return check._tag === "Ran" && check.exitCode === 0  }).pipe(Effect.orDie),)
import { Effect, Exit } from "effect"import { Akter } from "@akterjs/effect/contract"import { Idle, Verified, Verifying, Workspace } from "./workspace.contract.ts"export const WorkspaceLive = Workspace.toLayer({  commands: {    verify: (_workspace, { repo }) =>      Effect.gen(function* verify() {        const key = yield* Akter.actorKey        const jobId = yield* Akter.start(Workspace.jobs.verifyBuild, { key, repo })        return { next: Verifying.make({ repo }), output: jobId }      }),  },  initial: () => ({ next: Idle.make({}) }),  queries: {},  results: {    verifyBuild: (verifying, result) =>      Effect.succeed({        next: Verified.make({ passed: Exit.isSuccess(result) && result.value, repo: verifying.repo }),      }),  },})

Pause when idle. Wake with memory intact.

Idle for 30 minutes, the VM pauses. Resume it, and memory wakes intact.

EventStateKeepsCompute
ensurerunningmemory, processes, filesBilled
30 min idlepausedmemory, processes, filesNot billed
resumerunningmemory, processes, filesBilled
stopstoppedfiles onlyNot billed
ensurerunningfiles, fresh memoryBilled

Akter Cloud pauses an idle microVM after 30 minutes without an active process connection. Paused computers preserve memory and pay $0 for compute.

Work that finishes even if a host restarts.

Steps run once.

Actor SQLite journals each durable step before execution and records its exit status on completion. Retried jobs read back finished steps instead of running them twice.

Egress you allow.

Every computer spec declares an outbound host allowlist, and actor.db never mounts inside the guest. The egress proxy injects secrets on outbound requests so raw credentials stay off the VM.

Fork the whole machine.

Copy-on-write forks clone a computer’s filesystem and live memory onto a new actor branch. Run parallel candidate builds and keep the branch that passes.

Any size you name. Reaching only the hosts you allow.

See every price

size

Any whole vCPU

and any whole memoryMib

size: { vcpu, memoryMib }

egress

Allow-list

hosts or rules, never credentials

required on every spec

Akter Cloud bills active VM compute at $0.08 per vCPU-hour. A 2-vCPU computer costs $0.16 per active hour and $0 while paused.
Active VMs$0.08 per vCPU-hour
CoW delta storage$0.15 per GB-month
Paused or sleeping VMsFree
Recorded job stepsFree
Copy-on-write forksFree

Start with one actor.

Run akterd on your laptop with one command. Ship the same code to three zones when you’re ready.