---
name: Compute Resource Guard
slug: compute-resource-guard
category: DevOps
description: Compute Resource Guard checks whether local or remote GPU compute is actually available before experiments start. It stops the pipeline and reports what is missing when no usable resources are found.
github: "https://github.com/OpenLAIR/dr-claw/tree/main/skills/aris-compute-guard"
language: JavaScript
stars: 1047
forks: 116
install: "npx degit https://github.com/OpenLAIR/dr-claw/tree/main/skills/aris-compute-guard ~/.claude/skills/aris-compute-guard"
installs_to: ~/.claude/skills/aris-compute-guard
source_path: skills/aris-compute-guard/SKILL.md
collection_size: 25
category_size: 798
collection_url: "https://dirskills.com/collections/OpenLAIR/dr-claw"
added: 2026-08-21T05:13:56.561Z
last_synced: 2026-08-21T05:13:56.561Z
canonical_url: "https://dirskills.com/skills/compute-resource-guard"
---

# Compute Resource Guard

Compute Resource Guard checks whether local or remote GPU compute is actually available before experiments start. It stops the pipeline and reports what is missing when no usable resources are found.

**Install:**

```bash
npx degit https://github.com/OpenLAIR/dr-claw/tree/main/skills/aris-compute-guard ~/.claude/skills/aris-compute-guard
```

## README

# Compute Resource Guard

**MANDATORY** pre-flight check before any experiment execution. This skill determines whether the required compute resources are actually available. If they are not, you MUST stop immediately and inform the user — do NOT proceed to run experiments, and do NOT imagine or fabricate experiment results.

## Context: $ARGUMENTS

## CRITICAL RULE

**If this check determines compute resources are unavailable, you MUST:**
1. **STOP** all experiment execution immediately
2. **DO NOT** attempt to run any training scripts, evaluation scripts, or experiment code
3. **DO NOT** fabricate, imagine, or hallucinate any experiment results
4. **REPORT** clearly to the user what resources are missing and what they need to do
5. **MARK** the experiment task as blocked (not failed, not done)

## Workflow

### Step 1: Detect Target Environment

Read the project's `CLAUDE.md` to determine the experiment environment:

- **Local GPU** (`gpu: local`): Check local CUDA/MPS
- **Remote server** (`gpu: remote`): Check SSH connectivity + remote GPU
- **Vast.ai** (`gpu: vast`): Check for running instances
- **Modal** (`gpu: modal`): Check Modal CLI + auth (Modal is serverless — always "available" if configured)

If no `CLAUDE.md` exists or no `gpu:` setting is found, assume **local** environment.

### Step 2: Check Compute Availability

#### For Local GPU (Linux with CUDA):

```bash
# Check if nvidia-smi exists
which nvidia-smi 2>/dev/null
# If exists, check GPU status
nvidia-smi --query-gpu=index,name,memory.used,memory.total,utilization.gpu --format=csv,noheader 2>/dev/null
```

**Available** = `nvidia-smi` succeeds AND at least one GPU has `memory.used < 500 MiB` (free).
**Unavailable** = `nvidia-smi` not found, returns error, or ALL GPUs have `memory.used >= memory.total * 0.9`.

#### For Local GPU (Mac with MPS):

```bash
python3 -c "
import torch
mps_available = hasattr(torch.backends, 'mps') and torch.backends.mps.is_available()
print(f'MPS_AVAILABLE={mps_available}')
if mps_available:
    print('COMPUTE_OK=true')
else:
    print('COMPUTE_OK=false')
" 2>/dev/null
```

**Available** = MPS is available (Apple Silicon with PyTorch MPS support).
**Unavailable** = No MPS, no CUDA, pure CPU only — warn user that experiments will be extremely slow or may not work.

#### For Local CPU-only (no GPU):

```bash
# Check if any GPU framework is available
python3 -c "
import torch
cuda = torch.cuda.is_available()
mps = hasattr(torch.backends, 'mps') and torch.backends.mps.is_available()
print(f'CUDA={cuda}, MPS={mps}')
if not cuda and not mps:
    print('COMPUTE_OK=false')
    print('REASON=No GPU available (no CUDA, no MPS). CPU-only execution is not suitable for ML training experiments.')
else:
    print('COMPUTE_OK=true')
" 2>&1
```

