OpenClaw GPU Inference on LiquidWeb

Contains affiliate links. Disclosure.

Running a local language model with OpenClaw eliminates per-token API costs, keeps all data on your hardware, and lets you run larger context windows than most cloud APIs allow. This guide covers tier selection, hardware setup, and inference configuration for Liquid Web's single-tenant GPU bare metal.

GPU Tier Selection

Liquid Web offers six GPU SKUs (single and dual variants of L4, L40S, H100 NVL, H200 NVL). Prices below reflect the current 25%-off promo; list prices apply when the promo ends. Always confirm on the GPU hosting page before ordering.

GPU	VRAM	CPU	RAM	Storage	Promo / List	Best For
NVIDIA L4 Ada	24 GB	2× EPYC 9124 (32c/64t)	128 GB DDR5	1.92 TB NVMe RAID-1	$0.80 / $1.07/hr	Dev, 1–3 users, 7–13B models
NVIDIA L40S Ada	48 GB	2× EPYC 9124 (32c/64t)	256 GB DDR5	3.84 TB NVMe RAID-1	$1.44 / $1.92/hr	Team use, 70B quantized
NVIDIA H100 NVL	94 GB	2× EPYC 9124 (32c/64t)	256 GB DDR5	3.84 TB NVMe RAID-1	$2.98 / $3.97/hr	70B full precision, 120B quantized
2× NVIDIA H100 NVL	2× 94 GB	2× EPYC 9254 (48c/96t)	768 GB DDR5	7.68 TB NVMe RAID-1	$5.14 / $6.85/hr	Tensor-parallel 120B+, heavy concurrency
NVIDIA H200 NVL	141 GB	Xeon 6741P (48c/96t)	512 GB DDR5	3.84 TB NVMe RAID-1	$3.87 / $4.38/hr	120B+ models, fine-tuning
2× NVIDIA H200 NVL	2× 141 GB	Xeon 6741P (48c/96t)	1024 GB DDR5	3.84 TB NVMe RAID-1	$5.39 / $7.19/hr	Large-scale training and inference

Every tier is single-tenant bare metal (no MIG, no virtualization) with ∞ inbound and 10 TB outbound bandwidth on a 10 Gbps link. Liquid Web ships these with Ubuntu 22.04 and its GPU Stack (NVIDIA drivers + Container Toolkit pre-installed). Provisioning is typically under 15 minutes.

Choosing a Tier

Start with L4 if:

• You are evaluating GPU inference before committing
• Your team is 1–3 people
• You want models up to 13B at reasonable quantization (Llama 3.2 8B, Mistral 7B, Phi-3 medium). 13B+ at full precision won't fit, so use quantization
• Hourly billing lets you shut it down when not in use

Use L40S if:

• You need 70B-class models at production quality (Llama 3.3 70B at Q4 fits in ~40 GB; Q8 does not fit in 48 GB)
• Multiple team members hit OpenClaw concurrently
• You want vLLM's PagedAttention throughput

Use H100 NVL if:

• You need 70B at 8-bit (or close to full precision)
• You run NemoClaw with Nemotron 3 Super 120B-A12B via NIM
• You need fine-tuning headroom
• Uptime requirements are strict

Use H200 NVL if:

• You run 120B+ at higher precision or need long context windows
• You need the highest single-GPU throughput
• You are building production AI products, not just an internal assistant

Step 1: Provision the Liquid Web GPU Server

1. Go to Liquid Web GPU hosting
2. Select your tier
3. Choose Ubuntu 22.04 LTS
4. Add your SSH key during checkout
5. Complete the order. Provisioning is typically under 15 minutes

SSH into the server:

ssh root@YOUR_GPU_SERVER_IP

Verify GPU access:

nvidia-smi

You should see your GPU with VRAM size and driver version. If nvidia-smi fails, open a ticket: Liquid Web's GPU Stack ships NVIDIA drivers pre-installed.

Step 2: Install Docker with NVIDIA Runtime

Liquid Web GPU servers ship with Docker and the NVIDIA Container Toolkit pre-installed as part of the GPU Stack. Verify:

docker run --rm --gpus all nvidia/cuda:12.1-base-ubuntu22.04 nvidia-smi

If the above command shows your GPU, Docker GPU access is working. If it is not installed:

curl -fsSL https://get.docker.com | sh
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor \
  -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

Step 3: Install and Configure Ollama

Ollama is the simplest way to run local models with OpenClaw. It handles model downloads, quantization selection, and serves a compatible API endpoint.

curl -fsSL https://ollama.com/install.sh | sh

Verify GPU usage:

ollama serve &
nvidia-smi  # Should show Ollama process using GPU memory

Pull a Model

Choose based on your GPU tier:

# L4 Ada (24 GB VRAM) — up to 12B at reasonable quality
ollama pull llama3.2:latest       # 8B, fast
ollama pull mistral-nemo:12b      # 12B, strong instruction following

# L40S Ada (48 GB VRAM) — 70B Q4 fits; Q8 does not
ollama pull llama3.3:70b          # 70B Q4_K_M, ~40 GB VRAM

# H100 NVL (94 GB VRAM) — 70B Q8 fits, 120B quantized fits
ollama pull llama3.3:70b-q8_0     # 70B 8-bit, ~75–80 GB VRAM

Test inference speed:

ollama run llama3.3:70b "Explain tensor parallelism in two sentences"

You should see tokens streaming within 1–2 seconds on L40S or higher.

Step 4: Connect OpenClaw to Ollama

