vastai-reference-architecture
Provides architectural patterns and best practices for setting up scalable GPU compute workflows on Vast.ai.
Install
mkdir -p .claude/skills/vastai-reference-architecture && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/4818" && unzip -o skill.zip -d .claude/skills/vastai-reference-architecture && rm skill.zipInstalls to .claude/skills/vastai-reference-architecture
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Implement Vast.ai reference architecture for GPU compute workflows.Key capabilities
- →Define three-tier GPU compute architecture
- →Manage job queues and instance provisioning
- →Implement checkpoint saving to cloud storage
- →Configure GPU profiles for different job types
- →Monitor instance health and auto-recovery
How it works
The architecture separates the orchestrator, which manages job queues and provisioning, from the GPU workers that execute training and save artifacts to persistent storage.
Inputs & outputs
When to use vastai-reference-architecture
- →Design ML training pipelines
- →Structure GPU orchestration logic
- →Implement auto-recovery for GPU tasks
- →Establish architecture standards for Vast.ai apps
About this skill
Governed Vast.ai GPU Workload Architecture
Overview
Center the architecture on an immutable run or release manifest and a lifecycle ledger. Search and planning are read-only; paid resource creation crosses an approval boundary; execution writes recoverable state externally; teardown closes both cost and evidence.
Prerequisites
- Batch, training, interactive, or Serverless workload inventory with SLOs
- Data, model, image, credential, region, reliability, and spend policies
- Owners for approval, execution, recovery, billing, security, and platform incidents
Instructions
Step 1: Define the immutable intent
Create a signed or versioned manifest containing workload bytes, image/template/model identity, GPU policy, data/checkpoint routes, SLOs, budget, and expiry.
Step 2: Separate planner and mutator
Let a read-scoped planner evaluate offers or Serverless profiles. Require explicit approval before a narrowly scoped mutator creates, updates, transfers credit, or destroys.
Step 3: Choose the executor
Use an instance lifecycle for bounded jobs or dedicated services; use Serverless endpoint/workergroup control for managed inference scaling and rolling updates.
Step 4: Externalize durable state
Keep datasets, checkpoints, artifacts, event ledgers, and evidence outside disposable root disks with checksums and recovery objectives.
Step 5: Observe and reconcile
Combine provider states, signed notifications, bounded polling, workload SLOs, balance, charges, and resource inventory; reconcile events against periodic reads.
Step 6: Close every lifecycle
Accept output, copy evidence, destroy disposable resources, revoke temporary access, reconcile charges, and leave an auditable handoff for retained resources.
Authentication
Use native Teams roles and distinct scoped keys for planning, mutation, monitoring, and administration. Workload storage and registry credentials must never inherit control-plane authority.
Tool Discipline
Use Read and Grep to inspect manifests, configuration, provider output, and existing tests before proposing a mutation. Use Write or Edit only for the approved plan, implementation, test, or redacted receipt; do not create, update, destroy, or fund Vast.ai resources without explicit operator approval.
Output
- Trust-boundary and component decision record
- Immutable manifest, lifecycle ledger, recovery, and observability contracts
- Threat, failure, cost, rollback, and teardown evidence plan
Return workload classes, chosen executors, authority boundaries, immutable artifacts, recovery targets, SLOs, budgets, event reconciliation, and lifecycle owners.
Examples
A planner selects verified offers but cannot rent; an approved mutator creates from a signed run manifest; the training executor checkpoints externally; a signed event plus reconciliation loop detects failure; a finalizer destroys the instance and closes the charge ledger.
Error Handling
| Failure | Response |
|---|---|
| One service can plan, fund, mutate, and erase evidence | Split authority and add independent approval and audit. |
| Durable state exists only on an instance | Move it to an external verified store before production. |
| Event stream is treated as complete | Add periodic resource reconciliation and idempotent processing. |
| Resource has no expiry or cleanup owner | Reject the architecture until the lifecycle can close. |
Resources
When not to use it
- →For simple scripts not requiring persistent storage
- →When GPU compute is not the primary workload
Prerequisites
Limitations
- →Requires external cloud storage for checkpoints
- →Orchestrator must be reachable by workers
How it compares
This approach provides a structured, fault-tolerant framework for ML pipelines rather than relying on manual instance management.
Compared to similar skills
vastai-reference-architecture side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| vastai-reference-architecture (this skill) | 1 | 2mo | No flags | Advanced |
| mcp-builder | 136 | 5mo | Review | Advanced |
| architecture-patterns | 55 | 4mo | No flags | Advanced |
| deepwiki-rs | 25 | 11mo | Review | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by jeremylongshore
View all by jeremylongshore →You might also like
mcp-builder
anthropics
Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).
architecture-patterns
wshobson
Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use when architecting complex backend systems or refactoring existing applications for better maintainability.
deepwiki-rs
sopaco
AI-powered Rust documentation generation engine for comprehensive codebase analysis, C4 architecture diagrams, and automated technical documentation. Use when Claude needs to analyze source code, understand software architecture, generate technical specs, or create professional documentation from any programming language.
langchain-architecture
wshobson
Design LLM applications using the LangChain framework with agents, memory, and tool integration patterns. Use when building LangChain applications, implementing AI agents, or creating complex LLM workflows.
python-design-patterns
wshobson
Python design patterns including KISS, Separation of Concerns, Single Responsibility, and composition over inheritance. Use when making architecture decisions, refactoring code structure, or evaluating when abstractions are appropriate.
python-project-structure
wshobson
Python project organization, module architecture, and public API design. Use when setting up new projects, organizing modules, defining public interfaces with __all__, or planning directory layouts.