Galaxy: AI inference served from browser tabs, tested end to end · Gor Berlian · diadem.fun
← Gor Berlian
ReportNov 18, 20268 min read

Galaxy: AI inference served from browser tabs, tested end to end

Contents

Galaxy is an open inference network. Anyone with a graphics card can open one web page and serve AI requests from it: nothing to install, no drivers to set up. Developers call those GPUs through an API compatible with OpenAI's: chat, streaming, tool calling, JSON output and embeddings. Every job ends with a receipt signed by the node that did the work, and the network checks it before anything is charged.

This report shows what works today, measured on one ordinary desktop (AMD Radeon RX 9070, Chrome on Windows), with the tools we use to test it.

Live at gxypad.xyz#

Galaxy is now online at https://gxypad.xyz. The first provider is the desktop described in this report, joined as an installed node. Its node passed probation over the public internet, then answered visitors' prompts typed on the public page in a clean browser:

Prompt First token Speed Cost Receipt
"In three sentences: why could idle home GPUs serve AI requests?" 138 ms 315 tokens/s $0.000006 verified
"Write a haiku about a graphics card earning money at night." 120 ms 307 tokens/s $0.000003 verified

The node connects out to the gateway, so it needs no open port and no tunnel.

A visitor's prompt on gxypad.xyz, answered by an installed node at 315 tokens per second

The landing page with two live browser nodes

Earning without an account#

A GPU owner needs no account, no email and no password. The node page makes a Solana wallet right in the browser, and that's where the owner gets paid. Or they paste the address of a wallet they already have.

The secret key is generated in the browser and never sent anywhere. The page shows it once to download or copy, refuses to start until the owner confirms they saved it, and then forgets it. The network only ever sees the public address, and payouts can only go there.

We ran the whole journey against the live site with a fresh browser. All 7 checks passed:

  1. A wallet is created in the page, and its key file matches the shown address.
  2. Serving can't start until the key is confirmed saved; afterwards the page no longer holds it.
  3. The node registers with the public address alone, and passes probation before getting paid work.
  4. A visitor's prompt on the public page is answered by that browser tab.
  5. The job is credited to the wallet, which anyone can check at /v1/earnings/<address>.

The node page creates a payout wallet in the browser and asks the owner to save the key

The same tab serving paid jobs, with the earnings credited to its wallet

How we test it#

We built one command that runs the whole system for real:

  1. It starts the production gateway.
  2. It signs up two GPU owners through the normal sign-up.
  3. It opens the node page in Chrome on the GPU twice: one tab serves a chat model (Qwen3 1.7B), the other an embedding model.
  4. Both nodes must pass probation: fresh test questions they can only answer by really running the model.
  5. Then it acts as a customer: paid chat, streamed chat, structured JSON output and embeddings, checking every receipt and every charge.
  6. It freezes the chat tab for 40 seconds, the way browsers freeze background tabs, and times the recovery.
  7. It takes screenshots of what visitors see.

Latest run: 18 of 18 checks passed.

What Result
Paid chat answers correct, every receipt verified, charged exactly the metered amount
Structured output (JSON schema) valid JSON matching the schema, generated on the GPU in the browser
Chat speed seen by the customer first word after 0.1 s, then about 25 words (tokens) per second
Embeddings through the network 540–730 texts per second, every vector matching an independent reference copy of the model
Tab frozen for 40 seconds the node kept serving through it, and was ready again 0.8 s after waking
Probation with real models embeddings 4 of 4 every run; chat 3 of 4 (the small model misses one arithmetic question, and the pass mark allows that)

The test runs have already found and fixed three real problems that unit tests had missed:

  1. stray <think> tags in answers;
  2. nodes that looked busy for ten seconds after every job;
  3. an access token shown in plain text on the node page.

Embeddings from any laptop#

A node can serve embeddings only, which needs about 130 MB. On a GPU it runs through WebGPU; without one, it runs on the processor. Far more machines can take part than with chat models alone.

