# Introducing Cournot Protocol

Decentralized prediction markets are emerging as a foundational layer for global truth discovery and automated coordination. Yet despite growing adoption, they remain constrained by a fundamental limitation: **the Resolution Bottleneck**.

Today’s oracle landscape is bifurcated. Human-centric oracles can resolve subjective outcomes accurately but suffer from latency, cost, and attention scarcity, making them unsuitable for high-frequency or long-tail events. Meanwhile, data and compute oracles can securely transport information or prove execution, but lack the semantic architecture required to **verify how complex, unstructured real-world conclusions are reached**.

As markets, contracts, and autonomous agents increasingly depend on real-world judgment, this gap becomes systemic. The inability to produce fast, low-cost, and auditable resolution prevents prediction markets and onchain systems from expanding beyond a narrow set of globally legible events.

#### Why Long-Tail Markets Matter <a href="#why-long-tail-markets-matter" id="why-long-tail-markets-matter"></a>

Long-tail markets and contract triggers represent the majority of real-world economic activity:

* localized supply chain disruptions
* regional weather impacts and parametric insurance conditions
* compliance and policy thresholds
* software milestones and operational KPIs
* reputation, identity, and behavioral claims
* enterprise events that must remain confidential

These are the conditions agents and businesses actually need, yet they remain largely unaddressed because resolution risk is high.

#### The Definition Precision Problem <a href="#the-definition-precision-problem" id="the-definition-precision-problem"></a>

At first glance, many events in the prediction markets sound easy to resolve: *“Did X happen?” “Was Y delivered?” “Did the milestone ship?”*

In practice, these “simple questions” fail for a predictable reason: **the settlement outcome is determined by definitions, not vibes.** Small wording differences like what counts, what sources qualify, what time window applies, what exceptions exist, can flip the result.

For example:

* “Did the government shut down?” can hinge on **the signing time**, **an agency website update**, or **a formal declaration,** each producing a different settlement outcome.
* “Did the product launch?” can depend on **public availability**, **region coverage**, **version number**, or **a specific distribution channel**.

When these definitions are underspecified, disputes aren’t edge cases. They’re the default. Therefore, we can conclude that oracle resolution requires not only output, but it also requires:

1. a **semantic contract** (what exactly is being resolved), and
2. an **evidence contract** (what counts as valid proof, and how it must be collected). (end of the updated parts)

Cournot Protocol introduces **Proof of Reasoning (PoR),** a new oracle primitive that transforms AI from a passive inference engine into a **verifiable reasoning system**. Rather than trusting AI outputs, Cournot cryptographically anchors the full reasoning process: **source authenticity, logical coherence, and deterministic outputs** onchain. By binding economic accountability to each step of reasoning, Cournot replaces human voting and opaque computation with a permissionless network that can resolve unstructured reality at machine speed.

**Cournot Protocol is the first AI-native reasoning oracle designed to produce verifiable, auditable resolution for unstructured real-world events**, enabling scalable automation across the agent economy, with low-cost execution and machine-speed finality.


# The Oracle Evolution

Traditional oracles made trusted data available on-chain. They solved a critical first problem: connecting blockchains to the real world. But data delivery is only the beginning.\
As onchain systems evolve, from simple financial primitives to prediction markets, real-world asset platforms, trading intelligence, risk management, and autonomous agent economies, the oracle must evolve with them.&#x20;

The questions being asked are no longer just "What is the price?" but "What does it mean?", "What is happening?", and "What should happen next?"<br>

Cournot expands the oracle model into a full intelligence stack:

<figure><img src="/files/5NbJtc9YpMmerJlwSO3r" alt=""><figcaption></figcaption></figure>

Each layer builds on the previous. Each layer unlocks new categories of applications that were previously impossible. Together, they form **Oracle 4.0: a verifiable intelligence layer for the autonomous economy**.

#### Where Cournot Stands Today

| Layer                                   | Status             | Description                                                                                                 |
| --------------------------------------- | ------------------ | ----------------------------------------------------------------------------------------------------------- |
| **Oracle 1.0: Data Feed**               | Industry baseline  | What traditional oracles provide. Cournot also supports standard services (VRF, price feeds) at this layer. |
| **Oracle 2.0: The Semantic Oracle**     | Foundation         | Cournot's semantic query layer over aggregated, multi-source trusted data.                                  |
| **Oracle 3.0: The Intelligence Oracle** | Live in production | Cournot's core product: the Resolution Oracle, actively serving prediction market platforms.                |
| **Oracle 4.0: The Agentic Oracle**      | Active development | This is where Cournot is building towards; autonomous agents that continuously monitor, reason, and act.    |


# Oracle 1.0: Data Feed

Traditional oracles provide predefined data feeds for specific use cases: crypto prices, equities, weather, and other structured data. A price oracle answers a fixed question ("What is the ETH/USD price?") and delivers it securely on-chain.This model is reliable and has enabled the first generation of DeFi and Web3 applications:

* Lending and borrowing protocols
* Derivatives and perpetuals
* Stablecoins
* Automated trading strategies
* Basic RWA applications

### The Limitation

The model is static. Every new data requirement demands a new feed, a new transformation, or a new integration: One requirement → One feed → One integration.

This works when the number of questions is small and well-defined. It breaks down when applications need to ask thousands of different questions over the same underlying data, or when the questions themselves are described in natural language rather than predefined schemas.

### What Oracle 1.0 Unlocks

Cournot supports standard Oracle 1.0 services as the base layer of the stack:

|        **Vertical**       |                      **What It Enables**                     |                                      **Example**                                     |
| :-----------------------: | :----------------------------------------------------------: | :----------------------------------------------------------------------------------: |
|          **DeFi**         |           Price feeds for core financial primitives          |         Spot price oracles for lending, derivatives, stablecoins, AMM pricing        |
| **Gaming & Collectibles** | Verifiable Random Functions (VRF) for provably fair outcomes |   Fair NFT minting, loot box mechanics, random trait assignment, tournament seeding  |
|  **Parametric Insurance** |     Structured data triggers from authoritative endpoints    | Earthquake magnitude, wind speed, rainfall thresholds from official weather stations |
|         **Sports**        |     Final scores and match outcomes from structured APIs     |   Match results, player statistics, league standings for sports betting settlement   |
|         **TradFi**        |                     Standard market data                     |                  Equity close prices, FX rates, commodity benchmarks                 |

These are solved problems at Oracle 1.0; reliable, well-understood, and necessary as the foundation for everything above.


# Oracle 2.0: The Semantic Oracle

*This is the Foundation layer. This is where Cournot begins.*

**Multiple trusted data sources, one resilient semantic layer, unlimited verifiable queries.**

**Oracle 2.0** introduces a fundamental shift: instead of building a new feed for every requirement, Cournot aggregates multiple oracle networks and primary data sources, cross-checks inconsistencies, normalizes the data, and uses AI to translate natural-language requirements into deterministic queries or computation.

For example, the same BTC dataset can answer:

* Spot price
* 15-minute average
* Max / min over a window
* TWAP / VWAP
* Threshold crossing ("Was BTC above $100K?")
* Time-above-threshold ("Did BTC stay above $100K for 10 consecutive minutes?")
* Multi-exchange composite prices ("Average across Binance, Coinbase, and OKX")

Without building a new oracle feed for every requirement.

### Why Applications Already Need This

Today's prediction market platforms illustrate the problem clearly. For straightforward crypto price markets — "Will BTC be above $100K at 4 PM UTC?" — platforms rely on traditional price feed oracles. A single price feed resolves the question. This works.But the moment a platform wants to offer richer market types, Oracle 1.0 breaks down:

* *"Was BTC's 30-minute VWAP above $100K?"* — requires aggregation logic over raw trade data, not a single spot price.
* *"Did BTC stay above $100K for 10 consecutive minutes across Binance, Coinbase, and OKX?"* — requires multi-exchange time-series analysis with threshold logic.
* *"Was the average price across 3 exchanges above $100K, excluding outlier wicks?"* — requires cross-validation, anomaly filtering, and composite calculation.

Each of these is still a structured data question. No AI reasoning is needed. But Oracle 1.0 would require a separate custom feed or integration for every variant.

Oracle 2.0 handles all of them as semantic queries over the same trusted data layer:

<figure><img src="/files/Q2PzzvH9YRjC7X6sU8wB" alt=""><figcaption></figcaption></figure>

The AI interprets *what is being asked*. Deterministic code computes *the answer*. This is why platforms that start with simple crypto price markets inevitably need Oracle 2.0 to scale their market catalog without scaling their oracle integrations.

### Real-World Asset Pricing: Beyond Simple Feeds

