Remote Compute

Ported from companion-inc/feynman's docker, modal-compute, and runpod-compute skills (generic CLI usage — no feynman dependency). One skill, three backends: the agent stays on the host, the job runs elsewhere, raw outputs come back into the artifact folder.

Pick a backend

Need	Backend	Availability check
Isolation, untrusted code, reproducible env, no GPU or a local GPU	Docker	command -v docker
Burst GPU, bounded job, no state between runs	Modal	command -v modal
Long run, persistent state, large datasets, SSH between iterations	RunPod	command -v runpodctl

Never install packages, start training, or run an experiment before the user has confirmed the environment (research-paper asks this explicitly). Tie every remote resource to a named replication/benchmark objective — this skill is not for deploying services, unrelated batch jobs, or provider administration.

---

Docker sandbox

Mount the project into a container, run the commands inside, results write back through the mount.

Python (most common):

docker run --rm -v "$(pwd)":/workspace -w /workspace python:3.11 bash -c "
  pip install -r requirements.txt &&
  python train.py
"

Project with a Dockerfile:

docker build -t research-experiment .
docker run --rm -v "$(pwd)/results":/workspace/results research-experiment

GPU workloads (requires the NVIDIA Container Toolkit):

docker run --rm --gpus all -v "$(pwd)":/workspace -w /workspace pytorch/pytorch:latest bash -c "
  pip install -r requirements.txt &&
  python train.py
"

Choosing the base image

Research type	Base image
Python ML/DL	pytorch/pytorch:latest or tensorflow/tensorflow:latest-gpu
Python general	python:3.11
Node.js	node:20
R / statistics	rocker/r-ver:4
Julia	julia:1.10
Multi-language	ubuntu:24.04 with manual installs

Persistent containers

For an iterative loop (e.g. the research-paper autoresearch loop), use a named container instead of --rm so installed packages survive across iterations:

docker create --name <name> -v "$(pwd)":/workspace -w /workspace python:3.11 tail -f /dev/null
docker start <name>
docker exec <name> bash -c "pip install -r requirements.txt"
docker exec <name> bash -c "python train.py"
docker stop <name> && docker rm <name>   # clean up

Containers are network-enabled by default — add --network none for full isolation.

---

Modal (serverless burst GPU)

No pod lifecycle to manage: write a decorated Python script, run it, save raw outputs back into the artifact folder.

pip install modal
modal setup

Command	Description
modal run script.py	Run one experiment script on Modal
modal run --detach script.py	Run a long experiment and record the returned app/run identifier
modal shell --gpu a100	Interactive GPU shell for environment debugging

GPU types: T4, L4, A10G, L40S, A100, A100-80GB, H100, H200, B200. Multi-GPU: "H100:4".

import modal

app = modal.App("experiment")
image = modal.Image.debian_slim(python_version="3.11").pip_install("torch==2.8.0")

@app.function(gpu="A100", image=image, timeout=600)
def train():
    import torch
    # training code here

@app.local_entrypoint()
def main():
    train.remote()

---

RunPod (persistent GPU pods)

brew install runpod/runpodctl/runpodctl   # macOS
# or: curl -sSL https://raw.githubusercontent.com/runpod/runpodctl/main/install.sh | bash
runpodctl config --apiKey=YOUR_KEY

Command	Description
runpodctl create pod --gpuType "NVIDIA A100 80GB PCIe" --imageName "runpod/pytorch:2.4.0-py3.11-cuda12.4.1-devel-ubuntu22.04" --name experiment	Create a pod
runpodctl get pod	List all pods
runpodctl stop pod <id>	Stop (preserves volume)
runpodctl start pod <id>	Resume a stopped pod
runpodctl remove pod <id>	Terminate and delete
runpodctl gpu list	List available GPU types and prices
runpodctl send <file> / runpodctl receive <code>	Transfer files to/from pods

SSH access (pods must expose 22/tcp; get details from runpodctl get pod <id>):

ssh root@<IP> -p <PORT> -i ~/.ssh/id_ed25519

GPU types: NVIDIA GeForce RTX 4090, NVIDIA RTX A6000, NVIDIA A40, NVIDIA A100 80GB PCIe, NVIDIA H100 80GB HBM3.

Always stop or remove pods after the experiment — they bill while running.