Nyxos
Whitepaper · v0.1

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.

NyxosDecentralized inferenceToken · $NYXOSnyxos.dev
01 · Abstract

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.

02 · The problem

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.

03 · Architecture

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.

04 · Pillar I · Private

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.

05 · Pillar II · Unstoppable

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.

06 · Pillar III · Open

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"}]}'
07 · Pillar IV · Train & own

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.

08 · Pillar V · Publish & earn

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.

Provide compute

Run a node

One command turns a GPU into a provider. It answers prompts and runs training jobs, earning $NYXOS per job at launch.

Provide a model

Publish weights

List a model others can call and collect a royalty in $NYXOS on every inference it serves at launch.

Consume

Spend to run

Pay per request from the chat app or the API, settled atomically on the ledger.

09 · Pillar VI · Your data

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.

10 · Token

$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.
$NYXOS contract address · Solana
6fJxSDFFqdfYwki8xPR6USZ1qotd3yyqmxEkDAFpump
11 · Status & honesty

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.

CapabilityStateNotes
Private chat appLivePer-message cost, no accounts, nothing logged but the ledger.
OpenAI-compatible APILive/v1/chat/completions, works with existing tooling.
Provider nodesLiveSingle-binary node dials out and serves jobs.
Atomic settlement ledgerLiveDeterministic per-job accounting.
Fine-tune & keep weightsDesignedDistributed training jobs across capable nodes.
Model marketplace & royaltiesDesignedPublish a model, earn per inference.
Private data / retrievalDesignedBring-your-own-data embeddings and chat.
$NYXOS rewards & on-chain settlementAt launchProvider earnings and the token activate at network launch.
Discovery · PoW verification · reputationDeferredLaunch-phase hardening of the open network.
Sovereign AI

Run free.

Open models, peer-to-peer settlement, no accounts, no logging, no off switch. AI that belongs to the people who run it.