The same pattern applies to Real-World Assets (RWA). Some RWA use cases are straightforward Oracle 1.0 problems; Cournot provides these as well, including services like **Verifiable Random Functions (VRF)** for applications such as collectible NFT minting, loot box mechanics, and fair selection processes.

But most RWA pricing quickly exceeds what any single feed can provide. Consider **collectibles pricing**: trading cards, luxury watches, rare sneakers, vintage wines. Unlike crypto tokens with 24/7 orderbooks, collectibles have:

* **Sparse, irregular transactions:** a specific card may sell once a month across multiple marketplaces
* **Condition and grading dependencies:** a PSA 10 card is worth 5-50x a PSA 7 of the same card
* **Multi-marketplace fragmentation**: sales happen across eBay, StockX, PWCC, specialist dealers, and private sales
* **Seasonal and event-driven pricing:** a player's card spikes after a championship win, a watch model surges after a celebrity sighting
* **Authenticity verification**: provenance and grading must be cross-referenced, not just price

Oracle 1.0 cannot answer *"What is the fair market value of a PSA 9 1986 Michael Jordan Fleer rookie card?"* because there is no single feed for that. Oracle 2.0 can: it aggregates recent sales across marketplaces, normalizes for condition grade, filters outliers, weights by recency and volume, and produces a verified composite price, all from a semantic query, not a custom integration.

This extends to broader RWA categories:

|  **RWA Category** | **Oracle 1.0 (Feed)** |                  **Oracle 2.0 (Semantic)**                 |
| :---------------: | :-------------------: | :--------------------------------------------------------: |
| **Crypto tokens** |    Spot price feed    |           TWAP, VWAP, composite, threshold logic           |
|  **Collectibles** |      Not feasible     |   Multi-marketplace composite with grading normalization   |
|  **Real estate**  |    Basic index feed   | Location-specific valuation with comparable sales analysis |
|  **Luxury goods** |      Not feasible     |     Cross-platform pricing with authenticity weighting     |
|  **Commodities**  |   Spot/futures feed   |     Basis-adjusted, delivery-location-specific pricing     |

### Multi-Oracle Resilience

This architecture also naturally supports multi-oracle resilience. Cournot does not depend on any single data provider:

<figure><img src="/files/tZKPiIyfa0oRk7pzQIpN" alt=""><figcaption></figcaption></figure>

Multiple independent sources are combined, compared, and scored before producing the final output. This reduces single-source failure risk while creating a stronger foundation for application-specific queries.

### Scaling by Queries, Not Feeds

Oracle 1.0 scales by adding feeds. Oracle 2.0 scales by adding queries over a resilient data layer:

|           **Traditional Oracle**          |                 **Semantic Oracle**                |
| :---------------------------------------: | :------------------------------------------------: |
| New question → New feed → New integration | New question → New query → Same trusted data layer |

### What Oracle 2.0 Unlocks

The semantic layer turns every structured data source into a programmable query surface:

|             **Vertical**            |                       **What It Enables**                      |                                                                   **Example**                                                                  |
| :---------------------------------: | :------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------: |
|          **Advanced DeFi**          |        Complex settlement conditions over standard data        | TWAP/VWAP triggers for liquidation, multi-exchange composite pricing for derivatives, threshold-over-window conditions for structured products |
| **Prediction Markets (structured)** |       Rich market types without custom oracle integration      |            "Was BTC's 30-min VWAP above $100K across 3 exchanges, excluding outlier wicks?" — one semantic query, not a custom feed            |
|           **RWA Pricing**           | Multi-source valuation for non-fungible and alternative assets |  Collectible card valuation across eBay, StockX, and specialist dealers, normalized by grading; luxury watch pricing across fragmented markets |
|       **Commodities & TradFi**      |               Derived analytics over market data               |                   Basis-adjusted commodity pricing, delivery-location-specific calculations, cross-venue arbitrage detection                   |
|         **Risk Management**         |        Portfolio-level analytics from aggregated sources       |                        Multi-source exposure calculation, cross-asset correlation monitoring, concentration risk scoring                       |
|        **RWA Infrastructure**       |           Data quality services for tokenized assets           |                      Cross-marketplace price validation for collectibles, grading verification, provenance chain checking                      |

Oracle 2.0 is the multiplier: one trusted data layer serves unlimited queries, replacing the "one feed per question" economics of Oracle 1.0.


# Oracle 3.0: The Intelligence Oracle

*The Intelligence Oracle is the Cournot's current core product. It is live in production as the Cournot Resolution Oracle*

**The Intelligence Oracle** **understands unstructured real-world events and produce verified judgments.**

Many important questions cannot be answered by structured feeds, no matter how flexible the query layer:

* Did a company announce a new product?
* Did a regulator approve an asset?
* Did a political event occur?
* How should a prediction market with subjective conditions resolve?
* Did a supply chain disruption meet the threshold for an insurance payout?

These questions require reading, interpreting, and synthesizing unstructured information, a cognitive task that no deterministic query can handle. Oracle 3.0 extends the stack with:

* Real-time monitoring of unstructured data sources
* Evidence collection with cryptographic provenance
* Multi-source verification and cross-checking
* Semantic reasoning over collected evidence
* Specialized skills for domain-specific resolution
* Audit and dispute mechanisms for accountability

**AI begins where deterministic oracle logic ends.**

