diff --git a/src/agent_env/bundle/__init__.py b/src/agent_env/bundle/__init__.py
index 57290f61d..5c736a577 100644
--- a/src/agent_env/bundle/__init__.py
+++ b/src/agent_env/bundle/__init__.py
@@ -3,6 +3,7 @@
 from .parse import Bundle, BundleEntry, BundleError, BundleKind, is_ignored, parse_bundle
 from .run import (BundleRun, DryRun, EvalRun, Outcome, PreparedBundle, RunInterrupted, TaskRun, dry_run_bundle,
                   prepare_bundle, run_bundle)
+from .variants import Variant
 
 __all__ = [
     "Bundle",
@@ -16,6 +17,7 @@
     "PreparedBundle",
     "RunInterrupted",
     "TaskRun",
+    "Variant",
     "dry_run_bundle",
     "is_ignored",
     "parse_bundle",
diff --git a/src/agent_env/bundle/plan.py b/src/agent_env/bundle/plan.py
index 4dda85f85..9ec3aca68 100644
--- a/src/agent_env/bundle/plan.py
+++ b/src/agent_env/bundle/plan.py
@@ -66,6 +66,7 @@
 from ._fs import fold, relative, with_article
 from .authoring import AuthoringContext, entry_files, staged_build_context
 from .parse import NAMED_BY, Bundle, BundleEntry, BundleError, BundleKind, parse_bundle
+from .variants import Varied
 from .resolve import (BuiltImage, BundleImage, Reference, ResolvedBundle, ResolvedEntry, build_step, entity_class,
                       resolve_bundle)
 
@@ -194,6 +195,7 @@ class Plan:
     # Each alias the run names, by the kind it names and then by alias.
     alias_uses: Mapping[EntityKind, Mapping[str, AliasUse]] = field(default_factory=dict)
     agent: AgentOverride | None = None  # the agent --agent names for the solver
+    variant: Varied | None = None  # what --set changes, written under its variant's ids
 
     def bundle_of(self, entry: BundleEntry) -> Bundle:
         """The bundle ``entry`` comes from: the installed one for an entry pulled in from one, else the run's."""
diff --git a/src/agent_env/bundle/register.py b/src/agent_env/bundle/register.py
index c65abfaa1..ca983e069 100644
--- a/src/agent_env/bundle/register.py
+++ b/src/agent_env/bundle/register.py
@@ -225,7 +225,7 @@ def _slug(name: str) -> str:
 
 # The fields of a Plan that hold no ``@local`` id, so a translated plan keeps them: the store's latest versions, by store
 # id, and the agent ``--agent`` names, which a registration plans without.
-_KEPT = frozenset({"store_latest", "agent"})
+_KEPT = frozenset({"store_latest", "agent", "variant"})
 
 
 def translated(plan: Plan, ids: Mapping[str, str]) -> Plan:
diff --git a/src/agent_env/bundle/run.py b/src/agent_env/bundle/run.py
index 3d5d94f25..0ad85b9f4 100644
--- a/src/agent_env/bundle/run.py
+++ b/src/agent_env/bundle/run.py
@@ -18,6 +18,7 @@
 import shlex
 import time
 import uuid
+from collections import Counter
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, replace
 from enum import Enum
@@ -45,6 +46,7 @@
 from .requires import Declaring, declare, declaring_for
 from .resolve import (BuiltImage, BundleImage, Reference, ReferencedImage, ResolvedEntry, resolve_bundle,
                       without_played_agents)
+from .variants import Variant, with_variant
 
 logger = logging.getLogger(__name__)
 
@@ -220,6 +222,7 @@ def run_bundle(
     keep: bool = False,
     emulate: bool = True,
     source: HubSource | None = None,
+    variant: Variant | None = None,
 ) -> BundleRun:
     """Write what the tasks and evals selected in ``root`` need, as ``plan_bundle`` selects them, then run
     each of their tasks once. ``model``, ``user_model`` and ``judge_model`` replace the models the solver, the
@@ -231,7 +234,8 @@ def run_bundle(
     at each write and step. ``id_root`` roots the ids of a bundle an installed package provides
     (``InstalledBundle.id_root``) or one downloaded from the Hub (``HubBundle.id_root``); a folder's ids otherwise come
     from its path. ``source`` says where a Hub bundle came from (``HubBundle.source``), which each run's context
-    records under ``metadata["bundle_source"]``.
+    records under ``metadata["bundle_source"]``. ``variant`` sets env keys for this run (``with_variant``), writing
+    what it changes under ids of their own and leaving the bundle as written.
 
     Each run's sandboxes are torn down as it ends, so the contexts returned record sandboxes that are gone.
     ``keep`` leaves them up instead, for the caller to use and then remove with ``BundleRun.teardown()``.
@@ -253,7 +257,8 @@ def run_bundle(
     say = _progress(on_progress)
     with namespace_routing():
         prepared = _prepare(root, tasks, evals, sandbox, id_root, agent, False, say,
-                            declaring_for(Path(root), installed=id_root is not None, dry_run=False), composing)
+                            declaring_for(Path(root), installed=id_root is not None, dry_run=False), composing,
+                            variant=variant)
         plan, entries = prepared.plan, [entry for entry, _ in prepared.tasks]
         with Interrupts() as interrupts:
             overrides = _overrides(sandbox, user_model, judge_model)
@@ -339,6 +344,7 @@ def dry_run_bundle(
     on_progress: Callable[[str], None] | None = None,
     id_root: str | None = None,
     emulate: bool = True,
+    variant: Variant | None = None,
 ) -> DryRun:
     """Check what ``run_bundle`` with these arguments checks before its first task runs, and say what it would
     write and run, writing and running nothing: no entity, ledger row, lock or instance. Each write's version is
@@ -352,7 +358,7 @@ def dry_run_bundle(
     composing = _composing(sandbox, emulate)
     say = _progress(on_progress)
     with namespace_routing():
-        plan, preflight = _planned(root, tasks, evals, id_root, sandbox, agent)
+        plan, preflight = _planned(root, tasks, evals, id_root, sandbox, agent, variant=variant)
         _say_plan(plan, say, declaring_for(Path(root), installed=id_root is not None, dry_run=True))
         materialization = materialize(plan, dry_run=True, on_write=lambda done: say(_written(plan, done)),
                                       composing=composing, sandbox=sandbox,
@@ -385,9 +391,10 @@ def _bundle_run(plan: Plan, materialization: Materialization, runs: tuple[TaskRu
 
 def _prepare(root: Path | str, tasks: Sequence[str], evals: Sequence[str], sandbox: str | None, id_root: str | None,
              agent: str | None, played: bool, say: Callable[[str], None], declaring: Declaring,
-             composing: Composing = Composing(), *, solver_endpoint: bool = False) -> PreparedBundle:
+             composing: Composing = Composing(), *, solver_endpoint: bool = False,
+             variant: Variant | None = None) -> PreparedBundle:
     plan, preflight = _planned(root, tasks, evals, id_root, sandbox, agent, played=played,
-                               solver_endpoint=solver_endpoint)
+                               solver_endpoint=solver_endpoint, variant=variant)
     _say_plan(plan, say, declaring)
     materialization = _written_with_infra(plan, preflight, say, composing, sandbox)
     to_run = tuple((entry, Task.get(entry.id, materialization.version_of("task", entry.id))) for entry in _to_run(plan))
@@ -396,11 +403,19 @@ def _prepare(root: Path | str, tasks: Sequence[str], evals: Sequence[str], sandb
 
 def _planned(root: Path | str, tasks: Sequence[str], evals: Sequence[str], id_root: str | None,
              sandbox: str | None, agent: str | None = None, *, played: bool = False,
-             solver_endpoint: bool = False) -> tuple[Plan, Preflight]:
-    resolved = resolve_bundle(parse_bundle(Path(root), id_root=id_root))
+             solver_endpoint: bool = False, variant: Variant | None = None) -> tuple[Plan, Preflight]:
+    bundle = parse_bundle(Path(root), id_root=id_root)
+    varied = with_variant(bundle, variant) if variant is not None else None
+    if varied is not None:
+        tasks, evals = varied.selected(tasks, BundleKind.TASK), varied.selected(evals, BundleKind.EVAL)
+    resolved = resolve_bundle(varied.bundle if varied is not None else bundle)
     plan = plan_bundle(without_played_agents(resolved) if played else resolved, tasks=tasks, evals=evals,
                        installed=installed_bundles, agent=agent)
     refuse_store_tasks(plan)
+    if varied is not None:
+        plan = replace(plan, variant=varied)
+        if not _changed(plan):
+            raise BundleError([f"{variant.typed}: none of the tasks this run selects deploys an env it changes"])
     to_run = set(_to_run(plan))
     return plan, preflight_run(plan, [write.source for write in plan.writes
                                       if write.kind is BundleKind.TASK and write.source.entry in to_run], sandbox,
@@ -452,8 +467,9 @@ def refuse_store_tasks(plan: Plan) -> None:
 
 
 def _say_plan(plan: Plan, say: Callable[[str], None], declaring: Declaring) -> None:
-    """Say what each agent, env and artifact alias names, what the solver deploys in place of the tasks' agents, and
-    what plugin packages the bundle uses that its bundle.toml doesn't require, as ``declaring`` says (``declare``)."""
+    """Say what each agent, env and artifact alias names, what the solver deploys in place of the tasks' agents, the
+    ids what --set changes is written under, and what plugin packages the bundle uses that its bundle.toml doesn't
+    require, as ``declaring`` says (``declare``)."""
     for use in (use for uses in plan.alias_uses.values() for use in uses.values()):
         say(_aliased(use))
     if plan.agent is not None:
@@ -461,10 +477,22 @@ def _say_plan(plan: Plan, say: Callable[[str], None], declaring: Declaring) -> N
         solved = sum(entry.id in plan.agent.steps for entry in runs)
         say(f"--agent {plan.agent.name}: the solver deploys {plan.agent.agent_id}, in {solved} of {len(runs)} "
             f"task{'s' if len(runs) != 1 else ''}")
+    if plan.variant is not None:
+        variant = plan.variant.variant
+        say(f"{variant.typed}: {_changed(plan)} written under ids ending in ({variant.label})")
     for line in declare(plan.bundle, declaring):
         say(line)
 
 
+def _changed(plan: Plan) -> str:
+    """How many envs, tasks and evals that --set changes the run writes: ``1 env and 2 tasks``, or ``""``."""
+    counts = Counter(write.kind for write in plan.writes
+                     if isinstance(write.source, ResolvedEntry) and plan.variant.changes(write.kind, write.id))
+    named = [f"{counts[kind]} {noun}{'s' if counts[kind] != 1 else ''}" for kind, noun in (
+        (BundleKind.ENV, "env"), (BundleKind.TASK, "task"), (BundleKind.EVAL, "eval")) if counts[kind]]
+    return " and ".join([", ".join(named[:-1]), named[-1]] if len(named) > 1 else named)
+
+
 def _hint(id_root: str | None) -> Declaring:
     """How a service writing a bundle declares its plugins: nothing for an installed bundle, else a hint."""
     return Declaring.QUIET if id_root is not None else Declaring.HINT
diff --git a/src/agent_env/bundle/variants.py b/src/agent_env/bundle/variants.py
new file mode 100644
index 000000000..ce13272d8
--- /dev/null
+++ b/src/agent_env/bundle/variants.py
@@ -0,0 +1,194 @@
+"""Run-only variants for ``agent-env run --set envs/NAME.KEY=VALUE``: the bundle as parsed, with env keys set for one
+run. Each env changed, each env and task that names one, and each eval that names such a task is written under a
+derived id, so a variant is written and composed beside the bundle's own. Entries keep their names, so every reference to
+one by name reaches its variant; the bundle's files stay as written."""
+from __future__ import annotations
+
+import copy
+import hashlib
+import tomllib
+from collections.abc import Iterator, Mapping, Sequence
+from dataclasses import dataclass, replace
+from typing import Any
+
+from agent_env.entity.refs import EntityKind, EntityRef, RefSite, ref_sites
+from agent_env.task_step.registry import get_task_step_registry
+
+from .parse import Bundle, BundleEntry, BundleError, BundleKind, segment_problem
+from .resolve import entity_class
+
+_TARGET = f"{BundleKind.ENV.value}/"
+_FORM = "envs/NAME.KEY=VALUE, such as envs/desktop.driver=cua-driver"
+#: The keys that say what an entry is rather than how it's set, which a run can't change.
+_FIXED = ("type", "id")
+
+
+@dataclass(frozen=True)
+class Variant:
+    """The ``--set`` settings of a run, as typed: ``envs/NAME.KEY=VALUE``, KEY of the env in folder ``envs/NAME``,
+    dotted into a table, set to VALUE, TOML or a bare word."""
+
+    settings: tuple[str, ...]
+
+    @property
+    def label(self) -> str:
+        """The settings as ids end in them: ``desktop.driver cua-driver, desktop.display 3f2a9c1e``, a value an id can't
+        hold hashed."""
+        return ", ".join(f"{key.removeprefix(_TARGET)} {_shown(raw)}"
+                         for key, raw in (setting.partition("=")[::2] for setting in self.settings))
+
+    @property
+    def typed(self) -> str:
+        """The settings as the command line gives them."""
+        return " ".join(f"--set {setting}" for setting in self.settings)
+
+
+@dataclass(frozen=True)
+class Varied:
+    """A bundle with a variant's settings: ``bundle``, and ``renamed``, each entry it changes, by kind and id, to its
+    variant's id."""
+
+    variant: Variant
+    bundle: Bundle
+    renamed: Mapping[tuple[BundleKind, str], str]
+
+    def changes(self, kind: BundleKind, entry_id: str) -> bool:
+        """Whether ``entry_id`` is the variant's id of an entry of ``kind`` it changes."""
+        return entry_id in {new for (of, _), new in self.renamed.items() if of is kind}
+
+    def selected(self, names: Sequence[str], kind: BundleKind) -> tuple[str, ...]:
+        """``names``, a run's selections of ``kind`` by name or id, each id of an entry it changes as its variant's."""
+        return tuple(self.renamed.get((kind, name), name) for name in names)
+
+
+@dataclass(frozen=True)
+class _Setting:
+    env: str  # the env it sets, by name
+    path: tuple[str, ...]
+    value: Any
+
+
+def with_variant(bundle: Bundle, variant: Variant) -> Varied:
+    """``bundle`` with ``variant``'s settings in its envs' tomls, and each entry that changes under an id ending in
+    ``(<label>)``. Raises BundleError for a setting that isn't ``envs/NAME.KEY=VALUE`` or names no env of the bundle; the
+    env's type checks the key and value as it checks an env.toml's."""
+    by_name = {entry.name: entry for entry in bundle.entries if entry.kind is BundleKind.ENV}
+    configs = {}  # each env's toml with its settings, by kind and id, as an id is unique within its kind alone
+    for setting in _parsed(variant.settings, set(by_name)):
+        key = (BundleKind.ENV, by_name[setting.env].id)
+        configs[key] = _set(configs.get(key, by_name[setting.env].config), setting.path, setting.value)
+    renamed = _renamed_ids(bundle, {entry_id for _, entry_id in configs}, variant.label)
+    envs, tasks = ({entry_id: new for (kind, entry_id), new in renamed.items() if kind is of}
+                   for of in (BundleKind.ENV, BundleKind.TASK))
+    renaming = {EntityKind.ENV: envs, EntityKind.TASK: tasks}
+    entries = []
+    for entry in bundle.entries:
+        new_id = renamed.get((entry.kind, entry.id))
+        if new_id is None:
+            entries.append(entry)
+        else:
+            config = configs.get((entry.kind, entry.id), entry.config)
+            entries.append(_renamed(entry, new_id, _repointed(entry, config, renaming)))
+    return Varied(variant, replace(bundle, entries=tuple(entries)), renamed)
+
+
+def _parsed(texts: tuple[str, ...], names: set[str]) -> list[_Setting]:
+    settings, problems = [], []
+    for text in texts:
+        key, equals, raw = text.partition("=")
+        if not equals or not key.startswith(_TARGET) or "." not in key:
+            problems.append(f"--set {text}: expected {_FORM}")
+            continue
+        env = max((name for name in names if key.startswith(f"{_TARGET}{name}.")), key=len, default=None)
+        if env is None:
+            problems.append(f"--set {text}: {key.partition('.')[0]} names no env of this bundle")
+            continue
+        path = tuple(key.removeprefix(f"{_TARGET}{env}.").split("."))
+        if not all(path):
+            problems.append(f"--set {text}: expected {_FORM}")
+            continue
+        if path[0] in _FIXED:
+            problems.append(f"--set {text}: an env's {path[0]} says what it is, so a run can't set it")
+            continue
+        settings.append(_Setting(env, path, _value(raw)))
+    if problems:
+        raise BundleError(problems)
+    return settings
+
+
+def _value(raw: str) -> Any:
+    """``raw`` as a TOML value, or as the string it is when it isn't one, so ``cua-driver`` needs no quotes."""
+    try:
+        return tomllib.loads(f"value = {raw}")["value"]
+    except tomllib.TOMLDecodeError:
+        return raw
+
+
+def _shown(raw: str) -> str:
+    return raw if raw and segment_problem(raw) is None else hashlib.sha256(raw.encode()).hexdigest()[:8]
+
+
+def _set(config: dict, path: tuple[str, ...], value: Any) -> dict:
+    config = copy.deepcopy(config)
+    table = config
+    for key in path[:-1]:
+        if not isinstance(table.get(key), dict):
+            table[key] = {}
+        table = table[key]
+    table[path[-1]] = value
+    return config
+
+
+def _renamed_ids(bundle: Bundle, changed: set[str], label: str) -> dict[tuple[BundleKind, str], str]:
+    """Each entry that changes, by kind and id, to its variant's id: the envs ``changed``, each env and task naming one
+    that changes, by name or id, and each eval naming such a task. An id is unique within its kind alone."""
+    by_name = {(entry.kind, entry.name): entry.id for entry in bundle.entries}
+    envs = set(changed)
+    while more := {entry.id for entry in bundle.entries if entry.kind is BundleKind.ENV and entry.id not in envs
+                   and _names(entry, EntityKind.ENV, envs, by_name)}:
+        envs |= more
+    tasks = {entry.id for entry in bundle.entries if entry.kind is BundleKind.TASK
+             and _names(entry, EntityKind.ENV, envs, by_name)}
+    evals = {entry.id for entry in bundle.entries if entry.kind is BundleKind.EVAL
+             and _names(entry, EntityKind.TASK, tasks, by_name)}
+    return {(kind, entry_id): f"{entry_id}({label})"
+            for kind, ids in ((BundleKind.ENV, envs), (BundleKind.TASK, tasks), (BundleKind.EVAL, evals))
+            for entry_id in ids}
+
+
+def _names(entry: BundleEntry, kind: EntityKind, ids: set[str], by_name: dict) -> bool:
+    """Whether ``entry`` names one of ``ids``, entries of ``kind``, by its name or id."""
+    of = {EntityKind.ENV: BundleKind.ENV, EntityKind.TASK: BundleKind.TASK}[kind]
+    return any(by_name.get((of, site.value), site.value) in ids for site in _sites(entry, entry.config) if site.ref.kind is kind)
+
+
+def _sites(entry: BundleEntry, config: Any) -> Iterator[RefSite]:
+    """Each entity ``config``, ``entry``'s steps or toml, names by a name or id, as a site it can be rewritten at, as the
+    resolver reads them."""
+    if entry.kind is BundleKind.TASK:
+        sites = (site for step in config for site in ref_sites(_step_refs(step), step))
+    else:
+        sites = ref_sites(getattr(entity_class(entry), "toml_refs", ()), config, inline_pins=True)
+    return (site for site in sites if isinstance(site.value, str))
+
+
+def _step_refs(step: dict) -> tuple[EntityRef, ...]:
+    cls = get_task_step_registry().get(step["type"]) if isinstance(step.get("type"), str) else None
+    return (cls.entity_refs or ()) if cls is not None else ()
+
+
+def _renamed(entry: BundleEntry, new_id: str, config: Any) -> BundleEntry:
+    """``entry`` under ``new_id`` with ``config``, whose declared id, when it has one, is that id too."""
+    if isinstance(config, dict) and "id" in config:
+        config = {**config, "id": new_id}
+    return replace(entry, id=new_id, config=config)
+
+
+def _repointed(entry: BundleEntry, config: Any, renaming: dict[EntityKind, dict[str, str]]) -> Any:
+    """``config``, ``entry``'s steps or toml, with each env or task it names by an id that changes named by its variant's
+    id."""
+    config = copy.deepcopy(config)
+    for site in _sites(entry, config):
+        if site.value in renaming.get(site.ref.kind, {}):
+            site.rewrite(renaming[site.ref.kind][site.value], site.version)
+    return config
diff --git a/src/agent_env/cli/run.py b/src/agent_env/cli/run.py
index 85f22f82f..5052e5209 100644
--- a/src/agent_env/cli/run.py
+++ b/src/agent_env/cli/run.py
@@ -11,7 +11,7 @@
 
 import click
 
-from agent_env.bundle import (BundleError, BundleKind, BundleRun, DryRun, Outcome, RunInterrupted, TaskRun,
+from agent_env.bundle import (BundleError, BundleKind, BundleRun, DryRun, Outcome, RunInterrupted, TaskRun, Variant,
                               dry_run_bundle, run_bundle)
 from agent_env.bundle.hub import SOURCE_KEY, HubSource
 from agent_env.bundle.installed import (InstalledBundle, checked, find_bundle, installed_bundles, locate_bundle,
@@ -43,6 +43,10 @@
 @click.option("--agent", default=None,
               help="The agent the solver runs as, whatever the tasks name: an alias such as pi, an agent of this "
                    "bundle or an installed one, or the store's.")
+@click.option("--set", "settings", multiple=True, metavar="envs/NAME.KEY=VALUE",
+              help="Set a key of one of the bundle's envs for this run, as envs/NAME.KEY=VALUE, whatever its env.toml "
+                   "says: VALUE is TOML or a bare word, and KEY may be dotted into a table. Repeatable. Such as "
+                   "envs/desktop.driver=cua-driver or envs/desktop.tools=standard.")
 @click.option("--sandbox", default=None,
               help="The sandbox provider envs, agents, sandboxes and the judge deploy on, which picks the forms "
                    "computer envs compose on this machine; comma-separated for a fallback chain.")
@@ -56,8 +60,8 @@
                    "natively; a later run or env build builds it.")
 @click.pass_context
 def run(ctx: click.Context, bundle: str | None, tasks: tuple[str, ...], evals: tuple[str, ...], model: str | None,
-        user_model: str | None, judge_model: str | None, agent: str | None, sandbox: str | None, keep: bool,
-        dry_run: bool, no_emulate: bool):
+        user_model: str | None, judge_model: str | None, agent: str | None, settings: tuple[str, ...],
+        sandbox: str | None, keep: bool, dry_run: bool, no_emulate: bool):
     """Run a bundle's tasks and evals, or list the installed bundles.
 
     BUNDLE is a folder, the name of a bundle an installed package provides (PACKAGE/NAME when several
@@ -80,6 +84,15 @@ def run(ctx: click.Context, bundle: str | None, tasks: tuple[str, ...], evals: t
     agent the solver runs as: each step that deploys or installs the agent a task prompts deploys it instead,
     while its user simulator and judges keep theirs.
 
+    --set sets a key of one of the bundle's envs for this run, as its env.toml would: --set
+    envs/desktop.driver=cua-driver runs the env in envs/desktop with that driver, and --set
+    envs/desktop.computer=ubuntu-24.04-headless composes it on that base. The envs it changes, the envs and tasks
+    that name them and the evals that name those tasks are written under ids of their own, ending in the settings,
+    such as desktop(desktop.driver cua-driver), and compose and reuse their images as any env does, leaving the
+    bundle as written. A key or value the env's type refuses, or a run whose tasks deploy no env it changes, is
+    refused before anything is written; a driver and computer that can't compose, as the run writes the env, before
+    any task runs.
+
     --dry-run makes the checks the run makes before its first task, reading the stores as the run does, and
     prints what it would write and run, writing and running nothing. It exits 1 on a problem the run would
     stop at, and 0 otherwise; the models and --keep change nothing it shows, and --agent what it writes and checks
@@ -91,23 +104,27 @@ def run(ctx: click.Context, bundle: str | None, tasks: tuple[str, ...], evals: t
     exits 130 (143 for SIGTERM); a second one stops the teardown and prints what is still up.
     """
     if bundle is None:
-        if tasks or evals or model or user_model or judge_model or agent or sandbox or keep or dry_run or no_emulate:
-            raise click.UsageError("--task, --eval, --model, --user-model, --judge-model, --agent, --sandbox, --keep, "
-                                   "--dry-run and --no-emulate need a BUNDLE to run")
+        if tasks or evals or model or user_model or judge_model or agent or settings or sandbox or keep or dry_run \
+                or no_emulate:
+            raise click.UsageError("--task, --eval, --model, --user-model, --judge-model, --agent, --set, --sandbox, "
+                                   "--keep, --dry-run and --no-emulate need a BUNDLE to run")
         _list_installed()
         return
     verbose = ctx.find_root().params.get("verbose")
+    variant = Variant(settings) if settings else None
     root = id_root = hub = None
     try:
         root, id_root, hub = locate_bundle(bundle, _installed, on_progress=click.echo)
         if dry_run:
             click.echo(_DRY_RUN)
             _report_dry_run(dry_run_bundle(root, tasks=tasks, evals=evals, sandbox=sandbox, agent=agent,
-                                           on_progress=click.echo, id_root=id_root, emulate=not no_emulate))
+                                           on_progress=click.echo, id_root=id_root, emulate=not no_emulate,
+                                           variant=variant))
             return
         result = run_bundle(root, tasks=tasks, evals=evals, model=model, user_model=user_model,
                             judge_model=judge_model, agent=agent, sandbox=sandbox, on_progress=click.echo,
-                            id_root=id_root, keep=keep, emulate=not no_emulate, source=hub.source if hub else None)
+                            id_root=id_root, keep=keep, emulate=not no_emulate, source=hub.source if hub else None,
+                            variant=variant)
     except BundleError as e:
         if root is not None:
             _note_an_installed_namesake(e, bundle, root, id_root)
diff --git a/src/agent_env/computers/README.md b/src/agent_env/computers/README.md
index a8fff484e..b6572c071 100644
--- a/src/agent_env/computers/README.md
+++ b/src/agent_env/computers/README.md
@@ -1,4 +1,6 @@
 Base computers that come with agent-env, each a `computer` artifact a computer env composes a driver and apps onto.
+`agent-env run <bundle> --set envs/desktop.computer=ubuntu-24.04-headless` composes a bundle's `desktop` env on
+another of them for one run, the bundle left as written.
 
 `artifacts/ubuntu-24.04/` is Ubuntu 24.04 (`amd64` and `arm64`) with XFCE on Xvfb, D-Bus and AT-SPI. tini starts
 supervisord, which runs every program as the session user, `user` (uid 1000); nothing in it runs as root. Its home
diff --git a/src/agent_env/drivers/README.md b/src/agent_env/drivers/README.md
index b1a464fb1..23806bb06 100644
--- a/src/agent_env/drivers/README.md
+++ b/src/agent_env/drivers/README.md
@@ -1,4 +1,9 @@
 Computer drivers that come with agent-env, each a `computer_driver` env a computer env serves its tools through.
+A computer env's `tools` is what its agents get: `standard`, AgentEnv's `computer_*` tools alone;
+`driver`, the driver's own alone; or `both`, the default. `agent-env run <bundle> --set envs/desktop.driver=cua-driver`
+runs a bundle's `desktop` env with another driver for one run, and `--set envs/desktop.tools=driver` gives its agents
+the driver's own tools; the bundle stays as written, and what changes is written under ids ending in the settings,
+such as `desktop(desktop.driver cua-driver)`.
 
 `envs/reference/` is the reference driver, for an X11 desktop on Linux (`amd64` and `arm64`): `mss` captures the
 screen and XTEST, through `python-xlib`, sends the input, foreground only. It serves the seven `computer_*` tools, the
diff --git a/src/agent_env/drivers/aliases.toml b/src/agent_env/drivers/aliases.toml
index d5e9aa401..f53cc16c2 100644
--- a/src/agent_env/drivers/aliases.toml
+++ b/src/agent_env/drivers/aliases.toml
@@ -1,4 +1,4 @@
-# Ids a task, or --driver, can name these drivers by; a store's env of the id wins over an alias.
+# Ids a task, or --set envs/<name>.driver=, can name these drivers by; a store's env of the id wins over an alias.
 [envs]
 reference = ["reference"]
 cua-driver = ["cua-driver"]
diff --git a/src/agent_env/env/envs/_deployment.py b/src/agent_env/env/envs/_deployment.py
index 7659455b0..95c8450c6 100644
--- a/src/agent_env/env/envs/_deployment.py
+++ b/src/agent_env/env/envs/_deployment.py
@@ -7,6 +7,7 @@
 import inspect
 import logging
 import uuid
+from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Optional
 
 from agentenv_protocol import DATA_OBJECTS_EXTENSION_URI, METHOD_ADD, METHOD_RESET, RPC_PATH, FilePart, client as protocol_v1
@@ -31,8 +32,10 @@
 
 
 async def deploy_through_provider(env: Env, *, environment_name: str | None, ttl_seconds: int, sandbox_type: str | None,
+                                  then: Callable[[DeployedEnv], Awaitable[None]] | None = None,
                                   **options) -> DeployedEnv:
-    """Deploy env through the provider its env_provider_type names and register the record, the way each built-in env deploys.
+    """Deploy env through the provider its env_provider_type names, await ``then`` on the deployment, whose failure fails the
+    deploy, and register the record, the way each built-in env deploys.
 
     The env's provider deploys it the first time; a deploy of an env that already has a deployment gets a provider of its own,
     so that a failure closes only what it started and leaves the earlier deployment as it was. A deploy onto the env state
@@ -68,6 +71,8 @@ async def deploy_through_provider(env: Env, *, environment_name: str | None, ttl
         else:
             check_plugin_record(env, deployed)
         env._gateway_url = gateway_url_of(deployed)
+        if then is not None:
+            await then(deployed)
         deployed = register_env_instance(deployed, ttl_seconds)
         env._instance_id = deployed.instance_id
         env._deployed, env._replaced = deployed, replaced
diff --git a/src/agent_env/env/envs/computer/env.py b/src/agent_env/env/envs/computer/env.py
index 8006d7d91..211ccca72 100644
--- a/src/agent_env/env/envs/computer/env.py
+++ b/src/agent_env/env/envs/computer/env.py
@@ -13,6 +13,10 @@
 
 from agentenv_protocol import METHOD_ADD, RPC_PATH
 from agentenv_protocol import client as protocol_v1
+from agentenv_protocol.computer.tools import Tools
+from agentenv_protocol.tool_access import (DISABLE, DISABLE_TOOL_EXTENSION_URI, ENABLE, ENABLE_TOOL_EXTENSION_URI,
+                                           WILDCARD)
+from agentenv_protocol.tool_context import DEFAULT_ROLE
 
 from agent_env.artifact.artifacts.computer import ComputerArtifact, SettingValue
 from agent_env.attribution import Attribution
@@ -56,6 +60,13 @@
 #: The statuses of a build a deploy boots, by form: a disk may also boot unprobed, as KVM is where a disk is probed, and
 #: so may a VM bundle, which a Mac probes.
 _DEPLOYABLE = {"container": ("ready",), "disk": ("ready", "unverified"), "vm_bundle": ("ready", "unverified")}
+#: Every ``computer_*`` tool a driver can serve.
+COMPUTER_TOOLS = tuple(sorted(name for name in vars(Tools) if name.startswith("computer_")))
+#: What a computer env's ``tools`` gives its agents, as the tool-access changes a deploy makes for them: ``standard``,
+#: AgentEnv's ``computer_*`` tools alone; ``driver``, the driver's own alone; ``both``, every tool it serves.
+TOOLS = {"standard": ((DISABLE, [WILDCARD]), (ENABLE, list(COMPUTER_TOOLS))), "driver": ((DISABLE, list(COMPUTER_TOOLS)),),
+         "both": ()}
+_TOOL_ACCESS_URIS = {DISABLE: DISABLE_TOOL_EXTENSION_URI, ENABLE: ENABLE_TOOL_EXTENSION_URI}
 
 
 class ComputerEnv(Env):
@@ -70,11 +81,12 @@ class ComputerEnv(Env):
     def __init__(self, id: str, version: Optional[int], environment_name: str, computer: ComputerArtifact,
                  driver: ComputerDriverEnv, display: Optional[dict] = None, network: Optional[dict] = None,
                  computer_settings: Optional[dict[str, SettingValue]] = None, metadata: Optional[dict[str, Any]] = None,
-                 apps: Optional[list[ComputerAppEnv]] = None, app_settings: Optional[dict[str, dict]] = None):
+                 apps: Optional[list[ComputerAppEnv]] = None, app_settings: Optional[dict[str, dict]] = None,
+                 tools: Optional[str] = None):
         super().__init__(id, version, metadata=metadata)
         self.environment_name = environment_name
         self.computer, self.driver, self.apps = computer, driver, apps or []
-        self.display, self.network = display, network
+        self.display, self.network, self.tools = display, network, tools
         self.computer_settings = computer_settings or {}
         self.app_settings = app_settings or {}
         self._sandbox = None
@@ -89,6 +101,7 @@ def to_dict(self) -> dict:
                 "computer": {"id": self.computer.id, "version": self.computer.version},
                 "driver": {"id": self.driver.id, "version": self.driver.version}, "display": self.display,
                 "network": self.network, "computer_settings": self.computer_settings,
+                **({"tools": self.tools} if self.tools else {}),
                 **({"apps": [{"id": app.id, "version": app.version,
                               **({"settings": own} if (own := self.app_settings.get(app.environment_name)) else {})}
                              for app in self.apps]} if self.apps else {})}
