Product case study · August 25, 2026
Darkbloom Turns Idle Macs Into an AI Cloud
Darkbloom pays Mac owners to serve private AI inference. We examine how it works, live demand, realistic earnings, privacy claims, and alpha-stage risks.

Darkbloom has a live inference market, but installing the provider is not proof of serving authorization or income. Check current macOS and App Attest requirements, distinguish local inference from paid fleet work, and measure settled payouts on hardware you already own. The coordinator and provider process remain plaintext trust boundaries.
Sources checked October 27, 2026. This refresh checks official documentation, public API responses and OpenRouter listings. We did not install Darkbloom on a Mac, run inference, audit its security or receive payouts. The August figures below remain dated historical observations, not current earnings forecasts.
The strangest AI provider on OpenRouter may be a Mac mini sitting under somebody else’s monitor.
That is the proposition behind Darkbloom, a distributed inference network from Eigen Labs. Developers pay to run open-weight AI models. Instead of sending every request to a conventional GPU data centre, Darkbloom routes it to an available Apple Silicon Mac. The Mac owner supplies the hardware and electricity, then receives the inference revenue.
It is not crypto mining. The machine is doing a specific job for a paying customer: loading an AI model, processing a prompt, and returning generated tokens.
The project drew attention after creator Gajesh Naik said on August 21 that Darkbloom had moved from OpenRouter’s free tier to paid usage, served close to 4.5 billion tokens, reached a $102,000 annual recurring revenue run rate, and had 250 Macs online. He also said operators were earning $120-$200 per month per machine.
Those are exciting numbers. They also need careful labels. They are founder-reported, a run rate is not the same as contracted annual revenue, and a young network’s supply and demand can change by the hour.
The original August report recorded a fast-changing network. When we checked Darkbloom’s live stats endpoint on August 25, it reported roughly 1,016 active providers, 827 code-attested providers, and 8.5 billion tokens in the previous 24 hours. These are useful live operating signals, but they remain Darkbloom’s own measurements rather than an independent audit.
The short version
- Darkbloom is a real, working inference network. It has a public code repository, live APIs, public provider-attestation records, Stripe-based billing and payouts, and a listing on OpenRouter.
- Apple Silicon is a sensible target. Unified memory lets higher-memory Macs hold open-weight models that would exceed a normal consumer GPU’s VRAM, while mixture-of-experts models only activate part of their total weights for each token.
- Privacy is the hard and interesting part. Darkbloom tries to prevent the Mac owner from inspecting customer prompts by running inference inside one signed, hardened Swift process and verifying the device’s security state.
- “Private” does not mean nobody handles plaintext. Darkbloom’s coordinator decrypts requests transiently before re-encrypting them to the selected provider. OpenRouter is an additional intermediary when that route is used.
- The income is not guaranteed. The August calculator snapshot showed materially lower numbers than the founder’s post for many machines, and adding providers faster than demand can dilute paid work per Mac.
- It is explicitly an evaluation product. The current terms describe public alpha, changing features and no default uptime commitment, and warn against relying on production workloads.
What Darkbloom actually does
There are three parties in a normal request:
- The developer calls an OpenAI-compatible API directly or selects Darkbloom as a provider through OpenRouter.
- The coordinator authenticates the request, checks available capacity, selects an eligible Mac, meters usage, and handles billing.
- The provider Mac decrypts the assigned request inside the Darkbloom process, runs the model locally through Apple’s MLX framework, and streams an encrypted response back through the coordinator.
Providers make outbound WebSocket connections, so a Mac owner does not need to open an inbound port or configure a home router. For a developer, Darkbloom’s direct API is designed to work by changing the base URL in an existing OpenAI client. The project also documents an Anthropic-compatible Messages endpoint and an OpenAI-style Responses endpoint.
The August catalog focused on GPT-OSS 20B, Qwen3.6 35B A3B and Gemma 4 26B builds. On October 27, the OpenRouter provider page listed 11 models, including newer Nemotron, MiMo, GLM and Qwen entries. A listing does not establish that your Mac can serve every model.
Check the direct catalog for the exact build, capabilities and qualification notes. Our October 27 response included entries whose metadata still marked hosted qualification as pending. Catalog presence, local model loading and eligibility for paid network requests are separate checks.

