Xiron

Verifiable AI Search

Verifiable Trustless Composable

Vision How it works For Developers Node Network Whitepaper

Vision

Build a verifiable, trustless, and composable AI search aggregation network where every answer is proven — from data provenance to model invocation and ranking.

Mission
Principles
Value
Flow
Proof Card
Stats
Get access

Interactive 3D

Overview

Plan Parallelize, fallback, dedup
Retrieve BM25 + dense + freshness
Assemble Evidence & alignment
Rank Transparent scoring
Prove Commit & zk batch

Mission

Create an aggregation layer for AI search where trust is earned by cryptographic proof, not by brand claims. Every answer is shipped with verifiable provenance, model-call receipts, and optional zk ranking proofs.

Principles

Verifiable by default — answers come with a Proof Card.
Open, modular, and market-driven — contributors stake and earn by quality.
Privacy-first — anonymized queries and optional zk receipts.

For users

Higher recall via multi-engine + vertical indexes
Auditable ranking logic and bias controls
Hallucination defense with evidence coverage thresholds

For contributors

Stake + revenue share for Crawlers / Indexers / Models / Verifiers
Reputation attestations (EAS) improve routing and rewards
Arbitration + SLA to maintain quality

Flow

Planner routes the query to engines and vertical indexes
RAG assembles evidence; Verifier samples and validates
Proof Card is committed on-chain; the answer returns

Proof Card

{
  "source": {"url": "https://...", "hash": "sha256:...", "snapshot": "ar://..."},
  "model": {"id": "Xiron-Research", "weights": "blake3:...", "prompt_hash": "..."},
  "output_hash": "sha256:...", "commitment": "0x...", "zk_batch": "#217"
}

95%Success rate

P95 1.8sLatency

85%Evidence coverage

0.7%Arbitration rate

Get early access

Answer

Query: —

Generating with deepseek-ai/DeepSeek-V3.1…

Node Network

Join the network as a Crawler, Indexer, Model, or Verifier. Stake for quality, earn for contribution.

Roles
Staking & Slash
Reputation
Routing & SLA
Economics
Run a node

Run the network

Power the verifiable AI search with your infrastructure. Earn by crawling, indexing, modeling, and proving.

SLAReputationSlash

Crawler

Fetches pages, dedupes, normalizes, signs snapshots.

Indexer

Builds inverted/Vector index and KG; updates freshness.

Model

Runs inference, RAG, and summarization; attaches receipts.

Verifier

Samples, checks coverage, batches zk proofs.

Staking & Slash

Stake required to receive jobs
Slash on missed SLA or arbitration failure
Higher reputation lowers required stake

Escrowed jobs

Payments flow via smart contracts with clear SLA.

Arbitration

Disputes resolved on-chain; transparent outcomes.

Reputation

EAS attestation-backed scores, composable across networks.

completionlatencyquality

Routing & SLA

Market-aware router selects nodes by price/SLA/quality
Timeouts and retries
QoS tiers for enterprise

Fees

USDC or XRN; discounts with staking.

Revenue

Share from routing and proving fees.

Buyback

Fees accumulate to buyback XRN (or partial burn).

Run a node

docker run -d --name xiron-node \
 -e XIRON_KEY=... -p 8080:8080 \
 ghcr.io/xiron/node:latest

Register on-chain and stake
Healthchecks and metrics
Automatic updates via tags

For Developers

Build on Xiron with a unified API, SDKs, and verifiable RAG components.

REST API
SDKs
Verifiable RAG
Web components
Examples

REST API

One endpoint for answers with attached evidence. Use JSON or stream with JSONL.

POST /searchGET /proof/:idPOST /ingest

POST /search
{
  "query": "latest L2 rollup security incidents",
  "sources": ["web", "on-chain"],
  "top_k": 5,
  "explain": true
}

TypeScript SDK

import { Xiron } from '@xiron/sdk'
const client = new Xiron({ apiKey: '...' })
const res = await client.search({ query: 'zk rollups overview' })
console.log(res.answers[0].proof)

Python SDK

from xiron import Client
cli = Client(api_key='...')
res = cli.search(query='verifiable RAG')
print(res.answers[0].proof)

Web Component

<xiron-search proof="true"></xiron-search>
<script src="https://cdn.xiron.dev/widget.js"></script>

Verifiable RAG

Attach Proof Card to each citation
Enforce evidence coverage threshold
Anti-hallucination by design

Proof-first

Answers are only returned if citations meet coverage criteria.

Privacy

Query anonymization and optional zk receipts.

Web components

Drop-in search box and proof viewer with customizable theming.

xiron-searchxiron-proof

Next.js

// app/api/search/route.ts
export async function POST(req: Request) {
  const { query } = await req.json();
  const res = await fetch('https://api.xiron.dev/search',{ method:'POST', body: JSON.stringify({ query }) })
  return new Response(await res.text())
}

Node

import fetch from 'node-fetch'
const r = await fetch('https://api.xiron.dev/search',{ method:'POST', body: JSON.stringify({ query:'xiron proof' }) })
console.log(await r.json())

cURL

curl -X POST https://api.xiron.dev/search \
 -H 'Content-Type: application/json' \
 -d '{"query":"verifiable ai search"}'

How it works

From query planning to verifiable answers — a pipeline designed for recall, relevance, and proofs.

Planner
Retrieval
RAG
Ranking
Proof
Privacy

Planner

Agentic planning to parallelize across search engines and vertical indexes, with backoff and dedup strategies.

Parallel multi-engine search with cascading fallback
Deduplication and freshness weighting
Route by price/SLA/quality in market-aware mode

Retrieval

Combine BM25 and dense embeddings with time decay and domain-specific boosts.

BM25 + dense retrievers (E5 / ColBERT / multi-modal)
Time decay and freshness boost
Domain-specific vertical indexes

RAG

Assemble evidence, enforce coverage thresholds, and detect contradictions to reduce hallucinations.

Evidence coverage threshold and conflict detection
Attribution to exact snapshots
Verifier sampling for QA

Ranking

Transparent scoring with optional zk proofs over public weights and features (V2).

Mono/Duo reranking
zk verifiable scoring with public weights
Bias controls and policy filters

Proof

Commit provenance and model receipts on-chain; batch zk proofs for cost efficiency.

Content hashes + snapshot pointers (Arweave/IPFS)
Model id, weights hash, prompt hash, output hash
Commit-then-prove with batch zk

Privacy

Anonymous queries with optional zk receipts to prove access without revealing the query.

DID/anonymous credentials
Minimal logs and tenant isolation
zk receipts (future)

Anti-hallucination

Evidence coverage thresholds and contradiction checks before answer synthesis.

Privacy receipts

Optional zk receipts let you prove access happened without revealing the query.

Proof Card example

Planner

Retrieval

RAG

Ranking

Proof

Privacy

Answer

Query: —