Prediction markets are the ideal proving ground because every market is effectively a new oracle query. Cournot is already serving platforms such as [42space](https://42.space) as an official resolution oracle.

### The Resolution Bottleneck

The long-term value of autonomous onchain systems lies not in a handful of global events like elections or central bank decisions. It lies in digitizing the full spectrum of reality: regulatory interpretations, corporate milestones, hyper-local supply chain disruptions, private operational states, and millions of long-tail conditions that agents and businesses actually depend on.Current infrastructure forces an unacceptable tradeoff:

* **The Human Limit**: Human-voting oracles cannot process millions of concurrent, nuanced decisions. Latency of 24–72 hours and escalating costs make them incompatible with automated hedging, agent coordination, or micro-market settlement.
* **The Semantic Gap**: Standard API oracles can fetch data, but they cannot verify meaning. They cannot answer: *"Based on the latest filings and regulatory language, does Protocol X qualify as a security?"* Resolving such outcomes requires reading, interpreting, and synthesizing unstructured information. Without cryptographic verification of how that interpretation occurs, AI introduces a new black box.

Cournot breaks this tradeoff by enabling high-fidelity resolution for any event that can be described, reasoned about, and verified.

**Comparative Analysis**

|         **Feature**         |           **Price Feed Mode**l           |     **Human Consensus Model**     |             **Computational Integrity Model**            |        **Reasoning Verifier (Cournot)**        |
| :-------------------------: | :--------------------------------------: | :-------------------------------: | :------------------------------------------------------: | :--------------------------------------------: |
|     **Core Positioning**    |           Secure Data Transport          |       Human Social Consensus      |                    On-chain AI Compute                   |            AI Reasoning Verification           |
| **The "Black Box" Problem** | Unsolved (verifies transport, not logic) | N/A (human cognition, unscalable) | Partial (computation integrity, no semantic constraints) |        Solved (Merkle Trace + SOP Audit)       |
|     **Speed / Latency**     |              Fast (minutes)              |         Slow (24–72 hours)        |                Variable (model-dependent)                |           Sub-second (Fast Path TEE)           |
|    **Long-Tail Support**    |       Weak (custom feeds required)       | Weak (limited by voter attention) |              Strong (custom app dev needed)              | Very Strong (automated SOP scales to millions) |
|       **Token Value**       |             Payment + Staking            |          Voting + Buyback         |                       Compute Fees                       |       Atomic Staking + Strategy Royalties      |


# Proof of Reasoning (PoR)

### Proof of Reasoning (PoR)

**Proof of Reasoning (PoR)** is the central engine of Oracle 3.0. It transforms AI inference from a fleeting, opaque process into a persistent, cryptographic evidence chain orchestrated via a **Role-Based Standard Operating Procedure (SOP)**.While other architectures reduce AI to a single "inference call," Cournot enforces a granular, multi-agent workflow spanning the full resolution lifecycle, from raw data ingestion to the final verdict.

### **The Reasoning Merkle Tree**

Cournot eliminates the "Black Box" problem by structuring AI cognition into a **Merkle-ized Reasoning Trace**:

* **Leaf Nodes**: Each atomic step in the SOP is encapsulated as a cryptographic leaf (e.g., *Leaf 1: zkTLS Fetch*; *Leaf 2: Fact Audit*; *Leaf 3: Final Verdict*).
* **The Root**: These leaves are aggregated to form a unique **Reasoning Merkle Root.**
* **The Anchor**: By storing only the Root on-chain, Cournot achieves **unbounded cognitive complexity** with **constant gas costs**, allowing for deep verification without network congestion.

### PromptSpec: The Semantic Contract

Ambiguity is the root cause of oracle disputes. A question like "Did the product launch?" can depend on public availability, region coverage, version number, or a specific distribution channel. Small wording differences can flip the settlement outcome entirely.

**PromptSpec** is Cournot's solution: a canonical semantic contract that deterministically specifies what is being resolved. It encodes:

1. **The specific question** under evaluation
2. **Interpretive scope boundaries** (what counts, what doesn't)
3. **Verdict schemas** (the set of valid outcomes)
4. **Logical constraints** (rules governing edge cases and exceptions)

PromptSpec makes resolution semantics explicit, repeatable, and inspectable. It separates semantic definition from execution, allowing deterministic resolution logic without sacrificing flexibility in market design.All resolution processes are bound to the same semantic definition, ensuring consistency across executions and verifications. Terms are defined and aligned off-chain before cryptographic commitment on-chain.

### The SOP Framework: Three-Stage Verification

Oracle failures frequently stem from **data source drift**: shifts in availability, interpretation, freshness, or trustworthiness of inputs. Rather than treating data requirements implicitly, Cournot formalizes them as protocol-level responsibilities:

* Permitted authoritative sources
* Verifiable retrieval methods with cryptographic receipts
* Freshness windows for temporal bounds
* Conflict resolution rules for inconsistent evidence

Resolution proceeds through three stages, each with its own accountability:

<figure><img src="/files/lU4csei7vwJD6WEF6oDs" alt=""><figcaption></figcaption></figure>

#### **Stage 1: Proof of Authenticity (Collector Role)**

The Collector Agent retrieves evidence per predefined data requirements, admitting only items that meet authoritative source criteria and freshness constraints. Each item includes a cryptographic receipt.

**Technology**: zkTLS (Zero-Knowledge Transport Layer Security) generates zero-knowledge proofs confirming data origin via secure TLS sessions.

**Accountability**: The Collector stakes the network token on Source Integrity, with slashing penalties for invalid proofs.

#### **Stage 2: Proof of Logic (Auditor Role)**

The Auditor Agent performs structured reasoning exclusively over the PromptSpec and verified evidence, generating a Merkle-ized Reasoning Trace. Only the Reasoning Merkle Root is anchored on-chain, enabling granular auditing without excessive on-chain costs.

**Technology**: DSPy-Optimized Chain-of-Thought ensures reasoning follows structured, inspectable patterns.

**Accountability**: The Auditor stakes the network token on Logical Coherence, facing penalties for reasoning fallacies.

#### **Stage 3: Proof of Determinism (Judge Role)**

The Judge Agent maps reasoning outcomes deterministically to predefined verdict schemas, ensuring outputs are predictable and machine-verifiable.

**Technology**: Neuro-Symbolic Constraints (Outlines/Logit Locking) enforce that outputs conform to the verdict schema.

**Accountability**: The Judge stakes on Schema Compliance, guaranteeing machine-readable settlement payloads.

### Verifiable Reasoning

Cournot divides oracle resolution into two distinct trust problems:

1. **Evidence Trust:** validating that evidence was collected from authorized sources
2. **Reasoning Trust:** ensuring verdicts correctly follow from agreed evidence

Evidence Trust is addressed through PromptSpec, DataRequirements, and EvidenceBundles, with **zkTLS** providing cryptographic proof that each piece of evidence originated from an authorized source via a verified TLS session. Once evidence is frozen and authenticated, reasoning verification becomes a separate, bounded computation challenge.

Cournot freezes the inputs to the reasoning stage:

* Semantic specification (PromptSpec)
* Finalized evidence bundle (authenticated via zkTLS)
* Verdict schema
* Reasoning policy
* Fixed model weights and execution environment

This creates a **replayable reasoning target** and this is where **opML (Optimistic Machine Learning)** becomes essential.


# opML: Making AI Inference Provable

opML applies the optimistic verification pattern, proven at scale by optimistic rollups, to AI inference. The core insight: rather than requiring every node to re-execute the same inference (which is prohibitively expensive for large models), opML assumes the result is correct and provides a mechanism for any single honest node to prove it wrong.

**How opML works in Cournot**:

1. **Execute once**: An Anchor Node runs the AI inference inside a TEE and publishes the result along with the frozen inputs (PromptSpec, evidence bundle, model hash, execution parameters).
2. **Challenge window**: The result enters a challenge period during which any Sentinel Node can dispute it.
3. **Deterministic replay**: If challenged, the inference is replayed with the same frozen inputs, fixed model weights, and controlled execution environment. Because Cournot freezes all inputs at the PromptSpec and evidence stages, the replay target is fully specified.
4. **Bisection protocol**: Rather than replaying the entire inference, the challenger and defender engage in an interactive bisection protocol, narrowing down to the exact computation step where results diverge, then proving that single step on-chain.

**The result**: Verification cost is reduced from "run the full model N times" to "one honest node submits a compact fraud proof." This is what makes AI verification economically viable at scale.

#### **The zkTLS + opML Verification Stack**

Together, zkTLS and opML form a complete verification stack where **a single honest node can prove the entire pipeline**:

<figure><img src="/files/NICtvER5XiJwOIZNoppE" alt=""><figcaption></figcaption></figure>

**This one-honest-node assumption** is what separates Cournot from architectures that require multiple nodes to independently run the same expensive inference to reach consensus. Those approaches make the dominant cost, model inference, multiplicative with the number of nodes. Cournot runs inference once and makes verification cheap.


# Why This Matters for Scalability

Recent research confirms that inference nondeterminism stems from systems-level factors like dynamic batching, and that floating-point precision differences can affect even greedy decoding. This is why Cournot controls the full execution environment (fixed model weights, fixed precision, TEE attestation) to ensure replay determinism and why opML's bisection protocol can pinpoint exact divergence points when they occur.

The practical impact:

* **Cost**: Verification is orders of magnitude cheaper than re-execution. A single fraud proof costs a fraction of the original inference.
* **Speed**: The optimistic path (no challenge) settles at Fast Path speed. Challenges add latency only when disputes actually occur.
* **Scalability**: The protocol can resolve millions of markets without multiplying inference costs, because verification only happens when someone disputes.
* **Security**: The system is secure as long as at least one honest Sentinel is watching. Economic incentives (Sentinel Bounties) ensure this.

### What Oracle 3.0 Unlocks

The intelligence layer handles questions that no structured query can answer — where the oracle must read, interpret, and reason:

|               **Vertical**               |                       **What It Enables**                      |                                                                                          **Example**                                                                                         |
| :--------------------------------------: | :------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
|   **Prediction Markets (unstructured)**  |        Resolution of event-based and subjective markets        | <p>"Did the US government shut down?" </p><p>These kind of cases require evidence collection from multiple sources, interpretation of what constitutes a shutdown, and reasoned judgment</p> |
| **Insurance (i.e., Claim Verification)** |       Complex claim assessment beyond parametric triggers      |       <p>"Did the supply chain disruption meet the force majeure threshold defined in the policy?" </p><p>This case requires reading contract language against real-world evidence</p>       |
|        **Compliance & Regulatory**       |         Regulatory interpretation with auditable trails        |             <p>"Does Protocol X qualify as a security under latest SEC guidance?"</p><p>These kind of cases require synthesizing filings, regulatory language, and precedent</p>             |
|          **Credit Intelligence**         |            Point-in-time creditworthiness assessment           |                                 Synthesizing financial statements, news sentiment, regulatory filings, and on-chain behavior into a structured credit opinion                                |
|            **RWA Attestation**           | Authenticity and provenance verification for high-value assets |                         Verifying the authenticity chain for a $100K collectible, cross-referencing grading certificates, ownership history, and marketplace listings                        |
|          **Social & Reputation**         |             Contextual claims that require judgment            |                        <p>"Did this account engage in coordinated manipulation?" </p><p>These kind of cases require analyzing behavioral patterns across platforms</p>                       |
|    **Event-Based Financial Products**    |       Structured products triggered by real-world events       |                                                  Corporate action verification, M\&A completion confirmation, regulatory milestone tracking                                                  |

**Oracle 3.0** is where AI begins and where **Cournot's Proof of Reasoning ensures that AI judgment fast and verifiable**.


# Oracle 4.0: The Agentic Oracle

*Oracle 4.0 is what Cournot is actively developing at the moment, enabling continuous monitoring, reasoning, and triggering actions.*

The final evolution is not simply answering questions. Oracle 4.0 moves from:

**What is the data? → What does it mean? → What is happening? → What should happen next?**\
\
The oracle becomes an **Agentic Intelligence Network**: a layer that doesn't wait to be queried but continuously monitors reality, detects events, produces verified judgments, and triggers downstream actions.

### From One-Shot AI to Autonomous Agents

The evolution of Oracle 4.0 mirrors the broader evolution of AI itself:

|                                               **AI Evolution**                                               |                                                **Oracle Parallel Comparison**                                                |          **Capability**          |
| :----------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------: | :------------------------------: |
|                     <p><strong>LLM Chat</strong></p><p>ask a question, get an answer</p>                     |                     <p><strong>Oracle 3.0</strong></p><p>Submit a query, receive a one-time judgment</p>                     |    Single inference, stateless   |
|        <p><strong>AI Coding Assistant</strong></p><p>understands context, handles multi-step tasks</p>       |                 <p><strong>Early Agent</strong><br>Routes to tools, manages multi-step evidence gathering</p>                |     Context-aware, multi-step    |
| <p><strong>AI Agent</strong></p><p>plans, decides, uses tools, self-corrects, finishes work autonomously</p> | <p><strong>Oracle 4.0</strong></p><p>Monitors, reasons, decides when and how to act, self-corrects, settles autonomously</p> | Persistent, autonomous, adaptive |

In building Oracle 3.0, we learned that many real-world questions cannot be resolved with a single AI call. A prediction market asking "Will Company X announce a product this quarter?" is not a question with a known answer at a known time. It requires an agent that:

1. **Decides what to watch**: identifies relevant data sources (press releases, SEC filings, social media, company blogs)
2. **Decides when to check**: schedules monitoring at intelligent intervals, not just fixed cron cycles
3. **Decides which tools to use**: selects from news APIs, social media scrapers, on-chain event listeners, or custom data connectors depending on the market type
4. **Interprets partial signals**: evaluates whether a leaked memo, a rumor, or an executive's tweet constitutes evidence, and at what confidence level
5. **Self-corrects**: recognizes when an initial approach isn't producing results and switches strategies (e.g., pivoting from press monitoring to regulatory filing analysis)
6. **Decides when to settle**: determines the moment when accumulated evidence is sufficient for a confident verdict, rather than waiting for an arbitrary deadline

This is fundamentally different from a one-shot oracle call. It is an **autonomous reasoning loop** that persists over hours, days, or weeks.

### The Complexity Spectrum

Different questions demand different levels of agent sophistication:

<figure><img src="/files/VXC1tBhmhJtpF2TdeRxn" alt=""><figcaption></figcaption></figure>

For a crypto price market, one API call at the right timestamp is enough. For "Will the EU approve MiCA implementation changes before Q3?", for example, the agent must monitor regulatory databases, parliamentary schedules, press conferences, and leaked drafts over weeks, adjusting its strategy as the situation evolves.

Cournot's agent architecture handles the full spectrum. Simple queries flow through Oracle 2.0's deterministic path. Complex, open-ended questions are assigned to persistent agents that autonomously manage their own lifecycle.

### The Agent Resolution Loop

Each Cournot agent operates as a self-directed resolution loop:

<figure><img src="/files/W6WGOYFV1loB3NcsWVnl" alt=""><figcaption></figcaption></figure>

This loop runs autonomously within **human-defined policy boundarie**s. Humans do not need to schedule individual checks or hardcode data sources, the agent handles operational decisions on its own. But the PromptSpec, DataRequirements, permitted tool set, confidence thresholds, and verdict schemas are all defined by humans before the agent begins. The agent operates with autonomy over *how* to execute, while humans retain control over *what* the agent is allowed to do and *what constitutes a valid outcome*.

### Beyond Prediction Markets: The Expanding Application Surface

The agentic architecture unlocks capabilities far beyond market settlement:

1. **Trading Intelligence**\
   Agents continuously monitor on-chain activity, social sentiment, news flow, and market microstructure to produce verified trading signals. Unlike raw data feeds, these signals carry reasoning provenance, the agent can explain *why* it flagged an anomaly, what evidence it used, and how confident it is.
2. **RWA Continuous Verification**\
   Real-world assets require ongoing verification, not just one-time attestation. A tokenized real estate portfolio needs continuous monitoring of occupancy rates, rental income, insurance status, and local market conditions. Cournot agents track these conditions persistently, flagging deviations and triggering revaluation when thresholds are crossed.
3. **Risk Monitoring and Early Warning**\
   Insurance protocols, lending platforms, and treasury management systems need continuous risk assessment. Agents monitor for credit events, regulatory changes, operational failures, and market regime shifts, producing verified alerts with full evidence chains rather than simple threshold alarms.
4. **Credit Intelligence**\
   Assessing creditworthiness requires synthesizing financial statements, market conditions, news sentiment, regulatory filings, and on-chain behavior over time. Agents maintain persistent credit profiles that update as new evidence emerges, producing verifiable credit signals for DeFi lending, undercollateralized protocols, and institutional credit markets.
5. **Autonomous Agent Economy**\
   As AI agents increasingly transact, negotiate, and coordinate with each other, they need a shared intelligence layer that produces verified world-state. Cournot agents serve as the "eyes and ears" of the autonomous economy, providing other agents with trusted, reasoned assessments of real-world conditions rather than raw data they must interpret independently.

### The Cournot Agent Layer, Powered by OpenClaw

Cournot's agentic capabilities are powered by the **OpenClaw** framework, which combines Proof of Reasoning primitives with persistent agent infrastructure to create a proactive intelligence layer.The Cournot Agent Layer transforms the protocol from a passive settlement oracle into **a continuous perception and arbitration layer for real-world events.**

#### **Event-Driven Settlement**

Traditional prediction markets depend on scheduled oracle queries or manual settlement triggers, creating resolution lag. Cournot agents provide **persistent monitoring** of diverse data sources:

* Official status pages and regulatory disclosures
* Social media feeds and community signals
* RSS updates and news wires
* On-chain contract events
* Infrastructure and operational changes
* Price feeds and market data across exchanges
* Domain-specific data connectors (sports APIs, weather services, financial databases)

When trigger conditions are detected, the agent activates the PoR pipeline immediately, enabling **event-driven settlement** rather than time-based settlement, reducing latency between real-world occurrence and oracle activation.

#### **Autonomous Dispute Arbitration**

The dispute workflow combines agent intelligence with opML's cryptographic verification:

1. **Social Forensics & Extended Evidence Discovery**: Cournot agents analyze unstructured sources permitted under DataRequirements policy, archived web snapshots, forum discussions, community logs, and regulatory clarifications. New evidence is authenticated via zkTLS before entering the dispute pipeline.
2. **Adversarial Multi-Agent Review**: Competing agents analyze reasoning traces, identify inconsistencies, and validate semantic rule adherence while remaining constrained to committed artifacts. Each agent's analysis is itself a frozen reasoning target, verifiable via opML if contested.
3. **Targeted opML Replay**: Rather than re-running the entire inference, the dispute mechanism leverages opML bisection to isolate the exact reasoning step where the original verdict diverged from correct logic. This pinpoint verification means dispute costs are bounded and predictable, proportional to a single computation step, not the full model inference. The on-chain bisection contract produces an objective, math-verified ruling without requiring human arbitrators or token-weighted votes.

### What Oracle 4.0 Unlocks

The agentic layer adds persistence, autonomy, and action to the intelligence stack:

|             **Vertical**            |                  **What It Enables**                  |                                                                               **Example**                                                                               |
| :---------------------------------: | :---------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
|        **Prediction Markets**       |     Automatic settlement the moment events unfold     |                   Agent monitors regulatory filings, detects approval, triggers PoR pipeline and settles the market minutes after the event, not hours                  |
|       **Trading Intelligence**      |         Continuous verified signal generation         |                 Agent monitors on-chain flows, social sentiment, and news for a token, produces signals with full reasoning provenance, not just alerts                 |
| **Risk Monitoring & Early Warning** | Persistent risk assessment with evidence-based alerts |                 Agent tracks a DeFi protocol's TVL, governance proposals, and smart contract changes, flags risk regime shifts before they become crises                |
|       **Insurance Automation**      |           Event-driven parametric settlement          |               Agent monitors weather stations, shipping logs, and IoT feeds, triggers payout the moment the insured event occurs, with full evidence chain              |
|   **RWA Continuous Verification**   |      Ongoing compliance and collateral monitoring     |            Agent tracks occupancy rates, rental income, and insurance status for a tokenized real estate portfolio, flags deviations and triggers revaluation           |
|       **Credit Surveillance**       |               Persistent credit profiles              | Agent maintains a rolling credit assessment, updating as new financial filings, news, and on-chain activity emerge, produces verifiable credit signals for DeFi lending |
|          **Agent Economy**          |    Verified world-state for autonomous coordination   |          Other AI agents consume Cournot's verified intelligence feeds as trusted inputs for their own decisions, the shared perception layer for M2M commerce          |

Oracle 4.0 is the destination: the oracle stops waiting to be asked and starts actively watching, reasoning, and acting.

#### The Road Ahead

**Oracle 4.0** represents a substantial engineering challenge. Building agents that reliably reason over extended time horizons, self-correct under uncertainty, and maintain verifiability throughout requires advances across the full stack: from LLM reliability and tool orchestration to cryptographic anchoring of multi-step agent trajectories.

This is the frontier. The progression from Oracle 1.0 to 4.0 is not just a product roadmap. It reflects the maturation of AI itself:

From **Static feeds → Semantic queries → One-shot intelligence → Autonomous agents**

Each step demands more from the underlying AI and verification infrastructure. Cournot is building each layer in production, with prediction markets as the proving ground and the full agent economy as the destination.


# Fast & Slow Paths

Cournot's dual-layer architecture combines immediate execution with decentralized verification.

<figure><img src="/files/Sllk1jXk1mxNaZhpvms4" alt=""><figcaption></figcaption></figure>

### The Fast Path: Instant Finality <a href="#the-fast-path-execution-of-por-sub-second-settlement" id="the-fast-path-execution-of-por-sub-second-settlement"></a>

Anchor Nodes operate within Trusted Execution Environments (TEEs) to generate Proof of Reasoning results with sub-second settlement. The Anchor Node signs the final verdict, the reasoning root, and the committed PromptSpec hash, producing an immediately usable result.

### The Slow Path: Decentralized Security via opML <a href="#the-slow-path-verification-of-por-the-security-guarantee" id="the-slow-path-verification-of-por-the-security-guarantee"></a>

Permissionless **Sentinel Nodes** validate Fast Path results through the **opML optimistic verification** model:

1. **Evidence verification (zkTLS)**: Sentinel Nodes verify zkTLS proofs to confirm that each piece of evidence originated from an authorized source. A single invalid proof is sufficient to invalidate the entire evidence bundle.
2. **Reasoning verification (opML replay)**: If a Sentinel suspects the reasoning is flawed, it initiates an opML challenge. The frozen inputs (PromptSpec, evidence bundle, model hash) are replayed, and any divergence is isolated via the bisection protocol down to a single computation step provable on-chain.
3. **Output verification (determinism check)**: The verdict is checked against the PromptSpec's verdict schema to confirm it conforms to the allowed output space.

Because both zkTLS and opML operate under a **one-honest-node security model**, the Slow Path does not require a quorum or multi-node re-execution. A single honest Sentinel detecting a fault is sufficient to trigger correction and slashing. This makes decentralized security economically sustainable even for low-value markets.

### **Granular Challenge Mechanism**

A key innovation is Pinpoint Verification: the combination of Merkle-ized Reasoning Traces and opML bisection allows disputes to target specific reasoning steps rather than entire outcomes. A challenger does not need to re-run the full inference — they narrow the dispute to the exact leaf node where the reasoning diverged, and prove that single step on-chain.This dramatically reduces verification costs:

* **Without opML**: Dispute requires full inference re-execution across multiple nodes → cost scales with model size × node count
* **With opML**: Dispute narrows to a single computation step via bisection → cost is bounded regardless of model complexity

The result: **Instant Finality** via trusted hardware execution, with **Decentralized Security** maintained through opML's one-honest-node guarantee and economic incentives tied to stake slashing.


# Privacy & Confidential Truth

While blockchain thrives on transparency, the real world runs on privacy. A prediction market for corporate mergers or supply chain delays requires analyzing sensitive data that cannot be publicly exposed on-chain.

Cournot introduces a "**Confidential Truth**" paradigm: verifying facts without revealing the underlying raw data.

### **Zero-Knowledge Inputs (zkTLS)**

Traditional oracles require data to be public to be verified. This makes it impossible to resolve markets based on private data such as *"Did I receive a transaction confirmation from PayPal?"* or *"Is my private bank balance above $1M?"*

Through **zkTLS**, the Collector Node acts as a blind notary:

* The user generates a proof locally in their browser (Client-Side Proving).
* The proof confirms: *"This data originated from* [*paypal.com*](http://paypal.com) *via a secure TLS session, and the field amount > 1000."*
* **Privacy Guarantee**: The Collector Node verifies the *proof*, but never sees the *content*. No sensitive PII ever leaves the user's device.

### **Eyes-Off Reasoning (TEE Confidential Computing)**

Even if input is private, sending it to an AI model usually means the model operator can see it. This "Reasoning Leakage" is unacceptable for institutional use cases.

All Fast Path inference occurs within **Hardware Enclaves (TEEs like Intel TDX / NVIDIA H100 Confidential Computing)**:

* **Memory Encryption**: The AI model's weights and user input data are encrypted in RAM. Even the physical server owner cannot inspect the reasoning process.
* **Remote Attestation**: The TEE generates a cryptographic quote proving: *"I am running the official, un-tampered Cournot Auditor code, and I processed this specific encrypted input."*

The result is "**Eyes-Off Reasoning**": the AI judges the case, but no human ever sees the evidence.

### **Use Case: Private Prediction Markets (Dark Pools)**

This privacy architecture unlocks enterprise hedging — a new category of markets:

* *Scenario:* A shipping company wants to hedge against a delay in their specific cargo shipment.
* *Mechanism:* They open a prediction market on Cournot. Resolution relies on their private ERP data.
* *Privacy:* Cournot's TEE nodes ingest the private ERP API feed via zkTLS, verify the delay, and settle the market. **Competitors never see the shipping data; they only see the settlement result.**


# Why Cournot is Different

### 1. Semantic Scalability

**Traditional oracle architecture:**

*New requirement → New feed → New integration*

**Cournot Oracle architecture:**

***Trusted data → Semantic query → Deterministic computation***

The same underlying infrastructure can support dramatically more use cases. Instead of scaling by adding feeds, Cournot scales by adding queries and skills over a resilient data layer.

### 2. Resilience by Design

Cournot does not depend on one oracle or one data provider. Multiple independent sources can be combined, compared, and scored before producing the final output. This reduces single-source failure risk while creating a stronger foundation for application-specific queries.

### 3. AI Without Replacing Determinism

Cournot does not use large AI models unnecessarily. For structured use cases such as crypto, equities, weather, or sports:

**Natural Language → AI Interpretation → SQL / Deterministic Code → Verified Result**

AI interprets the requirement; deterministic computation produces the answer. For harder real-world events, Cournot progressively adds evidence retrieval, reasoning, verification, and human escalation; each layer applied only when the previous one is insufficient.

### 4. Verifiable AI: The zkTLS + opML Foundation

Cournot's goal is not to ask applications to trust an AI model. It is to make AI inference provable so that any participant can verify the result without re-running the computation themselves.

This is achieved through two complementary technologies:

1. **zkTLS: Proving the Inputs**\
   Zero Knowledge Transport Layer Security proves that evidence originated from a specific source via a verified TLS session, without revealing the raw data. This solves the evidence trust problem: you don't need to trust the Collector, because the proof is cryptographically self-verifying.
2. **opML Proving the Reasoning**\
   Optimistic Machine Learning proves that AI inference was computed correctly over the verified inputs. Rather than requiring multiple nodes to re-execute the same expensive inference, opML allows any single honest node to submit a compact fraud proof via bisection if the result is wrong.

Together, they create a one-honest-node verification model:

<figure><img src="/files/mZ8HFPNiHHaDV653iZsS" alt=""><figcaption></figcaption></figure>

The trust stack becomes:

<figure><img src="/files/LZUPfyjov4zVKPNvpLZA" alt=""><figcaption></figcaption></figure>

This is fundamentally different from architectures where N nodes must independently run the same model to reach consensus. In those systems, inference cost scales as O(model\_cost × N). In Cournot, inference runs once; verification cost is O(1) per challenge. The security guarantee comes not from redundant computation, but from the economic certainty that any fraud will be caught and punished by a single honest Sentinel.

***


# Verticals: What Cournot Enables

Prediction markets are the proving ground. The sections below map the full landscape of verticals Cournot is tackling from live production use cases to near-term expansions to the long-term destination.


# Prediction Markets

Oracle layers: 2.0 + 3.0 + 4.0 | Status: Live

Prediction markets are the ideal first application because every market is effectively a unique oracle query. A traditional oracle can easily answer *"Will BTC be above $100K at 4 PM?"* but markets also ask questions that exercise the full stack:

|           **Market Type**          |  **Oracle Layer**  |                                        **Example**                                       |
| :--------------------------------: | :----------------: | :--------------------------------------------------------------------------------------: |
|   **Structured price conditions**  |   2.0 (Semantic)   |                  "Was BTC's 30-min VWAP above $100K across 3 exchanges?"                 |
| **Unstructured real-world events** | 3.0 (Intelligence) |           "Did the government shut down?" / "Did a regulator approve the ETF?"           |
|   **Open-ended event monitoring**  |    4.0 (Agentic)   | "Will Company X announce a product this quarter?" — requires persistent agent monitoring |

For traditional infrastructure, each of these becomes a custom feed or integration. For Cournot, **the market rule itself becomes the oracle query**.

Cournot is already serving platforms such as [**42 Space**](https://42.space) as an official resolution oracle, resolving markets across crypto, sports, politics, and current events.


# Real-World Assets (RWA)

Oracle layers: 1.0 + 2.0 + 3.0 | Status: Live

RWA is one of the broadest verticals for Cournot because tokenized real-world assets require oracle services at every layer of the stack.

### Collectibles & Trading Cards (TCG)

Collectibles: trading cards, rare sneakers, vintage watches, fine art — represent a market that Oracle 1.0 cannot serve. There is no single price feed for a PSA 9 1986 Michael Jordan Fleer rookie card. Pricing requires:

* Multi-marketplace aggregation (eBay, StockX, PWCC, specialist dealers, private sales)
* Condition and grading normalization (PSA 10 vs. PSA 7 can mean a 5-50x price difference)
* Recency and volume weighting (a card that sold once last month vs. daily trades)
* Event-driven adjustments (a player's card spikes after a championship win)

Cournot provides **Oracle 2.0 semantic pricing** for these assets, aggregating fragmented data into a verified composite valuation. For collectible minting and pack openings, Cournot also provides **Oracle 1.0 VRF** for provably fair randomness.

For high-value items requiring authenticity verification, **Oracle 3.0 attestation** cross-references grading certificates, ownership history, and marketplace listings to produce a verified provenance chain.

### Treasuries, Fixed Income & ETFs

Tokenized treasuries, corporate bonds, municipal bonds, and ETFs need:

* Oracle 1.0: NAV price feeds, yield data, coupon schedules
* Oracle 2.0: Cross-source composite pricing, basis calculations, yield curve analytics
* Oracle 3.0: Issuer credit assessment, covenant compliance verification, event-driven revaluation (rating changes, regulatory actions)

### Real Estate

Tokenized real estate portfolios require ongoing verification, not just one-time attestation:

* Oracle 2.0: Location-specific valuation from comparable sales, rental yield analytics
* Oracle 3.0: Occupancy verification, insurance status confirmation, regulatory compliance
* Oracle 4.0: Continuous collateral monitoring — flagging deviations in occupancy, rental income, or local market conditions

### Commodities

Physical commodity tokens need:

* Oracle 1.0: Spot and futures prices
* Oracle 2.0: Basis-adjusted pricing by delivery location, quality grade normalization, multi-venue composites


# Trading Intelligence & Signals

Oracle layers: 2.0 + 4.0 | Status: Live

Traditional market data providers deliver raw feeds. Cournot delivers verified intelligence, signals that carry reasoning provenance, confidence levels, and full evidence chains.

|      **Signal Type**      | **Oracle Layer** |                                                                                              **What Makes It Different**                                                                                              |
| :-----------------------: | :--------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
|  **Quantitative signals** |        2.0       |                                        Multi-source composite metrics, anomaly-scored, with cross-validation, not just a price feed but a reasoned assessment of price quality                                        |
|  **Event-driven signals** |     3.0 + 4.0    | Agent detects a regulatory filing, assesses market impact via PoR, and produces a verified signal, the consumer knows *why* the signal was generated, what evidence supported it, and how confident the assessment is |
| **Continuous monitoring** |        4.0       |                          Agent tracks on-chain flows, social sentiment, governance proposals, and news for a specific token or protocol, produces ongoing intelligence with reasoning trails                          |

The key differentiator from raw data feeds: every signal is verifiable. Consumers can inspect the evidence, replay the reasoning, and assess confidence, rather than trusting an opaque model.


# DeFi & Financial Products

Oracle layers: 1.0 + 2.0 | Status: Live

Oracle 2.0 enables the next generation of DeFi by making oracle infrastructure programmable rather than static:

<table data-header-hidden data-search="false"><thead><tr><th width="259.83984375" align="center"></th><th align="center"></th></tr></thead><tbody><tr><td align="center"><strong>DeFi Application</strong></td><td align="center"><strong>What Cournot Provides</strong></td></tr><tr><td align="center"><strong>Advanced Lending</strong></td><td align="center">Multi-source composite pricing for collateral, TWAP-based liquidation triggers that resist manipulation, cross-asset correlation feeds</td></tr><tr><td align="center"><strong>Structured Products</strong></td><td align="center">Threshold-over-window conditions (e.g., "BTC above $100K for 10 consecutive minutes"), multi-leg conditions for exotic derivatives</td></tr><tr><td align="center"><strong>DEX &#x26; AMM</strong></td><td align="center">Multi-exchange composite prices for more accurate reference pricing, anomaly-filtered feeds that exclude wash trading</td></tr><tr><td align="center"><strong>Risk Management</strong></td><td align="center">Portfolio-level exposure analytics, concentration risk scoring, cross-protocol dependency mapping</td></tr><tr><td align="center"><strong>Stablecoins</strong></td><td align="center">Multi-oracle resilient peg monitoring, deviation alerting, collateral adequacy checks</td></tr></tbody></table>

The key shift: DeFi protocols no longer need to build custom oracle integrations for every new product variant. One semantic query layer serves unlimited product designs.


# Insurance

Oracle layers: 1.0 + 2.0 + 3.0 + 4.0 | Status: In Development

Insurance exercises every layer of the stack, from simple parametric triggers to complex claim adjudication:

|      **Insurance Type**     | **Oracle Layer** |                                                                              **How Cournot Resolves It**                                                                              |
| :-------------------------: | :--------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
|   **Parametric (simple)**   |     1.0 + 2.0    |    For example, earthquake magnitude > 6.0, rainfall below threshold —  structured data triggers from authoritative sources, with semantic aggregation for multi-station composites   |
|   **Parametric (complex)**  |     2.0 + 3.0    | "Average wind speed across 5 stations exceeded 120 km/h for 30+ minutes during the policy window" — semantic computation over time-series data, with PoR for condition interpretation |
|    **Claim Verification**   |        3.0       |       "Did the supply chain disruption meet the force majeure threshold?" — requires reading policy language against real-world evidence, collecting and verifying documentation      |
| **Event-Driven Settlement** |        4.0       |         Agent monitors weather stations, shipping logs, or IoT sensors in real-time — triggers payout the moment the insured event occurs, with full evidence chain for audit         |

The progression from Oracle 1.0 to 4.0 mirrors the insurance industry's own ambition: from manual claims processing, to parametric automation, to fully event-driven settlement.


# Credit Intelligence

Oracle layers: 3.0 + 4.0 | Status: In Development

Credit assessment is inherently a judgment problem, not a data problem. Determining creditworthiness requires synthesizing:

* Financial statements and balance sheet data
* Market conditions and sector trends
* News sentiment and management signals
* Regulatory filings and compliance history
* On-chain behavior (for DeFi protocols and DAOs)

Oracle 1.0 can deliver individual data points. Oracle 3.0 can synthesize them into a structured credit opinion with Proof of Reasoning producing an auditable judgment trail rather than an opaque score.

Oracle 4.0 takes this further: persistent credit agents maintain rolling assessments that update as new evidence emerges, producing **verifiable credit signals** for:

* Undercollateralized DeFi lending (where the lender needs more than just collateral ratios)
* Institutional DeFi (where counterparty risk assessment is a regulatory requirement)
* RWA credit markets (where on-chain credit assessment can unlock new lending verticals)


# Compliance & Regulatory

Oracle layers: 3.0 | Status: In Development

Regulatory interpretation is one of the highest-value oracle problems and one that Oracle 1.0 cannot touch. Questions like:

* "Does Protocol X qualify as a security under latest SEC guidance?"
* "Does this transaction trigger a reporting obligation under MiCA?"
* "Has this entity been added to a sanctions list?"

These require reading regulatory language, cross-referencing precedent, and producing a reasoned judgment exactly what Oracle 3.0's Proof of Reasoning is built for.

The output is an auditable reasoning trail: the PromptSpec specifies the regulatory question, the evidence bundle contains the source documents, and the reasoning trace shows how the conclusion was reached. This audit trail is valuable in itself as compliance teams demonstrate *how* they reached a determination, not just *what* the determination was.


# The Agent Economy

Oracle layers: 4.0 | Status: Long-term vision

As AI agents increasingly transact, negotiate, and coordinate with each other, they need a shared intelligence layer that produces **verified world-state**, not raw data they must each interpret independently.

This is where every layer of the Cournot stack converges:

* **Oracle 1.0** provides the raw data feeds agents consume
* **Oracle 2.0** makes that data queryable by meaning, not by feed ID
* **Oracle 3.0** adds judgment: agents can ask "Did this happen?" and receive a verified answer
* **Oracle 4.0** adds persistence: agents can subscribe to continuous intelligence about the conditions they care about

The result is an **Agentic Intelligence Network**: a shared perception layer where autonomous systems can trust the information they act on, verify the reasoning behind it, and hold the network accountable when it's wrong. Use cases at this layer include:

<table data-header-hidden><thead><tr><th width="218.5859375" align="center"></th><th align="center"></th></tr></thead><tbody><tr><td align="center"><strong>Application</strong></td><td align="center"><strong>How Agents Use Cournot</strong></td></tr><tr><td align="center"><strong>Autonomous trading</strong></td><td align="center">Trading agents consume verified signals as trusted inputs with full provenance, not black-box predictions</td></tr><tr><td align="center"><strong>M2M commerce</strong></td><td align="center">Agents verifying delivery conditions, quality thresholds, and contract fulfillment against Cournot's verified world-state</td></tr><tr><td align="center"><strong>Multi-agent coordination</strong></td><td align="center">Agents that need to agree on facts ("Did the shipment arrive?", "Is the collateral sufficient?") use Cournot as the shared truth layer</td></tr><tr><td align="center"><strong>Agent risk management</strong></td><td align="center">Meta-agents that monitor other agents' behavior and flag anomalies, using Cournot's verified signals as baseline</td></tr></tbody></table>

The agent economy is the destination where Cournot's full stack (data, semantics, intelligence, action) becomes the infrastructure layer for autonomous systems at scale.


# Tokenomics: Atomic Accountability

The Cournot network token acts as "Truth Collateral", enforcing atomic accountability for each role within the SOP. Rather than a single stake pool, token bonds are mapped directly to specific roles, ensuring precise accountability and risk isolation.

### Why opML Makes Token Economics Work

Traditional multi-node consensus models face a fundamental tension: verification requires N nodes to re-run inference independently, making security costs scale linearly with the number of validators. This means either high costs (many validators) or weak security (few validators).

Cournot's opML-based verification resolves this tension:

* **Fraud is provable**: Because zkTLS proves evidence authenticity and opML enables deterministic inference replay, any malicious behavior produces a cryptographic proof of fault — not a subjective judgment.
* **Slashing is objective**: When a Sentinel submits a valid fraud proof via opML bisection, the on-chain contract can verify the single divergent computation step. Slashing is triggered by math, not by votes.
* **One honest node is enough**: The entire security model requires only one honest Sentinel watching. This means the protocol doesn't need to incentivize a large validator set — it only needs to ensure that at least one Sentinel is economically motivated to check.
* **Cheating is unprofitable**: The expected value of cheating is negative: the probability of a single honest Sentinel catching fraud is high, and the slashing penalty exceeds any possible gain.

This makes token staking economically credible at a fraction of the cost of multi-node consensus systems.

### Role-Based Staking

|      **Role**     |          **Stake**         |            **Slashing Condition**           |        **Verification Method**        |
| :---------------: | :------------------------: | :-----------------------------------------: | :-----------------------------------: |
|   **Collector**   |      Source Integrity      |    Invalid zkTLS proofs or stale evidence   |  zkTLS proof verification (on-chain)  |
|    **Auditor**    |      Logical Coherence     | Reasoning fallacies or violated constraints |   opML replay + bisection (on-chain)  |
|     **Judge**     |      Schema Compliance     |   Non-deterministic or malformed verdicts   | Deterministic schema check (on-chain) |
|  **Anchor Node**  | Infrastructure Grand Stake |     TEE attestation failure or downtime     |    Remote attestation verification    |
| **Sentinel Node** |       Challenge Bond       |    False challenge (invalid fraud proof)    |     On-chain bisection resolution     |

Errors in one function do not penalize participants in other roles. Each stake is isolated to its specific responsibility. Critically, every slashing condition is backed by an objective, on-chain-verifiable proof, either a zkTLS proof for evidence faults or an opML bisection result for reasoning faults. No human judgment or voting is required.

### Strategy Mining

Developers can create optimized resolution workflow NFTs (**Strategy NFTs**) as tradeable assets. When nodes use these strategies to resolve markets, creators receive micro-royalties in the network token, establishing a **decentralized marketplace for reasoning logic**.

This creates an incentive flywheel:

* Better strategies → higher resolution success → more usage → more royalties
* Competition drives strategy quality upward over time

### Dual-Engine Reward System

Two parallel incentive paths support the architecture:

* **Anchor Yield**: Predictable, salary-like compensation for high-performance infrastructure operators. Ensures network reliability and uptime. Anchor Nodes stake heavily and earn consistently, their incentive is to run honest inference because opML makes cheating provably detectable.
* **Sentinel Bounties**: Whistleblower-model rewards for security participants. Sentinel Nodes earn substantial rewards only when they successfully submit valid fraud proofs via opML challenges. The one-honest-node guarantee means even a single well-funded Sentinel provides full network security, making the bounty pool highly concentrated and attractive.

### The Economic Loop

<figure><img src="/files/IlHx4GWHkH33mx7I2zU1" alt=""><figcaption></figcaption></figure>

Because zkTLS and opML make both evidence faults and reasoning faults objectively provable on-chain, the token economics are grounded in cryptographic guarantees rather than social consensus. This is what gives the Cournot token its utility as Truth Collateral, it is not a governance token requiring subjective votes, but a performance bond verified by math.


# Partner Public API

Cournot provides partners with public endpoints to retrieve market verdicts and file disputes. The system produces final settlement records including verdicts, confidence assessments, and blockchain proofs.

### Base URL

> <https://interface.cournot.ai>

#### Response Envelope

All responses return HTTP 200. Branch on the `code` field, not HTTP status:

```json
// Success
{ "code": 0, "msg": "Success", "data": { /* payload */ } }

// Error
{ "code": 4100, "msg": "slug is required", "detail": "slug is required" }
```

<table data-header-hidden><thead><tr><th width="158.44140625" align="center"></th><th width="107.1875" align="center"></th><th align="center"></th></tr></thead><tbody><tr><td align="center"><strong>Field</strong></td><td align="center"><strong>Type</strong></td><td align="center"><strong>Description</strong></td></tr><tr><td align="center"><pre><code>code
</code></pre></td><td align="center">int</td><td align="center">0 = success; non-zero = error</td></tr><tr><td align="center"><pre><code>msg
</code></pre></td><td align="center">string</td><td align="center">Human-readable status</td></tr><tr><td align="center"><pre><code>data
</code></pre></td><td align="center">object</td><td align="center">Present on success</td></tr><tr><td align="center"><pre><code>detail
</code></pre></td><td align="center">string</td><td align="center">Present on error</td></tr></tbody></table>

### GET `/cournot/markets/public`

Retrieve a market's public settlement record. No authentication required.

**Query Parameters**:

<table data-header-hidden><thead><tr><th width="139.34765625" align="center"></th><th width="142.44140625" align="center"></th><th width="137.65625" align="center"></th><th align="center"></th></tr></thead><tbody><tr><td align="center">Parameter</td><td align="center">Type</td><td align="center">Required</td><td align="center">Description</td></tr><tr><td align="center"><code>slug</code></td><td align="center">string</td><td align="center">Yes</td><td align="center">Market slug (no leading/trailing slashes)</td></tr><tr><td align="center"><code>source</code></td><td align="center">string</td><td align="center">Yes</td><td align="center">Partner-specific identifier issued by Cournot</td></tr></tbody></table>

#### Example Request:

```json
curl -G "https://interface.cournot.ai/cournot/markets/public" \
  --data-urlencode "slug=ram-average-price-above-600-by-end-of-march" \
  --data-urlencode "source=YOUR_SOURCE_ID"
```

#### Example Response:

```json
{
  "code": 0,
  "msg": "Success",
  "data": {
    "markets": [
      {
        "id": 61,
        "source": "YOUR_SOURCE_ID",
        "slug": "ram-average-price-above-600-by-end-of-march",
        "status": "resolved",
        "verdict": "YES",
        "resolved_at": "2026-04-28T10:08:40Z",
        "confidence": "HIGH",
        "reasoning": "multi-source evidence confirmed the final outcome is YES",
        "proofs": [
          { "chain": "base", "tx_hash": "0xabc..." },
          { "chain": "bsc", "tx_hash": "0xdef..." }
        ],
        "disputes": [
          {
            "id": 4,
            "status": "closed",
            "submitter_selection": "NO",
            "reason_text": "we believe the resolved outcome is incorrect",
            "submitted_at": "2026-04-28T10:30:00Z",
            "decision": {
              "type": "override",
              "partner_final_verdict": "NO",
              "reason_text": "submitted dispute is valid",
              "decided_at": "2026-04-28T11:00:00Z"
            }
          }
        ]
      }
    ]
  }
}
```

#### Response Fields (`data.markets[]`):

<table data-header-hidden><thead><tr><th width="147.43359375" align="center"></th><th width="140.875" align="center"></th><th align="center"></th></tr></thead><tbody><tr><td align="center"><strong>Field</strong></td><td align="center"><strong>Type</strong></td><td align="center"><strong>Description</strong></td></tr><tr><td align="center"><code>id</code></td><td align="center">int64</td><td align="center">Market identifier</td></tr><tr><td align="center"><code>source</code></td><td align="center">string</td><td align="center">Partner source identifier</td></tr><tr><td align="center"><code>slug</code></td><td align="center">string</td><td align="center">Market slug</td></tr><tr><td align="center"><code>status</code></td><td align="center">string</td><td align="center"><code>monitoring</code> / <code>resolved</code> / <code>disputed</code> / <code>closed</code></td></tr><tr><td align="center"><code>verdict</code></td><td align="center">string</td><td align="center">Final verdict text</td></tr><tr><td align="center"><code>resolved_at</code></td><td align="center">string</td><td align="center">RFC 3339 UTC timestamp</td></tr><tr><td align="center"><code>confidence</code></td><td align="center">string</td><td align="center"><code>VERY_HIGH</code> / <code>HIGH</code> / <code>MEDIUM</code> / <code>LOW</code> / <code>VERY_LOW</code></td></tr><tr><td align="center"><code>reasoning</code></td><td align="center">string</td><td align="center">Human-readable explanation</td></tr><tr><td align="center"><code>proofs</code></td><td align="center">array</td><td align="center">On-chain proof records</td></tr><tr><td align="center"><code>disputes</code></td><td align="center">array or null</td><td align="center">Dispute records; <code>null</code> if none</td></tr></tbody></table>

#### Proof Item:

| **Field** | **Type** |  **Description** |
| :-------: | :------: | :--------------: |
|  `chain`  |  string  |  `base` or `bsc` |
| `tx_hash` |  string  | Transaction hash |

#### Dispute Item:

<table data-header-hidden><thead><tr><th width="222.2109375" align="center"></th><th width="203.828125" align="center"></th><th align="center"></th></tr></thead><tbody><tr><td align="center"><strong>Field</strong></td><td align="center"><strong>Type</strong></td><td align="center"><strong>Description</strong></td></tr><tr><td align="center"><code>id</code></td><td align="center">int64</td><td align="center">Dispute identifier</td></tr><tr><td align="center"><code>status</code></td><td align="center">string</td><td align="center"><code>open</code> or <code>closed</code></td></tr><tr><td align="center"><code>submitter_selection</code></td><td align="center">string</td><td align="center">Claimed correct outcome</td></tr><tr><td align="center"><code>reason_text</code></td><td align="center">string</td><td align="center">Justification</td></tr><tr><td align="center"><code>submitted_at</code></td><td align="center">string</td><td align="center">RFC 3339 UTC timestamp</td></tr><tr><td align="center"><code>decision</code></td><td align="center">object or null</td><td align="center">Present only when closed</td></tr></tbody></table>

#### Decision Object:

<table data-header-hidden><thead><tr><th width="217.4296875" align="center"></th><th width="169.484375" align="center"></th><th align="center"></th></tr></thead><tbody><tr><td align="center"><strong>Field</strong></td><td align="center"><strong>Type</strong></td><td align="center"><strong>Description</strong></td></tr><tr><td align="center"><code>type</code></td><td align="center">string</td><td align="center"><code>keep</code> or <code>override</code></td></tr><tr><td align="center"><code>partner_final_verdict</code></td><td align="center">string</td><td align="center">Final verdict after decision</td></tr><tr><td align="center"><code>reason_text</code></td><td align="center">string</td><td align="center">Decision justification</td></tr><tr><td align="center"><code>decided_at</code></td><td align="center">string</td><td align="center">RFC 3339 UTC timestamp</td></tr></tbody></table>

Notes:

* When no disputes exist, `disputes` is `null` (not an empty array).
* When no market matches, `data.markets` returns an empty array.

***

### POST `/cournot/markets/dispute/submit`

File a dispute on behalf of an end user. Requires API key authentication.

#### Headers:

<table data-header-hidden><thead><tr><th width="266.7421875" align="center"></th><th width="304.3671875" align="center"></th></tr></thead><tbody><tr><td align="center"><strong>Header</strong></td><td align="center"><strong>Value</strong></td></tr><tr><td align="center"><code>Content-Type</code></td><td align="center"><code>application/json</code></td></tr><tr><td align="center"><code>x-api-key</code></td><td align="center">Partner API key</td></tr></tbody></table>

#### Request Body:

<table data-header-hidden data-search="false"><thead><tr><th width="205.22265625" align="center"></th><th align="center"></th><th align="center"></th><th align="center"></th></tr></thead><tbody><tr><td align="center"><strong>Field</strong></td><td align="center"><strong>Type</strong></td><td align="center"><strong>Required</strong></td><td align="center"><strong>Description</strong></td></tr><tr><td align="center"><code>market_id</code></td><td align="center">int64</td><td align="center">Yes</td><td align="center">Market ID from <code>get_public_market</code></td></tr><tr><td align="center"><code>submitter_id</code></td><td align="center">string</td><td align="center">Yes</td><td align="center">End user's unique identifier on partner platform</td></tr><tr><td align="center"><code>submitter_name</code></td><td align="center">string</td><td align="center">Yes</td><td align="center">Submitter's display name</td></tr><tr><td align="center"><code>submitter_selection</code></td><td align="center">string</td><td align="center">Yes</td><td align="center">Outcome the submitter claims is correct</td></tr><tr><td align="center"><code>reason_text</code></td><td align="center">string</td><td align="center">Yes</td><td align="center">Dispute justification</td></tr><tr><td align="center"><code>submitted_at</code></td><td align="center">string</td><td align="center">Yes</td><td align="center">RFC 3339 UTC timestamp</td></tr></tbody></table>

#### Example Request:

```json
curl -X POST "https://interface.cournot.ai/cournot/markets/dispute/submit" \
  -H "content-type: application/json" \
  -H "x-api-key: YOUR_PARTNER_API_KEY" \
  -d '{
    "market_id": 61,
    "submitter_id": "partner_user_1001",
    "submitter_name": "alice",
    "submitter_selection": "NO",
    "reason_text": "we believe the resolved outcome is incorrect based on source evidence",
    "submitted_at": "2026-04-28T10:30:00Z"
  }'
```

#### Example Response:

```json
{ "code": 0, "msg": "Success", "data": { "dispute_id": 4 } }
```

**Business Rules:**

* The partner's `source` (derived from API key) must match the market's source. Cross-partner disputes are forbidden.
* Only markets with `status = resolved` can be disputed.
* Each market accepts a maximum of one dispute.

***

### Integration Workflows

#### Standard Resolution Flow:

1. Poll `GET /cournot/markets/public` for your markets.
2. When a market reaches `status: resolved`, extract the `verdict`, `confidence`, and `proofs`.
3. Use this record to settle the corresponding market on your platform.

#### Dispute Handling Flow:

1. End user contests a verdict on your platform.
2. Submit dispute via `POST /cournot/markets/dispute/submit`.
3. Market transitions from `resolved` → `disputed`.
4. Cournot conducts internal review.
5. Market becomes `closed` with a `decision` object (`type: keep` or `type: override`).
6. Poll `GET /cournot/markets/public` to retrieve the final decision.

#### Market Lifecycle:

<figure><img src="/files/LEuJIEXQWJttYJrePeHX" alt=""><figcaption></figcaption></figure>

***

Traditional oracles made trusted data available on-chain. Cournot makes trusted data programmable by meaning, extends it into intelligence, and ultimately enables action.

<figure><img src="/files/rY30XuM5sTLQJx8chXoN" alt=""><figcaption></figcaption></figure>

Prediction markets prove the architecture. RWA pricing proves semantic aggregation. Trading intelligence proves persistent monitoring. The agent economy is where it all converges.

**Data → Semantic Data → Intelligence → Action.**

Cournot is building Oracle 4.0.