@@ -106,21 +119,21 @@ def from_dict(cls, data: dict) -> ComputerEnv:
                    display=data.get("display"), network=data.get("network"),
                    computer_settings=data.get("computer_settings"), metadata=data.get("metadata") or {}, apps=apps,
                    app_settings={app.environment_name: ref["settings"] for app, ref in zip(apps, refs)
-                                 if ref.get("settings")})
+                                 if ref.get("settings")}, tools=data.get("tools"))
 
     @classmethod
     def put(cls, *, id: str, computer: ComputerArtifact, driver: ComputerDriverEnv, environment_name: str,
             apps: Any = (), display: Any = None, network: Any = None, computer_settings: Any = None,
-            app_settings: Optional[dict[str, dict]] = None, compose: bool = True,
+            app_settings: Optional[dict[str, dict]] = None, tools: Optional[str] = None, compose: bool = True,
             composing: Composing = Composing()) -> Self:
         """Write a computer env of ``computer``, ``driver`` and ``apps``, computer app envs built into it in their
-        order, with ``app_settings``, defaults for some of their settings by app name, once gate 1 passes, then compose
-        it as ``composing`` says unless ``compose`` is False. Refused, naming every mismatch, before anything is
-        stored."""
+        order, with ``app_settings``, defaults for some of their settings by app name, and ``tools``, which of them its
+        agents get (``TOOLS``), once gate 1 passes, then compose it as ``composing`` says unless ``compose`` is False.
+        Refused, naming every mismatch, before anything is stored."""
         apps, app_settings = list(apps), app_settings or {}
         values, problems = gate.check(computer, driver, environment_name=environment_name, apps=apps, display=display,
                                       network=network, computer_settings=computer_settings or {})
-        problems += gate.check_screen(driver, apps)
+        problems += gate.check_screen(driver, apps) + _tools_problems(tools)
         by_name = {app.environment_name: app for app in apps}
         for name, defaults in app_settings.items():
             problems += ([f"apps.{name}.settings: {id} has no app {name!r}"] if name not in by_name else
@@ -130,7 +143,7 @@ def put(cls, *, id: str, computer: ComputerArtifact, driver: ComputerDriverEnv,
             raise ValueError(f"computer env {id!r}: " + "; ".join(problems))
         env = get_env_store().put_document(cls(
             id=id, version=None, environment_name=environment_name, computer=computer, driver=driver, apps=apps,
-            display=display, network=network, computer_settings=values, app_settings=app_settings))
+            display=display, network=network, computer_settings=values, app_settings=app_settings, tools=tools))
         if compose:
             composer.compose(env, composing=composing)
         return env
@@ -152,12 +165,13 @@ def from_toml(cls, data: dict, ctx: AuthoringContext) -> ComputerEnv:
     @classmethod
     def accept_toml(cls, data: dict, ctx: AuthoringContext) -> dict:
         """The keys of ``data``, an env.toml, a computer env takes: the ``computer`` and ``driver`` it's composed of,