An embeddings-only browser node serving paid jobs

How we catch a node that fakes it. Embeddings are deterministic, so the network keeps its own copy of the model and re-checks a share of the answers. Every vector must match at a cosine similarity of 0.98 or better. We measured the threshold rather than guessing it:

Compared with the reference copy Similarity
The browser's answer on WebGPU 1.00000 (identical to five decimals)
The coarsest honest version of the model (8-bit) 0.990 at worst
The answer for a different but similar text 0.955 at best
Random numbers 0.13 at best

An honest node clears the bar easily, and a node that cheats can't. A node with three disagreements in its last ten checks is paused.

Installed nodes: native speed, set up automatically#

A GPU owner who wants full speed installs the node agent instead of using a browser tab. The agent:

  • picks the right build of llama.cpp, a fast native AI runtime, for the graphics card (Vulkan for AMD and Intel, CUDA for NVIDIA, Metal on Macs);
  • downloads it and the models, verifying each file against a pinned checksum;
  • keeps them running, and restarts them if they crash.

We test it with a second end-to-end command that joins this desktop as a real node and sends paid calls through it. All 9 checks pass:

What Result on the RX 9070
Chat speed seen by the customer 297 tokens per second, about 12× the browser node
Paid chat correct answers in 0.2 s, every receipt verified
Embeddings identical to the network's reference copy of the model

The first runs found and fixed three problems:

  1. unpacking failed on Windows machines with Git installed;
  2. a self-check always failed against the gateway;
  3. calls were sent before the node had connected.

The network under load#

Our load test runs thousands of simulated nodes over real connections, plus customers making real paid calls. After every run it checks that every charge in the money records matches the usage.

5,000 nodes connected Before the fixes Now
150 paid calls per second 62 per second got through, 2,635 errors, slowest 1% waited 19.6 s all 150, 0 errors, 29 ms
300 paid calls per second – all 300, 0 errors, 98 ms
400 paid calls per second – all 400, 0 errors, 413 ms

Charges matched usage exactly in every run.

The two changes that mattered most:

  • Node choice per call. Choosing a node used to scan every node on every call. It now looks at a small window of nodes in turn, taking 0.03 ms however large the network grows.
  • Stored balances. Customer balances are now stored, and the database updates them in the same transaction as every money record. It refuses any change that would make a balance negative.

Developer documentation, tested against the real network#

The gateway now serves its own documentation at /docs:

  • a quickstart with curl, Python and JavaScript using the official OpenAI SDKs;
  • models and prices, read live from the network's database;
  • chat, tools and JSON output, embeddings, errors and retries, limits;
  • how to verify a job's signed receipt yourself;
  • how to run a node.

A machine-readable OpenAPI 3.1 description of all 50 routes is at /openapi.json.

Every runnable example in the docs is executed against a live test network on each test run, and the page marks those examples "Tested". Running the Python example found a real incompatibility: the official OpenAI Python SDK asks for embeddings in base64 by default, which the network refused. It now supports base64, matching OpenAI's format, with a test that the decoded vectors are identical.

The documentation quickstart

What's next#

  • Installed nodes pass probation too, like browser nodes, and serve larger models (Qwen3 4B to 14B).
  • One-click setup: a ready installer, downloaded from the operator console, with no terminal.
  • One model name, two speeds: a request goes to the fastest equivalent node, installed or browser.
  • Faster chat in the browser. A token there costs a fixed 35 ms. A recent paper (arXiv 2610.39761) shows a way around it, but its code isn't released yet.
  • 400 paid calls a second with the slowest 1% under 250 ms, and a test with 20,000 nodes spread over more than one machine.
  • A first public server.

Galaxy is in beta. In this version nodes see the prompts they serve, so don't send secrets.

Gor Berlian

One person, many companies, one coin. Every project I build sends a share of its revenue back to buy $BERLIAN on the open market, and every buy is published with its transaction.

See the page

More from Gor Berlian