GPU for Agents · open source

Your agent rents the GPU it needs, on its own.

You pay only while it works: we watch every machine and shut down the idle ones.

Claude Code, Codex, Gemini CLI or Cursor rents a GPU from the provider you pick, serves a model behind an OpenAI-compatible API and runs its experiment. The machine stops when the work does, even after the conversation ends.

Install in your agent Watch the 1-minute video

Works withClaude Code Codex Gemini CLI Cursor

The pitch, in one minute

1:00 · sound on

Two promises

The agent gets the GPU.
You pay only for the work.

01 · PROVISION

Your agent rents what it needs.

Ask for a benchmark. The agent checks prices against your budget, rents the machine, serves the model with vLLM and gets an endpoint back, then runs the experiment with any OpenAI SDK. Nobody has to open a dashboard or file a ticket.

Compare Qwen 7B and Llama 8B on these 50 prompts.

gpu_offersRTX 4090 · 24 GB · $0.38/h ✓ under $0.60/h cap

gpu_setuprenting the machine…

readybase_url https://…:8000/v1 · model Qwen/Qwen2.5-7B-Instruct

02 · WATCH

You pay only while it works.

A watchdog runs on the rented machine itself. After 15 minutes without a request it shuts the machine down and billing ends, even if the agent forgot about it, the chat closed or your laptop is asleep.

requestsidle 00:00 / 15:00

agent workinglast requeststop

RUNNING$0.38/h

How it works

One request, start to finish.

The agent uses MCP tools, or the CLI with --json. The skill tells it to show you the price and ask before renting.

Ask

"Run this eval on Llama 8B." The agent writes jambu.yaml with gpu_init.

Price

gpu_offers lists matching GPUs under your cap. You say yes.

Serve

gpu_setup rents, boots vLLM and returns base_url, api_key, model. A stalled host is replaced.

Run, then stop

gpu_run runs the job. When requests stop, the watchdog stops the GPU.

Guardrails

Limits the agent can't talk its way past.

They live in jambu.yaml and on the machine, and they work the same with every provider. The agent would have to edit the file to raise them, and the skill tells it to ask you first.

15 min

Idle timeout

The watchdog on the machine stops it once requests stop. lifecycle.idle_timeout

$/h

Hourly and session budget

Offers above the cap are never rented, and a session that reaches its total stops. budget.max_hourly_cost_usd

6 h

Maximum lifetime

The machine stops at this age, busy or not. lifecycle.max_lifetime

10 min

Stalled hosts replaced

If the image download stops moving, gpu rents another host instead of waiting 30 minutes. health.pull_stall_timeout

sweep

Account sweep

gpu ls shows everything billing, and gpu sweep --install-timer cleans up machines no project owns.

jambu.yaml

gpu_runtime:
  provider: {name: vast}  # or your adapter
  model_profile: qwythos-9b
  lifecycle:
    idle_timeout: 15m   # watchdog stops it
    max_lifetime: 6h
  budget:
    max_hourly_cost_usd: 0.60
    max_session_cost_usd: 5.00
  health:
    pull_stall_timeout: 10m

Install

Paste one line into your agent.

The agent installs the gpu command, the Python it needs, the skill with the rules, and its tools. You connect your GPU provider in your own terminal, so the agent never sees the key.

Paste this into Claude Code.
When it asks, connect your GPU provider. Run gpu login in your terminal and paste your API key into the hidden prompt. Vast.ai works out of the box. Any other provider takes one adapter, and the agent can write it.
Restart Claude Code and ask for an experiment. It shows the price and asks before renting anything.

Prefer a terminal?

$ curl -fsSL https://gpu4agents.jambu.ai/install.sh | sh

Installs uv, Python and gpu, then sets up every agent it finds. Linux and macOS (Windows: WSL).

Install the skill in Claude Code

The way Claude Code installs other skills. The skill installs the gpu command the first time it runs.

From an app, any language

$ gpu --json setup

{ "base_url": "…/v1", "api_key": "…", "model": "…" }

Works with any OpenAI SDK. When your app stops sending requests, the idle timeout shuts the machine down.

Any GPU provider

Use the provider you already pay for.

Vast.ai is built in. For RunPod, Lambda, your company's cluster or anything else with an API, your agent writes an adapter: one Python file that implements our provider contract. The watchdog, budgets, CLI and MCP tools work the same with every provider.

Name the provider and paste this into your agent. Provider
The agent writes and checks the adapter. It runs gpu providers new, fills in each method from the provider's API docs, then checks prices with gpu offers without renting anything.
You connect the account. gpu login --provider runpod in your terminal. The agent asks before one small test rental.

gpu_providers/runpod.py

class RunpodProvider(GPUProvider):
    name = "runpod"
    required_credentials = ["RUNPOD_API_KEY"]

    def find_offers(spec)   # GPUs that fit, cheapest first
    def setup(spec)         # rent one, run the boot script
    def status(instance)    # map states and ports
    def stop(instance)
    def destroy(instance)
    def list_instances()    # only jambu-* machines

# runs on the machine: stops it when idle
def provider_stop(ctx)
def provider_destroy(ctx)

jambu.yaml provider: {name: runpod, plugin: ./gpu_providers/runpod.py:RunpodProvider}