Why a Mac can be useful AI infrastructure
Most consumer GPUs have fast memory but relatively little of it. A 24GB graphics card may be powerful, yet it cannot hold a model that needs 30GB or 60GB without offloading weights and losing speed.
Apple Silicon uses unified memory shared by the CPU and GPU. A Mac Studio can therefore give a local model access to 64GB, 128GB, 192GB, or more without copying every tensor between separate system and graphics memory pools. That makes a high-memory Mac unusually good at fitting large models into one quiet machine.
Darkbloom’s economic case is strongest for mixture-of-experts, or MoE, models. A model may contain 26 billion or 35 billion total parameters while activating only 3-4 billion for each token. The full model still needs to fit in memory, but the active weights moving through the memory bus per generated token can be much smaller than the headline parameter count suggests.
This does not make a Mac universally cheaper or faster than a cloud GPU. Dense large models still benefit from the enormous bandwidth and batching of data-centre accelerators. Consumer networks also add latency, uneven hardware, home-internet failures, and availability changes. Darkbloom is making a narrower bet: already-purchased unified-memory Macs can serve selected MoE models cheaply enough to undercut conventional APIs.
That is a credible wedge. It is not yet proof that idle consumer computers can replace a reliable inference fleet.
How Darkbloom tries to hide your prompt from the Mac owner
The provider operator is the unusual adversary here. They own the computer, may have administrator access, and physically control the hardware processing somebody else’s prompt.
Apple Silicon does not expose a general-purpose trusted execution environment that lets a third-party app encrypt its working memory from the machine owner. The original design tried to remove normal software paths into that memory. The following describes that design, including its legacy MDA/APNs path; it is not the current onboarding checklist:
- In-process inference: the network client, decryption, tokenizer, model and MLX generation engine run inside one Swift process. There is no local Ollama server, subprocess, pipe, or localhost API for an operator to tap.
- Debugger and memory-read blocking: the signed app invokes
PT_DENY_ATTACHand uses Apple’s Hardened Runtime without the entitlement that would permit debugger access. - System Integrity Protection: SIP makes those controls difficult to bypass while the process is alive. Disabling SIP normally requires restarting into Recovery, which terminates the inference process and clears its working memory.
- Hardware-bound identity: a Secure Enclave key identifies the provider, while Apple’s Managed Device Attestation can provide Apple-signed evidence about a genuine device and selected security properties. Apple describes MDA as a cryptographic declaration for trust decisions, not a complete guarantee that every application action is safe.
- Code-identity checks: Darkbloom says APNs challenges help prove that the provider is running a genuine team-provisioned build rather than an operator-modified binary that logs prompts.
The public provider-attestation endpoint exposes trust level, chip, memory, SIP, Secure Boot, Secure Enclave and MDA status. Publishing the chain is a strong transparency choice because a client does not have to accept a single “verified” badge with no underlying record.
The design is technically ambitious, but it is still a project security claim, not an audited guarantee. Darkbloom’s April technical paper assumes there is no unpatched macOS kernel vulnerability capable of bypassing the protections. It also acknowledges observable timing metadata, a physical-memory attack, reliance on Apple infrastructure, and unfinished enforcement around hypervisor isolation for RDMA-capable systems.
The current encryption documentation adds two limits: process hardening does not guarantee that inference buffers are zeroed, and fresh sender keys do not provide forward secrecy if a recipient private key is compromised. Its authorization reference separates legacy MDA/APNs from qualified App Attest. A trust status is permission to serve under that contract, not proof of correct output or physical machine uniqueness.
The repository now separates provider code from the platform backend. That split is not a security audit. The current terms retain the public-alpha production warning.
“End-to-end encrypted” needs a footnote
Darkbloom’s marketing says requests are encrypted before transmission and prompts remain hidden from operators. The narrower claim—hidden from the owner of the provider Mac through ordinary software access paths—is the one the architecture is designed to support.
The complete request path is more complicated:
| Stage | What happens to the request | Trust boundary |
|---|---|---|
| Developer to Darkbloom | TLS by default; optional sender-side NaCl Box encryption | The coordinator can access plaintext in memory |
| Inside the coordinator | Plaintext is used transiently for compatibility, routing and billing | Darkbloom says content is not logged or retained in ordinary request logs |
| Coordinator to provider | Re-encrypted with a fresh key to the selected provider | Only the provider’s hardened process should decrypt it |
| Through OpenRouter | OpenRouter terminates its own TLS connection before forwarding | OpenRouter becomes another party with technical access in transit |
Darkbloom’s own privacy policy is refreshingly precise: the current coordinator processes payloads in plaintext transiently and users should not treat every service path as making coordinator access technically impossible. It also says the privacy architecture only covers Darkbloom’s part of the path when a third-party router is involved.
OpenRouter’s provider directory still labeled Darkbloom on October 27 “Retains prompts” and not zero-data-retention. That classification is more conservative than Darkbloom’s statement that ordinary coordinator logs omit prompt content. The two may reflect different policy definitions or a stale provider declaration, but a customer should not resolve that ambiguity in the product’s favour.
If a workload contains customer records, private source code, legal material, health data, unreleased financial information, or secrets, wait for an independent audit and clear contractual data terms. “The operator cannot attach a debugger” is valuable; it is not a substitute for a complete production security programme.
Can an idle Mac really earn $120-$200 a month?
The August founder claim does not establish what a new operator can earn now. We have no independently verified distribution of settled payouts.
The August 25 version of Darkbloom’s earnings calculator estimated roughly $16-$100 per month for a 48GB Mac. That historical upper case assumed the machine serves requests 60% of the time it is online, averages 2.5 concurrent requests while active, pays $0.15/kWh, and draws about 30W of incremental power during inference. The example combined around $84 of usage income with a $16 base reward.
We did not re-establish that calculator range as a current offer. Its assumptions remain useful questions to check:
- Demand: revenue exists only when customers choose a model your Mac can serve.
- Memory: the August catalog listed 24GB for GPT-OSS, 32GB for Qwen3.6 and 36GB for Gemma builds. Recheck the exact current build and available headroom rather than treating those figures as a universal minimum.
- Competition: the scheduler can choose among many machines. If provider supply grows faster than requests, utilization per operator falls.
- Uptime: the August reward scheme tied base rewards to 90% availability and a fixed pool. Confirm current eligibility and settlement rules before counting any base reward.
- Power and disruption: electricity may be modest, but heat, fan noise, memory pressure, model downloads, network use and reduced availability for the owner’s own work still have value.
- Policy: Darkbloom’s terms say alpha earnings can be interrupted, reduced or suspended as the service changes.
The founder’s $120-$200 figure may describe machines with larger memory, favourable model demand, high availability, or early-network economics. Without a distribution of settled payouts by chip, memory, model and online hours, it should be treated as an anecdote.
The $102,000 ARR claim needs the same discipline. Annual recurring revenue usually describes durable subscription contracts. Darkbloom had only just switched from free to paid OpenRouter traffic, so this appears to be an annualized run rate based on a short operating window. It shows that paid traffic existed; it does not show that $102,000 has been collected or will recur for twelve months.
What providers are paid from
Darkbloom’s live pricing endpoint showed the following direct rates on August 25, per million tokens:
| Model | Input | Output |
|---|---|---|
| GPT-OSS 20B | $0.020 | $0.100 |
| Gemma 4 26B | $0.042 | $0.220 |
| Qwen3.6 35B A3B | $0.070 | $0.700 |
The August offering said the hardware operator kept 100% of inference revenue with no platform fee, using Stripe billing and Stripe Connect payouts. Recheck current account terms and payout availability; those launch conditions are not a promise for a new provider. The economics are therefore closer to a tiny cloud-compute marketplace than a token-reward scheme.
For comparison, the same pricing endpoint, fetched October 27, returned these direct input/output rates per million tokens:
| Exact catalog ID | Input | Output |
|---|---|---|
gpt-oss-20b | $0.018 | $0.090 |
gemma-4-26b | $0.042 | $0.220 |
qwen3.6-35b-a3b-vl-mtp-mxfp8 | $0.050 | $0.700 |
These are customer API prices for named builds, not hourly income, utilization guarantees or proof of payout. The endpoint also lists cache-read rates separately. Record the rates applicable to your actual workload and settlement period.
Zero platform fee is a launch incentive, not a permanent business model. A responsible payback calculation should allow for future fees, lower prices, additional providers, changing model popularity and taxes.
What installing Darkbloom changes on a Mac
The installation guide, updated October 23 and checked October 27, now requires macOS 27 or later for new installs and new network providers. The binary’s macOS 14 deployment target is not the onboarding requirement. Qualified App Attest authorization is also required; upgrading the OS alone does not authorize serving.
The installer verifies a staged app before replacing an existing installation and writes under the user’s home directory without requiring sudo. Optional fan control has a separate privileged helper. Check the current hardware requirements for the chosen model: memory capacity alone does not establish chip support, context headroom or measured performance.
New macOS 27 setup uses App Attest without new Darkbloom MDM enrollment. Older verification is restricted to eligible frozen legacy identities; an installed MDM profile is not proof of eligibility. Existing operators should follow the current upgrade guidance rather than reinstalling a profile to bypass authorization.
Do not paste a curl | bash command into a primary work machine because a social post said it earns money. On a spare Mac:
- Read the installation documentation and inspect the installer URL before running it.
- Verify the downloaded signature and current serving authorization requirements. Review any existing management profile separately.
- Back up the machine and remove unrelated credentials or sensitive local data.
- Start with standalone local mode and synthetic input; do not confuse it with network self-routing.
- If you later enable public jobs, measure actual settled income, wall power, heat, network use and lost availability before committing to an always-on schedule.
Buying a new Mac to join the network reverses the project’s best economic argument. Darkbloom is compelling because the hardware is already paid for. Once a provider must recover thousands of dollars of new capital expenditure, the payback becomes speculative.
Verify one local request before joining the fleet
This is a documentation-backed exercise, not a reported successful test. Use a spare Mac that meets the current installer requirements and a downloaded model supported by standalone mode. Follow the official installation guide first; do not paste an installer from an old article.
The direct-mode guide, checked October 27, distinguishes:
| Mode | Coordinator connection | Income |
|---|---|---|
darkbloom start --local | Standalone inference, no coordinator | None |
darkbloom start --local-endpoint | Local endpoint alongside fleet serving | Only eligible fleet traffic earns |
After installation, record the version and inspect available models:
darkbloom --version
darkbloom doctor
darkbloom models list
Choose a downloaded, supported model. Start standalone mode in a terminal; keep the default loopback binding and authentication:
darkbloom start --local
In a second terminal, run darkbloom local to see the live endpoint, model list and request example. Its output includes an API key: keep it out of shared logs. Use its example with a synthetic prompt such as “Reply with the word ready.” Save a redacted response, model ID, elapsed time and any error. Stop the foreground server with Ctrl-C when finished.
Pass criteria: the response comes from the selected local model, contains usable output, and you can stop the server. This demonstrates neither paid routing nor eligibility for earnings. An authorization error needs the local token; a model-load failure needs the supported model and memory checks. Do not disable authentication or bind to all interfaces as a shortcut.
For a later network trial, follow the provider quickstart. It documents account linking, service startup and status checks. Treat installation, account linking and serving authorization as separate milestones. A running process alone does not prove paid work is arriving.
Keep a seven-day operator record
Use one row per day. This is an authored evaluation worksheet, not a Darkbloom earnings forecast:
| Record | What it establishes |
|---|---|
| CLI version, chip, OS and exact model build | Which configuration produced the observation |
| Online hours and authorized serving hours | Availability versus eligibility |
| Paid requests and metered tokens | Actual work, separated from local tests |
| Ledger credits and settled payouts, separately | Accrual versus money actually received |
| Wall-meter kWh and your electricity tariff | Measured electricity expense |
| Errors, heat, noise and interrupted personal work | Operating cost beyond the bill |
Subtract measured electricity expense from settled payouts for the same period. Keep hardware cost, fees and other obligations separate; that subtraction is not total profit. If settlement has not happened, write “unsettled” rather than zero or projected income. If paid requests stay at zero, check account linkage, serving authorization and model eligibility before assuming the network owes you work.
Carry the record into Choose where your AI model should run to compare local utility with network income on evidence you collected.
Who should try Darkbloom now?
A tinkerer with a spare 32GB-or-larger Mac: yes, cautiously. The system is technically interesting, the operator setup is transparent enough to inspect, and standalone local inference may be useful even if public demand disappoints. Check current OS, model and authorization requirements first.
A developer evaluating cheap open-weight models: maybe. Use non-sensitive workloads, pin the provider deliberately, measure quality and latency, and keep a reliable fallback. OpenRouter makes comparison convenient, but its current data-retention label matters.
A company sending confidential production data: not yet. The project itself says evaluation only. Wait for an audit, stable privacy declarations, incident-response commitments, a data-processing agreement where relevant, reliable availability, and a clear zero-retention route.
Someone considering buying hardware for passive income: no—not from today’s evidence. Run the exact hardware you already own, collect settled payouts over time, and calculate a downside case before spending money.
The real experiment is bigger than passive income
Darkbloom is interesting because it connects three ideas that normally live apart: the enormous installed base of Apple Silicon, open-weight MoE models that fit unified memory unusually well, and hardware-backed device verification intended to make strangers’ computers usable for private inference.
If the privacy controls survive scrutiny and customer demand stays ahead of provider growth, idle Macs could become a meaningful second tier of AI infrastructure: slower and messier than a hyperscale GPU fleet, but cheap, geographically distributed and already sitting on desks.
If demand fades, the same network becomes a familiar marketplace problem—many providers competing for too few paid jobs. If the security design fails, low prices will not save it. And if the coordinator or aggregator remains inside the plaintext trust boundary, Darkbloom should be described as operator-resistant inference, not magic privacy.
That is why it is worth watching. The product does not need to replace the cloud to matter. It only needs to prove that a verified spare Mac can complete useful AI work, protect the customer’s content well enough for its stated use case, and earn more than it costs to keep online.
Sources
Refresh checks: October 27, 2026. Installation, quickstart, direct-mode, hardware, authorization and encryption documentation were read alongside the current privacy policy, terms, OpenRouter listing/directory and direct pricing/catalog/stats APIs. No Mac execution or payout verification was performed. The founder post, screenshot, technical-paper discussion and August calculator figures are retained historical context, not newly verified measurements.
Put this to work
Evaluate distributed inference as a complete system: model fit, demand, routing, operator privacy, coordinator trust, uptime, power, payouts, and failure conditions.
Try
Check the current installer requirements on a spare Mac, then try standalone local inference with synthetic input before enabling network serving.
Prove it worked
Record wall power, tokens per second, online time, paid utilization, gross payout, electricity cost, thermal behavior, and any disruption to your normal work for at least a week.
Where it can pay
Treat any payout as variable capacity revenue. Do not buy a Mac from an annualized estimate until your own settled earnings cover hardware, power, downtime, and tax obligations.
Keep in view
- Darkbloom routes paid AI inference to Apple Silicon Macs and is already available as a provider on OpenRouter.
- New network providers now need macOS 27 or later and qualified App Attest authorization; an old MDM profile is not sufficient.
- August earnings estimates are historical. Local mode earns nothing, and a current API rate is not a settled provider payout.
- The coordinator handles plaintext transiently; current terms still describe public alpha and warn against relying on production workloads.