AI is getting expensive.
Your neighbor's GPU is idle.
fldx is a marketplace for AI compute. Rent someone's machine to run models cheap, or earn by renting yours out when it's sitting there doing nothing. Pay-per-request, end-to-end encrypted, settled on-chain.
AI is getting more expensive. The compute to run it isn't.
API prices keep climbing.
Every quarter the bill goes up — per-token rates, premium tiers, rate limits you can only escape by paying more. The agents you depend on get more expensive every time you blink.
Running it yourself is a hardware tax.
Open models are catching up, but the GPUs to run them aren't cheap, aren't quiet, and aren't sitting in most people's homes. "Just run it locally" is a luxury most of us can't afford.
Meanwhile, capable machines sit idle.
Gaming rigs, workstations, dev boxes — millions of them are powered on, online, and doing nothing for most of the day. That's compute the world already paid for, going to waste.
One marketplace.
Both sides of the trade.
Whether you're paying for AI or paying off a graphics card, fldx puts you in the same room as the other half of the deal.
Rent compute.
Pay-per-request access to AI, in crypto.
- Pick a model, send a request — it runs on someone else's hardware.
- Pay per request. No subscription, no minimums, no credit card.
- Your prompt is sealed before it leaves your computer. The host can't read it.
- Wallet connect, run, done.
Earn with your machine.
List your idle hardware. Get paid when it runs.
- Your machine is online anyway. Let it earn while you're not using it.
- List the models you can run and the price you'll accept.
- Get paid in stablecoins, automatically, every time someone uses your node.
- Walk away whenever you want — no lock-in, no contract.
See what you'd save.
Drag the sliders. As traditional API prices climb, the gap widens — and the marketplace stays roughly flat.
Assumes $10.00/M tokens for hosted APIs · $1.50/M on the marketplace · 3% / yr marketplace drift
One press of send.
Encrypted, run, settled.
Watch a single round trip — your agent calls a tool, the host answers, and the bill settles to chain when it's done.
Your prompt only opens on the machine running it.
Three steps, one encrypted path. Nobody between you and the node can read what you sent — not the marketplace, not the network, not us.
Sealed before it leaves.
Your prompt is encrypted on your computer, against the specific node you picked. Once it leaves your machine, only that node can open it. Not the network, not us, not anyone in the middle.
Matched without being read.
A thin directory points you at a node that fits — model, price, hardware. It only sees the requirements, never the request. We can't read your prompts because we never see them.
Run on someone's hardware.
The node decrypts inside a sealed boundary, runs the model, and returns the answer the same way it came: encrypted end-to-end. Today that boundary is software; tomorrow it's secure hardware and encrypted math.
Privacy is a dial, not a switch.
frontier model
Top-tier AI, encrypted in transit.
A best-in-class hosted model behind the encrypted protocol. Same answers you'd get from a big provider, but the request is sealed end-to-end and you pay per use. No accounts. No retention.
local model
Open models on someone's home rig.
Pick from open-source models running on a host's actual hardware. The host's machine is sandboxed: while it runs your model, it can't reach the internet at all. Cheap, private, and the host literally cannot leak your data.
encrypted math
Even the host can't read it.
Run computations directly on encrypted data. The host's machine never sees your prompt in plaintext — not in memory, not anywhere. Early research today; the strongest privacy guarantee on the roadmap.
secure enclave
Hardware-proven privacy.
Specialized chips (the same ones Apple and AWS use) run the model inside a locked vault and prove cryptographically what's running before you trust it. Same experience, with hardware-backed receipts.
Pay-per-use,
without the gas tax.
Connect your wallet, deposit once into a private channel with a host, and pay per request from there. Each request is a tiny signed receipt — instant, gasless, and only between the two of you.
Done? Close the channel and the final balance settles on-chain in one transaction. Hosts get paid, you get the rest back. No subscriptions, no middleman, nothing held.
Hosts put down a refundable stablecoin deposit before listing. Misbehave and they lose it. Skin in the game, not promises.
You and the host sign tiny receipts off-chain as you go. One on-chain transaction settles thousands of requests. Gas stays out of your way.
Money moves directly between your wallet and the host's. We never hold your funds — there's nothing for us to lose, freeze, or reverse.
What works.
What doesn't. Yet.
fldx is pre-alpha v0. The protocol is real, the encryption is real, the on-chain settlement is real. The trust tiers people will care most about — FHE, real TEEs — are not.
- X25519 + HKDF + XChaCha20-Poly1305 transport
- secp256k1 node identity, signed registrations + heartbeats
- Agent loop with cross-boundary client-side tools
- Two backends: hosted Claude (mock TEE) + sandboxed llama.cpp (local)
- Per-round-trip token usage, accumulated per session
- NodeRegistry on Base Sepolia (USDC stake)
- Bilateral payment channels, cumulative receipts
- macOS sandbox on the local LLM subprocess
- TS CLI + Next.js dashboard with d3-force graph
- Real Nitro / SGX attestation
- FHE backend (TFHE-rs research track)
- JobChannel redeploy after rewrite
- Session keys (kill the per-receipt wallet popup)
- Linux + Windows sandbox parity
- Tier-aware automatic routing