Jarvis Labs

Provides ephemeral GPU instances (H100, H200, A100, A6000, L4, RTX 6000 Ada) that can be created and destroyed on-demand with per-minute billing granularity. Instances launch in <90 seconds and support up to 8 GPUs per instance with configurable vCPU and RAM allocations. Users select GPU type and storage size (20GB–2TB) via CLI or web dashboard, and billing stops immediately upon instance termination with no minimum commitment or long-term contracts required.

Provides persistent block storage (20GB–2TB) that persists across instance stop/resume cycles and can be accessed via SSH for direct file transfer. Storage is mounted to instances as a filesystem accessible from the OS, enabling users to store training datasets, model checkpoints, and code that survives instance termination. Users can transfer files via standard SSH tools (scp, rsync) or through web IDE file browsers without requiring external object storage services.

Provides community metrics (27,343 AI developers, 50M+ GPU hours served) and lists trusted users (Tesla, Hugging Face, Kaggle, Zoho, Weights & Biases, upGrad, Saama) to build credibility and social proof. However, no documented community features (forums, model sharing, code repositories, user profiles, discussions) or social interactions (likes, follows, comments) exist on the platform. The community metrics are marketing claims without verification, and no community-driven content or collaboration features are available.

Jarvis Labs supports deploying custom Docker images on instances for advanced use cases beyond pre-configured templates. Users can specify a Docker image URI at instance creation time, and the platform will boot the instance with that image. The platform also provides raw SSH access to instances, enabling users to install arbitrary software, configure custom environments, or run non-containerized workloads. This flexibility allows advanced users to bypass pre-configured templates and use custom ML frameworks, tools, or configurations.

Jarvis Labs provides instance status monitoring via CLI commands (e.g., `jl status <instance-id>`) and web dashboard, showing instance state (running, paused, terminated), GPU utilization, memory usage, and network activity. Users can view logs and metrics in real-time to monitor training progress and diagnose issues. The monitoring interface is basic and does not include advanced features like custom alerts, metric aggregation, or historical analysis.

Provides pre-installed and pre-configured environments for PyTorch, TensorFlow, Hugging Face, ComfyUI, and Automatic1111 that eliminate manual dependency installation and environment setup. Each template includes the framework, CUDA toolkit, cuDNN, and common libraries (numpy, pandas, scikit-learn) pre-compiled and optimized for the selected GPU. Users can launch an instance with a template and immediately start training or inference without running pip install or managing version conflicts.

Provides a `jl run` CLI command that uploads local Python scripts to an instance, automatically installs dependencies from requirements.txt, executes the script, and streams logs back to the user's terminal in real-time. The command abstracts away SSH key management and manual environment setup, allowing users to run training jobs with a single CLI invocation. Logs are streamed to stdout/stderr, enabling real-time monitoring of training progress without SSH into the instance.

Provides direct SSH access to instances, enabling users to open a terminal shell and execute arbitrary commands, install custom packages, modify configurations, and run interactive workloads. SSH keys are managed by Jarvis Labs (generated or user-provided; mechanism unknown), and connection details (host, port, username) are provided via CLI or web dashboard. Users can use standard SSH tools (ssh, scp, rsync) and IDE integrations (VS Code Remote SSH, PyCharm SSH interpreter) to interact with instances.

Provides browser-based access to JupyterLab and VS Code running on instances, enabling users to edit code, run notebooks, and execute commands without installing local development tools. JupyterLab provides a notebook interface for exploratory analysis and interactive development, while VS Code provides a full IDE with syntax highlighting, debugging, and extensions. Both are accessed via HTTPS URLs provided by Jarvis Labs, with authentication handled via instance credentials.

Provides native integration with AI-powered code editors (Claude Code, Cursor, Codex) via a `jl setup` command that configures the IDE to use Jarvis Labs instances as remote execution environments. The integration allows users to write code in their local IDE and execute it on GPU instances without manual SSH or CLI commands. The mechanism for IDE integration is unknown (likely SSH interpreter configuration or custom IDE extension), but it enables seamless local-to-cloud development workflows.

Enables users to provision instances with multiple GPUs (up to 8 per instance) for distributed training, data parallelism, and model parallelism workloads. GPU selection is made at instance creation time, and all GPUs are of the same type (e.g., 8x H100 or 4x A100). The interconnect topology (NVLink vs PCIe), bandwidth specifications, and multi-GPU communication libraries (NCCL, Gloo) are not documented, but instances support standard PyTorch DistributedDataParallel and TensorFlow distributed training APIs.

Provides CLI commands (`jl create`, `jl pause`, `jl resume`, `jl destroy`) for managing instance lifecycle without web dashboard interaction. Users can create instances with GPU type and storage size, pause instances to stop billing while preserving state, resume paused instances to continue work, and destroy instances to free resources. Pause/resume functionality enables cost savings by stopping instances during breaks without losing data or configuration, as persistent storage and instance state are preserved.

Provides transparent, per-minute billing for GPU instances with published hourly rates for each GPU type (H100: $2.69/hr, A100-80GB: $1.49/hr, L4: $0.44/hr, etc.). Billing starts when an instance is created and stops immediately upon termination, with no minimum commitment, long-term contracts, or hidden egress/bandwidth charges documented. Users can estimate costs by multiplying hourly rate by usage duration, and billing is calculated to the minute (not rounded to the hour), enabling fine-grained cost control.