DEV Community: Lium

Let your AI agent rent a GPU: llms.txt, --json and --budget

Lium — Thu, 24 Sep 2026 02:52:35 +0000

Posted by the Lium team. Lium is the GPU marketplace used in this post. Every command below is taken from the live CLI help (lium.io 0.8.0) and lium.io/llms.txt, read on 24 September 2026.

Video (26 s, play the MP4): the opening chat illustrates the ask. The terminal clip is a real recording of lium.io/llms.txt and lium up --help, sped up 1.5x.

Most GPU clouds assume a person with a browser: a sign-up form, a dashboard, a console to click through. An AI agent working in a terminal needs something else: prices it can read without an account, a way to sign up without a form, a rent command that returns machine-readable output, and a hard stop so a forgotten pod can't run up a bill. This post walks through those five steps on Lium, in the order an agent takes them.

1. Read llms.txt

lium.io/llms.txt is a short plain-text file written for models. It says when Lium fits a task (a job that needs an NVIDIA GPU for minutes to days, started from a script) and when it doesn't (managed inference endpoints, serverless functions, CPU-only hosting). It then lists the price feeds, the install commands, the headless sign-up call and the reference docs. One fetch gives an agent everything below.

2. Check prices with no account

curl -sL https://lium.io/pricing.json | jq -r '.models[]
  | select(.available_gpus > 0)
  | "\(.name)  from $\(.min_price_usd_per_gpu_hour)/GPU-hour  \(.available_gpus) free"'

At 02:44 UTC on 24 September 2026 that printed, among others: H100 80GB HBM3 from $1.30 per GPU-hour, H200 from $3.00, B200 from $5.60, B300 from $8.25, RTX 5090 from $0.58 and RTX 4090 from $0.45. Providers set their own prices, so run it again for the current numbers, or see lium.io/pricing. For one row per rentable node, read the public nodes feed.

3. Sign up without a form

curl -f -X POST https://lium.io/api/auth/signup

The response carries a fingerprint (a 32-character dashboard login, shown once, with no recovery) and an api_key when minting succeeds. The key can be null, and sign-up credit depends on the platform setting and on prior use of the IP. The CLI has the same step as lium signup, which stores the key it mints. Renting needs a funded balance that covers at least 15 minutes of the pod's hourly price (billing docs).

4. Rent with JSON output and a budget

lium up --gpu H100 -y --json --budget 12.50 --ttl 3h --timeout 600

What each flag does, from lium up --help:

--gpu H100 picks the lowest-priced H100 node that matches.
-y --json skips the prompt, waits for the pod, and prints it as JSON, with no SSH session to hang the agent's shell.
--budget 12.50 ends the pod once $12.50 has been spent. At $1.30 per GPU-hour that is about 9.6 hours of one H100.
--ttl 3h ends it three hours after the rent, whichever comes first.
--timeout 600 gives the whole rent 10 minutes, then exits 1 and names the pod, so the agent can clean up rather than wait forever.

Billing is per second at the node's hourly price, from deploy until the pod is removed, with no minimum. Ten minutes of an H100 at $1.30 per GPU-hour costs $0.22.

5. Run the job, then stop billing

lium exec <pod> "nvidia-smi -L"
lium spend
lium rm <pod> -y

lium exec runs a command in the pod, lium spend shows the hourly burn and the estimated spend per active pod, and lium rm removes the pod, which stops the meter.

Give your agent the skill

The Lium skill documents this sequence and its failure modes for any agent that supports the Agent Skills standard (Claude Code, Cursor, Codex and others):

npx skills add Datura-ai/lium-skill --skill lium
# without node:
curl -fsSL https://lium.io/agents/install.sh | bash

Source: github.com/Datura-ai/lium-skill. The agent guide on the docs site is docs.lium.io/developers/agents.

Renting an 8x B300 by the hour: what it costs and how to start

Lium — Thu, 24 Sep 2026 02:52:30 +0000

Posted by the Lium team. Lium is the GPU marketplace used in this post. Every number links to a public source you can check yourself.

Video (24 s, play the MP4): one command for 8x B300. The prices on screen were live on lium.io at 02:29 UTC on 24 September 2026.

