Exécuter Muse Code dans une sandbox

Run Muse Code inside a CoreWeave sandbox to edit files and execute commands in a remote workspace. This guide uses the Sandbox software development kit (SDK) to install the command-line interface (CLI) and clone a repository. You then run a task without an interactive terminal and retrieve the result before you stop the sandbox. The agent process and workspace run on CoreWeave, and model requests go to Meta.

Prerequisites

Before you begin, you need the following:

Une clé API W&B. Ces exemples utilisent l’authentification W&B.
Une clé API Meta donnant accès à Muse Code.
L’URL d’un dépôt public que le sandbox peut cloner. Pour les dépôts privés, des identifiants Git doivent être configurés dans le sandbox.
Python 3.11 ou version ultérieure avec uv, ou Node.js 22 ou version ultérieure avec npm.

Chargez vos identifiants d’authentification depuis votre gestionnaire de secrets dans l’environnement de votre terminal local. Remplacez [WANDB-API-KEY] par votre clé API W&B et [META-API-KEY] par votre clé API Meta :

export WANDB_API_KEY="[WANDB-API-KEY]"
export META_API_KEY="[META-API-KEY]"

Le script transmet la clé Meta via l’entrée standard afin qu’elle n’apparaisse ni dans les arguments de la commande ni dans la configuration du sandbox. Pour utiliser un identifiant d’authentification partagé par l’équipe et injecté en tant que variable d’environnement lors de la création du sandbox, consultez Secrets W&B.

Install the Sandbox client

Choose a language and prepare a local project:

Python
TypeScript

mkdir muse-sandbox
cd muse-sandbox
uv init --bare --python 3.11
uv venv --python 3.11
source .venv/bin/activate
uv pip install 'cwsandbox[wandb]>=1.14.2'

mkdir muse-sandbox
cd muse-sandbox
npm init -y
npm install @coreweave/cwsandbox@0.5.0-beta.0 tsx

Run a task in the sandbox

Save the script for your language using the filename shown. Each script creates a serverless sandbox with a 30-minute maximum lifetime and performs these steps:

Installs Muse Code with Meta’s installer.
Clones your repository into the /workspace/project directory.
Runs muse exec to build and test a sparkline CLI that renders numbers as a small chart.
Runs the generated CLI independently, checks its output, and saves the sparkline.mjs file locally.
Stops the sandbox in a finally block, including when setup or execution fails.

These examples were tested with Muse Code 1.3.0. The installer can install a newer version, so each script runs muse --version after installation. The example uses --yolo to disable Muse Code’s approval prompts and operating system (OS) sandbox and trust the workspace for this run. CoreWeave supplies the outer sandbox. Muse can access files, credentials, and network destinations available inside that sandbox. Use a repository you trust and provide only the credentials the task needs. For more information, see Muse Code permissions.

Python
TypeScript

run_muse.py

import os
import sys
from pathlib import Path

from cwsandbox import AuthStrategy, Sandbox

if len(sys.argv) != 2:
    raise SystemExit("Usage: python run_muse.py [REPOSITORY-URL]")
meta_api_key = os.environ["META_API_KEY"]

sandbox = Sandbox.run(
    auth=AuthStrategy.WANDB,
    container_image="node:22-bookworm",
    resources={"cpu": "2", "memory": "4Gi"},
    max_lifetime_seconds=1800,
    tags=["muse-code"],
)
try:
    sandbox.wait()
    commands = [
        ["bash", "-o", "pipefail", "-ec", "curl -fsSL https://dev.meta.ai/install.sh | bash"],
        ["bash", "-ec", '"$HOME/.local/bin/muse" --version'],
        ["git", "clone", "--", sys.argv[1], "/workspace/project"],
    ]
    for command in commands:
        result = sandbox.exec(command, timeout_seconds=600, check=True).result()
        print(result.stdout, end="")

    agent = sandbox.exec(
        [
            "bash", "-ec",
            'IFS= read -r META_API_KEY; export META_API_KEY; '
            'exec "$HOME/.local/bin/muse" exec --yolo "$1"',
            "bash",
            "Create sparkline.mjs, a dependency-free Node.js CLI that converts its "
            "numeric arguments to a sparkline using ▁▂▃▄▅▆▇█. Scale from the minimum "
            "to the maximum and round to the nearest bar index. "
            "Running node sparkline.mjs 2 4 8 4 2 must print ▁▃█▃▁ followed by "
            "a newline. Run that command to test it.",
        ],
        cwd="/workspace/project",
        stdin=True,
        timeout_seconds=600,
    )
    # Laisser stdin ouvert jusqu’à ce que Muse ait terminé, pour ne pas interrompre une requête qui ne produit aucune sortie.
    agent.stdin.writeline(meta_api_key).result()
    result = agent.result()
    print(result.stdout, end="")
    print(result.stderr, end="", file=sys.stderr)
    if result.returncode != 0:
        raise SystemExit(result.returncode)

    chart = sandbox.exec(
        ["node", "sparkline.mjs", "2", "4", "8", "4", "2"],
        cwd="/workspace/project", check=True,
    ).result()
    if chart.stdout != "▁▃█▃▁\n":
        raise RuntimeError(f"Unexpected sparkline: {chart.stdout!r}")
    print(chart.stdout, end="")
    source = sandbox.exec(
        ["cat", "/workspace/project/sparkline.mjs"], check=True
    ).result()
    Path("sparkline.mjs").write_text(source.stdout, encoding="utf-8")
