PureSapiens

What is it:

PureSapiens is a decentralized AI training platform that combines Chainlink CRE
and World ID to create the first trustless, human-only AI training pipeline. It
ensures that every piece of data used to train AI models is verified as coming
from a real human, and that every training decision is made by a decentralized
network — not a centralized server.

How it works:

Users verify their humanity via World ID (zero-knowledge proof of personhood)
and receive a privacy-preserving nullifier hash.
They then chat with AI models through a WebSocket-powered interface.
When sessions close, the data is encrypted (AES-256-GCM), uploaded to IPFS, and
fed into a two-stage Chainlink CRE pipeline.

Stage 1 (Session Evaluator) runs across multiple independent CRE oracle nodes.
Each node fetches the session from IPFS, decrypts it, strips PII, summarizes it
using Machine Learning and semantic matching, and scores its training relevance.

The DON must reach consensus before calling
TrainingDataManager.assignTrainingData() on-chain.

Stage 2 (Proof Generator) creates an ECDSA proof over the training batch via
DON threshold signing and submits it to FinetuneProofRegistry on-chain.
The result: an immutable, publicly auditable chain from
verified human → session → CRE evaluation → on-chain proof.

All compute are assumed to be done in AWS enclave or similar TEE alternative

What problem it solves:

AI models today are trained on data of unknown origin — there is no guarantee
that it comes from humans, no transparency in how it is selected, and no
verifiable proof of training provenance.

PureSapiens eliminates all three gaps:

• World ID guarantees human origin.
• CRE guarantees decentralized and untampered evaluation.
• On-chain proofs guarantee immutable auditability.

No bots, no centralized gatekeepers, and no trust assumptions.

The platform is built around the synergy of World ID for human verification and Chainlink CRE for decentralized computation.

World ID layer:
The frontend uses IDKit to generate zero-knowledge proofs of personhood. A VerificationGate component wraps all protected pages (chatbot, admin) and blocks access until verification passes. The proof is verified server-side against World ID's v4 API, and a nullifier hash (unique per user, privacy-preserving) is extracted and persisted per wallet. This nullifier hash is attached to every chat session, travels through the CRE pipeline, and is recorded on-chain alongside training data — creating an auditable link between training data and verified humans.

CRE layer:
Two CRE workflows form the core engine.
The Session Evaluator workflow uses HTTPClient with identical consensus aggregation to fetch encrypted sessions from IPFS (all nodes must see the same data), ConfidentialHTTPClient to securely call OpenAI for summarization and scoring (API keys never leave the CRE enclave), and EVMClient to submit consensus-signed assignTrainingData() transactions on-chain.

The Proof Generator workflow uses callContract() to verify model existence, computes a keccak256 proof hash over session batches, calls runtime.report() for DON threshold signing (multiple nodes must agree), and submits the consensus-signed storeProof() transaction via EVMClient.writeReport().

The combination:
World ID provides the input guarantee (data comes from humans), - Acts as Human only entry Firewall
CRE provides the processing guarantee (evaluation is decentralized and deterministic), and Solidity contracts provide the output guarantee (proofs are immutable and publicly verifiable). - Decentralized decisions on Private TEE Compute
The closed loop means anyone can trace an on-chain training proof back through session hashes, IPFS CIDs, and nullifier hashes to a verified human — without knowing who that human is.