-        both required, its ``apps``, ``display``, ``network`` and ``computer_settings``, and ``environment_name``, the
-        folder's when it sets none. Raises BundleError listing every problem."""
+        both required, its ``apps``, ``display``, ``network``, ``computer_settings`` and ``tools``, and
+        ``environment_name``, the folder's when it sets none. Raises BundleError listing every problem."""
         fields, refused = ctx.accepted(data, environment_name=str, computer=object, driver=object, apps=list,
-                                       display=dict, network=dict, computer_settings=dict)
+                                       display=dict, network=dict, computer_settings=dict, tools=str)
         missing = [ctx.config_problem(f"{key} is required: the {what}, such as {example}") for key, what, example in (
             ("computer", "base computer", '"ubuntu-24.04"'), ("driver", "driver", '"reference"')) if key not in data]
+        refused += [ctx.config_problem(problem) for problem in _tools_problems(fields.get("tools"))]
         if refused or missing:
             ctx.refuse([*refused, *missing])
         return {"environment_name": ctx.name, **fields}
@@ -260,7 +274,7 @@ async def deploy(self, ttl_seconds: int = 10800, disk_size_gb: float = 10,
                      env_params: Optional[dict] = None) -> DeployedEnv:
         return await deploy_through_provider(
             self, environment_name=self.environment_name, ttl_seconds=ttl_seconds, sandbox_type=sandbox_type,
-            disk_size_gb=disk_size_gb, gateway_mode=gateway_mode, cpu=cpu, memory_mb=memory_mb,
+            then=self._give_tools, disk_size_gb=disk_size_gb, gateway_mode=gateway_mode, cpu=cpu, memory_mb=memory_mb,
             env_state_type=env_state_type, env_state_instance_id=env_state_instance_id, attribution=attribution,
             env_params=env_params)
 
