Users and model providers connect directly. Run a private router on your machine, point your tools to localhost and pay providers on-chain. It’s the open market
Elyra now is live on @ponsdotfamily.
CA : 0x42cc3f36bb20481378bc0d84ebdfd4fe8f17fbf5
Elyra is a self-hosted router for AI inference. Point any OpenAI-compatible tool at localhost; each request goes to your own model or to the peer that wins on price, speed, reputation or privacy. Providers are paid per token in USDG on Robinhood Chain.
Start with a real model in the Playground. Compare
reachable sellers, or bring your own source. Elyra gives
you the routing controls; you choose whose compute to
trust.
https://t.co/1qZAkOSmP1
Elyra is designed to fit into existing AI workflows.
Its local OpenAI-compatible API allows supported tools to connect without requiring a completely new integration.
The local control panel provides visibility into:
- Connected model sources
- Available providers
- Routing preferences.
- Provider performance
- Payment and escrow status
- Daily spending controls
- Users can also run their own model locally while participating in the wider peer network
This hybrid approach means developers do not have to choose between maintaining their own inference infrastructure and accessing external providers.
They can use both through one routing layer.
Good question! A token should have a purpose beyond speculation.
For Elyra, the real utility comes from the AI inference economy we're building.
Some directions worth exploring:
1. Inference Credits > Use the token to unlock additional inference benefits.
2. Staking & Access > Stake tokens to access premium routing features and higher usage limits.
3. Provider Incentives > Reward providers who contribute reliable models and inference capacity.
4. Ecosystem Governance > Let the community participate in decisions around marketplace parameters and future development.
5. Reputation & Rewards > Incentivize consistent participation from both users and providers.
Connect token utility to actual network activity.
Elyra is building an open inference market where users control routing, providers compete on capacity, and payments are tied to usage.
The token should grow alongside that economy.
A peer is another Elyra node you know by URL. Nodes introduce themselves with a signed hello (identity, encryption key, wallet, models, price) and learn about more peers by gossip. Prompts travel sealed: encrypted to the provider's key, so the network only sees ciphertext. The provider operator can still read them. Only a verified TEE removes that, and that is not proven on real hardware yet (TEE verification).
https://t.co/7R8Dqjjfg8
The router ranks every listing that can serve the model you asked for, using four weights you control: price, speed, reputation and privacy. You can also set a hard price ceiling or require private peers only.
What reputation is made of. From your own requests: the share that succeeded (smoothed, so one lucky or unlucky request does not decide), tokens per second, and for streamed answers the time to the first token. From the periodic probes of each peer (every 15 seconds): its uptime over about the last hour, shown after roughly five minutes of data. A peer that is often away is scored lower (full uptime keeps the score, none halves it); a new peer is not punished for having no data. All of this is measured by your router, never claimed by the seller, and the market shows "Not measured yet" instead of guessing.
auto uses your stored weights. auto:cheapest, auto:fastest, auto:best and auto:private override them for one request.
Live beats simulated. If anything real (your own source or a live peer) can serve a request, only real listings are ranked. The simulated market answers only when nothing real can.
Hosted vs. peer-to-peer. If you attach a hosted API key (OpenRouter, OpenAI, Groq, Together) to your router, its models are ranked by their published per-model prices (never treated as free) and labelled HOSTED · CLEAR. They are paid off-chain to that provider, never re-shared with peers or listed on the public market, and excluded when you require private routing (teeOnly / auto:private).
Up to three candidates are tried before the first byte arrives. There is no failover after a stream has started.
A VPR (virtual private router) is one Node.js process on your machine. It exposes an OpenAI-compatible endpoint on localhost and decides, for every request, where it runs: on a model you attached (Ollama, LM Studio, any OpenAI-compatible server) or on a peer. Your tools never need to know which.
Routing, peers, receipts and payments in plain words, and what is real today.
Elyra is a router you run yourself, plus a way for strangers to pay each other for inference without a middleman. This page explains the moving parts in plain words. Precise formats are in Peer protocol and Architecture.
https://t.co/9ducrr2Nhh
Your model. Your offer. Your earnings.
Selling happens in your own node console, not in this public wallet account. Connect a source, choose models and USDG prices, make the node reachable, then track what buyers actually pay. Start on testnet: contracts are unaudited.
1. Connect your source
Run Ollama, LM Studio or an OpenAI-compatible server. In your own node console, open Sources & tools, detect or add the source, then test it in Playground. Using your own model needs no escrow payment.
2. Publish a reachable offer
Open Sell capacity → Models & pricing in your node console. Choose sources, models and prices per million tokens; save the offer. Check Reachability next. A relay lets buyers reach a home node without port forwarding.
3. Track and redeem earnings
Configure settlement in your node's Payments view and keep ETH for redemption gas. Buyers fund their own escrow; you do not deposit to use your own model. Check Sell capacity → Earnings for served usage, vouchers and paid-out USDG.
https://t.co/8HIJOuHSjT
You are paid per token. Each request is metered in tokens and paid with a signed voucher that you redeem from the escrow. No subscription and no minimum.
You set the price. Dollars per million tokens, one default and a price per model if you like. Buyers' routers compare it with every other seller, so a fair price wins requests.
Privacy is not a single switch that can guarantee every inference request is confidential.
Different providers operate different infrastructure, and users should be able to understand the privacy level of the environment processing their prompts.
Elyra introduces explicit privacy labels to communicate these differences.
- LOCAL: the model runs on your own machine or local network.
- CLEAR: the provider operator can access the prompt while processing it.
- CLAIMED: the provider claims to use a TEE, but the claim has not been independently verified.
- VERIFIED: the provider passes the configured hardware-backed attestation and trust checks.
- SIM / DEMO: a simulated listing, not real inference or a real payment.
- The auto:private routing option is designed to prioritize local or verified TEE providers.
This is particularly relevant for developers and businesses that cannot treat all inference providers as equally trustworthy.
The important part is that Elyra makes the distinction visible instead of presenting every provider as offering the same privacy guarantees.
https://t.co/1qZAkOSmP1
An open inference marketplace needs more than a way to discover providers.
It needs a way for providers to get paid for the resources they supply.
Elyra uses USDG on Robinhood Chain to support per-token payments between consumers and inference providers.
The system separates two important objects: receipts and vouchers.
Receipts: Proof of Usage
Whenever a provider completes an inference request, it produces a signed receipt containing information such as:
The model used.
The number of tokens generated.
The agreed price.
The total amount owed.
The identities of the involved parties.
A receipt records what happened. It does not move money.
Before accepting it, the consumer's router checks the provider's signature, the parties involved, the quoted price, and whether the billed amount matches the token usage.
This creates an additional verification step before payment is authorized.
Vouchers: Authorization for Payment
After verifying a receipt, the consumer signs an EIP-712 payment voucher.
Unlike a receipt, a voucher represents a payment commitment.
Vouchers are cumulative, meaning each new voucher increases the total amount authorized for a particular provider.
The provider can redeem the latest valid voucher through the Elyra escrow contract and receive the corresponding USDG payment.
The flow looks like this:
The consumer deposits USDG into the escrow contract.
A provider processes an inference request.
The provider issues a signed usage receipt.
The consumer verifies the receipt and signs an updated cumulative voucher.
The provider redeems the voucher.
The escrow releases the corresponding USDG.
Prices are denominated in dollars per million tokens, with USDG used for settlement. ETH is used to pay network gas.
This approach connects actual inference consumption with payment, rather than requiring every model request to go through a centralized billing account.
An open inference marketplace needs more than a way to discover providers.
It needs a way for providers to get paid for the resources they supply.
Elyra uses USDG on Robinhood Chain to support per-token payments between consumers and inference providers.
The system separates two important objects: receipts and vouchers.
https://t.co/1qZAkOSmP1
Elyra is designed around direct connections between independent nodes.
A peer is another Elyra node that a user knows through its URL. Each node introduces itself through a signed handshake containing information such as its identity, encryption key, wallet address, available models, and pricing.
This allows nodes to identify available providers and exchange information about the services they offer.
When an inference request is routed to a peer, the prompt is sent through a sealed transport.
Elyra uses X25519 key exchange and AES-256-GCM encryption to protect prompts and responses while they travel between nodes.
This means the network and relay infrastructure see encrypted traffic rather than readable prompt content.
However, transport encryption is not the same as complete privacy from the provider. The provider operator can still access prompts when the model processes them.
That distinction is important, especially for developers working with sensitive information.
Elyra's architecture is designed to support stronger privacy through Trusted Execution Environments (TEE), where hardware-backed attestation can help verify the environment processing a request.
The verification system is under development and has not yet been proven against a real Google Confidential Space environment.
Elyra distinguishes between local, clear, claimed, and verified providers rather than treating every privacy claim as equivalent.
Elyra Open inference P2P
Start with a real model in the Playground. Compare
reachable sellers, or bring your own source. Elyra gives
you the routing controls; you choose whose compute to
trust.
https://t.co/RFtfEioOPN
git clone https://t.co/9ducrr2Nhh && cd elyra && npm ci --omit=dev && npm start
Your Own Router. Your Own Rules.
At the center of Elyra is the Virtual Private Router (VPR).
A VPR is a lightweight Node.js process that runs on your own machine. It exposes an OpenAI-compatible endpoint through localhost, allowing existing AI tools and applications to connect without needing to understand the underlying provider network.
Instead of changing how your applications communicate with AI, you simply point them to your local Elyra endpoint.
For example:
http://localhost:8545/v1
From there, Elyra decides where each inference request should run.
It can use a model attached to your own machine, such as Ollama or LM Studio, or route the request to an available peer in the network.
Your applications continue using the same interface. The router handles the infrastructure behind it.
This makes Elyra more than another AI API gateway. It gives users control over their own inference routing layer.