Your Mac earns
when you are not using it.
Core Node joins your Mac to a trusted, distributed network for local AI compute. The GPU sitting idle in your machine runs real inference work — language models, image generation, transcription — and you are paid directly for every job you complete. Add a second machine and a third, and the earnings accumulate together.
Free to install. No account to create. Nothing to configure before it starts working.
The node shows what it is doing
Core Node draws itself as the chip it runs on. Cores fill with measured load, work flows along the traces beneath the modules, each application’s share is on the right, and seven days of history run along the bottom.
A live rendering with illustrative activity. On your Mac, every cell is measured.
Three steps, and none of them is a signup form
1 Install it
Core Node is free. One download, no licence key, no trial period. Early access is by invitation now — join the waitlist. The Mac App Store release follows.
2 It creates your identity
At first launch your Mac generates its own keypair and derives your identifier from it. That happens entirely on the machine — no email, no password, no approval from us. The private key goes into your Keychain and stays there.
3 Say when it is available
Set the hours your Mac is available. The network places work where capacity is needed, on machines that can run it; when a job lands on yours, a signed receipt records what ran and you are paid for what it completes.
Adding another Mac repeats step one. Machines you own bind into a single domain and earn together, reported as one position rather than several.
Eighty per cent goes to the machine that did the work
Of what a requester pays, 80% goes to the operator. Of the remaining fifth, half funds the build-out of the mesh itself, and half — 10% — is the only share the company holds.
That is a long way from what a platform normally keeps, and it is deliberate. A network worth joining has to be worth joining for the people who supply it, not chiefly for the people who run it. The rate is the same for every operator, published in advance, and identical whether you have one machine or forty — so nobody negotiates what their work is worth, and nobody can bid the rate down for everybody else.
You are paid in money. Not credits, not points, not a token that only spends inside our network. Earnings settle to your bank account through Stripe, and a node accrues before you have chosen a payout method at all — you are never asked for payment details in order to start working. What you earn is yours in the ordinary sense of the word.
The price is known before a job runs — not an estimate that moves afterwards, but a figure both sides compute from the same signed specification. You are paid only for work that is accepted, and there are no consolation payments in either direction. A generous economy is one where the terms are legible and the same for everyone; that is easier to verify than to promise, which is why the numbers are here.
Whatever the job needs, while you are not needing it
Workloads differ, and we do not pretend to know in advance which part of your machine a given job will lean on. Your node reports what it actually has, and is only offered work it can actually do.
GPU
The heart of most AI work — inference, image generation, transcription. On Apple Silicon it shares unified memory with the rest of the chip, and it is unusually capable for the power it draws.
CPU
Plenty of real work is not GPU-shaped: preparing assets, encoding output, indexing, orchestration. Cores that would otherwise be idle still earn.
Memory
Unified memory lets a Mac hold models that would need a discrete accelerator elsewhere. Capacity is frequently the thing that decides whether a job can run at all.
Storage
Modest and bounded — caching model weights and job assets so the same large file is not fetched twice. Your disk is not the product, but the space you lend is counted.
Beyond that, nothing. No background scanning, no data collection, no use of your machine for anything other than the jobs you accepted. Stopped, the node does nothing at all.
The machines already exist
There is an enormous amount of capable AI hardware already built, already bought, already sitting on desks — and idle for most of the hours it owns. The industry’s standing answer to rising demand is to build more data centres, with the land, power and water that implies.
Core Node is the other answer. Every job that runs on a machine someone already owns is one that did not require a new one to be built, and the person whose hardware did the work is the person who gets paid for it. Whether that matters to you or not, the economics work the same way.
Your machine, your terms of participation
Whether, and when
You decide if your node participates at all, and when it is available. Stopping is immediate and costs nothing.
Where work goes
The network places each job on a machine able to run it, where capacity is needed at that moment. There is no quota to meet and no volume promised — you are paid for what your machine completes.
What can run
Only registered applications can place work on a node, and only workloads Core Node itself executes. Nothing else runs on your hardware.
What you do not set is the price or the split. Both are published in advance and identical for every operator, whether you run one machine or forty — so no one has to negotiate what their work is worth, and no one can bid the rate down for everybody else.
Nobody earns for being here. You earn for what your machine did.
There is no membership income, no referral tier, no passive yield, and no position that pays you for other people’s work. Every payment traces to one job, one delivery, and one acceptance. A machine that does nothing earns nothing — which is not a restriction so much as the point, because every scheme that pays for presence is ultimately paying someone out of what somebody else produced.
That is what makes the split generous rather than charitable. It is not a gift; it is a fair reading of who did the work. The operator supplied the thing of value, so the operator keeps the majority of it. The rest pays for what genuinely enabled the exchange — and none of it is a dividend for standing nearby.
It also means nobody joining later dilutes you. Your earnings come from jobs your hardware completed, so a network ten times larger is simply a network with more work in it. There is no reason to be territorial about a newcomer, and every reason to want the thing to grow.
A receipt that says what ran, not just who ran it
Exact bytes, or a refusal
Assets are content-addressed. A node runs precisely the files a job specified or declines the job, naming both hashes so a mismatch is never silent.
Two signatures, or no payment
The node signs the delivery; the requester signs the acceptance. Neither half alone is payable, and an acceptance cannot be replayed against a different delivery.
Only for accepted work
Race several nodes and all may deliver — only the accepted one is paid. That is structural, not a policy that could change later.
No rail required to earn
A node accrues before you choose how to be paid. Payment details are never asked for at onboarding.
Every receipt also names the exact notarized build that did the work, and counts reused work separately from newly computed work — so nobody pays twice for the same computation.
Sealed, end to end
Sealed in transit
Every job is encrypted to your node’s own key. The relay that carries it routes ciphertext and can read nothing, in either direction.
Only whom you allow
Each request is signed by a key you registered. Stale, replayed or misaddressed requests are refused before any work starts.
Nothing left behind
No prompt is logged or stored, and one requester’s work never shapes another’s answer: the model’s cache is cleared between them.
Verified at every step
Verified before it runs
Every build is signed and notarized by Apple, and pinned to our developer identity. Anything else is refused before it is installed.
Every job names its build
Each receipt carries the code hash of the exact release that did the work, checked against our published list of releases.
Bound to its owner
A node answers to one owner, confirmed with Face ID. A second person cannot take it over; a transfer must be signed by the current owner.
Generated on your device. Never issued to you.
At first run Core Node generates an Ed25519 keypair on your machine and derives your identifier from your own public key. Anyone can verify it offline, with no server involved. There is no account for us to approve, suspend, or revoke, and no document to upload. Your private key stays in your Keychain and is never transmitted.
A grouping we assign you is a wallet underneath your own key — never the root of your identity. If any part of this product ever requires us to issue you an identity, that is a defect, not a feature.
Your own domain, or the lattice
There are two answers, and neither of them asks you to manage machines.
A sovereign domain
Bind your own nodes into a single private domain and send work only there. Membership is established cryptographically, not by network address — so your machines can sit in three countries and still form one closed space. Work admitted to that domain never leaves it, and no node outside it is ever offered the job.
The lattice
Everything else is simply submitted, and the mesh satisfies it under its own rules — capacity, capability, proximity, and the conditions attached to the request. You are not picking hardware or waiting on a particular machine. You ask for work to be done, and it comes back done.
A domain is a boundary you hold the keys to, not a network you have to administer. Opening work beyond it is always a deliberate act.
Language, image, speech — on hardware you already own
Core Node runs models locally on Apple Silicon. Weights are content-addressed, so a node either holds the exact file a job specified or fetches it once and keeps it — there is no ambiguity about which model produced a result.
Language models
GGUF models through an embedded llama.cpp runtime, accelerated on Metal — from small instruction-tuned models up to 26B mixture-of-experts at 4-bit. Speculative decoding pairs a small draft model on the Neural Engine with the full model on the GPU, so throughput rises without a second machine.
Image generation and rendering
ComfyUI workflows in API format, executed against a node’s local install. Checkpoints, LoRAs, VAEs and control nets are addressed by content hash — a node runs the exact weights a job named, or declines and says which hash it was missing.
Speech and transcription
On-device speech-to-text for audio a node is given. Nothing is sent to a third-party service, and the audio does not leave the machine that transcribes it.
Embeddings and retrieval
Vector embeddings computed locally for search and retrieval over a corpus, so a knowledge base can be indexed without handing the corpus to anyone.
A node advertises what it can actually serve — engine, available memory, and the exact models it holds. Work is never offered to a machine that cannot run it, which is why a job either completes or is refused for a stated reason, and never fails halfway.
What people put on it
Rendering that would tie up your Mac
Send a frame sequence out instead of watching a progress bar for an evening. A price is agreed before anything runs, and you pay only for frames you accept.
A private model for your own work
Bind your machines into one domain and run a model across them. Nothing leaves hardware you own, and no external service sees the prompt or the output.
Capacity you did not have
A model too large for the Mac in front of you runs on one that can hold it, returning a result rather than an out-of-memory error.
Earning from an idle machine
A Mac that sits unused overnight can take work it is capable of and accrue for it, without your having to watch or manage anything.
Indexing a corpus you cannot share
Embed and search documents that are not permitted to leave your control, using compute you also control.
Applications built on top
Independent products for rendering, inference and research reach the same mesh through the same routes, each bringing its own users. An application is named here only when its developer chooses to be listed.
Join the waitlist
Core Node is opening to operators in waves. Leave an address and we will send you a personal invitation with the signed, notarized build as soon as there is room in the next one.
Requires an Apple Silicon Mac on macOS 15 or later. Free — no in-app purchases, no subscription. Your address is used for the invitation and nothing else; see the privacy policy.