An 8x B300 node has 2,304 GB of GPU memory (288 GB per card, per Lium's price feed). That is enough to hold very large models on one machine. This post covers three things: what is on the market right now, what an hour costs to the cent, and the commands that take you from nothing to a running 8-GPU pod.

What is free right now

Lium publishes two unauthenticated feeds: pricing.json, one row per GPU model, and the public nodes feed, one row per rentable node. I read both at 02:44 UTC on 24 September 2026 (nodes feed generated_at 02:44:13Z). These are the whole 8-GPU hosts that were free at that minute:

GPU	Free 8x hosts	Price per GPU-hour
B300	5	$8.50–$9.50
B200	0	–
H200	1	$4.00
H100 80GB HBM3	1	$2.75
A100-SXM4-80GB	4	$1.13–$1.23

On the same read, single GPUs were free too: 43 B300 at $8.25–$9.50, 2 B200 at $5.60, 19 H200 at $3.00–$4.22, 27 H100 at $1.30–$2.75 and 33 A100 80GB at $0.999–$1.23.

Video (23 s, play the MP4): the lowest live ask for ten GPU models, from one curl. Its prices are from 02:29 UTC; the table above is the 02:44 UTC read.

Providers set their own prices, so these numbers move. The feed is rebuilt at most once a minute (docs). This one-liner prints every free 8-GPU host of these five models when you read this:

curl -sS https://lium.io/api/public/v1/nodes | jq -c '.nodes[]
  | select((.gpu_model | test("B300|B200|H200|H100|A100")) and .available_gpu_count >= 8)
  | {gpu_model, available_gpu_count, price_per_gpu_hour, reliability_score, country_code}'

What it costs

Lium bills per second at the listed hourly price: a pod costs hourly price × seconds / 3600 for the exact seconds it exists, with no minimum (billing docs). At $8.50 per GPU-hour, the lowest 8x B300 ask on this read, an 8x B300 pod costs $68.00 per hour:

Pod lifetime	Cost for 8x B300 at $8.50/GPU-hour
20 seconds (a smoke test that fails fast)	$0.38
1 minute	$1.13
10 minutes	$11.33
1 hour	$68.00

Three billing details are worth knowing before you start:

Balance floor. A rent needs a balance that covers at least 15 minutes of the pod's hourly price. For $68.00/hour that is $17.00.
When money moves. Running pods are charged every 5 minutes, and the remainder is settled the moment the pod is removed.
The clock starts at deploy. The short provisioning window before the pod reads RUNNING is billed, so a pod that takes 60 seconds to boot costs $1.13 before your code runs.

Start from the CLI

The CLI and the Python SDK come in one package (README). Install and sign in:

curl -fsSL https://lium.io/install.sh | bash   # or: pip install lium.io
lium init                                     # opens the browser to approve; --no-browser prints the URL
lium balance

Top up in the dashboard (card or crypto). Then list the B300 nodes. --gpu B300 matches both B300 SXM6 model names on Lium (AC and PC), which are the same card (CLI quickstart):

lium ls --gpu B300

Rent eight GPUs with a hard stop, and have the CLI prove the pod has the GPUs you pay for:

lium up --gpu B300 --count 8 --name b300 --ttl 2h --verify-gpus --strict-gpus --yes --no-ssh

--gpu with --count 8 takes the lowest-priced matching node. --ttl 2h removes the pod after two hours, so a forgotten pod stops billing on its own. --budget 150 stops it once $150 has been spent.
--verify-gpus counts the GPUs nvidia-smi -L sees inside the pod and compares that with the billed count. --strict-gpus removes the pod on a mismatch (lium up reference).

Run, copy results back, and stop billing:

lium exec b300 "nvidia-smi -L"
lium scp b300 /workspace/out.tar ./ -d
lium rm b300 -y

Start from Python

The SDK's rent() picks a node that fits a spec. dry_run=True shows the node and the price without renting (SDK reference):

from lium.sdk import Lium

lium = Lium()
quote = lium.rent(gpu_type="B300", gpu_count=8, max_price_per_gpu_hour=9.50,
                  name="b300", dry_run=True)
print(quote.executor.huid, quote.gpu_count, quote.price_per_hour)

rented = lium.rent(gpu_type="B300", gpu_count=8, max_price_per_gpu_hour=9.50, name="b300")
pod = lium.wait_ready(rented.pod, timeout=900)
print(lium.exec(pod, command="nvidia-smi -L", timeout=60)["stdout"])
lium.down(pod)

Two minutes of checks before a big job

On any 8-GPU pod, the first two commands decide whether a tensor-parallel job will run well (Before you rent 8 GPUs):

lium exec b300 "nvidia-smi topo -m && nvidia-smi topo -p2p r"

Every off-diagonal GPU cell of topo -m should read NV#, and every cell of -p2p r should read OK. Then time a real download to the disk you will use, since checkpoint pulls vary widely between nodes:

lium exec b300 "cd /workspace && time hf download openai-community/gpt2 model.safetensors --local-dir /workspace/probe"

Two notes for Blackwell from the README: use a cu128 or newer PyTorch build (pip install torch --index-url https://download.pytorch.org/whl/cu130), and use FlashAttention-4 or cuDNN attention, since FlashAttention-3 is Hopper-only.

When no 8x B300 is free

File a machine request: dashboard → Machine Requests → ADD NEW, then pick the GPU model and a GPU count of 8. Providers subscribed to that GPU type are emailed your request. Lium checks the marketplace every 5 minutes for 30 days and emails you, at most once a day, when a node that fits is listed (docs). New 8x B300 hosts go fast: on 22 September, Lium's rental records show two new hosts rented within 22 and 41 minutes of listing, so rent from the link when the email arrives.

Current prices per model are on lium.io/pricing, and the B300 page is lium.io/gpu/b300-sxm6-ac.