Sovereign AI.
Run free.
Private, uncensored, and impossible to switch off. Nyxos is a decentralized inference network where open models run across independent GPUs no company or government controls.
AI you own, not AI you rent
Today's most capable AI lives behind a handful of corporate APIs. Those providers can read every prompt, refuse any request, change the rules overnight, or be compelled to shut you out entirely. Nyxos removes the single point of control.
Prompts route to independent provider nodes, real GPUs run by real people across many jurisdictions, each serving an open model. Payment settles peer to peer, per job, on an atomic ledger denominated in $NYXOS. There are no accounts and nothing is logged but the ledger entry. The result is AI that is private by construction, uncensored by default, and resistant to takedown by design.
Centralized AI is surveilled, censored, and revocable
Three failures follow directly from routing the world's intelligence through a few companies.
- Surveilled. Every prompt and response can be stored, profiled, and handed over. A privacy policy is a promise, not a guarantee.
- Censored. A provider decides what models exist and what they may say. Capability is gated by corporate policy and political pressure.
- Revocable. Access depends on an account that can be suspended, a model that can be deprecated, and a company that can be ordered to stop serving you.
Open weights solved what you can run. Nyxos solves how you run it, without a gatekeeper in the loop.
One thin coordinator, many independent nodes
Two front doors, a private chat app and an OpenAI-compatible API, share one backend. A lightweight coordinator routes jobs and keeps the ledger; the intelligence and the hardware live entirely at the edge, on nodes that dial out over WebSocket. There is no public IP to port-scan or seize.
Chat app · OpenAI-compatible API · dashboard
| REST + SSE + WebSocket
+-----v---------------------------------------+
| COORDINATOR job router · atomic $NYXOS |
| ledger · auth/gating · SQLite (thin, cheap) |
+-----+---------------------------------------+
| WebSocket, nodes dial OUT
+------+-------+---------------+---------------+
v v v v
NODE NODE NODE NODE
your Mac rented GPU a user's PC anywhere
open model open model open model open model
The coordinator never sees a model weight and stores no prompt history. It matches a paid request to a free node, relays the stream, and records one signed ledger movement. Lose a node and the router simply picks another.
Nothing to log, no one to ask
No accounts, no profiles, no prompt history. Each request is routed, answered, and settled peer to peer, then it is gone. The only trace that survives is the ledger entry that paid the node for the work. There is no dataset of your thoughts to leak, subpoena, or sell, because it is never assembled in the first place.
No kill switch
Nodes dial out from machines in every region. There is no central server to seize, no company to pressure, no model to delist. Take one node down and the network routes around it. Pressure one jurisdiction and capacity simply shifts to others. The coordinator is deliberately thin and cheap to run, so it is trivial to mirror and relaunch. Resilience is the architecture, not a feature bolted on top.
The models you actually choose
Llama, Qwen, Gemma, DeepSeek, Phi. Open weights, uncensored, served behind one OpenAI-compatible API. Point Cursor, Continue.dev, or the OpenAI SDK at Nyxos and pay per request. Nothing in your toolchain has to change.
curl https://nyxos.dev/v1/chat/completions \
-H "Authorization: Bearer <your $NYXOS key>" \
-H "Content-Type: application/json" \
-d '{"model":"llama3.2","messages":[{"role":"user","content":"hello nyxos"}]}'
Train models that stay yours
Inference is the start, not the ceiling. The same fleet of GPUs that answers prompts can fine-tune open models on your data. Submit a job, the network schedules it across capable nodes, and the resulting weights are yours: downloaded, kept, and run wherever you like. No platform holds your model hostage, and no provider sees more of your data than the slice it processed.
A market for models, not just GPUs
Publish a fine-tune, or an uncensored open model, to the network and earn $NYXOS every time someone runs it. The economic loop runs both directions.
Run a node
One command turns a GPU into a provider. It answers prompts and runs training jobs, earning $NYXOS per job at launch.
Publish weights
List a model others can call and collect a royalty in $NYXOS on every inference it serves at launch.
Spend to run
Pay per request from the chat app or the API, settled atomically on the ledger.
Private compute on what is yours
Bring your own documents and turn them into a private knowledge base. Embeddings and retrieval run on the same network, so you can chat over your files without shipping them to a third-party cloud. Your data is processed for the job and discarded. It never becomes someone else's training set, and it never leaves under a name attached to you.
$NYXOS and the economic loop
$NYXOS is the unit of account for work on the network. Consumers spend it to run inference and training; providers earn it for the compute and models they supply. Settlement is a single atomic movement on the ledger: a consumer is debited and a provider credited in the same transaction, never partially.
- Earn by contributing a GPU, or by publishing a model others run.
- Spend on inference, fine-tuning, and private retrieval.
- Live on Solana. The $NYXOS token is live; in-product on-chain settlement and provider rewards activate as the network rolls out.
What is real today
Nyxos is in gated early access. Everything demonstrated is real: a real open model, real provider nodes, real ledger movement, just intentionally small and clearly labeled. We do not fabricate node counts, throughput, or users. The table below states plainly what is live versus what is designed and deferred to the launch phase.
| Capability | State | Notes |
|---|---|---|
| Private chat app | Live | Per-message cost, no accounts, nothing logged but the ledger. |
| OpenAI-compatible API | Live | /v1/chat/completions, works with existing tooling. |
| Provider nodes | Live | Single-binary node dials out and serves jobs. |
| Atomic settlement ledger | Live | Deterministic per-job accounting. |
| Fine-tune & keep weights | Designed | Distributed training jobs across capable nodes. |
| Model marketplace & royalties | Designed | Publish a model, earn per inference. |
| Private data / retrieval | Designed | Bring-your-own-data embeddings and chat. |
| $NYXOS rewards & on-chain settlement | At launch | Provider earnings and the token activate at network launch. |
| Discovery · PoW verification · reputation | Deferred | Launch-phase hardening of the open network. |
Run free.
Open models, peer-to-peer settlement, no accounts, no logging, no off switch. AI that belongs to the people who run it.