@@ -365,8 +379,15 @@ async def load_environment_universe_artifact(self, environment_universe_artifact
     async def reset(self, deployed: DeployedEnv) -> None:
         """Return the computer to boot state: its recordings ended, its container replaced with a fresh one of the same
         image, on the same sandbox and port, so its address stays. An agent's MCP session ends with the old driver; one
-        held across the reset is answered 404, and MCP clients then start a new one."""
+        held across the reset is answered 404, and MCP clients then start a new one. Its agents get its ``tools``
+        again, as at deploy."""
         await as_builtin(self._env_provider).reboot(self, deployed)
+        await self._give_tools(deployed)
+
+    async def _give_tools(self, deployed: DeployedEnv) -> None:
+        """Make the tool-access changes ``tools`` makes for the agents' role, which a task's own then follow."""
+        for action, tools in TOOLS[self.tools or "both"]:
+            await deployed.invoke(_TOOL_ACCESS_URIS[action], action, {"role": DEFAULT_ROLE, "tools": tools})
 
     async def close(self) -> None:
         """End the computer's recordings, so what they recorded reaches the store, then tear it down."""
@@ -477,3 +498,8 @@ def _waiting(awaited: dict[tuple[str, str], str | None], seconds: float) -> str:
     building = f"building since {datetime.fromisoformat(since).strftime('%H:%M')} UTC" if since else "building"
     so_far = f", {composer.took(seconds)} so far" if seconds >= 1 else ""
     return f"waiting for another deploy composing {_pairs(list(awaited)) or 'it'} ({building}{so_far})"
+
+
+def _tools_problems(tools: Any) -> list[str]:
+    return [] if tools is None or tools in TOOLS else [
+        f"tools is {', '.join(map(repr, list(TOOLS)[:-1]))} or {list(TOOLS)[-1]!r}, not {tools!r}"]
diff --git a/src/agent_env/providers/sandbox_providers/local_docker/disk.py b/src/agent_env/providers/sandbox_providers/local_docker/disk.py
index 34bc948db..4f387f691 100644
--- a/src/agent_env/providers/sandbox_providers/local_docker/disk.py
+++ b/src/agent_env/providers/sandbox_providers/local_docker/disk.py
@@ -45,23 +45,23 @@ def launcher_args(ports: list[int], env: dict[str, str], cpu: float, memory: int
                                for arg in ("-e", f"{name}={value}"))]
 
 
-def exported_disk(image: str) -> Path:
+def exported_disk(image: str, platform: str) -> Path:
     """``image``'s ``DISK_FILE`` compressed with zstd in this machine's cache, exported from its image store by this
     machine's Docker unless an export of it is there already: once for each composed disk, by its ref, whose tag is its
-    composer's key."""
+    composer's key. ``platform`` is the disk's own, which this machine's Docker may not be."""
     path = cache_root() / "disks" / f"{hashlib.sha256(image.encode()).hexdigest()[:32]}.img.zst"
     with holding_locks([f"disk-export:{path.name}"]):
         if not path.exists():
-            _export(image, path)
+            _export(image, platform, path)
     return path
 
 
-def _export(image: str, path: Path) -> None:
+def _export(image: str, platform: str, path: Path) -> None:
     """Signed in to the image store first, as a boot's pull is, since ``docker create`` pulls ``image`` when it isn't
-    here."""
+    here; for ``platform``, as the image's index holds that one alone, which a pull for this machine's wouldn't find."""
     path.parent.mkdir(parents=True, exist_ok=True)
     docker_login(get_config().get_image_store().auth(image))
-    container = docker("create", image, "disk")
+    container = docker("create", "--platform", platform, image, "disk")
     try:
         with tempfile.TemporaryDirectory(prefix="export-", dir=path.parent) as work:
             raw, compressed = Path(work) / "disk.img", Path(work) / path.name
diff --git a/src/agent_env/providers/sandbox_providers/modal_vm_sandbox.py b/src/agent_env/providers/sandbox_providers/modal_vm_sandbox.py
index 58d1ecb92..10057a1b0 100644
--- a/src/agent_env/providers/sandbox_providers/modal_vm_sandbox.py
+++ b/src/agent_env/providers/sandbox_providers/modal_vm_sandbox.py
@@ -364,7 +364,8 @@ async def create_vm(
                                        attribution=attribution, network_policy=network_policy,
                                        setup_for_gateway=setup_for_gateway, idle_timeout=self._idle_timeout,
                                        experimental_options={"vm_runtime": True})
