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.
| Event | State | Keeps | Compute |
|---|---|---|---|
| ensure | running | memory, processes, files | Billed |
| 30 min idle | paused | memory, processes, files | Not billed |
| resume | running | memory, processes, files | Billed |
| stop | stopped | files only | Not billed |
| ensure | running | files, fresh memory | Billed |
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 pricesize
Any whole vCPU
and any whole memoryMib
size: { vcpu, memoryMib }
egress
Allow-list
hosts or rules, never credentials
required on every spec
| Active VMs | $0.08 per vCPU-hour |
|---|---|
| CoW delta storage | $0.15 per GB-month |
| Paused or sleeping VMs | Free |
| Recorded job steps | Free |
| Copy-on-write forks | Free |
Start with one actor.
Run akterd on your laptop with one command. Ship the same code to three zones when you’re ready.