If you deployed OpenClaw using the VPS guide, update ~/.openclaw/config.yaml to point at Ollama:

llm:
  provider: ollama
  base_url: http://localhost:11434
  model: llama3.3:70b

agent:
  max_steps: 50
  timeout_seconds: 600  # Larger models need more time

server:
  port: 18789
  host: 0.0.0.0

If running OpenClaw in Docker on the same host, use host.docker.internal instead of localhost:

llm:
  provider: ollama
  base_url: http://host.docker.internal:11434
  model: llama3.3:70b

Restart the container:

cd ~/openclaw && docker compose restart

Step 5: Configure vLLM (For NemoClaw or High Throughput)

vLLM is required for NemoClaw's vllm-local inference provider and outperforms Ollama for concurrent multi-user sessions.

Start vLLM with GPU access:

docker run -d \
  --name vllm \
  --gpus all \
  --restart unless-stopped \
  -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  -e HUGGING_FACE_HUB_TOKEN="${HF_TOKEN}" \
  vllm/vllm-openai:latest \
  --model meta-llama/Llama-3.3-70B-Instruct \
  --host 0.0.0.0 \
  --port 8000 \
  --max-model-len 32768 \
  --tensor-parallel-size 1

The first run downloads the model weights (~140 GB for Llama 3.3 70B at full precision). On Liquid Web's 10 Gbps network expect 10–20 minutes plus HuggingFace's own rate limits. Mind the 10 TB monthly outbound cap, since model downloads count against it (though the weights are cached locally after the first pull).

Verify vLLM is serving:

curl http://localhost:8000/v1/models

Update OpenClaw config:

llm:
  provider: vllm
  base_url: http://localhost:8000/v1
  model: meta-llama/Llama-3.3-70B-Instruct

vLLM vs Ollama: When to Use Which

Factor	Ollama	vLLM
Setup complexity	Simple	Moderate
Concurrent users	1–3	10+
Throughput	Moderate	High
Model support	Wide (GGUF)	Wide (HuggingFace)
NemoClaw compatibility	Via custom config	Native (vllm-local provider)
Memory efficiency	Good	Excellent (PagedAttention)

For a single user or small team, Ollama is simpler and sufficient. Switch to vLLM when you need concurrent sessions or are using NemoClaw.

Model Performance Reference

Indicative throughput on Liquid Web L40S Ada (48 GB VRAM) with Ollama. Actual numbers depend on prompt length, batch size, and concurrency:

Model	VRAM Used	Tokens/sec (single request)	Notes
llama3.2:latest (8B)	~5 GB	85–100 t/s	Fast, good for most assistant tasks
mistral-nemo:12b	~8 GB	60–75 t/s	Strong instruction following
llama3.3:70b (Q4)	~40 GB	18–25 t/s	Near-frontier quality

On H100 NVL (94 GB), llama3.3:70b-q8_0 typically runs 2–3× faster than Q4 on L40S, with higher output fidelity. Always benchmark your own workload before committing, because MoE models, long contexts, and concurrent users change the math significantly.

Cost Comparison: GPU Bare Metal vs Cloud APIs

Rough monthly costs for a busy single-user scenario at ~1M tokens/day. GPU bare metal assumes 24×7 uptime at promo rates; you can drop cost significantly by running hourly only during working hours.

Option	Monthly Cost	Notes
Claude Sonnet (API)	~$300	~$3/M output tokens; data leaves your network
GPT-4o (API)	~$450	~$10–15/M output tokens; data leaves your network
Liquid Web L4 24/7 + Ollama	~$585	Promo: $0.80/hr × 730 hrs; unlimited tokens
Liquid Web L40S 24/7 + Ollama	~$1,050	Promo: $1.44/hr × 730 hrs; 70B quantized
Liquid Web H100 NVL 24/7 + Ollama	~$2,175	Promo: $2.98/hr × 730 hrs; 70B Q8 or 120B quantized

Bare metal wins on privacy, token volume, and model control. Cloud APIs win on bursty or low-volume workloads. Break-even is roughly 500K tokens/day for 70B-class quality or 2M+ tokens/day for smaller models, plus anything with a data residency requirement.

For most solo users or small teams under that threshold, a VPS with a cloud API is more cost-effective. Use GPU bare metal when volume, privacy, or model control requirements override pure cost.

Frequently Asked Questions

The NVIDIA L4 Ada at $0.80/hr on the current 25%-off promo ($1.07/hr list, ~$585/mo at 24×7). It has 24 GB VRAM, runs models up to ~12B at reasonable quantization, and is sufficient for 1–3 person teams.

Yes. Liquid Web GPU servers bill hourly. Spin one up for development or a batch job and shut it down when done. For ongoing team use, expected 24×7 costs are L4 ~$585/mo, L40S ~$1,050/mo, H100 NVL ~$2,175/mo at promo rates.

NemoClaw itself is CPU-only: the sandbox and policy engine run without a GPU. The GPU is required only if you use the NIM or vLLM local inference providers. NVIDIA cloud inference works on any hardware.

Ollama is simpler to set up and works well for 1–3 concurrent users. vLLM uses PagedAttention for higher throughput, which is better for teams or when using NemoClaw's native vllm-local inference provider.

Not always. Cloud APIs (Claude, OpenAI) are more cost-effective at low usage and give access to frontier models. GPU bare metal wins on privacy, unlimited token volume, and full model control. The break-even point is roughly 500K–2M tokens/day depending on the model.