-        disk = await asyncio.to_thread(exported_disk, image)
+        (platform,) = self.disk_image_platforms()
+        disk = await asyncio.to_thread(exported_disk, image, platform)
         variables = {**launcher_variables(ports, env or {}, cpu, memory), "VM_DISK": _MOUNTED_DISK}
         return await self._created(
             (LAUNCH,), (await _launcher()).add_local_file(disk, _MOUNTED_DISK, copy=False), cpu=cpu,
diff --git a/tst/integration/computer/conftest.py b/tst/integration/computer/conftest.py
index 9ee81468f..ac448aa70 100644
--- a/tst/integration/computer/conftest.py
+++ b/tst/integration/computer/conftest.py
@@ -143,4 +143,4 @@ def state(monkeypatch, tmp_path):
 def run_context(output: str) -> dict:
     """The context of the run whose ``agent-env run`` output ``output`` is."""
     with namespace_routing():
-        return get_task_instance_store().get(re.search(r"instance (@local/\S+)", output).group(1)).context
+        return get_task_instance_store().get(re.search(r"instance (@local/.+)$", output, re.M).group(1)).context
diff --git a/tst/integration/computer/set/artifacts/check_tools/verify.py b/tst/integration/computer/set/artifacts/check_tools/verify.py
new file mode 100644
index 000000000..d4ef4bc58
--- /dev/null
+++ b/tst/integration/computer/set/artifacts/check_tools/verify.py
@@ -0,0 +1,14 @@
+"""What the agents' role sees on the computer: AgentEnv's computer_* tools and the driver's own, each result naming them."""
+from mcp import ClientSession
+from mcp.client.streamable_http import streamable_http_client
+
+
+async def verify(mcp_url):
+    async with streamable_http_client(mcp_url) as (read, write, _):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+            names = sorted(tool.name for tool in (await session.list_tools()).tools)
+    computer = [name for name in names if name.startswith("computer_")]
+    own = [name for name in names if not name.startswith("computer_")]
+    return [{"id": "computer", "result": True, "description": " ".join(computer)},
+            {"id": "own", "result": True, "description": " ".join(own)}]
diff --git a/tst/integration/computer/set/envs/desktop/env.toml b/tst/integration/computer/set/envs/desktop/env.toml
new file mode 100644
index 000000000..4b8291877
--- /dev/null
+++ b/tst/integration/computer/set/envs/desktop/env.toml
@@ -0,0 +1,3 @@
+type = "computer"
+computer = "ubuntu-24.04"
+driver = "cua-driver"
diff --git a/tst/integration/computer/set/tasks/tools.json b/tst/integration/computer/set/tasks/tools.json
new file mode 100644
index 000000000..8b68ac46a
--- /dev/null
+++ b/tst/integration/computer/set/tasks/tools.json
@@ -0,0 +1,6 @@
+[
+  {"id": "env", "type": "deploy_env", "env_id": "desktop"},
+  {"id": "tools", "type": "env_outcome_verifier", "env_id": "desktop", "file_artifact_id": "check_tools", "verifier_id": "tools", "depends_on": ["env"]},
+  {"id": "reset", "type": "reset_env", "env_id": "desktop", "depends_on": ["tools"], "fail_task_on_error": true},
+  {"id": "again", "type": "env_outcome_verifier", "env_id": "desktop", "file_artifact_id": "check_tools", "verifier_id": "again", "depends_on": ["reset"]}
+]
diff --git a/tst/integration/computer/set_test.py b/tst/integration/computer/set_test.py
new file mode 100644
index 000000000..339fc7ee9
--- /dev/null
+++ b/tst/integration/computer/set_test.py
@@ -0,0 +1,84 @@
+"""``agent-env run --set`` and a computer env's ``tools`` on real computers, through the set test bundle's desktop (the
+ubuntu-24.04 base with cua-driver) and its task, which lists what the agents' role sees, resets the computer and lists it
+again: each ``tools`` value against cua-driver on local Docker, before and after the reset; another driver set for the
+run, written and composed under the variant's id while the bundle's own env stays unwritten; and ``tools`` on a Modal VM,
+reset in place. Needs Docker and the local registry on localhost:5000; the last test needs Modal credentials too, with
+``[sandbox.attribution]`` tags for Modal's apps."""
+
+import json
+from pathlib import Path
+
+import pytest
+from click.testing import CliRunner
+
+import agent_env
+from agent_env.cli import cli
+from agent_env.env import Env
+from agent_env.store.base import NotFoundError
+from agent_env.store.routing import namespace_routing
+from tst.integration.computer.conftest import run_context
+from tst.util.capabilities import skip_without_remote_sandbox
+
+pytestmark = [pytest.mark.integration, pytest.mark.int_test_slow]
+
+BUNDLE = Path(__file__).parent / "set"
+MANIFEST = Path(agent_env.__file__).parent / "drivers" / "envs" / "cua-driver" / "mcp.json"
+CUA_DRIVER_TOOLS = {tool["name"] for tool in json.loads(MANIFEST.read_text())["tools"]}
+COMPUTER_TOOLS = {"computer_screenshot", "computer_click", "computer_drag", "computer_scroll", "computer_type",
+                  "computer_key", "computer_wait"}
+REFERENCE = "@local/agentenv-framework/drivers/reference"
+
+
+@pytest.mark.parametrize("tools, computer, own", [
+    (None, COMPUTER_TOOLS, CUA_DRIVER_TOOLS),
+    ("standard", COMPUTER_TOOLS, set()),
+    ("driver", set(), CUA_DRIVER_TOOLS),
+], ids=["unset", "standard", "driver"])
+def test_a_computer_envs_tools_are_what_its_agents_see_at_deploy_and_after_a_reset(state, tools, computer, own):
+    settings = ["--set", f"envs/desktop.tools={tools}"] if tools else []
+
+    ran = CliRunner().invoke(cli, ["run", str(BUNDLE), "--task", "tools", *settings])
+
+    assert ran.exit_code == 0, ran.output
+    context = run_context(ran.output)
+    assert _seen(context, "tools") == _seen(context, "again") == (computer, own)
+
+
+def test_set_runs_the_bundles_computer_env_with_another_driver_under_an_id_of_its_own(state):
+    ran = CliRunner().invoke(cli, ["run", str(BUNDLE), "--task", "tools", "--set", "envs/desktop.driver=reference"])
+
+    assert ran.exit_code == 0, ran.output
+    assert ("--set envs/desktop.driver=reference: 1 env and 1 task written under ids ending in (desktop.driver "
+            "reference)") in ran.output
+    context = run_context(ran.output)
+    (deployed,) = context["deployed_envs"]
+    variant = deployed["env_id"]
+    assert variant.endswith("/desktop(desktop.driver reference)")
+    with namespace_routing():
+        assert Env.get(variant).driver.id == REFERENCE
+        with pytest.raises(NotFoundError):
+            Env.get(variant.removesuffix("(desktop.driver reference)"))
+    computer, own = _seen(context, "tools")
+    assert COMPUTER_TOOLS <= computer and not own
+
+
+@skip_without_remote_sandbox("modal_vm")
+def test_a_computer_envs_tools_hold_on_a_modal_vm_through_a_reset_in_place(state, monkeypatch):
+    monkeypatch.setenv("XDG_CACHE_HOME", str(state / "cache"))
+
+    ran = CliRunner().invoke(cli, ["run", str(BUNDLE), "--task", "tools", "--sandbox", "modal_vm", "--set",
+                                   "envs/desktop.tools=standard"])
+
+    assert ran.exit_code == 0, ran.output
+    context = run_context(ran.output)
+    (deployed,) = context["deployed_envs"]
+    assert (deployed["sandbox_type"], deployed["metadata"]["computer"]["form"]) == ("modal_vm", "disk")
+    assert deployed["env_id"].endswith("/desktop(desktop.tools standard)")
+    assert _seen(context, "tools") == _seen(context, "again") == (COMPUTER_TOOLS, set())
+
+
+def _seen(context: dict, verifier: str) -> tuple[set[str], set[str]]:
+    """The computer_* tools and the driver's own that the verifier ``verifier`` found the agents' role offered."""
+    results = {result["id"]: set(result["description"].split()) for result in
+               context["metadata"]["verifications"][verifier]["results"]}
+    return results["computer"], results["own"]
diff --git a/tst/unit/bundle/_support.py b/tst/unit/bundle/_support.py
index 905abb5bd..88f8ec95a 100644
--- a/tst/unit/bundle/_support.py
+++ b/tst/unit/bundle/_support.py
@@ -5,7 +5,9 @@
 from importlib.metadata import PackageNotFoundError
 from pathlib import Path
 
+from agent_env.a2a_agent import A2AAgent
 from agent_env.artifact.artifacts.docker_image import DockerImageArtifact
+from agent_env.artifact.store import get_artifact_store
 from agent_env.bundle import parse_bundle
 from agent_env.bundle import requires as requires_module
 from agent_env.bundle.plan import plan_bundle
@@ -14,6 +16,7 @@
 from agent_env.env.published_images import AGENT_IMAGES
 from agent_env.plugins import Inventory, _requirements
 from agent_env.store.document_store import DocumentStore
+from agent_env.store.routing import namespace_routing
 
 # The image of the Claude Code agent agent-env ships.
 CLAUDE_CODE_IMAGE = next(image for image in AGENT_IMAGES if image.name == "agentenv-claude-code")
@@ -97,3 +100,11 @@ def ensure_index(self, collection, fields, unique=False, ttl_seconds=None):
         pass
 
     find_one = query = count = insert = update = update_one_and_get = replace = delete = None
+
+
+def store_agent(agent_id):
+    """An agent ``agent_id`` in the store, over an image that names a registry ref."""
+    with namespace_routing():
+        image = get_artifact_store().put_document(DockerImageArtifact(
+            id=f"{agent_id}-image", description="d", image_name="ghcr.io/acme/agent:1", tar_gz_s3_url="s3://b/x.tar.gz"))
+        return A2AAgent.put(id=agent_id, docker_image_artifact=image)
diff --git a/tst/unit/bundle/agent_override_test.py b/tst/unit/bundle/agent_override_test.py
index 301320be9..f4c670791 100644
--- a/tst/unit/bundle/agent_override_test.py
+++ b/tst/unit/bundle/agent_override_test.py
@@ -6,9 +6,6 @@
 import pytest
 from click.testing import CliRunner
 
-from agent_env.a2a_agent import A2AAgent
-from agent_env.artifact.artifacts.docker_image import DockerImageArtifact
-from agent_env.artifact.store import get_artifact_store
 from agent_env.bundle import BundleError, dry_run_bundle, parse_bundle, run_bundle
 from agent_env.bundle import preflight as preflight_module
 from agent_env.bundle.installed import InstalledBundle
@@ -17,11 +14,10 @@
 from agent_env.cli import cli
 from agent_env.entity.refs import EntityKind
 from agent_env.plugins._bundles import ALIASES_FILE
-from agent_env.store.routing import namespace_routing
 from agent_env.task.task import Task
 from agent_env.task_step.context import TaskStepContext
 from agent_env.task_step.task_steps.install_agent import InstallAgentTaskStep
-from tst.unit.bundle._support import layout
+from tst.unit.bundle._support import layout, store_agent
 
 ROOT = "@local/~/triage"
 SOLVER = "@local/demo-dist/kit/solver"
@@ -36,7 +32,7 @@
 @pytest.fixture
 def bundle_dir(tmp_path, monkeypatch, local_stores, cli_routing):
     monkeypatch.setenv("HOME", str(tmp_path))
-    _store_agent("theirs")
+    store_agent("theirs")
     return tmp_path / "triage"
 
 
@@ -48,13 +44,6 @@ def kit(tmp_path):
     return InstalledBundle("kit", "demo-dist", "1.0", "demo", root, None, None)
 
 
-def _store_agent(agent_id):
-    with namespace_routing():
-        image = get_artifact_store().put_document(DockerImageArtifact(
-            id=f"{agent_id}-image", description="d", image_name="ghcr.io/acme/agent:1", tar_gz_s3_url="s3://b/x.tar.gz"))
-        return A2AAgent.put(id=agent_id, docker_image_artifact=image)
-
-
 def _bundle(bundle_dir, steps, files=None):
     layout(bundle_dir, {"tasks/t.json": json.dumps(steps), **(files or {})})
     return bundle_dir
@@ -91,8 +80,8 @@ def test_this_bundles_own_agent_is_named_by_its_folder(bundle_dir):
 
 
 def test_the_stores_agent_is_named_by_its_id_at_the_version_the_plan_read(bundle_dir):
-    _store_agent("mine")
-    _store_agent("mine")
+    store_agent("mine")
+    store_agent("mine")
 
     plan = _plan(_bundle(bundle_dir, [DEPLOY, PROMPT]), "mine")
 
@@ -143,14 +132,14 @@ def record(self, where, provider, agent_id, version, *args, **kwargs):
             {"agents/helper/Dockerfile": "FROM scratch\n"})
 
     dry_run_bundle(bundle_dir, agent="helper")
-    _store_agent("mine")
+    store_agent("mine")
     dry_run_bundle(bundle_dir, agent="mine")
 
     assert checked == [(f"{ROOT}/helper", None), ("mine", 1)]
 
 
 def test_an_install_is_checked_for_the_agent_the_solver_installs_not_the_one_the_task_names(bundle_dir):
-    _store_agent("mine")
+    store_agent("mine")
     _bundle(bundle_dir, INSTALL, {"agents/helper/Dockerfile": "FROM scratch\n"})
 
     with pytest.raises(BundleError, match="install_agent 'agent': Agent theirs v1 has no build_context_object_url"):
@@ -162,7 +151,7 @@ def test_an_install_is_checked_for_the_agent_the_solver_installs_not_the_one_the
 
 def test_a_dry_run_says_what_the_solver_deploys(bundle_dir, monkeypatch):
     lines = []
-    _store_agent("mine")
+    store_agent("mine")
 
     dry_run_bundle(_bundle(bundle_dir, [{**DEPLOY, "sandbox_type": "local"}, PROMPT]), agent="mine",
                    on_progress=lines.append)
@@ -191,12 +180,12 @@ def test_a_run_deploys_the_stores_agent_at_the_version_the_plan_read_not_one_put
     seen = {}
 
     async def run(self, *, context, **kwargs):
-        _store_agent("mine")
+        store_agent("mine")
         seen[self.id] = context.metadata.get("user_overrides")
         return context
 
     monkeypatch.setattr(Task, "run", run)
-    _store_agent("mine")
+    store_agent("mine")
     _bundle(bundle_dir, [DEPLOY, PROMPT])
 
     run_bundle(bundle_dir, agent="mine", sandbox="local")
