prime-cli

name: prime-cli description: > Use when the user works with Prime Intellect packages (prime-rl, prime, verifiers, etc.) and mentions: GPU, pods, compute, sandboxes, ML environments, evaluations, evals, RL training, reinforcement learning, inference, Docker images, tunneling, disks, secrets, Prime Intellect, prime CLI, deploy model, rent GPU, SSH pod, sandbox SDK, verifiers, GEPA, OpenEnv, code execution, persistent storage, team management.

Prime CLI Reference

The prime CLI manages GPU compute, sandboxes, ML environments, evaluations, RL training, and more on the Prime Intellect platform.

Authentication

prime login                  # Browser-based login (recommended)
prime login --headless       # Print URL without opening browser
prime config set-api-key     # Set API key directly (prompts securely)

Environment variables (override config file):

• PRIME_API_KEY - API key
• PRIME_TEAM_ID - Team ID
• PRIME_USER_ID - User ID
• PRIME_API_BASE_URL / PRIME_BASE_URL - API base URL
• PRIME_FRONTEND_URL - Frontend URL
• PRIME_INFERENCE_URL - Inference API URL
• PRIME_SSH_KEY_PATH - SSH private key path

Config file: ~/.prime/config.json (created by prime login)

Global Options

• --version / -v - Show version
• --context / -c <name> - Use a specific config context for this command
• --output / -o table|json - Output format (most list/get commands)
• --yes / -y - Skip confirmation prompts
• --watch / -w - Real-time refresh (pods list, disks list)
• --num / -n and --page / -p - Pagination (evals, rl, env, deployments)

Account Commands

prime login

Browser-based authentication. Prompts for team selection after login.

• --headless - Don't open browser

prime whoami

Show current user info, team, and token permissions.

prime config

prime teams list

List teams for current user. -o table|json

prime secret

prime upgrade

Auto-detect install method (uv/pipx/pip) and upgrade.

• --check / -c - Only check, don't upgrade
• --force / -f - Force upgrade even if on latest

Compute Commands

prime availability

prime pods

prime sandbox

prime disks

prime images

prime registry

prime tunnel

prime inference

Lab Commands

prime env

Explore:

Manage:

prime eval

By default, prime eval <environment> runs prime eval run <environment>.

prime rl

Commands:

Monitoring:

prime gepa

prime lab

prime deployments

Common Workflows

Get a GPU pod running

prime availability list --gpu-type H100_80GB
prime pods create --id <ID_FROM_ABOVE>     # Interactive setup
prime pods list --watch                     # Wait for ACTIVE
prime pods ssh <POD_ID>

Create and use a sandbox

prime sandbox create python:3.11-slim --cpu-cores 2 --memory-gb 4
prime sandbox run <ID> -- python -c "print('hello')"
prime sandbox upload <ID> ./script.py /app/script.py
prime sandbox run <ID> -- python /app/script.py
prime sandbox delete <ID>

GPU sandbox

prime sandbox create --gpu-count 1 --gpu-type H100_80GB --timeout-minutes 120
prime sandbox ssh <ID>

Run and push evaluations

prime eval run gsm8k                       # Run eval
prime eval push                            # Auto-discover and push results
prime eval push ./outputs/evals/gsm8k/     # Push specific directory
prime eval list                            # View pushed evals

RL training lifecycle

prime rl init                              # Generate rl.toml template
# Edit rl.toml with model, env, hyperparams
prime rl run rl.toml                       # Start training
prime rl list                              # List runs
prime rl logs <RUN_ID> --follow            # Stream logs
prime rl metrics <RUN_ID>                  # Check metrics
prime rl checkpoints <RUN_ID>              # View checkpoints
prime rl stop <RUN_ID>                     # Stop when done

Persistent disks with pods

prime availability disks                   # See disk locations
prime disks create --id <ID> --size 100    # Create 100GB disk
prime pods create --id <GPU_ID> --disks <DISK_ID>  # Attach to pod

Custom Docker images

prime images push myapp:v1.0.0             # Build & push from Dockerfile
prime images list                          # Check build status
prime sandbox create myapp:v1.0.0          # Use in sandbox

Team collaboration

prime login                                # Select team during login
prime config set-team-id <TEAM_ID>         # Switch team
prime config remove-team-id                # Switch to personal
prime teams list                           # List your teams

Tunneling

prime tunnel start --port 8080             # Expose local port
prime tunnel list                          # List active tunnels
prime tunnel stop <TUNNEL_ID>              # Stop tunnel

Deploy trained model for inference

prime rl list                              # Find completed run
prime deployments list                     # Check adapter status
prime deployments create <MODEL_ID>        # Deploy for inference
prime inference models                     # Verify model available

Python SDK (Sandboxes)

pip install prime-sandboxes

Sync usage

from prime_sandboxes import APIClient, SandboxClient, CreateSandboxRequest

client = APIClient(api_key="your-api-key")  # Or reads from env/config
sandbox_client = SandboxClient(client)

sandbox = sandbox_client.create(CreateSandboxRequest(
    name="my-sandbox",
    docker_image="python:3.11-slim",
    cpu_cores=2, memory_gb=4,
    environment_vars={"DEBUG": "true"},
    secrets={"API_KEY": "sk-..."},
    labels=["experiment"],
))
sandbox_client.wait_for_creation(sandbox.id)

result = sandbox_client.execute_command(sandbox.id, "python --version")
print(result.stdout)

sandbox_client.upload_file(sandbox.id, "/app/script.py", "./script.py")
sandbox_client.download_file(sandbox.id, "/app/output.txt", "./output.txt")

# Background jobs for long-running tasks
job = sandbox_client.start_background_job(sandbox.id, "python train.py")
status = sandbox_client.get_background_job(sandbox.id, job)

sandbox_client.delete(sandbox.id)

Async usage

import asyncio
from prime_sandboxes import AsyncSandboxClient, CreateSandboxRequest

async def main():
    async with AsyncSandboxClient(api_key="your-api-key") as client:
        sandbox = await client.create(CreateSandboxRequest(
            name="async-sandbox", docker_image="python:3.11-slim",
        ))
        await client.wait_for_creation(sandbox.id)
        result = await client.execute_command(sandbox.id, "echo hello")
        print(result.stdout)
        await client.delete(sandbox.id)

asyncio.run(main())

Bulk operations

# Create multiple sandboxes
ids = [sandbox_client.create(CreateSandboxRequest(...)).id for _ in range(5)]
sandbox_client.bulk_wait_for_creation(ids)
sandbox_client.bulk_delete(sandbox_ids=ids)
# Or delete by labels
sandbox_client.bulk_delete(labels=["experiment"])

Troubleshooting

• "Not authenticated" - Run prime login or set PRIME_API_KEY
• Config issues - Check prime config view, reset with prime config reset
• Pod stuck INSTALLING - Check prime pods status <ID> for installation_error
• SSH fails - Verify key path: prime config set-ssh-key-path ~/.ssh/id_rsa
• Sandbox auth errors - Try prime sandbox reset-cache
• Wrong team context - Check prime whoami, switch with prime config set-team-id
• Multiple environments - Use prime config save <name> / prime config use <name> or prime -c <name> <command>