Skip to content
FrazerDocs
Start building
AgentsProduct page

Agent images

Agent images define what an agent’s microVM boots: the tools, the packages and the harness. Start from one of four Frazer tiers, or layer your own image on one. Frazer builds it in an isolated builder, scans it, signs it and promotes it from dev to staging to prod. Skills, tools, knowledge and models sit in an overlay applied at wake, so changing them needs no rebuild.

Product page: Agent images.

How it works

Section titled “How it works”

An image describes content. A size class describes resources. Each image declares the smallest class it needs, and every agent picks a class at or above it.

Tier Image Contents Size Default class
Lite frazer/agent-lite Debian slim, Python 3.14 with uv, Node 26, git, curl, jq, ripgrep, the frazer CLI and the runtime sidecar; no browser About 0.4 GB lite-1
Standard frazer/agent-standard Lite plus headless Chromium and Playwright, pandoc, poppler, LibreOffice, ffmpeg, tesseract, gh and kubectl About 1.3 GB std-2
Full frazer/agent-full Standard plus Go, Rust, JDK 21, build-essential, Docker inside the VM, language servers, Postgres 17 and Valkey (stopped), Claude Code, Codex CLI and Hermes About 4.9 GB full-4
GPU frazer/agent-gpu Full plus the CUDA 12.9 runtime, cuDNN 9, PyTorch, and vLLM and SGLang clients; model weights live on volumes, never in the image About 11 GB gpu-l4

An image is built in layers, from the ones that change least to the ones that change most:

  • Baked: the tier, then the harness, then packages and devcontainer features, then your Dockerfile steps. These change rarely and cache well.
  • Overlay: skills, MCP servers, knowledge, model routes, dotfiles and environment. Frazer renders them into the agent’s volume at every wake, so they reload without a rebuild.

The harness layer adds the agent loop and Frazer’s adapter for it:

Harness Smallest tier
Frazer harness Any
OpenClaw Standard
Claude Agent SDK Full
Codex CLI Full
OpenHands SDK Full
Your own harness Any

Each harness version carries a compatibility suite result covering workspace files, skills, wakes, channels, approvals, sub-agent limits, memory, and export and import. A version below 100 % runs in dev images only.

Agent images, runner images and devbox templates share base layers and one build pipeline: frazer/agent-full is the devbox base without the desktop. A repository’s CI, its devboxes and its coding agents can start from the same digest, so an agent that takes over a devbox session finds the same tools.

Build an image

Section titled “Build an image”

  1. Write the spec. from names a Frazer tier or another image of yours.

    image.yaml
    apiVersion: frazer.ai/v1
    kind: AgentImage
    metadata: { name: acme/coding, project: acme-production }
    spec:
      from: frazer/agent-full@2026.10.1
      harness: claude-agent-sdk@0.9.4
      packages: { apt: [protobuf-compiler, graphviz], go: [golangci-lint@v2.6, buf@1.58], npm: [pnpm@10] }
      features: { ghcr.io/devcontainers/features/aws-cli:1: {} }
      dockerfile: | # build secrets only as mounts
        RUN --mount=type=secret,id=npmrc pnpm fetch --dir /opt/acme
      start: { command: frazer-agentd, ready: { http: ":8790/readyz" } }
      class: { default: full-4, min: full-4 }
      warm: { pool: 1, snapshot: after-ready }
      smokeEval: evalSets/coding-smoke
    overlay: # rendered into the volume at wake, never baked
      skills: [acme/go-upgrade@3.1, acme/deploy@3]
      mcpServers: [frazer, github, linear]
      knowledge: [acme-engineering]
      models: { main: balanced, subagents: fast }
      dotfiles: acme/dotfiles@main

    A devcontainer.json works as the source of packages and features too.

  2. Build it.

    Terminal window
    frazer agents images build acme/coding -f image.yaml
    Output
      Plan   isolated build · SBOM · scan · sign · smoke eval
    ✓ acme/coding@v24 · 0 fixable critical or high · signed

    Each build runs a rootless image builder on an isolated builder. It attaches an SBOM and provenance to the image, scans it with two vulnerability scanners, signs it with your project’s key, runs the smoke eval on a fresh agent and takes a memory snapshot after the agent is ready. Versions are immutable digests.

  3. Promote it. The channels dev, staging and prod are tags that move by digest.

    Terminal window
    frazer agents images promote acme/coding@v24 --to prod

    Prod needs a signature, an SBOM, provenance, no fixable critical or high finding (or a dated exception) and a green smoke eval. Staging rolls out by ring: one agent first, then all of them after a number of runs without new failures.

  4. Use it. Name the image when you create an agent or add a squad member:

    Terminal window
    frazer agents squads members add platform-ops --agent acme-coder --role worker --image acme/coding