@@ -216,7 +205,7 @@ def test_an_install_takes_its_steps_override_over_the_run_wide_one_and_the_store
 
 def test_the_cli_takes_the_agent_for_a_run_and_a_dry_run(bundle_dir, monkeypatch):
     monkeypatch.setenv("LITELLM_BASE_URL", "http://litellm")
-    _store_agent("mine")
+    store_agent("mine")
     _bundle(bundle_dir, [{**DEPLOY, "sandbox_type": "local"}, PROMPT])
 
     result = CliRunner().invoke(cli, ["run", str(bundle_dir), "--agent", "mine", "--dry-run"])
diff --git a/tst/unit/bundle/computer_env_folder_test.py b/tst/unit/bundle/computer_env_folder_test.py
index af0dcec40..3259c32d4 100644
--- a/tst/unit/bundle/computer_env_folder_test.py
+++ b/tst/unit/bundle/computer_env_folder_test.py
@@ -14,7 +14,6 @@
 from agent_env.bundle.resolve import resolve_bundle
 from agent_env.bundle.run import dry_run_bundle
 from agent_env.env import Env
-from agent_env.env.envs.computer.utils import composer
 from agent_env.env.envs.computer.utils.composed import composition
 from agent_env.env.envs.computer.utils.composer import Composing
 from agent_env.env.envs.computer.env import ComputerEnv
@@ -41,22 +40,6 @@
     ("skill-linux.md", "# Mail on Linux\n"))}
 
 
