Sovereign AI infrastructure

The blind
supercomputer

The world's idle silicon, pooled into one private network — machines that can read neither your data nor your weights.

Start buildingRun a node

The idea

The compute already exists. It's just idle

Frontier-class machines sitting idle in millions of homes. A sealed vault built into every one. Money that settles anywhere in seconds. The pieces are all here — just scattered across the world.
HoloNEAR is what they add up to.

Millions of Macs idle most of the day512 GB unified memory — in a consumer MacA secure enclave in every recent machine

The guarantee

Two guarantees, one trust root

Everything rests on the hardware secure enclave on each machine — the trust root whose keys unlock compute only inside the attested, hardened process. Like a courier carrying sealed mail, a machine can't read what it computes on: not your prompt, not its own resident weights.

Hiding both data and weights at once — on untrusted residential and cloud hardware, over the open internet — is what HoloNEAR is. Neither guarantee alone is new; holding both together is.

Sealed tensors — never plaintextAttested enclave — decrypts inside onlyHardware-bound key — owner can't readTrust & settlement on NEAR

Build

A drop-in API for your model

A drop-in OpenAI & Anthropic-compatible API — change the base_url, keep your code. Every run inside a hard budget it can never overspend.

quickstart
npx holonear up                              # local mesh + dashboard
holonear use global                          # target the global network
holonear train --arch nanogpt-tiny --lora
holonear serve nanogpt-tiny                  # OpenAI-compatible API
curl -s localhost:8080/v1/completions \
  -H 'content-type: application/json' \
  -d '{"prompt": "hello", "max_tokens": 16}' # base_url = localhost:8080/v1
# served from the mesh — plaintext never left your process
Read the documentation

The math

Pay for work, not for capacity

Per token for inference, per GPU-hour for training — one rate card, no reserved capacity, no idle bill.

Model · contextInputCached inputOutput
Kimi-K2 · 128K$0.60$0.06$0.60
DeepSeek-V3 · 160K$0.50$0.05$0.50
GLM-4.6 · 198K$0.40$0.04$0.40
Qwen3.6-27B · 256K$0.30$0.03$0.30

Pricing is preliminary — rates and table format may change.

Become a provider

Paid for hours you weren't using

Your Mac earns for the hours it would otherwise sit idle — flip a switch in the HoloNear App, or run one command. Leaving is just as easy: a clean exit is never slashed, and your bond unlocks on a contract-enforced time-lock — automatic, no one to ask.

run a node
holonear node up --payout you.near   # join as a provider
holonear node status                 # running? where? who?
holonear node down                   # leave anytime
Get the app
orStart in your terminal

Provider economics

Same math seen from your Mac

What your hours could earn at public rates — and what machines like yours actually got paid. One is a ceiling, the other is a receipt; neither is a projection.

Your ceiling, at the public rates
Workload
up to $864/mo

Gross at public rates, before the protocol's revenue split — arithmetic, not a forecast. Demand decides how many hours actually serve. A node that serves nothing earns nothing; that's why the numbers can be trusted.

Earnings depend on the work your node serves — a node that serves nothing earns nothing. There is no payment for idle capacity, which is exactly why the reported numbers can be trusted.

How settlement works

The loop

Your nights
fund your days

One account, both directions: your Mac serves work overnight and earns a balance; by day, the same balance pays for your own training and inference — no top-up, no transfer, no second account. Results ship, the node keeps earning.

Join whitelist
Start building

Don't take our word for it

01

Attestation

A node proves it runs a genuine, unmodified build before any work reaches it.

02

Verified to the root

The attestation chain is checked back to the hardware vendor's root — and the design endpoint is your own client verifying it.

03

Sealed end-to-end

Sealed tensors in transit, enclave-bound weights at rest — unreadable even to a machine's owner, at the same floor as Apple's Private Cloud Compute.

04

Durability

Encrypted, sharded checkpoints — a dying node never costs you work.

05

Nothing to farm

The network pays only for demand-priced, verified work — never for idle capacity.

06

Limits

Where the guarantees stop — physical attacks, side-channels — we publish, adversary by adversary.

—
nodes online
—
jobs running
—
paid to providers
Live dashboard

FAQ

Questions a skeptic asks

The chain carries what must be trustless — identity, stake, settlement — and never your data or the hot path. Providers receive payouts to a NEAR account; consumers just use API keys and can pay in any asset.
Yes — that's the plan for consumers: you use API keys and pay in the asset that suits you, card included. The chain exists for what must be trustless — identity, stake, settlement — never for your checkout.
Exactly one thing runs: the signed HoloNear binary. Attestation is tiered: every node attests the build it runs before taking work, and the strongest proof — a hardware-attested, unmodified Apple device — comes with managed (MDM) enrollment. The work itself arrives as ciphertext, is computed inside the hardened process, and leaves as ciphertext: like a courier carrying sealed mail, you never hold — and can never read — anyone's data. Your earnings are income; how to report them depends on where you live.
Telemetry is metadata-only: ids, counts, sizes, durations, and error types. Never a prompt, a completion, or key material — the network can't log what it can't read. And that never isn't a policy — it's a CI gate: a source scan fails any build whose logs could carry payload.
Almost — one honest difference. A batch job's provider isn't known at submit time, so the request is sealed to the attested coordinator TEE and re-sealed to the provider that wins the slot; real-time requests are sealed straight to the chosen provider. Need strict end-to-end? Use the real-time path.
At the same floor as Apple Private Cloud Compute: lab-grade physical attacks, secure-enclave side-channels and kernel zero-days are out of scope — and we publish exactly that, adversary by adversary, in the security docs.
Anything that speaks OpenAI or Anthropic: change the base_url, keep your code. Both dialects, streaming included. Training runs are driven from the CLI or from Python.
Models too large for any single machine are the point — the mesh pools unified memory, so the ceiling is the fleet, not one box. Every job runs inside a hard budget envelope you set up front: it auto-stops and can never overspend.
Checkpoints are continuous, encrypted, and sharded; the mesh re-stripes around the loss and re-schedules the stage automatically. A job that loses too many nodes pauses — it never dies, and no work is lost.
No. You're paid for the work your machine serves — never judged on gradient quality or ML skill. Keep your machine on and honest; that's the whole job.
No. The desktop app is a menu-bar switch: it bundles the CLI, creates your payout account on first launch (keys live in your OS keychain, never in a file), and going offline is always a clean, never-slashed exit. The terminal path does exactly the same thing for those who prefer it.
An Apple Silicon Mac with free unified memory to spare — a node advertises how much it can offer (--free-mem-gb) and is only assigned stages that fit. More memory, more work, more earnings.
The node only takes on work that fits your free memory, and macOS manages heat at the hardware level. A plugged-in Mac mini or Studio is the ideal always-on node; a MacBook contributes when it can, and is best run on power.
Yes — start each node with the same --payout account and all of them settle to it. Each machine keeps its own identity on the fleet map.
Earnings accrue in a live balance and auto-settle about every 12 hours — one NEAR epoch, no claim step. Metering is dollar-denominated end to end — exact integer micro-USD, no float drift — and settlement pays your NEAR account in NEAR, converted at the live rate. And the split behind every payout is machine-checked, not promised: shares sum to exactly the pot — nothing minted, nothing burned.
Payouts land as NEAR, which you can off-ramp through any exchange or on-ramp service that supports it. Your full payout history is on the dashboard, exportable for your records.

Still have questions? Contact us