Change the overlay without a rebuild

Section titled “Change the overlay without a rebuild”

The overlay holds everything that is not a package: skills, MCP servers, knowledge bases, model routes, dotfiles and environment. Change it on the image and agents pick it up at their next wake. Mark each overlay item:

  • locked: applied; agents cannot remove or change it, and it heals itself.
  • default: applied; an agent may override it, and the override is shown.
  • suggested: offered, not applied.

When an agent drifts from its image’s overlay, the agent page shows it. Keep anything that is not a package in the overlay: it avoids one image per agent.

Override an image per agent

Section titled “Override an image per agent”

An agent may change, without a new image:

  • its size class, within the image’s minimum and the squad’s budget;
  • overlay items marked default;
  • environment and egress additions, each as a plan;
  • the image version it is pinned to.

Baked content changes only through a new image version. Each agent lists its overrides, and each image counts the agents that override it.

Wake faster with warm pools

Section titled “Wake faster with warm pools”

For each image digest and class, Frazer keeps a memory snapshot taken after the agent was ready, and warm pools of pre-booted microVMs sized from demand, with time-of-day schedules. Full and GPU images pull lazily from site caches. Snapshots stay in their region and need the same CPU family. A GPU agent’s wake adds the time to load its model.

warm: {pool: 1, snapshot: after-ready} in the spec asks for one warm microVM and a post-ready snapshot. A warm-pool reservation for one agent, instant wake, is billed per agent per month.

Access and audit

Section titled “Access and audit”
  • Builds: a build starts from a plan and runs in a rootless image builder on an isolated machine. Build secrets are only mounted for a step, never written into a layer.
  • Images: no secrets in the image, a read-only root and a non-root user. Frazer verifies the signature at every wake, and an image in use is never deleted.
  • Scans: two vulnerability scanners rescan images in use every day.
  • Placement: Lite and Standard agents may share a fleet host with other organizations’ microVMs; Full and GPU agents always get dedicated hosts. A squad manager may hire on Full or GPU only with a person’s approval.
  • Security Center lists images with their scan state, harness versions and the agents that run them.

Limits and quotas

Section titled “Limits and quotas”
Class vCPU Memory Volume
lite-1 0.5 1 GiB 5 GiB
std-2 2 4 GiB 10 GiB
std-4 4 8 GiB —
full-4 4 16 GiB 50 GiB
full-8 8 32 GiB —
gpu-l4 8 32 GiB, 1 × L4 —
gpu-h100 An H100 slice; see AI and GPUs — —

Memory is never overcommitted.

Pricing

Section titled “Pricing”

An image costs its registry storage while you keep it, and builds are billed as runner-seconds at the runner rate. The tier and class an agent uses set its runtime price; see Frazer Agents pricing. A warm-pool reservation for instant wake is billed per agent per month.

Every line, with the estimator: pricing.

Troubleshooting

Section titled “Troubleshooting”
  • Promotion to prod is refused. A gate failed: the signature, the SBOM, provenance, a fixable critical or high finding, or the smoke eval. Fix the image and build a new version, or record a dated exception for the finding.
  • An agent will not start on an image. The runtime checks the signature at every wake. Build the image through frazer agents images build so it is signed with your project’s key.
  • A harness version is only offered in dev. Its compatibility suite is below 100 %.
  • An agent cannot use a smaller class. The image declares a minimum class. Use a lighter tier, or lower class.min in a new version.
  • A package change does not reach agents. Packages are baked: build and promote a new version. Overlay changes arrive at the next wake.
  • An image cannot be deleted. Agents still use it. Move them to another version first.

Reference

Section titled “Reference”

CLI

CommandWhat it does
frazer agents images buildBuild an image from a spec in an isolated builder, with an SBOM, scans, a signature and a smoke eval.
frazer agents images promoteMove an image version to the dev, staging or prod channel, by digest.

All of them: CLI reference.

The API is frazer.agents.v1, with agent images, image builds, harnesses and agent instances.

Section titled “Related”