Warppool Ad-free webmonetize with compute, not surveillance
Documentation · Running jobs

Run a GPU kernel on the network.

Write a WebGPU compute kernel, describe how to split it, and submit. Warppool spreads the chunks across browser GPUs, folds the results, and bills you to the millisecond.

Step 1

Before you start

An account
Sign up with your email. Every job belongs to the account that submitted it, and only that account can see it.
The price
$0.04 per GPU-hour, metered by the millisecond. You pay for GPU time used, so spreading a job across more workers does not cost more.
Step 2

Write a kernel

A job is one compute kernel plus a manifest that says how to split it. Write the kernel in WGSL, or in plain Python with py2wgsl (pip install py2wgsl), which compiles it to WGSL for you.

kernel.py py2wgsl 
from py2wgsl import Array, f32, global_id, array_length

def square(values: Array[f32], result: Array[f32]):
    i = global_id()
    if i < array_length(result):
        result[i] = values[i] * values[i]

The manifest

language
"wgsl" or "py2wgsl".
kernel_source
The kernel as a string, up to 256 KB.
inputs
Read-only buffers: {name, dtype}. dtype is f32, u32 or i32. Supply the values in input_data.
outputs
Buffers the kernel writes: {name, dtype, length}. length is required.
dispatch
total_work (up to 1 billion items), plus optional chunk_size and workgroup_size (default 64).
aggregate.reducers
How each output folds across chunks: sum, mean, max, min or concat.
Step 3

Submit it

Three front doors, one set of rules. Each one runs as your account and bills to it.

Browser

Dashboard console

Advanced → Console on your dashboard. Paste a kernel and manifest, then watch it run.

Terminal

warppool CLI over SSH

Add a public key under Advanced → SSH access, then ssh to ssh.warppool.tech.

AI agent

MCP endpoint

Connect Claude or any MCP client with a personal access token. Set it up →

terminal
# Over SSH: a quick test job (Monte Carlo pi, 100M samples)
$ ssh wp-3f9a2c1b@ssh.warppool.tech
$ warppool submit --name first-run --samples 100M
Step 4

Track & fetch results

Every call below sees only your own jobs. A job you don't own returns 404.

warppool jobs
GET /api/dashboard/console
Your jobs and their state
warppool status <id>
GET /api/dashboard/jobs/{id}
Progress, timing, result
warppool output <id>
GET /api/dashboard/jobs/{id}/output
Download outputs as JSON
warppool cancel <id>
POST /api/dashboard/jobs/{id}/cancel
Stop it; time already used is billed
warppool usage
GET /api/dashboard/usage
What you've spent, per job
Step 5 · Optional

Use it from an AI agent

Warppool runs a hosted MCP server at https://warppool.tech/mcp. Connect Claude, or any MCP client, and it can plan, submit, watch and cancel jobs for you, as your account.

1. Create a token

On your dashboard, open Advanced → Agent access, name the token, and pick its scopes. The value (wp_pat_…) is shown once, so copy it then. Tokens can expire (1–365 days) and can be revoked at any time. You can hold up to 25.

jobs:read
See your jobs, their results and outputs, and plan a job before running it.
jobs:write
Submit and cancel jobs. These bill to your account.
usage:read
Read your usage ledger.

Give an agent only the scopes it needs. A token with just jobs:read can watch jobs but can't spend money.

2. Connect your client

terminal
# Claude Code
$ claude mcp add --transport http warppool https://warppool.tech/mcp \
    --header "Authorization: Bearer wp_pat_…"

Other clients: add a Streamable HTTP server with that URL and an Authorization: Bearer header. There is no OAuth sign-in flow; the token is the credential.

3. What the agent can do

plan_job
Check whether a job is worth distributing before you run it.
submit_job
Run a job, including a kernel with its manifest (job_type: "kernel").
list_jobs · get_job
Your jobs, and one job's progress and result.
get_job_output
The job's output buffers.
cancel_job
Stop a running job.
get_usage
What your jobs have cost.
Treat a token like a password. Anyone holding a token with jobs:write can run billed jobs on your account. If one leaks, revoke it under Agent access.
Step 6

Limits worth knowing

Compute shaders only
Workers are browser GPUs running WebGPU, so a job is a WGSL kernel, not a program or a container.
Broken kernels stop early
If three different workers can't compile or run your kernel, the job fails and you get the compiler's error message.
Partial results are kept
A failed or cancelled job still returns the outputs of every chunk that finished.
Don't put secrets in kernel source. The workers that run your kernel can read it.