Everything on-chain, machine-payable inference actually needs.

One API across PyTorch/Transformers, llama.cpp, and proxied OpenAI, Anthropic, Cohere, or Ollama. Switch backends without changing client code.

• A single pluggable backend abstraction exposes one API across local PyTorch/Transformers, llama.cpp (GGUF), and proxied OpenAI, Anthropic, Cohere, or Ollama.
• Switch backends without changing client code — the wire protocol is identical whether a request lands on a local GPU or a remote provider.
• Nodes declare available models in config; the registry routes requests to nodes that can serve the requested model.

FedAvg, FedProx, FedAdam, and SCAFFOLD implementations with non-IID data handling, circuit breakers, and automatic recovery on dropped clients.

• FedAvg, FedProx, FedAdam, and SCAFFOLD are implemented so you pick the aggregation strategy that suits your data skew.
• Non-IID data handling, circuit breakers, and automatic recovery keep rounds progressing when clients drop.
• Secure aggregation and (epsilon, delta)-differential privacy are on by default, with configurable noise for stricter regimes.

Optional 3-hop onion routing for confidential prompts and differential privacy on gradient updates. Sensitive workloads stop leaking metadata.

• Optional 3-hop onion routing means no single node sees both the request source and the prompt content.
• Differential privacy on gradient updates keeps federated rounds from leaking training data.
• Sensitive workloads stop leaking metadata without giving up the OpenAI-compatible interface.

Drop-in replacement for the OpenAI client. Point base_url at the gateway, pass a Solana wallet as the API key, and existing apps — or autonomous agents — work unchanged. Compatibility is the on-ramp to on-chain inference.

• The gateway exposes /v1/chat/completions and /v1/completions matching OpenAI’s schema.
• Point the OpenAI SDK base_url at the gateway and pass your Solana wallet address as the api_key — existing apps work unchanged.
• JWT plus Solana-signature auth, per-user rate limits, input sanitization, and audit logging protect the endpoint.

Per-request SOL micropayments with sub-second finality and ~$0.00025 fees — settlement built for agents that pay per call, not per invoice. Operators get paid on every served request and every training round; every payment leaves an on-chain audit trail.

• Per-request micropayments settle with sub-second (~0.4s) finality and ~$0.00025 fees — the settlement model that fits agents paying per call rather than per invoice.
• A funded session lets an autonomous agent pay as it goes: fund once, meter per request, settle in aggregate to keep on-chain overhead negligible.
• Node operators are paid in SOL on every served request and every training round.
• Signed transactions use solana-py, pynacl, and base58; every payment references an on-chain audit trail.

Prometheus metrics, WebSocket admin dashboard, structured request tracing, and a Textual TUI. Diagnose hot nodes and slow clients without grepping logs.

• Prometheus metrics, a WebSocket real-time admin dashboard, and structured request tracing come built in.
• A Textual TUI gives operators a unified monitoring view without grepping logs.
• Diagnose hot nodes and slow clients from the tooling, not from raw log files.

Nodes are just containers that phone home to the registry, so they drop straight onto DePIN GPU networks (io.net, Akash, Render, Nosana) or marketplace/spot GPUs (Vast.ai, RunPod). Turn the cheapest idle inference-capable hardware into SOL revenue.

• Nodes are plain containers that register on their first heartbeat, so they run wherever GPUs are cheapest — DePIN networks (io.net, Akash, Render, Nosana) or marketplace/spot GPUs (Vast.ai, RunPod).
• A single 24GB consumer/prosumer card serving a quantized 7B–8B model via the llama.cpp GGUF backend is enough to earn — a few dollars a day of hardware against per-request SOL.
• Docker Compose runs a gateway plus nodes locally; Kubernetes manifests with HPA/VPA and multi-zone deployments make production scaling first-class.

Every request and payout is anchored to an on-chain audit trail today. The roadmap moves from "trust the operator" toward verifiable inference — signed attestation of which model produced a result, then sampled re-execution, then cryptographic proofs.

• Every request and payout is anchored to an on-chain audit trail today — you can reconcile what was served and what was paid without trusting an invoice.
• The roadmap moves toward verifiable inference: signed attestation of which model and config produced a result, then sampled re-execution that slashes reputation on mismatch.
• Cryptographic proofs (TEE attestation, zkML) are kept behind a trust tier so most traffic never pays for verification it does not need.