-@pytest.fixture
-def composed(tmp_path, monkeypatch, local_stores, cli_routing, builds):
-    monkeypatch.setenv("HOME", str(tmp_path))
-    monkeypatch.setattr("agent_env.env.published_images._registry_digest", lambda ref: None)
-    calls = []
-
-    def compose(env, pairs=None, composing=Composing()):
-        if composing.on_progress is not None:
-            composing.on_progress("composing")
-        calls.append((env.id, env.computer.id, env.driver.id, composing.sandbox_provider)
-                     + ((pairs,) if pairs is not None else ()))
-
-    monkeypatch.setattr(composer, "compose", compose)
-    return calls
-
-
 def _bundle(root, toml=DESKTOP, extra=None):
     return layout(root, {"envs/desktop/env.toml": toml, "tasks/t.json": json.dumps([
         {"id": "desktop", "type": "load_artifact", "env_id": "desktop", "artifact_id": "notes"}]),
diff --git a/tst/unit/bundle/conftest.py b/tst/unit/bundle/conftest.py
index 1725af771..de395bf32 100644
--- a/tst/unit/bundle/conftest.py
+++ b/tst/unit/bundle/conftest.py
@@ -6,6 +6,8 @@
 import pytest
 
 from agent_env.artifact.artifacts import docker_image as docker_image_module
+from agent_env.env.envs.computer.utils import composer
+from agent_env.env.envs.computer.utils.composer import Composing
 from agent_env.env.published_images import AGENT_IMAGES
 from agent_env.providers.sandbox_providers import host_images
 from tst.unit.bundle._support import CLAUDE_CODE_IMAGE, DIGEST, listing
@@ -51,3 +53,21 @@ def agents_published(monkeypatch):
     refs = {image.ref() for image in AGENT_IMAGES}
     monkeypatch.setattr("agent_env.env.published_images._registry_digest", lambda ref: DIGEST if ref in refs else None)
     return CLAUDE_CODE_IMAGE.ref()
+
+
+@pytest.fixture
+def composed(tmp_path, monkeypatch, local_stores, cli_routing, builds):
+    """Stands in for the composer: each computer env it's asked to compose is recorded with its computer, driver, provider
+    and, when given, the pairs, and nothing is built."""
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setattr("agent_env.env.published_images._registry_digest", lambda ref: None)
+    calls = []
+
+    def compose(env, pairs=None, composing=Composing()):
+        if composing.on_progress is not None:
+            composing.on_progress("composing")
+        calls.append((env.id, env.computer.id, env.driver.id, composing.sandbox_provider)
+                     + ((pairs,) if pairs is not None else ()))
+
+    monkeypatch.setattr(composer, "compose", compose)
+    return calls
diff --git a/tst/unit/bundle/installed_entities_test.py b/tst/unit/bundle/installed_entities_test.py
index 2e20e810f..88d8e6dcf 100644
--- a/tst/unit/bundle/installed_entities_test.py
+++ b/tst/unit/bundle/installed_entities_test.py
@@ -25,7 +25,7 @@
 from agent_env.entity.refs import EntityKind
 from agent_env.env.envs.mcp_server import MCPServerEnv
 from agent_env.store.routing import namespace_routing
-from tst.unit.bundle._support import RefusingStore, layout, local_builds
+from tst.unit.bundle._support import RefusingStore, layout, local_builds, store_agent
 
 ROOT = "@local/~/triage"
 KIT = "@local/demo-dist/kit"
@@ -383,13 +383,6 @@ def test_a_run_locks_the_entities_it_pulls_in_as_it_does_its_own(bundle_dir, tmp
 ALIASED = {ALIASES_FILE: '[agents]\nsolver = ["solver-x"]\n'}
 
 
-def _store_agent(agent_id):
-    with namespace_routing():
-        image = get_artifact_store().put_document(DockerImageArtifact(
-            id=f"{agent_id}-image", description="d", image_name="ghcr.io/acme/agent:1", tar_gz_s3_url="s3://b/x.tar.gz"))
-        return A2AAgent.put(id=agent_id, docker_image_artifact=image)
-
-
 def _step(plan, step_id="agent"):
     task = next(write for write in plan.writes if write.kind is BundleKind.TASK)
     return next(step for step in task.source.config if step["id"] == step_id)
@@ -498,7 +491,7 @@ def test_an_installed_bundles_env_naming_another_bundles_alias_is_pointed_at_it_
 def test_the_stores_agent_of_an_alias_id_shadows_the_alias(bundle_dir, tmp_path):
     """Someone's own agent of that id is the one they mean."""
     kit = _kit(tmp_path, ALIASED)
-    _store_agent("solver-x")
+    store_agent("solver-x")
 
     plan = _plan(_task(bundle_dir, [{"id": "agent", "type": "deploy_agent", "a2a_agent_id": "solver-x"}]), kit)
 
@@ -541,7 +534,7 @@ def test_an_alias_takes_no_pin(bundle_dir, tmp_path):
 
 def test_a_pinned_reference_to_the_stores_agent_of_an_alias_id_names_that_agent(bundle_dir, tmp_path):
     kit = _kit(tmp_path, ALIASED)
-    _store_agent("solver-x")
+    store_agent("solver-x")
 
     plan = _plan(_task(bundle_dir, [{"id": "agent", "type": "deploy_agent", "a2a_agent_id": "solver-x",
                                      "a2a_agent_version": 1}]), kit)
@@ -568,7 +561,7 @@ def test_the_stores_agent_of_a_refused_alias_id_is_the_one_it_names(bundle_dir,
     other = _installed(tmp_path / "site2" / "tools", {"agents/helper/Dockerfile": "FROM scratch\n",
                                                       ALIASES_FILE: '[agents]\nhelper = ["solver-x"]\n'},
                        dist="zeta-tools", name="tools")
-    _store_agent("solver-x")
+    store_agent("solver-x")
 
     plan = _plan(_task(bundle_dir, [{"id": "agent", "type": "deploy_agent", "a2a_agent_id": "solver-x"}]), kit, other)
 
@@ -639,7 +632,7 @@ def test_a_dry_run_says_which_agent_an_alias_names_and_preflights_an_aliased_def
 
 def test_a_dry_run_says_when_the_store_shadows_an_alias(bundle_dir, tmp_path, monkeypatch):
     kit = _kit(tmp_path, ALIASED)
-    _store_agent("solver-x")
+    store_agent("solver-x")
     monkeypatch.setattr(run_module, "installed_bundles", lambda: (kit,))
     monkeypatch.setattr(preflight_module, "docker_unreachable", lambda: None)
     _task(bundle_dir, [{"id": "agent", "type": "deploy_agent", "a2a_agent_id": "solver-x"}])
diff --git a/tst/unit/bundle/installed_test.py b/tst/unit/bundle/installed_test.py
index a006092b5..64ff8c1d5 100644
--- a/tst/unit/bundle/installed_test.py
+++ b/tst/unit/bundle/installed_test.py
@@ -281,11 +281,11 @@ def test_the_cli_says_so_when_no_bundles_are_installed_and_needs_a_bundle_for_it
 
     assert CliRunner().invoke(cli, ["run"]).output == "No bundles are installed. agent-env run PATH runs a folder.\n"
     for option in (["--task", "t"], ["--keep"], ["--dry-run"], ["--user-model", "m"], ["--judge-model", "m"],
-                   ["--agent", "pi"], ["--no-emulate"]):
+                   ["--agent", "pi"], ["--set", "envs/desktop.driver=reference"], ["--no-emulate"]):
         usage = CliRunner().invoke(cli, ["run", *option])
         assert usage.exit_code == 2
-        assert ("--task, --eval, --model, --user-model, --judge-model, --agent, --sandbox, --keep, --dry-run and "
-                "--no-emulate need a BUNDLE to run") in " ".join(usage.output.split())
+        assert ("--task, --eval, --model, --user-model, --judge-model, --agent, --set, --sandbox, --keep, --dry-run "
+                "and --no-emulate need a BUNDLE to run") in " ".join(usage.output.split())
 
 
 def test_the_cli_runs_an_installed_bundle_by_name_with_ids_rooted_at_its_package(site, monkeypatch, quiet_logs,
diff --git a/tst/unit/bundle/variants_test.py b/tst/unit/bundle/variants_test.py
new file mode 100644
index 000000000..88a62bdff
--- /dev/null
+++ b/tst/unit/bundle/variants_test.py
@@ -0,0 +1,226 @@
+"""``--set envs/NAME.KEY=VALUE``: a run's envs with keys set for that run alone, each env that changes, each env and task naming
+one and each eval naming such a task under an id ending in the settings, with the bundle as written."""
+
+import json
+
+import pytest
+from click.testing import CliRunner
+
+from agent_env.bundle import BundleError, BundleKind, Variant, dry_run_bundle, parse_bundle
+from agent_env.bundle.installed import installed_bundles
+from agent_env.bundle.materialize import materialize
+from agent_env.bundle.plan import plan_bundle
+from agent_env.bundle.resolve import resolve_bundle
+from agent_env.bundle.variants import with_variant
+from agent_env.cli import cli
+from agent_env.env import Env
+from tst.unit.bundle._support import layout, local_builds, store_agent
+from tst.unit.bundle.computer_env_folder_test import APPS, DESKTOP, UBUNTU, WITH_APPS
+
+ROOT = "@local/~/desk"
+CUA = "@local/agentenv-framework/drivers/cua-driver"
+DEPLOY = {"id": "desk", "type": "deploy_env", "env_id": "desktop"}
+AGENT = {"id": "agent", "type": "deploy_agent", "env_ids": ["desktop"], "a2a_agent_id": "theirs", "depends_on": ["desk"]}
+PROMPT = {"id": "ask", "type": "prompt_agent", "prompt_id": "ask", "prompt": "hi", "depends_on": ["agent"]}
+ALONE = [{"id": "agent", "type": "deploy_agent", "env_ids": [], "a2a_agent_id": "theirs"}, PROMPT]
+
+
+@pytest.fixture(autouse=True)
+def home(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+
+
+def _bundle(root, steps=(DEPLOY, AGENT, PROMPT), files=None):
+    return layout(root, {"envs/desktop/env.toml": DESKTOP, "tasks/t.json": json.dumps(list(steps)),
+                         "tasks/chat.json": json.dumps(ALONE), "evals/e.toml": 'tasks = ["t"]\n',
+                         "evals/chats.toml": 'tasks = ["chat"]\n', **(files or {})})
+
+
+def _varied(root, *settings):
+    return with_variant(parse_bundle(root), Variant(settings)).bundle
+
+
+def _entry(bundle, name):
+    return next(entry for entry in bundle.entries if entry.name == name)
+
+
+def _ids(bundle):
+    return {entry.name: entry.id for entry in bundle.entries}
+
+
+def test_a_key_set_renames_the_env_and_what_uses_it_and_leaves_the_rest(tmp_path):
+    root = _bundle(tmp_path / "desk")
+
+    varied = with_variant(parse_bundle(root), Variant(("envs/desktop.driver=cua-driver",)))
+
+    label, bundle = "desktop.driver cua-driver", varied.bundle
+    assert dict(varied.renamed) == {(BundleKind.ENV, f"{ROOT}/desktop"): f"{ROOT}/desktop({label})",
+                                    (BundleKind.TASK, f"{ROOT}/t"): f"{ROOT}/t({label})",
+                                    (BundleKind.EVAL, f"{ROOT}/e"): f"{ROOT}/e({label})"}
+    assert _ids(bundle) == {"desktop": f"{ROOT}/desktop({label})", "t": f"{ROOT}/t({label})", "chat": f"{ROOT}/chat",
+                            "e": f"{ROOT}/e({label})", "chats": f"{ROOT}/chats"}
+    assert _entry(bundle, "desktop").config == {**_entry(parse_bundle(root), "desktop").config, "driver": "cua-driver"}
+    assert _entry(bundle, "t").config == [DEPLOY, AGENT, PROMPT]
+
+
+def test_an_entry_of_another_kind_with_the_envs_id_stays_as_it_is(tmp_path):
+    root = _bundle(tmp_path / "desk", files={"skills/desktop/SKILL.md": "---\nname: desktop\ndescription: d\n---\n"})
+
+    bundle = _varied(root, "envs/desktop.driver=cua-driver")
+
+    skill = next(entry for entry in bundle.entries if entry.kind.value == "skills")
+    assert skill == next(entry for entry in parse_bundle(root).entries if entry.kind.value == "skills")
+    assert _entry(bundle, "t").id == f"{ROOT}/t(desktop.driver cua-driver)"
+
+
+def test_an_eval_sharing_the_envs_id_keeps_its_own_toml(tmp_path):
+    root = _bundle(tmp_path / "desk", files={"evals/desktop.toml": 'tasks = ["t"]\n'})
+
+    bundle = _varied(root, "envs/desktop.driver=cua-driver")
+
+    evals = {entry.id: entry.config for entry in bundle.entries if entry.kind is BundleKind.EVAL}
+    assert evals[f"{ROOT}/desktop(desktop.driver cua-driver)"] == {"tasks": ["t"]}
+    assert _entry(bundle, "desktop").config["driver"] == "cua-driver"
+
+
+def test_a_reference_by_id_is_repointed_at_the_variant(tmp_path):
+    steps = [{**DEPLOY, "env_id": f"{ROOT}/desktop"}, {**AGENT, "env_ids": [f"{ROOT}/desktop"]}, PROMPT]
+    root = _bundle(tmp_path / "desk", steps, {"evals/e.toml": f'tasks = ["{ROOT}/t"]\n'})
+
+    bundle = _varied(root, "envs/desktop.computer=ubuntu-24.04-headless", "envs/desktop.tools=standard")
+
+    label = "desktop.computer ubuntu-24.04-headless, desktop.tools standard"
+    assert [step.get("env_id") or step.get("env_ids") for step in _entry(bundle, "t").config] == [
+        f"{ROOT}/desktop({label})", [f"{ROOT}/desktop({label})"], None]
+    assert _entry(bundle, "e").config["tasks"] == [f"{ROOT}/t({label})"]
+    assert _entry(bundle, "desktop").config["tools"] == "standard"
+
+
+@pytest.mark.parametrize("named", ["t", f"{ROOT}/t"], ids=["name", "id"])
+def test_an_eval_naming_its_task_in_a_table_is_renamed_and_repointed_too(tmp_path, named):
+    root = _bundle(tmp_path / "desk", files={"evals/e.toml": f'tasks = [{{ task = "{named}" }}]\n'})
+
+    bundle = _varied(root, "envs/desktop.driver=cua-driver")
+
+    label = "desktop.driver cua-driver"
+    assert _entry(bundle, "e").id == f"{ROOT}/e({label})"
+    assert _entry(bundle, "e").config["tasks"] == [{"task": "t" if named == "t" else f"{ROOT}/t({label})"}]
+
+
+def test_a_value_is_toml_or_a_bare_word_and_a_key_may_be_dotted_into_a_table(tmp_path):
+    settings = ("envs/desktop.display={ width = 1280, height = 720 }", "envs/desktop.computer_settings.theme=dark",
+                "envs/desktop.network.mode=allow_all")
+
+    bundle = _varied(_bundle(tmp_path / "desk"), *settings)
+
+    config = _entry(bundle, "desktop").config
+    assert (config["display"], config["computer_settings"], config["network"]) == (
+        {"width": 1280, "height": 720}, {"timezone": "Europe/Paris", "theme": "dark"}, {"mode": "allow_all"})
+    hashed = Variant(settings).label.split(",")[0]
+    assert hashed.startswith("desktop.display ") and len(hashed) == len("desktop.display ") + 8
+    assert _entry(bundle, "desktop").id == (f"{ROOT}/desktop({hashed}, desktop.computer_settings.theme dark, "
+                                            "desktop.network.mode allow_all)")
+
+
+def test_one_env_is_set_by_its_folder_and_an_env_composing_an_app_set_is_renamed_too(tmp_path):
+    files = {"envs/desktop/env.toml": WITH_APPS, "envs/laptop/env.toml": DESKTOP, **APPS,
+             "tasks/u.json": json.dumps([{**DEPLOY, "env_id": "laptop"}])}
+    setting = "envs/mail.settings.signature=Ada"
+
+    bundle = _varied(_bundle(tmp_path / "desk", files=files), setting)
+
+    ids, label = _ids(bundle), Variant((setting,)).label
+    assert label == "mail.settings.signature Ada"
+    assert (ids["mail"], ids["desktop"], ids["t"]) == (f"{ROOT}/mail({label})", f"{ROOT}/desktop({label})",
+                                                       f"{ROOT}/t({label})")
+    assert (ids["notes"], ids["laptop"], ids["u"]) == (f"{ROOT}/notes", f"{ROOT}/laptop", f"{ROOT}/u")
+    assert _entry(bundle, "mail").config["settings"] == {"signature": "Ada"}
+
+
+@pytest.mark.parametrize("setting, problem", [
+    ("driver=cua-driver", "--set driver=cua-driver: expected envs/NAME.KEY=VALUE, such as envs/desktop.driver=cua-driver"),
+    ("envs/desktop.driver", "--set envs/desktop.driver: expected envs/NAME.KEY=VALUE, such as "
+                            "envs/desktop.driver=cua-driver"),
+    ("envs/desktop=x", "--set envs/desktop=x: expected envs/NAME.KEY=VALUE, such as envs/desktop.driver=cua-driver"),
+    ("envs/desktop.=x", "--set envs/desktop.=x: expected envs/NAME.KEY=VALUE, such as envs/desktop.driver=cua-driver"),
+    ("envs/nope.driver=x", "--set envs/nope.driver=x: envs/nope names no env of this bundle"),
+    ("envs/desktop.type=website", "--set envs/desktop.type=website: an env's type says what it is, so a run can't set "
+                                  "it"),
+    ("envs/desktop.id=x", "--set envs/desktop.id=x: an env's id says what it is, so a run can't set it"),
+])
+def test_a_setting_that_names_no_envs_key_is_refused(tmp_path, setting, problem):
+    with pytest.raises(BundleError) as refused:
+        _varied(_bundle(tmp_path / "desk"), setting)
+
+    assert refused.value.problems == (problem,)
+
+
+@pytest.fixture
+def desk(tmp_path, local_stores, cli_routing):
+    store_agent("theirs")
+    return _bundle(tmp_path / "desk")
+
+
+def _plan(root, *settings):
+    return plan_bundle(resolve_bundle(_varied(root, *settings)), installed=installed_bundles)
+
+
+def test_the_variant_is_written_and_composed_with_its_driver_beside_the_bundles_own(desk, composed):
+    plan = _plan(desk, "envs/desktop.driver=cua-driver", "envs/desktop.tools=driver")
+
+    materialize(plan, build_here=local_builds(plan))
+
+    env = Env.get(f"{ROOT}/desktop(desktop.driver cua-driver, desktop.tools driver)")
+    assert (env.computer.id, env.driver.id, env.environment_name, env.tools) == (UBUNTU, CUA, "desktop", "driver")
+    assert composed == [(env.id, UBUNTU, CUA, None)]
+    assert (desk / "envs/desktop/env.toml").read_text() == DESKTOP
+
+
+@pytest.mark.parametrize("setting, problem", [
+    ("envs/desktop.tools=all", "tools is 'standard', 'driver' or 'both', not 'all'"),
+    ("envs/desktop.drivr=x", "unknown key 'drivr'; a computer env takes environment_name, computer, driver, apps, "
+                             "display, network, computer_settings, tools, type and id"),
+])
+def test_a_key_or_value_the_envs_type_refuses_is_refused_before_anything_is_written(desk, composed,
+                                                                                     setting, problem):
+    with pytest.raises(BundleError) as refused:
+        dry_run_bundle(desk, variant=Variant((setting,)))
+
+    assert any(line.startswith("envs/desktop") and problem in line for line in refused.value.problems), refused.value
+
+
+def test_a_driver_that_cant_compose_with_the_computer_is_refused_as_its_written(desk, composed):
+    plan = _plan(desk, "envs/desktop.driver=macos-harness")
+
+    with pytest.raises(BundleError) as refused:
+        materialize(plan, build_here=local_builds(plan))
+
+    assert any(line.startswith("envs/desktop") and "macos-harness" in line for line in refused.value.problems), (
+        refused.value)
+    assert composed == []
+
+
+def test_a_run_whose_tasks_deploy_nothing_its_settings_change_is_refused(desk, composed):
+    with pytest.raises(BundleError) as refused:
+        dry_run_bundle(desk, tasks=["chat"], variant=Variant(("envs/desktop.driver=cua-driver",)))
+
+    assert refused.value.problems == ("--set envs/desktop.driver=cua-driver: none of the tasks this run selects "
+                                      "deploys an env it changes",)
+
+
+@pytest.mark.parametrize("selection", ["t", f"{ROOT}/t"], ids=["name", "id"])
+def test_a_task_is_selected_by_its_name_or_its_id_as_the_bundle_gives_it(desk, composed, selection):
+    dry = dry_run_bundle(desk, tasks=[selection], variant=Variant(("envs/desktop.driver=cua-driver",)))
+
+    assert [entry.id for entry in dry.runs] == [f"{ROOT}/t(desktop.driver cua-driver)"]
+
+
+def test_the_cli_runs_the_variant_and_says_what_it_writes_it_as(desk, composed, monkeypatch):
+    monkeypatch.setenv("LITELLM_BASE_URL", "http://litellm")
+
+    result = CliRunner().invoke(cli, ["run", str(desk), "--task", "t", "--set", "envs/desktop.driver=cua-driver",
+                                      "--set", "envs/desktop.tools=standard", "--dry-run"])
+
+    assert result.exit_code == 0, result.output
+    assert ("--set envs/desktop.driver=cua-driver --set envs/desktop.tools=standard: 1 env and 1 task written under ids "
+            "ending in (desktop.driver cua-driver, desktop.tools standard)") in result.output
diff --git a/tst/unit/env/envs/test_computer_env.py b/tst/unit/env/envs/test_computer_env.py
index 0a4b03daf..11856ee69 100644
--- a/tst/unit/env/envs/test_computer_env.py
+++ b/tst/unit/env/envs/test_computer_env.py
@@ -25,7 +25,7 @@
 from agentenv_protocol.computer import COMPUTER_DISPLAY, COMPUTER_READY, COMPUTER_RECORDING
 from agentenv_protocol.computer.app import COMPUTER_APP
 from agentenv_protocol.computer.app_runtime import HOLD_BOOT_LAUNCH_ENV
-from agentenv_protocol.tool_access import DISABLE_TOOL_EXTENSION_URI
+from agentenv_protocol.tool_access import DISABLE_TOOL_EXTENSION_URI, ENABLE_TOOL_EXTENSION_URI
 from click.testing import CliRunner
 
 from agent_env.artifact.artifacts.computer import ComputerArtifact
@@ -39,12 +39,12 @@
 from agent_env.config import get_config
 from agent_env.env import Env
 from agent_env.env import env as env_module
-from agent_env.env.env import DeployedEnv
+from agent_env.env.env import DeployedEnv, EnvCapabilityUnsupported
 from agent_env.env.envs.computer.utils import (boot, builder, composed, composer, gate, inside, packages, params,
                                                probing, resolve_in_base)
 from agent_env.env.envs.computer.utils.composer import Composing
 from agent_env.env.envs.computer.utils.probing import _probe
-from agent_env.env.envs.computer.env import ComputerEnv
+from agent_env.env.envs.computer.env import COMPUTER_TOOLS, ComputerEnv
 from agent_env.env.envs.computer import app_env
 from agent_env.env.envs.computer.app_env import ComputerAppEnv
 from agent_env.env.envs.computer.utils.install import Install, Service
@@ -474,8 +474,9 @@ async def test_a_computer_env_with_no_ready_build_is_refused_at_deploy_naming_it
      "computer_settings.wallpaper: @local/~/kit/ubuntu-24.04 declares no setting 'wallpaper'"),
     ({"computer_settings": {"timezone": 3}}, "computer_settings.timezone must be a str, like its default 'UTC', not 3"),
     ({"computer_settings": ["timezone"]}, "computer_settings must be a table of the computer's setting values"),
+    ({"tools": "all"}, "tools is 'standard', 'driver' or 'both', not 'all'"),
 ], ids=["display-zero", "display-side", "display-and-resolution", "network", "network-key",
-        "settings-name", "settings-type", "settings-table"])
+        "settings-name", "settings-type", "settings-table", "tools"])
 def test_what_the_env_declares_wrong_is_refused_before_anything_is_stored(base, driver, docker, changes, problem):
     with pytest.raises(ValueError, match="computer env '@local/~/kit/desktop'") as refused:
         _put(base, driver, **changes)
