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

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

Each stage is audited for coverage and latency. Fallbacks are triggered on SLA breaches, and contradictions are surfaced before synthesis.

Routing & fallbacks

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"
}

{
  "receipts": [
    { "engine": "web", "ts": 1720000000, "evidence_hash": "sha256:..." },
    { "engine": "on-chain", "ts": 1720000030, "evidence_hash": "sha256:..." }
  ],
  "verifier": { "id": "xiron/verifier-1", "sample_rate": 0.2, "result": "pass" },
  "zk": { "scheme": "plonk", "batch_id": 217, "proof_ptr": "ar://..." }
}

Snapshots are immutable; links resolve to exact bytes.
Model receipts include id, weight hash, and prompt hash.
Verifier attests coverage; zk batch proves the scoring path.

95%Success rate

P95 1.8sLatency

85%Evidence coverage

0.7%Arbitration rate

Metrics are computed over anonymized production traffic with synthetic and human eval mixes.

Success rate: answer returned with required coverage threshold.
Latency: end-to-end from request to first token (streaming).
Arbitration: disputes raised per 1k requests (lower is better).

Get early access

Join the early adopter cohort to influence roadmap and APIs. We onboard in small waves.

Priority access to new endpoints and widgets
Direct channel for feedback and integrations
Eligibility for contributor programs

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.

Volume tiers for enterprises
QoS surcharge for P95 latency targets

Revenue

Share from routing and proving fees.

Split by role and SLA adherence
Bonus for verified coverage

Buyback

Fees accumulate to buyback XRN (or partial burn).

Programmatic treasury policy
Transparent on-chain ops

Pricing

Dynamic by market, demand, and quality.

Router selects best price/quality
Floor prices by resource class

Incentives

Reputation multipliers boost routing share.

Higher uptime → higher weight
Low arbitration → bonus tier

Costs

CapEx (GPU/CPU) + OpEx (bandwidth/storage).

Per-request cost modeling
Autoscale to meet SLA

Run a node

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

# docker-compose.yml
services:
  xiron-node:
    image: ghcr.io/xiron/node:latest
    restart: unless-stopped
    environment:
      - XIRON_KEY=...
      - LOG_LEVEL=info
    ports:
      - "8080:8080"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 10s
      timeout: 2s
      retries: 6

# k8s (helm values excerpt)
replicaCount: 2
image: { repository: ghcr.io/xiron/node, tag: latest }
env:
  - name: XIRON_KEY
    valueFrom: { secretKeyRef: { name: xiron-secrets, key: key } }
resources:
  requests: { cpu: "500m", memory: "512Mi" }
  limits:   { cpu: "2", memory: "2Gi" }
readinessProbe:
  httpGet: { path: /health, port: 8080 }
  periodSeconds: 5

Register on-chain and stake
Healthchecks and metrics
Automatic updates via tags
Expose /metrics (Prometheus) and /health
Configure QoS tiers per tenant
Use rolling deploys to keep SLA

Best practice

Pin images by digest for reproducibility; enable autoscaling on CPU/P95.

For Developers

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

REST API
SDKs
Verifiable RAG
Web components

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: —