Read a Loadout Before You Boot an Agent VM

Read a VM loadout, follow its layers, and check the tools and resources it requests before you boot.

Read a Loadout Before You Boot an Agent VM

You want one agent to write code and a second to review it. What should go into their VM before either tool starts?

Take a quick guess: does a profile called `dual-review` assign those jobs, or does it set up the tools for you to use?

It sets up the tools. Agentic Sandbox's `dual-review` loadout selects Claude Code and Codex, a shared set of development tools, and software workflow files for both. You still decide what each agent should do. The loadout does not start a code-and-review loop.

This guide follows that one setup from the source file to the command that boots it. First, read the complete profile. Then check the full merged plan, including the parts its layers supply. Finally, create the VM and check that setup has finished before you hand over work.

Start with the two-tool profile

A loadout is a YAML file that describes a VM's setup. This one lives at `images/qemu/loadouts/profiles/dual-review.yaml`. The loadout guide uses it for two providers to cross-check work, which fits our task.

The block below is the complete source file, with every original line left as it is. The numbered notes beneath it are this guide's annotations; none of them are part of the YAML.

apiVersion: loadout/v1
kind: loadout
metadata:
  name: dual-review
  description: Two-provider VM for cross-checking (Claude Code + Codex)
  labels:
    category: collaboration
    complexity: standard

extends:
  - layers/base-dev.yaml
  - layers/docker.yaml
  - layers/databases.yaml
  - providers/claude-code.yaml
  - providers/codex.yaml

resources:
  cpus: 4
  memory: 12G
  disk: 60G

network:
  mode: full

aiwg:
  enabled: true
  frameworks:
    - name: sdlc
      providers:
        - claude
        - codex

1. Format and name. `apiVersion` names the manifest format. `kind: loadout` marks a full profile. The name, description, and labels tell you its intended use. They help you choose it without implying that review starts on its own. 2. What it builds on. `extends` lists five files under `images/qemu/loadouts/`. The first adds the base development tools. Docker and database tools follow. The last two select Claude Code and Codex. Read this list as the source of the setup you cannot yet see. 3. Room for the task. `resources` requests four CPUs, 12G of memory, and a 60G disk. These are this profile's settings. They are not measured needs for every coding task. 4. Access beyond the VM. `network.mode: full` means unrestricted outbound access in the loadout guide. Check that this matches the services your project should reach before you boot. 5. Workflow files. `aiwg` asks setup to deploy the `sdlc` software development workflows for both `claude` and `codex`. It does not assign a writer and a reviewer.

The short file now answers which tools you chose and how much space it requests. But it leaves a practical question: what else will those five parent files bring in?

Follow the layers into one plan

The first parent, `layers/base-dev.yaml`, has its own parent: `layers/base-minimal.yaml`. That is why reading only the five names above would miss part of the setup.

The resolver reads parents depth-first, from left to right, then applies the profile. Later single values win. Nested groups merge by key. Nonempty lists of strings are joined, deduplicated, and sorted. Nonempty lists of objects are joined; if either list is empty, the later list wins.

For our VM, the base development layer asks for 8G of memory. The profile changes it to 12G. The base's disabled GPU setting stays in place because the profile does not replace it.

From the product repository root, you can inspect the combined plan with:

cd images/qemu/loadouts
./resolve-manifest.sh profiles/dual-review.yaml

The resolver needs Bash, Python 3, and PyYAML. It prints merged YAML without booting a VM. It also creates temporary files. The complete plan below was derived in memory from the source files and merge rules; it is not captured output from running that shell script.

All keys and values come from the repository. Formatting comes from YAML serialization. The notes after the block are added by this guide.

apiVersion: loadout/v1
kind: loadout
metadata:
  name: dual-review
  description: Two-provider VM for cross-checking (Claude Code + Codex)
  labels:
    category: collaboration
    complexity: standard
resources:
  cpus: 4
  memory: 12G
  disk: 60G
  gpu:
    enabled: false
network:
  mode: full
packages:
- apt-transport-https
- bat
- build-essential
- ca-certificates
- cmake
- curl
- dbus-user-session
- default-mysql-client
- dnsutils
- eza
- fd-find
- file
- fuse-overlayfs
- fzf
- git
- git-delta
- git-lfs
- gnupg
- htop
- jq
- libsecret-1-dev
- libssl-dev
- man-db
- meson
- ncdu
- netcat-openbsd
- ninja-build
- pkg-config
- postgresql-client
- python3
- python3-dev
- python3-venv
- qemu-guest-agent
- ripgrep
- rsync
- slirp4netns
- socat
- sqlite3
- tmux
- tree
- ufw
- uidmap
- unzip
- vim
- wget
- whois
runtimes:
  python:
    enabled: true
    method: uv
    tools:
    - ruff
  node:
    enabled: true
    method: fnm
    version: lts
    package_manager: pnpm
    global_packages:
    - '@openai/[email protected]'
  go:
    enabled: true
    version: latest
    tools:
    - github.com/fullstorydev/grpcurl/cmd/grpcurl@latest
  rust:
    enabled: true
    toolchain: stable
    profile: minimal
    components:
    - clippy
    - rustfmt
    - rust-analyzer
    crates:
    - xh
    - websocat
    - hyperfine
  bun:
    enabled: true
