Private AI infrastructure

The blind
supercomputer

Turn idle Macs into private AI infrastructure. Mac owners get paid when their machines do the work. Developers get secure AI compute.

For Mac owners For developers

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

Your data stays private

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

Become a provider

Put your idle Mac to work

Flip a switch in the HoloNear app and your Mac joins the network. You earn when it completes real AI jobs, and you're free to stop whenever you need your Mac back. No penalties for leaving the network.

Check how much you can earn with your Mac (Coming Soon)

Workload

Hours / Day8 h

up to XXX/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.

The desktop app, the CLI, provider docs and final rates are landing soon.

Build

Train on hardware you don't trust

Train on a mesh of machines that can read neither your data nor your weights. Pay per GPU-hour — no reserved capacity, no idle bill.

Trained something good? Publish it!
Every request to your model earns you a royalty.

Workload	HoloNear · per GPU-hour
LoRA fine-tune	X.XX
Full fine-tune	X.XX
RL	X.XX

Prices and step-by-step training docs are landing soon. Start getting your dataset ready!

Infer

A drop-in API

Top open-weight models and models published by the community, running on a private network.

OpenAI- and Anthropic-compatible: change the base_url, keep your code. Pay per token — no reserved capacity, no idle bill.

Model · context	Input	Cached input	Output
xxxxx · xxx	X.XX	X.XX	X.XX
xxxxx · xxx	X.XX	X.XX	X.XX
xxxxx · xxx	X.XX	X.XX	X.XX

Per 1M tokens. The full model lineup, final prices and API docs are landing soon.

The loop

Why pick one side?

Let your Mac earn while you're not using it. Use AI whenever you need it. Train your own model, publish it, and earn every time someone uses it.

Get early access

Don't take our word for it

Attestation

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

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.

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.

Durability

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

Nothing to farm

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

Limits

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

Coming soon — attestation posture, fleet reach, and whatever the network is running at any given moment.No account, no waiting.

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.

The blindsupercomputer