infrastructure-lambda-labs skill
✓ VerifiedProvision dedicated GPU instances and high-performance multi-node clusters for machine learning training and inference.
- GitHub stars
- 33,302
- Files
- 3
- Last commit
- Nov 11, 2026
- License
- MIT
- Allowed tools
- —
What does the infrastructure-lambda-labs skill do?
infrastructure-lambda-labs is an agent skill. Provision dedicated GPU instances and high-performance multi-node clusters for machine learning training and inference.
Summary generated from the skill's SKILL.md.
About the infrastructure-lambda-labs skill
Provisioning dedicated GPU instances and high-performance multi-node clusters for machine learning training and inference is what this skill enables. It is designed for developers and researchers who need specialized hardware like B200, H100, or A100 GPUs to run long training jobs that last hours or days. An agent should load this skill when a user requires full SSH access to a machine, persistent storage across sessions, or large-scale distributed training using Slurm clusters with InfiniBand.
The skill utilizes the lambda-cloud-client to manage infrastructure through a Python API or curl commands. It produces running compute instances, managed filesystems for saving checkpoints, and 1-Click Clusters containing between 16 and 512 GPUs. Unlike serverless alternatives, this provides a pre-installed Lambda Stack including PyTorch, TensorFlow, and CUDA, ensuring the environment is ready for immediate workload execution without manual driver configuration.
What an agent can do with it
- 1Manage persistent machine learning dataAttach filesystems to instances to ensure datasets and model checkpoints survive restarts.
Written from the skill's SKILL.md. Every use case is checked against a quote from it.
How to install the infrastructure-lambda-labs skill
Each command copies the skill folder into the client's skills directory. Restart the client or start a new session to load it.Install the infrastructure-lambda-labs skill in Claude Code
~/.claude/skills/infrastructure-lambda-labs/SKILL.md
$ npx degit davila7/claude-code-templates/cli-tool/components/skills/ai-research/infrastructure-lambda-labs ~/.claude/skills/infrastructure-lambda-labsInstall the infrastructure-lambda-labs skill in Claude Code (project)
.claude/skills/infrastructure-lambda-labs/SKILL.md
$ npx degit davila7/claude-code-templates/cli-tool/components/skills/ai-research/infrastructure-lambda-labs .claude/skills/infrastructure-lambda-labsInstall the infrastructure-lambda-labs skill in Codex
~/.agents/skills/infrastructure-lambda-labs/SKILL.md
$ npx degit davila7/claude-code-templates/cli-tool/components/skills/ai-research/infrastructure-lambda-labs ~/.agents/skills/infrastructure-lambda-labsInstall the infrastructure-lambda-labs skill in Gemini CLI
~/.gemini/skills/infrastructure-lambda-labs/SKILL.md
$ npx degit davila7/claude-code-templates/cli-tool/components/skills/ai-research/infrastructure-lambda-labs ~/.gemini/skills/infrastructure-lambda-labsInstall the infrastructure-lambda-labs skill in Claude.ai
npx degit davila7/claude-code-templates/cli-tool/components/skills/ai-research/infrastructure-lambda-labs infrastructure-lambda-labs && zip -r infrastructure-lambda-labs.zip infrastructure-lambda-labs # claude.ai → Customize → Skills → + → Create skill → Upload a skill → infrastructure-lambda-labs.zip
Automated checks
Ran Nov 15, 2026Full report →Passed our automated checks. That is not a security audit: read the scripts before you let an agent run them. How checks work · What to fix for more points
- Source repository linked and reachabledavila7/claude-code-templates/cli-tool/components/skills/ai-research/infrastructure-lambda-labs is public and reachablegithub.com/davila7/claude-code-templates/tree/HEAD/cli-tool/ ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit 2026-11-11github.com/davila7/claude-code-templates/commits ↗Pass
- No download-and-run or credential theft in scriptsNo scripts in the skill folderPass
- No hidden instructions in SKILL.mdNo override phrases, safeguard switches, credential requests or hidden charactersgithub.com/davila7/claude-code-templates/blob/HEAD/cli-tool/ ↗Pass
- Pre-approved tools are scopedNo pre-approved tools; the agent asks before using onegithub.com/davila7/claude-code-templates/blob/HEAD/cli-tool/ ↗Pass
- SKILL.md follows the Agent Skills formatSKILL.md is 546 lines; the spec suggests under 500github.com/davila7/claude-code-templates/blob/HEAD/cli-tool/ ↗Finding
SKILL.md
View on GitHubLambda Labs GPU Cloud
Comprehensive guide to running ML workloads on Lambda Labs GPU cloud with on-demand instances and 1-Click Clusters.
When to use Lambda Labs
Use Lambda Labs when:
- Need dedicated GPU instances with full SSH access
- Running long training jobs (hours to days)
- Want simple pricing with no egress fees
- Need persistent storage across sessions
- Require high-performance multi-node clusters (16-512 GPUs)
- Want pre-installed ML stack (Lambda Stack with PyTorch, CUDA, NCCL)
Key features:
- GPU variety: B200, H100, GH200, A100, A10, A6000, V100
- Lambda Stack: Pre-installed PyTorch, TensorFlow, CUDA, cuDNN, NCCL
- Persistent filesystems: Keep data across instance restarts
- 1-Click Clusters: 16-512 GPU Slurm clusters with InfiniBand
- Simple pricing: Pay-per-minute, no egress fees
- Global regions: 12+ regions worldwide
Use alternatives instead:
- Modal: For serverless, auto-scaling workloads
- SkyPilot: For multi-cloud orchestration and cost optimization
- RunPod: For cheaper spot instances and serverless endpoints
- Vast.ai: For GPU marketplace with lowest prices
Quick start
Account setup
- Create account at https://lambda.ai
- Add payment method
- Generate API key from dashboard
- Add SSH key (required before launching instances)
Launch via console
- Go to https://cloud.lambda.ai/instances
- Click "Launch instance"
- Select GPU type and region
- Choose SSH key
- Optionally attach filesystem
- Launch and wait 3-15 minutes
Connect via SSH
# Get instance IP from console
ssh ubuntu@<INSTANCE-IP>
# Or with specific key
ssh -i ~/.ssh/lambda_key ubuntu@<INSTANCE-IP>
GPU instances
Available GPUs
| GPU | VRAM | Price/GPU/hr | Best For |
|---|---|---|---|
| B200 SXM6 | 180 GB | $4.99 | Largest models, fastest training |
| H100 SXM | 80 GB | $2.99-3.29 | Large model training |
| H100 PCIe | 80 GB | $2.49 | Cost-effective H100 |
| GH200 | 96 GB | $1.49 | Single-GPU large models |
| A100 80GB | 80 GB | $1.79 | Production training |
| A100 40GB | 40 GB | $1.29 | Standard training |
| A10 | 24 GB | $0.75 | Inference, fine-tuning |
| A6000 | 48 GB | $0.80 | Good VRAM/price ratio |
| V100 | 16 GB | $0.55 | Budget training |
Instance configurations
8x GPU: Best for distributed training (DDP, FSDP)
4x GPU: Large models, multi-GPU training
2x GPU: Medium workloads
1x GPU: Fine-tuning, inference, development
Launch times
- Single-GPU: 3-5 minutes
- Multi-GPU: 10-15 minutes
Lambda Stack
All instances come with Lambda Stack pre-installed:
# Included software
- Ubuntu 22.04 LTS
- NVIDIA drivers (latest)
- CUDA 12.x
- cuDNN 8.x
- NCCL (for multi-GPU)
- PyTorch (latest)
- TensorFlow (latest)
- JAX
- JupyterLab
Verify installation
# Check GPU
nvidia-smi
# Check PyTorch
python -c "import torch; print(torch.cuda.is_available())"
# Check CUDA version
nvcc --version
Python API
Installation
pip install lambda-cloud-client
Authentication
import os
import lambda_cloud_client
# Configure with API key
configuration = lambda_cloud_client.Configuration(
host="https://cloud.lambdalabs.com/api/v1",
access_token=os.environ["LAMBDA_API_KEY"]
)
List available instances
with lambda_cloud_client.ApiClient(configuration) as api_client:
api = lambda_cloud_client.DefaultApi(api_client)
# Get available instance types
types = api.instance_types()
for name, info in types.data.items():
print(f"{name}: {info.instance_type.description}")
Launch instance
from lambda_cloud_client.models import LaunchInstanceRequest
request = LaunchInstanceRequest(
region_name="us-west-1",
instance_type_name="gpu_1x_h100_sxm5",
ssh_key_names=["my-ssh-key"],
file_system_names=["my-filesystem"], # Optional
name="training-job"
)
response = api.launch_instance(request)
instance_id = response.data.instance_ids[0]
print(f"Launched: {instance_id}")
List running instances
instances = api.list_instances()
for instance in instances.data:
print(f"{instance.name}: {instance.ip} ({instance.status})")
Terminate instance
from lambda_cloud_client.models import TerminateInstanceRequest
request = TerminateInstanceRequest(
instance_ids=[instance_id]
)
api.terminate_instance(request)
SSH key management
from lambda_cloud_client.models import AddSshKeyRequest
# Add SSH key
request = AddSshKeyRequest(
name="my-key",
public_key="ssh-rsa AAAA..."
)
api.add_ssh_key(request)
# List keys
keys = api.list_ssh_keys()
# Delete key
api.delete_ssh_key(key_id)
CLI with curl
List instance types
curl -u $LAMBDA_API_KEY: \
https://cloud.lambdalabs.com/api/v1/instance-types | jq
Launch instance
curl -u $LAMBDA_API_KEY: \
-X POST https://cloud.lambdalabs.com/api/v1/instance-operations/launch \
-H "Content-Type: application/json" \
-d '{
"region_name": "us-west-1",
"instance_type_name": "gpu_1x_h100_sxm5",
"ssh_key_names": ["my-key"]
}' | jq
Terminate instance
curl -u $LAMBDA_API_KEY: \
-X POST https://cloud.lambdalabs.com/api/v1/instance-operations/terminate \
-H "Content-Type: application/json" \
-d '{"instance_ids": ["<INSTANCE-ID>"]}' | jq
Persistent storage
Filesystems
Filesystems persist data across instance restarts:
# Mount location
/lambda/nfs/<FILESYSTEM_NAME>
# Example: save checkpoints
python train.py --checkpoint-dir /lambda/nfs/my-storage/checkpoints
Create filesystem
- Go to Storage in Lambda console
- Click "Create filesystem"
- Select region (must match instance region)
- Name and create
Attach to instance
Filesystems must be attached at instance launch time:
- Via console: Select filesystem when launching
- Via API: Include
file_system_namesin launch request
Best practices
# Store on filesystem (persists)
/lambda/nfs/storage/
├── datasets/
├── checkpoints/
├── models/
└── outputs/
# Local SSD (faster, ephemeral)
/home/ubuntu/
└── working/ # Temporary files
SSH configuration
Add SSH key
# Generate key locally
ssh-keygen -t ed25519 -f ~/.ssh/lambda_key
# Add public key to Lambda console
# Or via API
Multiple keys
# On instance, add more keys
echo 'ssh-rsa AAAA...' >> ~/.ssh/authorized_keys
Import from GitHub
# On instance
ssh-import-id gh:username
SSH tunneling
# Forward Jupyter
ssh -L 8888:localhost:8888 ubuntu@<IP>
# Forward TensorBoard
ssh -L 6006:localhost:6006 ubuntu@<IP>
# Multiple ports
ssh -L 8888:localhost:8888 -L 6006:localhost:6006 ubuntu@<IP>
JupyterLab
Launch from console
- Go to Instances page
- Click "Launch" in Cloud IDE column
- JupyterLab opens in browser
Manual access
# On instance
jupyter lab --ip=0.0.0.0 --port=8888
# From local machine with tunnel
ssh -L 8888:localhost:8888 ubuntu@<IP>
# Open http://localhost:8888
Training workflows
Single-GPU training
# SSH to instance
ssh ubuntu@<IP>
# Clone repo
git clone https://github.com/user/project
cd project
# Install dependencies
pip install -r requirements.txt
# Train
python train.py --epochs 100 --checkpoint-dir /lambda/nfs/storage/checkpoints
Multi-GPU training (single node)
# train_ddp.py
import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
def main():
dist.init_process_group("nccl")
rank = dist.get_rank()
device = rank % torch.cuda.device_count()
model = MyModel().to(device)
model = DDP(model, device_ids=[device])
# Training loop...
if __name__ == "__main__":
main()
# Launch with torchrun (8 GPUs)
torchrun --nproc_per_node=8 train_ddp.py
Checkpoint to filesystem
import os
checkpoint_dir = "/lambda/nfs/my-storage/checkpoints"
os.makedirs(checkpoint_dir, exist_ok=True)
# Save checkpoint
torch.save({
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': loss,
}, f"{checkpoint_dir}/checkpoint_{epoch}.pt")
1-Click Clusters
Overview
High-performance Slurm clusters with:
- 16-512 NVIDIA H100 or B200 GPUs
- NVIDIA Quantum-2 400 Gb/s InfiniBand
- GPUDirect RDMA at 3200 Gb/s
- Pre-installed distributed ML stack
Included software
- Ubuntu 22.04 LTS + Lambda Stack
- NCCL, Open MPI
- PyTorch with DDP and FSDP
- TensorFlow
- OFED drivers
Storage
- 24 TB NVMe per compute node (ephemeral)
- Lambda filesystems for persistent data
Multi-node training
# On Slurm cluster
srun --nodes=4 --ntasks-per-node=8 --gpus-per-node=8 \
torchrun --nnodes=4 --nproc_per_node=8 \
--rdzv_backend=c10d --rdzv_endpoint=$MASTER_ADDR:29500 \
train.py
Networking
Bandwidth
- Inter-instance (same region): up to 200 Gbps
- Internet outbound: 20 Gbps max
Firewall
- Default: Only port 22 (SSH) open
- Configure additional ports in Lambda console
- ICMP traffic allowed by default
Private IPs
# Find private IP
ip addr show | grep 'inet '
Common workflows
Workflow 1: Fine-tuning LLM
# 1. Launch 8x H100 instance with filesystem
# 2. SSH and setup
ssh ubuntu@<IP>
pip install transformers accelerate peft
# 3. Download model to filesystem
python -c "
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf')
model.save_pretrained('/lambda/nfs/storage/models/llama-2-7b')
"
# 4. Fine-tune with checkpoints on filesystem
accelerate launch --num_processes 8 train.py \
--model_path /lambda/nfs/storage/models/llama-2-7b \
--output_dir /lambda/nfs/storage/outputs \
--checkpoint_dir /lambda/nfs/storage/checkpoints
Workflow 2: Batch inference
# 1. Launch A10 instance (cost-effective for inference)
# 2. Run inference
python inference.py \
--model /lambda/nfs/storage/models/fine-tuned \
--input /lambda/nfs/storage/data/inputs.jsonl \
--output /lambda/nfs/storage/data/outputs.jsonl
Cost optimization
Choose right GPU
| Task | Recommended GPU |
|---|---|
| LLM fine-tuning (7B) | A100 40GB |
| LLM fine-tuning (70B) | 8x H100 |
| Inference | A10, A6000 |
| Development | V100, A10 |
| Maximum performance | B200 |
Reduce costs
- Use filesystems: Avoid re-downloading data
- Checkpoint frequently: Resume interrupted training
- Right-size: Don't over-provision GPUs
- Terminate idle: No auto-stop, manually terminate
Monitor usage
- Dashboard shows real-time GPU utilization
- API for programmatic monitoring
Common issues
| Issue | Solution |
|---|---|
| Instance won't launch | Check region availability, try different GPU |
| SSH connection refused | Wait for instance to initialize (3-15 min) |
| Data lost after terminate | Use persistent filesystems |
| Slow data transfer | Use filesystem in same region |
| GPU not detected | Reboot instance, check drivers |
References
- Advanced Usage - Multi-node training, API automation
- Troubleshooting - Common issues and solutions
Resources
- Documentation: https://docs.lambda.ai
- Console: https://cloud.lambda.ai
- Pricing: https://lambda.ai/instances
- Support: https://support.lambdalabs.com
- Blog: https://lambda.ai/blog
Files in this skill
3infrastructure-lambda-labs skill questions
How do I install the infrastructure-lambda-labs skill in Claude Code?
Run npx degit davila7/claude-code-templates/cli-tool/components/skills/ai-research/infrastructure-lambda-labs ~/.claude/skills/infrastructure-lambda-labs. Claude Code loads skills from ~/.claude/skills (all projects) or .claude/skills (one project) and uses a skill when its description matches the task.
Which clients can use the infrastructure-lambda-labs skill?
Any client that reads the Agent Skills format: Claude Code, Codex, Gemini CLI and claude.ai (upload as a ZIP). Scripts in the skill run only where the client allows code execution.