docker:
  enabled: true
  mode: rootless
ai_tools:
  claude_code:
    enabled: true
    channel: stable
    version: 2.1.270
    settings:
      model: claude-sonnet-4-5-20250929
    managed_settings:
      permissions:
        deny:
        - Bash(rm -rf /*)
        allow:
        - Read
        - Edit
        - Write
        - Glob
        - Grep
        - Bash(git *)
        - Bash(cargo *)
        - Bash(npm *)
        - Bash(pnpm *)
        - Bash(go *)
  codex:
    enabled: true
    config:
      model: gpt-4o
      approval_mode: suggest
aiwg:
  enabled: true
  frameworks:
  - name: sdlc
    providers:
    - claude
    - codex

Read the plan as a work environment

Read the merged file from top to bottom with the code-and-review task in mind.

1. Identity, resources, and network. The profile keeps its name and labels. Its CPU, memory, disk, and network settings win. The inherited `gpu.enabled: false` makes clear that this setup does not request GPU passthrough. 2. System packages. `packages` combines the base, development, Docker, and database lists. It includes build tools and tools for finding and reading files. The database layer adds `postgresql-client`, `default-mysql-client`, and `sqlite3`. It does not list PostgreSQL or MySQL server packages, so plan separately if your tests need those servers. 3. Language tools. `runtimes` enables Python through `uv`, Node through `fnm`, Go, Rust, and Bun. The child lists include Python tools, Node packages, Go tools, and Rust components and crates. This is a broad development setup; check that it fits the code you intend to give the agents. 4. Docker. `docker` enables rootless mode. That setting comes from the Docker layer and remains present even though the short profile has no Docker block of its own. 5. Agent tools. `ai_tools` selects both tools and their saved settings. Claude Code has a version, model setting, and managed permission entries. Codex has a model setting and an approval-mode value; its package pin appears above under Node's global packages. These are the source's values, not a recommendation about which model to use today. 6. Workflow setup. `aiwg` still targets both providers. The generator attempts to deploy the requested workflows into the guest user's workspace. A failed deployment logs a warning, so check the setup log before you rely on those files.

The full plan shows what the profile inherits, but it is not a full lockfile. Some entries use fixed versions while others say `lts`, `latest`, or `stable`. It also does not prove that downloads, installs, or tool sign-in will succeed. Those checks belong to the next step.

Boot the VM you just reviewed

Use a host with the VM prerequisites and base image in place. The Getting Started guide covers that preparation. The steps here assume you have completed it.

From the loadouts directory used above, move up to `images/qemu/` and run:

cd ..
./provision-vm.sh agent-02 --loadout profiles/dual-review.yaml --wait-ready

Here, `agent-02` is the VM name. `--loadout` selects the same profile we have read throughout. `--wait-ready` starts the VM, waits for SSH, then checks agent readiness and the profile's setup check when present.

The provisioner resolves the profile and passes it to `generate-from-manifest.sh`. That script turns the plan into cloud-init files for guest setup. You do not need to run the generator by hand for this path.

In a guest shell, check that both tools are on the path:

claude --version
codex --version

A readiness result does not prove that both tools can access your accounts or use the requested models. Check each tool in the guest before you give it project work. If a tool is missing or workflow setup failed, inspect `/var/log/agentic-setup.log` in the guest for the setup messages.

Give the two tools distinct jobs

Once setup is complete and both tools are usable, start with one small change in your project. Give the coding agent a clear goal and a way to check the result. Ask it to explain what it changed and which checks it ran.

Then give the review agent the same goal and the resulting changes. Ask it to look for missed cases, errors, and gaps in the checks. Keep this first review focused on findings before you ask for more edits. This is a suggested way to use the two tools; the loadout itself does not enforce that handoff.

Before you start, recall three parts of the plan: the providers choose the tools, the layers supply their environment, and the profile supplies the final settings. For this example, that means Claude Code and Codex, the inherited development setup, and the profile's 12G memory request.

You now have the full setup to inspect and the command to create it. Use that same `dual-review` profile for your first small code-and-review task, and compare the review findings with the goal you gave the coding agent.