Overview
The network for machine intelligence.
Machine learning requires resource coordination at massive scale. Data originates on every device. Training signals come from human action. Compute and capital are scattered across the globe. Gensyn is a protocol that connects these resources into a single network, supporting verifiable AI training, inference, evaluation, and payments by any user on any device.
Introduction
Frontier AI development is increasingly centralised, driven by escalating compute, capital, and data requirements. This limits innovation and concentrates control within the hands of a small few. The internet blossomed because its protocols were open.
TCP/IP, for example, offered a neutral substrate that anyone could build on. AI needs the same: a shared protocol that defines how devices train, verify, and pay for machine learning work, spread across any device - not just dedicated training clusters.
Gensyn consists of:
A training pipeline that allows models to learn continually across applications and devices through local preference tuning, distributed learning, and open market evaluation.
A verification system that guarantees correctness of ML work across heterogeneous hardware through deterministic reproducibility and cryptoeconomic arbitration.
A blockchain protocol that records resource ownership, quantifies ML work, enforces verification, powers financial evaluation markets, and supports general purpose application development.
Together these enable an open ecosystem of machine learning systems and applications.
1. Training Pipeline
Gensyn supports end‑to‑end machine learning through three interconnected layers.
1.1. Signal (Local Preference Tuning)
The Signal layer captures raw data and information (human or machine signals) within the application, in a way that improves on RLHF and other centralised data sourcing methods.
In systems like BlockAssist and CodeAssist, models run directly on user devices and observe real interactions inside the application itself. This produces preference signals (state-action-state transitions) grounded in authentic behaviour rather than the synthetic, task-based judgments used in RLHF or in labels bought from labelling companies.
BlockAssist captures how a user naturally plays, explores, or reacts inside a live environment, while CodeAssist learns from real edits, corrections, and code-completion acceptances during day-to-day coding.
These signals are richer, more continuous, and far more valuable than the one-shot ratings or curated preference prompts used in typical RLHF pipelines. Because training happens locally, raw data never leaves the device. This reduces labelling cost, enables continual information gathering, preserves privacy, and allows models to adapt to real user workflows while still contributing to global model improvement (via the Scale layer).
This assistance-learning approach is generalisable beyond coding or gaming. Any interactive application where a model can observe user behaviour - design tools, productivity apps, simulations, enterprise software, educational systems, creative tooling, robotics interfaces - can produce continuous information signals.
As long as the model can run locally and observe user choices, corrections, or trajectories, the same mechanism applies. This makes the Signal layer a universal method for collecting high-quality, real-world training data across many domains without requiring centralised data collection or human-curated labels.
Crucially, the data collected is inherently private - trained only into the user's local model unless explicitly shared with others via the blockchain or through Scale or Eval.
1.2. Scale (Global Distributed Learning)
The Scale layer coordinates large-scale, collaborative learning across heterogeneous devices. Within Scale is RL Swarm, which enables nodes to generate, share, and learn from rollouts in an open training loop without relying on centralised clusters or communication. This makes large-scale distributed learning viable by converting it into an embarrassingly parallel problem.
Recent work such as CodeZero extends this framework to multi-agent, role-based training environments. In CodeZero, nodes take on complementary roles - proposing tasks, solving them, and evaluating solutions - creating a self-reinforcing training economy in which problem difficulty, exploration, and scoring evolve automatically. This allows the swarm to produce richer training signals than single-agent reinforcement learning (RL).
Gensyn’s SAPO algorithm (Swarm sAmpling Policy Optimisation) further improves efficiency by allowing nodes to train independently and share decoded rollouts with the network. This asynchronous, hardware-agnostic approach outperforms isolated training and avoids the communication overhead of standard distributed RL methods.
Together, these components form a flexible, domain-general system for large-scale, open-ended learning. Any interactive environment - coding, games, simulations, productivity tools, or emerging multimodal tasks - can be deployed across the swarm, enabling continual improvement driven by diverse devices and real-world usage.
1.3. Eval (Verified Intelligence Markets)
The Eval layer measures model performance and allocates rewards through transparent, financialised competitions instead of static, one-off benchmarks. It turns evaluation into an ongoing market signal that updates as new models, data, environments, and reward functions arrive.
Delphi is the first implementation of this system. Anyone can participate by staking behind models in the competition. Throughout the market, evals are performed on the models and aggregate scores are updated. Market participants predict the final outcome and can enter and exit positions as the market progresses. In the future, perpetually-running markets will react to any new performance information in the world (e.g. newly released benchmarks, new environments, etc..).
Pricing and liquidity are handled by a Logarithmic Market Scoring Rule (LMSR) automated market maker (AMM). Rather than matching buyers and sellers directly, Delphi uses a cost function that always quotes a price for each model based on total stake and adjusts prices dynamically after every buy. This ensures continued liquidity in the market, regardless of activity.
When users buy or sell exposure to a model, they move along this cost curve, which guarantees continuous liquidity, smooth price updates, and bounded worst-case loss for the market. Prices at any moment reflect the market’s current belief about which models will win, so evaluation and price discovery happen at the same time.
Delphi will continue to expand into additional domains, longer-running markets, and higher-level vaults that hold baskets of models or model families. By combining verifiable scoring with an LMSR-based market that continuously prices model performance, Eval provides a durable mechanism for allocating capital and attention toward the most effective models.
In future versions of Delphi, users will be able to:
Create their own markets, sharing in the revenue from trading volume.
This incentivises useful benchmark, environment, and reward function creation - building a volume-ranked list of the most interesting problems machine learning could solve.
Run and verify evals trustlessly, with no central party required.
This removes bias and control when establishing model performance in any situation, solving the reproducibility problem within machine learning R&D.
Enter their own models and compete to win general and task-specific markets.
This incentivises machine learning model creation and training, towards the most interesting problems sourced by point 1. Using Gensyn, these models can be trained collaboratively, with attribution to resources (compute, data, information) tracked on-chain, to share in revenue.
This establishes a persistent, on-chain feedback system in which model quality, user belief, and economic incentives remain tightly aligned.
Together, Signal, Scale, and Eval form a continuous learning cycle for the entire machine learning lifecycle, operating across the decentralised network without centralised coordination.
Signal captures real-world information and user preferences directly from applications, producing high-quality, context-rich training signals without centralised data collection.
Scale distributes training across heterogeneous nodes, combining local rollouts, swarm collaboration, and shared experience to evolve and improve models efficiently and at low cost.
Eval tests these models in open markets, where verifiable scoring and LMSR-based pricing surface the best performers and direct capital and attention toward them.
Each layer feeds the next: real interaction generates new training signals; distributed training produces updated models from diversity; open evaluation selects the strongest ones and rewards contributors. This creates a global, permissionless loop of continual learning that strengthens as more users, developers, and compute nodes join.
2. Verification System
Decentralised training requires trust over machine learning operations performed by other entities. Gensyn achieves this through a combination of deterministic execution and cryptoeconomic arbitration, eliminating the need for trusted hardware or centralised verifiers.
2.1. RepOps: Deterministic ML Execution
RepOps is Gensyn’s deterministic ML execution framework, designed to ensure that the same computation produces bitwise-identical results across heterogeneous hardware. It achieves this by replacing nondeterministic ML operators with reproducible implementations, enforcing strict execution order, and emitting compact execution traces that Verde uses to pinpoint disagreements during verification. By constraining floating-point behaviour, operator scheduling, and backend-specific kernel variation, RepOps allows complex ML workloads to be re-executed exactly, making fraud proofs and on-chain arbitration practical without trusted hardware.
2.2. Verde: Cryptoeconomic Arbitration
Verde is Gensyn's on-chain dispute system for ML computation. It is designed for adversarial conditions and draws on ideas from fraud proofs, optimistic verification, and multi-round interactive proofs.
How Verde works:
Compute providers submit results along with a compact execution trace.
Independent verifiers may challenge any result by re-running the computation using RepOps.
If a discrepancy is detected, Verde enters a multi-step arbitration process that:
Narrows disagreement to a specific operator or execution step;
Deterministically identifies which party deviated from the correct trace; and
Enforces slashing of the dishonest party.
Correct providers are rewarded for verified work; correct challengers receive a portion of the slashed stake.
Verde ensures that the cheapest strategy for any participant is to compute honestly, rather than cheat.
2.3. Example: Deterministic Scoring in Evaluation
Delphi markets can use judge models that run under RepOps. Because judge executions are deterministic and reproducible:
Any participant can verify scoring independently.
Disputes can be settled through Verde using the same reproducibility guarantees.
Markets remain trustless: correctness does not rely on oracle operators or centralised scoring infrastructure.
This combination - deterministic ML execution plus economic enforcement - allows Gensyn to verify complex workloads across heterogeneous, untrusted hardware at scale.
3. Protocol
3.1. Blockchain Layer
Gensyn operates on a custom EVM Layer-2 rollup built with the OP Stack (Bedrock). The chain serves as the settlement and coordination layer for all activity across the network - compute execution, evaluation markets, verification, staking, and protocol governance.
Its key properties include:
Verifiable accounting. Every training job, inference task, or evaluation submission is posted on-chain with an accompanying execution record. This creates an auditable trail of model updates, rollouts, and evaluation outcomes, enabling transparent attribution of work and rewards.
Staking and slashing for correctness. Compute providers and verifiers post $AI as collateral before performing work. If results fail deterministic re-execution or are successfully challenged through Verde, their stake is slashed. This ensures that correctness is economically enforced rather than dependent on trusted hardware, private servers, or reputation.
General-purpose programmability. Because the chain is EVM-compatible, developers can deploy any smart-contract-based system - including DeFi, identity, or ML-specific applications - directly alongside the core Gensyn primitives. This allows AI agents, markets, and protocols to interoperate with the broader Ethereum ecosystem.
Account abstraction and sponsored execution. The chain supports account abstraction, allowing applications to pay gas on behalf of users and enabling frictionless onboarding for non-crypto-native participants.
Ethereum security inheritance. State roots and data batches are periodically committed to the Ethereum mainnet, inheriting its Proof-of-Stake security guarantees and ensuring that compute verification and economic penalties cannot be altered off-chain.
3.2 $AI Token
The $AI token coordinates economic activity across the network.
Payments
All computation, training, inference, and evaluation activity is paid for in $AI. Compute nodes and evaluation participants earn $AI for verified work.
Staking
Compute providers and verifiers stake $AI as collateral to ensure correctness. Users also stake behind models in evaluation markets, aligning incentives with model performance.
Governance
Over time, tokenholders govern protocol‑level parameters including emissions, treasury allocations, and system upgrades. A portion of network fees may be burned to offset issuance and maintain long‑term scarcity.
Conclusion
Gensyn creates a global market for machine intelligence - a system where anyone can contribute compute, training signals, or models, and where performance is priced transparently in real time. The combination of deterministic verification, open evaluation, and decentralised compute forms a market-driven system for continual learning, directed by true economic interest and supplied by anyone, or any system, in the world.
Last updated