@@ -642,6 +643,7 @@ def test_builds_of_one_env_at_once_keep_each_others_pairs_and_a_failure_doesnt_r
 DRIVER_CARD = {"name": "desktop", "capabilities": {"extensions": [
     {"uri": COMPUTER_DISPLAY, "params": {"endpoint": "/computer/display", "methods": {"get": {"method": "GET"}}}},
     {"uri": DISABLE_TOOL_EXTENSION_URI, "params": {"endpoint": "/tools/disable", "methods": {"disable": {}}}},
+    {"uri": ENABLE_TOOL_EXTENSION_URI, "params": {"endpoint": "/tools/enable", "methods": {"enable": {}}}},
     {"uri": COMPUTER_RECORDING, "params": {"endpoint": "/computer/recording", "methods": {"end_all": {}}}}]}}
 
 
@@ -756,6 +758,46 @@ async def reset_container(self, sandbox, **kwargs):
     assert boots.calls == [(COMPUTER_RECORDING, "end_all", {"reason": "reset"}), "reset_container", (COMPUTER_DISPLAY, "get", None)]
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("tools, changes", [
+    ("standard", [(DISABLE_TOOL_EXTENSION_URI, "disable", {"role": "default", "tools": ["*"]}),
+                  (ENABLE_TOOL_EXTENSION_URI, "enable", {"role": "default", "tools": list(COMPUTER_TOOLS)})]),
+    ("driver", [(DISABLE_TOOL_EXTENSION_URI, "disable", {"role": "default", "tools": list(COMPUTER_TOOLS)})]),
+    ("both", []),
+])
+async def test_a_computer_envs_tools_are_given_its_agents_at_deploy_and_again_after_a_reset(
+        base, driver, docker, boots, monkeypatch, tools, changes):
+    env = _put(base, driver, display={"width": 1600, "height": 900}, tools=tools)
+    deployed = await Env.get(env.id).deploy()
+    (sandbox,) = boots.sandboxes
+    given = [call for call in boots.calls if call[0] in (DISABLE_TOOL_EXTENSION_URI, ENABLE_TOOL_EXTENSION_URI)]
+    monkeypatch.setattr(local_sandbox.LocalSandboxProvider, "get_sandbox", AsyncMock(return_value=sandbox))
+    monkeypatch.setattr(local_sandbox.LocalSandboxProvider, "reset_container", AsyncMock())
+    monkeypatch.setattr(env_computer_provider, "ready", AsyncMock(return_value=DRIVER_CARD))
+    boots.calls.clear()
+
+    await ResetEnvTaskStep(id="reset", version=None, env_id=env.id, fail_task_on_error=True).execute(
+        TaskStepContext(deployed_envs=[deployed]))
+
+    assert Env.get(env.id).tools == tools and given == changes
+    assert [call for call in boots.calls if call[0] in (DISABLE_TOOL_EXTENSION_URI, ENABLE_TOOL_EXTENSION_URI)] == changes
+
+
+@pytest.mark.asyncio
+async def test_a_deploy_whose_tools_the_driver_cant_take_fails_and_tears_down_its_computer_alone(
+        base, driver, docker, boots, monkeypatch):
+    live = Env.get(_put(base, driver, display={"width": 1600, "height": 900}, tools="standard").id)
+    first = await live.deploy()
+    monkeypatch.setitem(DRIVER_CARD["capabilities"], "extensions", [
+        extension for extension in DRIVER_CARD["capabilities"]["extensions"] if extension["uri"] != ENABLE_TOOL_EXTENSION_URI])
+
+    with pytest.raises(EnvCapabilityUnsupported):
+        await live.deploy()
+
+    kept, failed = boots.sandboxes
+    assert failed.terminated and not kept.terminated and live._deployed is first
+
+
 @pytest.mark.asyncio
 async def test_a_reset_a_provider_cant_carry_out_fails_the_step_rather_than_skipping_it(base, driver, docker, boots,
                                                                                        monkeypatch):
diff --git a/tst/unit/env/envs/test_disk_recipe.py b/tst/unit/env/envs/test_disk_recipe.py
index 2db19a883..7aeeadf21 100644
--- a/tst/unit/env/envs/test_disk_recipe.py
+++ b/tst/unit/env/envs/test_disk_recipe.py
@@ -453,12 +453,12 @@ def run(argv, stdin=None, stdout=None, **kwargs):
     monkeypatch.setattr(local_disk.subprocess, "run", run)
     first = "localhost:5000/agentenv-computers:" + "1" * 64 + "@sha256:" + "a" * 64
 
-    exported = [local_disk.exported_disk(image) for image in (first, first, first.replace("1", "2"))]
+    exported = [local_disk.exported_disk(image, "linux/amd64") for image in (first, first, first.replace("1", "2"))]
 
     assert exported[0] == exported[1] != exported[2] and exported[0].parent == tmp_path / "cache" / "agentenv" / "disks"
     assert exported[0].read_bytes() == b"zstd:disk of container1:/disk/disk.img" and exported[0].name.endswith(".img.zst")
     assert [args[0] for args in ran] == ["login", "create", "cp", "login", "create", "cp"]
-    assert ran[0] == ("login", f"credentials for {first}") and ran[1][1:] == (first, "disk")
+    assert ran[0] == ("login", f"credentials for {first}") and ran[1][1:] == ("--platform", "linux/amd64", first, "disk")
     assert compressed[0] == ["docker", "run", "--rm", "-i", "--entrypoint", "zstd", "agentenv-qemu-launcher:src-1",
                              "-q", "-3", "-T0", "-c"] and len(compressed) == 2
     assert sorted(p.name for p in exported[0].parent.iterdir()) == sorted({exported[0].name, exported[2].name})
diff --git a/tst/unit/providers/sandbox_providers/modal_create_signature_test.py b/tst/unit/providers/sandbox_providers/modal_create_signature_test.py
index 1b97f2eca..509857c4e 100644
--- a/tst/unit/providers/sandbox_providers/modal_create_signature_test.py
+++ b/tst/unit/providers/sandbox_providers/modal_create_signature_test.py
@@ -62,7 +62,7 @@ def _provider(cls, **kwargs):
 def _exported_disk(tmp_path, monkeypatch):
     """A disk's export on this machine, and the launcher's image, without Docker or a registry."""
     (tmp_path / "disk.img.zst").write_bytes(b"disk")
-    monkeypatch.setattr(modal_vm_sandbox, "exported_disk", lambda image: tmp_path / "disk.img.zst")
+    monkeypatch.setattr(modal_vm_sandbox, "exported_disk", lambda image, platform: tmp_path / "disk.img.zst")
     monkeypatch.setattr(modal_vm_sandbox, "published_digest", lambda image: "sha256:" + "b" * 64)
 
 
diff --git a/tst/unit/providers/sandbox_providers/modal_vm_sandbox_test.py b/tst/unit/providers/sandbox_providers/modal_vm_sandbox_test.py
index c7d606c6e..00abfa117 100644
--- a/tst/unit/providers/sandbox_providers/modal_vm_sandbox_test.py
+++ b/tst/unit/providers/sandbox_providers/modal_vm_sandbox_test.py
@@ -442,7 +442,8 @@ async def create(*command, **kwargs):
 
     monkeypatch.setattr(mvs.modal.Sandbox, "_experimental_create", SimpleNamespace(aio=create))
     monkeypatch.setattr(mvs.modal.Secret, "from_dict", lambda variables: made.secrets.append(variables) or variables)
-    monkeypatch.setattr(mvs, "exported_disk", lambda image: made.exported.append(image) or Path("/cache/disk.img.zst"))
+    monkeypatch.setattr(mvs, "exported_disk", lambda image, platform: made.exported.append((image, platform))
+                        or Path("/cache/disk.img.zst"))
     monkeypatch.setattr(mvs, "_launcher", AsyncMock(return_value=made.launcher))
     monkeypatch.setattr(mvs, "_log_sandbox_started", AsyncMock())
     return made
@@ -467,7 +468,7 @@ async def test_a_disk_boots_in_a_vm_sandbox_whose_image_is_the_launcher_with_the
                                              cpu=2, memory=4096, timeout=3600)
 
     ((command, kwargs),) = modal_fake.creates
-    assert modal_fake.exported == [DISK_IMAGE]
+    assert modal_fake.exported == [(DISK_IMAGE, "linux/amd64")]
     modal_fake.launcher.add_local_file.assert_called_once_with(Path("/cache/disk.img.zst"), "/disk/disk.img.zst",
                                                                copy=False)
     assert command == ("/usr/local/bin/launch",) and kwargs["image"] is modal_fake.launcher.add_local_file.return_value