finally:
    sandbox.stop().result()

run_muse.mts

import { writeFile } from "node:fs/promises";
import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/wandb";

const repository = process.argv[2];
if (!repository) throw new Error("Pass a repository URL.");
const metaApiKey = process.env.META_API_KEY;
if (!metaApiKey) throw new Error("Set META_API_KEY.");

const client = createSandboxClientFromEnv();
const sandbox = await client.create({
  containerImage: "node:22-bookworm",
  resources: { cpu: "2", memory: "4Gi" },
  maxLifetimeSeconds: 1800,
  waitUntilRunning: false,
  tags: ["muse-code"],
});
try {
  await sandbox.wait();
  const commands = [
    ["bash", "-o", "pipefail", "-ec", "curl -fsSL https://dev.meta.ai/install.sh | bash"],
    ["bash", "-ec", '"$HOME/.local/bin/muse" --version'],
    ["git", "clone", "--", repository, "/workspace/project"],
  ];
  for (const command of commands) {
    const result = await sandbox.commands.run(command, { timeoutMs: 600_000, check: true });
    process.stdout.write(result.stdout);
  }

  const agent = await sandbox.commands.start(
    [
      "bash", "-ec",
      'IFS= read -r META_API_KEY; export META_API_KEY; ' +
        'exec "$HOME/.local/bin/muse" exec --yolo "$1"',
      "bash",
      "Create sparkline.mjs, a dependency-free Node.js CLI that converts its " +
        "numeric arguments to a sparkline using ▁▂▃▄▅▆▇█. Scale from the minimum " +
        "to the maximum and round to the nearest bar index. " +
        "Running node sparkline.mjs 2 4 8 4 2 must print ▁▃█▃▁ followed by " +
        "a newline. Run that command to test it.",
    ],
    {
      cwd: "/workspace/project",
      stdin: true,
      timeoutMs: 600_000,
    },
  );
  // Laisser stdin ouvert jusqu’à ce que Muse ait terminé, afin de ne pas interrompre une requête qui ne produit aucune sortie.
  await agent.stdin.write(metaApiKey + "\n");
  const result = await agent.wait();
  process.stdout.write(result.stdout);
  process.stderr.write(result.stderr);
  if (!result.ok) throw new Error(`Muse Code exited with code ${result.exitCode}.`);

  const chart = await sandbox.commands.run(
    ["node", "sparkline.mjs", "2", "4", "8", "4", "2"],
    { cwd: "/workspace/project", check: true },
  );
  if (chart.stdout !== "▁▃█▃▁\n") {
    throw new Error(`Unexpected sparkline: ${JSON.stringify(chart.stdout)}`);
  }
  process.stdout.write(chart.stdout);
  const source = await sandbox.commands.run(
    ["cat", "/workspace/project/sparkline.mjs"], { check: true },
  );
  await writeFile("sparkline.mjs", source.stdout, "utf8");
} finally {
  await sandbox.stop();
}

In your local project directory, replace [REPOSITORY-URL] with your public repository URL, then run the script:

Python
TypeScript

python run_muse.py [REPOSITORY-URL]

npx tsx run_muse.mts [REPOSITORY-URL]

After the installation and agent output, the script checks and prints the sparkline:

▁▃█▃▁

The script saves the generated sparkline.mjs file in your local project directory, then stops the sandbox. If the file already exists locally, the script overwrites it. The output check runs independently of Muse’s own test and verifies this example’s input. For a larger task, replace it with tests for your requirements. Ces exemples ne configurent pas de stockage persistant. Copiez les fichiers dont vous avez besoin hors de la sandbox avant l’exécution du bloc finally. Voir opérations sur les fichiers et snapshots du système de fichiers.

Troubleshoot

Use these checks to resolve common issues:

Si la création de la sandbox échoue, vérifiez votre clé W&B et vos paramètres d’authentification.
Si Muse Code signale une erreur d’authentification, vérifiez META_API_KEY et la configuration de votre compte Meta. L’identifiant d’authentification de la sandbox ne sert pas à authentifier les requêtes adressées au modèle.
Si l’installation, le clonage ou les requêtes adressées au modèle échouent, vérifiez l’accès sortant vers Meta et vers votre hébergeur Git.
Si une tâche plus longue dépasse le délai imparti, ajustez au préalable le délai d’expiration de la commande et la durée de vie de la sandbox. La durée de vie de 30 minutes inclut le démarrage et l’installation. Voir délais d’expiration des commandes et cycle de vie de la sandbox.

Next steps

For more information, see these guides:

Interactive shells and TTY covers terminal access for interactive agents.
Run agents on CoreWeave sandboxes compares agent integrations and workspace options.
Meta’s sandboxed execution cookbook demonstrates a reproduce, fix, and verify workflow with a custom tool loop in Docker.
Muse Code documentation covers agent configuration and other CLI workflows.

​Prerequisites

​Install the Sandbox client

​Run a task in the sandbox

​Troubleshoot

​Next steps

Prerequisites

Install the Sandbox client

Run a task in the sandbox

Troubleshoot

Next steps