If `python3` or `torch` is not installed:
```bash
# Fallback: check for nvidia-smi directly
nvidia-smi 2>/dev/null || echo "COMPUTE_OK=false"
echo "REASON=Neither nvidia-smi nor PyTorch found. Cannot verify GPU availability."
```

#### For Remote Server (SSH):

```bash
# Check SSH connectivity (timeout 10s)
ssh -o ConnectTimeout=10 -o BatchMode=yes <server> "echo CONNECTED" 2>/dev/null
# If connected, check GPU
ssh -o ConnectTimeout=10 <server> "nvidia-smi --query-gpu=index,memory.used,memory.total --format=csv,noheader" 2>/dev/null
```

**Available** = SSH connects AND GPU has free memory.
**Unavailable** = SSH fails (server down, auth issue, network) OR no free GPU.

#### For Vast.ai:

```bash
# Check for running instances
cat vast-instances.json 2>/dev/null
# Or query Vast.ai API
vastai show instances 2>/dev/null
```

**Available** = A running instance exists with SSH access.
**Unavailable** = No running instances (need to provision one first).

#### For Modal (serverless):

```bash
# Check Modal CLI is installed and authenticated
modal token verify 2>/dev/null || echo "MODAL_NOT_CONFIGURED"
```

**Available** = Modal CLI installed and authenticated.
**Unavailable** = Modal not installed or not authenticated.

### Step 3: Decision Gate

| Check Result | Action |
|---|---|
| **COMPUTE_OK = true** | Proceed with experiment. Print brief resource summary and continue. |
| **COMPUTE_OK = false** | **STOP IMMEDIATELY.** Do NOT run any experiments. Go to Step 4. |

### Step 4: Stop and Report (when compute unavailable)

When compute resources are NOT available, respond with a clear, structured message:

```
⚠️ COMPUTE RESOURCES UNAVAILABLE — Experiment Stopped

I checked the compute resources and they are NOT available for running experiments.

**Environment:** [local / remote / vast.ai / modal]
**Issue:** [specific reason — e.g., "No GPU detected", "SSH connection failed", "All GPUs fully occupied"]

**What you need to do:**
- [Actionable step 1 — e.g., "Ensure your machine has a CUDA-compatible GPU"]
- [Actionable step 2 — e.g., "Free up GPU memory by stopping other processes"]
- [Actionable step 3 — e.g., "Configure a remote server in CLAUDE.md"]

**Alternative options:**
- Set `gpu: modal` in CLAUDE.md to use Modal serverless GPU (no local GPU needed)
- Set `gpu: vast` in CLAUDE.md to rent an on-demand GPU from Vast.ai
- Configure a remote GPU server with `gpu: remote` in CLAUDE.md

I will NOT proceed with running experiments or generating results, as doing so without actual compute resources would produce fabricated output. Please resolve the compute issue and try again.
```

**After this message, STOP. Do not continue with any experiment workflow steps.**

### Step 5: Proceed Summary (when compute available)

When compute IS available, print a brief summary and return control:

```
✅ Compute resources verified:
- Environment: [local / remote / vast.ai / modal]
- GPU: [GPU name, count, free memory]
- Status: Ready for experiments

Proceeding with experiment execution.
```

## Integration

This skill is called automatically by:
- `/aris-run-experiment` (Step 0, before environment detection)
- `/aris-experiment-bridge` (Phase 0, before parsing experiment plan)

It can also be called standalone:
```
/aris-compute-guard
/aris-compute-guard local
/aris-compute-guard remote
```

## Rules

- NEVER skip this check. It exists to prevent wasted time and hallucinated results.
- If the check itself fails (e.g., `python3` not found), treat it as **unavailable** and report.
- For `gpu: modal`, the check is lenient — Modal handles GPU allocation automatically. Only fail if Modal CLI is not installed/authenticated.
- For CPU-only environments, warn but allow if the experiment is explicitly CPU-compatible (e.g., small-scale testing, data preprocessing).
- This check should complete in under 30 seconds. If SSH times out, report as unavailable.