Prime Intellect CLI & SDKs
Command line interface and SDKs for Hosted Training, hosted evaluations, GPU resources, sandboxes, and environments.
Overview
Prime is the official CLI and Python SDK for Prime Intellect, providing seamless access to Hosted Training, hosted evaluations, GPU compute infrastructure, remote code execution environments (sandboxes), and AI inference capabilities.
What can you do with Prime?
- Deploy GPU pods with H100, A100, and other high-performance GPUs
- Set up Lab workspaces for verifiers environments, evals, GEPA, and training
- Discover and launch Hosted Training runs against verifiers environments
- Create and manage isolated sandbox environments for running code
- Access hundreds of pre-configured development environments
- SSH directly into your compute instances
- Manage team resources and permissions
- Run OpenAI-compatible inference requests
Installation
Using uv (recommended)
First, install uv if you haven't already:
curl -LsSf https://astral.sh/uv/install.sh | sh
Then install prime:
uv tool install prime
Using pip
pip install prime
Quick Start
Authentication
# Interactive login (recommended)
prime login
# Cap what the key minted by this login can do (see `prime login --help`)
prime login --max-concurrent-sandboxes 10 --max-concurrent-tunnels 2
# Or set API key directly
prime config set-api-key
# Or use environment variable
export PRIME_API_KEY="your-api-key-here"
Get your API key from the Prime Intellect Dashboard.
Basic Usage
# Browse environments on the hub
prime env list
# Set up a Lab workspace for environments, evals, GEPA, and Hosted Training
prime lab setup
# See available Hosted Training models, capacity, and pricing
prime train models
# Launch a prime-rl config as a Hosted Training run
prime train rl.toml
# List available GPUs
prime availability list
# Create a GPU pod
prime pods create --gpu A100 --count 1
# SSH into a pod
prime pods ssh <pod-id>
# Create a sandbox
prime sandbox create python:3.11
Features
Lab and Hosted Training
Start with prime lab setup to create a local workspace with starter configs, coding-agent skills and a verifiers install; build and evaluate environments there with verifiers' vf-init and vf-eval. Then use prime train models to choose a Hosted Training model with current capacity and pricing. Hosted Training runs take prime-rl configs as-is; its examples/ are good starting points.
# Set up a Lab workspace
prime lab setup
# List cached models and on-demand GPU capacity and pricing
prime train models
# Launch a prime-rl config (RL, or SFT with --sft) on a dedicated cluster
prime train rl.toml
# Inspect and manage Hosted Training runs
prime train list
prime train logs <run-id> -f
prime train metrics <run-id>
prime train checkpoints <run-id>
Environments Hub
Access hundreds of RL environments on our community hub with deep integrations with sandboxes, training, and evaluation stack.
# Browse available environments
prime env list
# View environment details
prime env info <environment-name>
# Inspect environment source without downloading the archive
prime env inspect <environment-name>
# Install an environment locally
prime env install <environment-name>
# Push your own environment (scaffold one with verifiers' `vf-init`)
prime env push my-environment
Environments provide pre-configured setups for machine learning, data science, and development workflows, tested and verified by the Prime Intellect community.
GPU Pod Management
Deploy and manage GPU compute instances:
# Browse available configurations
prime availability list --gpu-type H100_80GB
# Create a pod with specific configuration
prime pods create --id <config-id> --name my-training-pod
# Monitor pod status
prime pods status <pod-id>
# SSH access
prime pods ssh <pod-id>
# Terminate when done
prime pods terminate <pod-id>
Sandboxes
Isolated environments for running code remotely:
# Create a sandbox (VM-backed)
prime sandbox create python:3.11
# Create a sandbox with GPUs
prime sandbox create user-1/vm-image:latest --gpu-count 1 --gpu-type RTX_PRO_6000
# Create a one-shot workload (arguments after -- are preserved exactly)
prime sandbox create user-1/vm-image:latest -- /worker --platform linux/amd64
# List sandboxes
prime sandbox list
# Execute commands
prime sandbox run <sandbox-id> -- python script.py
# Run as an existing guest account
prime sandbox run <sandbox-id> --user ubuntu -- id
# Request a filesystem checkpoint; check again until it is DURABLE
prime sandbox checkpoint create <sandbox-id>
prime sandbox checkpoint list <sandbox-id> [--checkpoint-id <checkpoint-id>]
prime sandbox checkpoint restore <checkpoint-id> --name restored-sandbox
# Checkpoint + restore in one step, inheriting the source's resources
prime sandbox fork <sandbox-id> [--name forked-sandbox]
# Upload/download files
prime sandbox upload <sandbox-id> local_file.py /remote/path/
prime sandbox download <sandbox-id> /remote/file.txt ./local/
# Clean up
prime sandbox delete <sandbox-id>
Volume contents
Inspect stored files without starting an SSH session:
prime volumes list # List volumes
prime volumes ls my-data # List files and directories
prime volumes ls my-data datasets/ -l -h # Sizes and modified times
prime volumes ls my-data runs/ -R # Include nested run outputs
prime volumes ls my-data -o json # Volume-relative paths and metadata
prime volumes du my-data -h # Stored bytes, object count, and cap
prime volumes du my-data datasets/ -o json # Subtree and whole-volume usage
prime volumes cat my-data config.json | jq .
Paths use the same validation as volumes get and put: they are relative
to the volume root, and / selects that root. ls -R includes nested
directories, including empty directories. du scans the entire volume
with paginated listings so the usage percentage always compares the
whole volume with its cap, even when a file or subtree is selected.
Directory marker objects count toward the object total; internal SSH sync
metadata is excluded. These commands report usage without enforcing the cap.
Reads use the stored copy. Read-write SSH changes appear after the next
sync, normally about 60 seconds later. This freshness note is printed to
stderr; cat writes only the file's bytes to stdout, without adding a newline.
Team Management
Manage resources across personal and team contexts:
# List your teams
prime teams list
# Switch context directly
prime switch
prime switch personal
prime switch <team-slug>
prime switch <team-id> # fallback for teams without a slug
# All subsequent commands use the selected context
prime pods list
Configuration
API Key
Multiple ways to configure your API key:
# Option 1: Interactive (hides input)
prime config set-api-key
# Option 2: Direct
prime config set-api-key YOUR_API_KEY
# Option 3: Environment variable
export PRIME_API_KEY="your-api-key"
Configuration priority: CLI config > Environment variable
SSH Key
Configure SSH key for pod access:
prime config set-ssh-key-path ~/.ssh/id_rsa.pub
View Configuration
prime config view
Python SDK
Prime also provides a Python SDK for programmatic access:
from prime_sandboxes import APIClient, SandboxClient, CreateSandboxRequest
# Initialize client
client = APIClient(api_key="your-api-key")
sandbox_client = SandboxClient(client)
# Create a sandbox
sandbox = sandbox_client.create(CreateSandboxRequest(
name="my-sandbox",
docker_image="python:3.11-slim",
cpu_cores=2,
memory_gb=4,
))
# Wait for creation
sandbox_client.wait_for_creation(sandbox.id)
# Execute commands
result = sandbox_client.execute_command(sandbox.id, "python --version")
print(result.stdout)
# Request a filesystem checkpoint and wait until it is durable
checkpoint = sandbox_client.checkpoint(sandbox.id)
checkpoint = sandbox_client.wait_for_checkpoint(checkpoint.id, timeout_seconds=300)
restored = sandbox_client.create(CreateSandboxRequest(
name="restored-sandbox", checkpoint_id=checkpoint.id
))
# Clean up
sandbox_client.delete(sandbox.id)
Async SDK
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())
Use Cases
Machine Learning Training
# Deploy a pod with 8x H100 GPUs
prime pods create --gpu H100 --count 8 --name ml-training
# SSH and start training
prime pods ssh <pod-id>
Support & Resources
- Documentation: github.com/PrimeIntellect-ai/prime
- Dashboard: app.primeintellect.ai
- API Docs: api.primeintellect.ai/docs
- Discord: discord.gg/primeintellect
- Website: primeintellect.ai
Related Packages
- prime-sandboxes - Lightweight SDK for sandboxes only (if you don't need the full CLI)
License
MIT License - see LICENSE file for details.
1 maintainer
Metadata
1 maintainer
Release files for prime 0.14.0
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | |
|---|---|---|---|
| prime-0.14.0.tar.gz | 654.8 kB | Details |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Reset |
|---|---|---|---|---|
| prime-0.14.0-py3-none-any.whl | Python 3 | none | any | Details |
Total release size: 1.0 MB
Release files / prime-0.14.0.tar.gz
| Download URL | prime-0.14.0.tar.gz |
|---|---|
| Size | 654.8 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
44e20e12daf775ad339ca99122619b248548cdb2eb9f235c9fda0ac0e4ff9235
|
|
BLAKE2b-256 checksum How to use checksums |
df589dd2618f24ac68fa6843bf0172e4e05ca5745d78be34f5865f210032294a
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.14
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Oct 14, 2026.
Transparency logRelease files / prime-0.14.0-py3-none-any.whl
| Download URL | prime-0.14.0-py3-none-any.whl |
|---|---|
| Size | 347.9 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
2248802a6794b46ad99c0857be8fbd07cdf7f314b6078094352007305bf04f74
|
|
BLAKE2b-256 checksum How to use checksums |
dddf2767c2d8286b825fd840182a426e5c303c9cdbb20992b60ed8e56e661f5d
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.14
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Oct 14, 2026.
Transparency log
