# 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 Resolution Bottleneck

#### The Infinite Resolution Challenge

The long-term value of prediction markets does not lie solely in the "head" of global events such as elections or central bank decisions. It lies in digitizing the **full spectrum of reality**, from regulatory interpretations and corporate milestones to hyper-local supply chain disruptions and private operational states.

As systems move toward automation, the agent economy requires an oracle layer capable of resolving **arbitrary events described in natural language**, not just numeric feeds. Current infrastructure forces an unacceptable tradeoff: restrict markets to simple data, or accept slow, expensive, and contestable resolutions.

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

* **The Human Limit:** Human-voting oracles face a biological constraint. They cannot process millions of concurrent, nuanced decisions. Latency ranging from 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 questions such as: *"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, a cognitive task suited to AI. But without cryptographic verification of how that interpretation occurs, AI introduces a new black box. Cournot addresses this semantic gap by combining AI cognition with verifiable reasoning.

#### Why Existing Architectures Fall Short (The Comparative Analysis)

The current oracle landscape is divided into distinct categories, each optimizing for specific metrics while sacrificing others necessary for autonomous infinite resolution demands.

| Feature                 | Price Feed Model                                | Human Consensus Model                           | Computational Integrity Model                                        | Reasoning Verifier Model (Cournot)                        |
| ----------------------- | ----------------------------------------------- | ----------------------------------------------- | -------------------------------------------------------------------- | --------------------------------------------------------- |
| Core Positioning        | Secure Data Transport Layer                     | Human Social Consensus                          | On-chain AI Compute Infra                                            | AI Reasoning Verification                                 |
| The "Black Box" Problem | Unsolved (Verifies transport, not source logic) | N/A (Relies on human cognition, but unscalable) | Partial (Solves computational integrity, lacks semantic constraints) | Solved (Via Merkle Trace and SOP Audit)                   |
| Speed / Latency         | Fast (Minutes)                                  | Slow (24-72 Hours)                              | Variable (Depends on model size)                                     | Sub-second (Fast Path TEE)                                |
| Long-Tail Support       | Weak (Requires custom feeds)                    | Weak (Limited by voter attention)               | Strong (But requires custom app dev)                                 | Very Strong (Automated SOP scales to millions of markets) |
| Token Value             | Payment and Staking                             | Voting Rights and Buyback                       | Compute Fees                                                         | Atomic Staking and Strategy Royalties (Strategy Mining)   |

* **The Price Feed Model:**
  * *Strength:* Unmatched connectivity and secure workflow orchestration.
  * *Limitation:* **The "Black Box" Problem.** This model moves data securely from Point A to Point B, but it does not inherently audit the *semantic quality* of the data or the AI's internal logic. If a connected LLM hallucinates, the oracle securely transports that hallucination on-chain. It verifies *transmission*, not *reasoning*.
  * There is also a **structural cost implication** when AI inference is embedded directly into oracle execution. When AI inference is embedded directly into oracle execution, runtime or DON-based models require multiple nodes to independently run the same inference to reach consensus. This makes the dominant cost—model inference—compute-multiplicative, scaling with the number of participating nodes. While viable for large, infrequent events, this cost structure breaks down for long-tail or high-throughput markets. Cournot's Proof of Reasoning avoids this by verifying resolution artifacts: semantic specifications, evidence, and reasoning traces, rather than re-executing full inference across many nodes, enabling scalable, low-cost AI resolution.
* **The Human Consensus Model:**
  * *Strength:* High accuracy for complex, subjective disputes.
  * *Limitation:* **Latency and Scalability.** Relying on human voting creates a "resolution bottleneck" of 24-72 hours. Furthermore, the "Attention Scarcity" problem means global voters lack the incentive to research and resolve millions of niche, hyper-local micro-markets.
* **The Computational Integrity Model:**
  * *Strength:* Proving that a model was executed correctly without tampering (Computation Integrity).
  * *Limitation:* **Logic vs. Compute.** opML proves *that* the model ran, but not *why* the model made a specific decision. It lacks semantic orchestration to prevent logical fallacies or context blindness (e.g., using outdated news).
* **Reasoning Verifier Model:** Cournot does not replace data transport, human judgment, or computation proofs, it sits above them. Proof of Reasoning adds a semantic verification layer that ensures AI conclusions are derived from authentic inputs, coherent logic, and deterministic outputs before affecting the onchain state.


# Proof of Reasoning (PoR)

**Proof of Reasoning (PoR)** is the central engine of the Cournot Protocol. It transforms AI inference from a fleeting 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 **network token** acts as "Truth Collateral," enforcing atomic accountability for each role within this SOP.

**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

To address ambiguity at the definition layer, Cournot introduces **PromptSpec**, a canonical semantic contract that deterministically specifies what is being resolved.

PromptSpec is a structured, machine-readable definition that encodes:

* the precise question being evaluated,
* the scope and boundaries of acceptable interpretations,
* the verdict schema and outcome space,
* and the logical constraints governing resolution.

Rather than relying on free-form prompts or implicit assumptions, PromptSpec ensures that resolution semantics are explicit, repeatable, and inspectable. This significantly reduces ambiguity, lowers dispute rates, and improves AI reasoning reliability by narrowing the interpretive surface area.

PromptSpec can be authored and aligned off-chain,by market creators, protocol designers, or counterparties and then cryptographically committed onchain prior to resolution. Once committed, all resolution processes are bound to the same semantic definition, ensuring consistency across executions and verifications.

By separating semantic definition from execution, Cournot enables deterministic resolution logic without sacrificing flexibility in market design.


# SOP Framework

Accurate resolution depends not only on how questions are defined, but also on how evidence is sourced. In practice, many oracle failures arise from **data source drift**: changes in availability, interpretation, freshness, or trustworthiness of inputs over time.

Cournot treats data requirements as a first-class protocol responsibility rather than an implicit assumption. Each resolution specifies explicit constraints on evidence collection, including:

* **Authoritative sources** permitted for resolution,
* **Verifiable retrieval methods** with cryptographic receipts,
* **Freshness windows** defining acceptable temporal bounds,
* **Conflict resolution rules** for handling inconsistent or competing evidence.

By formalizing these requirements, Cournot reduces unpredictability in AI reasoning, minimizes disputes caused by shifting data assumptions, and lowers verification costs by narrowing the evidence set. Explicit data requirements ensure that all parties: resolvers, verifiers, and challengers, evaluate outcomes against the same evidentiary ground truth.

The Proof of Reasoning workflow is enforced by a **Role-Based SOP**, ensuring that every resolution undergoes three mandatory verification stages:

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

Cournot structures AI cognition into a Merkle-ized State Machine, allowing for zero-knowledge privacy on inputs and granular fraud proofs on reasoning.

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

* **SOP Action:** The **Collector Agent** is responsible for the "Input" phase. The Collector retrieves real-world evidence strictly according to the predefined data requirements associated with the resolution. Only evidence that satisfies the authoritative source list, freshness constraints, and verifiable retrieval criteria is admitted into the reasoning process. Each evidence item is accompanied by a cryptographic receipt, ensuring provenance and replayability.
* **Technology:** **zkTLS (Zero-Knowledge Transport Layer Security).**
* **Mechanism:** When fetching data (e.g., a tweet or a sports score), the Collector generates a ZK-proof confirming the data originated from the specific server (e.g., `twitter.com`) via a secure TLS session. While zkTLS provides the gold standard for verification, the protocol supports a tiered verification model to accommodate long-tail data sources that may lack modern TLS infrastructure.
* **Tokenomics:** The Collector stakes $COUR on the **Source Integrity**. If the zkTLS proof is invalid, their stake is slashed.

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

* **SOP Action:** The **Auditor Agent** is responsible for the "Processing" phase. The Auditor performs structured reasoning exclusively over:
  * the committed PromptSpec (semantic contract), and
  * the verified evidence set produced by the Collector.
  * Reasoning traces are constrained to reference only admissible evidence and must adhere to the logical rules defined by the semantic specification. This prevents out-of-scope inference, hallucinated inputs, or post-hoc reinterpretation.
* **Technology:** **DSPy-Optimized Chain-of-Thought.**
* **Mechanism:** The Auditor generates a **Merkle-ized Reasoning Trace** — a cryptographic tree structure of the step-by-step log (e.g., Search -> Verify -> Deduce). Only the **Reasoning Merkle Root** is anchored on-chain, allowing for granular, gas-efficient auditing where specific logical fallacies can be proven via a simple Merkle Branch.
* **Tokenomics:** The Auditor stakes $COUR on the **Logical Coherence**. If the reasoning contains fallacies (e.g., concluding "Yes" despite contradictory evidence in the trace), they are penalized.

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

* **SOP Action:** The **Judge Agent** is responsible for the "Output" phase. The Judge maps the reasoning outcome deterministically to the final verdict schema defined in the PromptSpec. The verdict space is closed and predefined, ensuring that resolution outputs are predictable, bounded, and machine-verifiable.
* **Technology:** **Neuro-Symbolic Constraints (Outlines/Logit Locking).**
* **Mechanism:** The Judge enforces strict schema compliance (e.g., mapping the conclusion to `Enum: {YES, NO, INVALID}`). It filters out ambiguity to ensure the smart contract can execute settlement without error.
* **Tokenomics:** The Judge stakes network token on **Schema Compliance**, ensuring the final payload is machine-readable.


# Verifiable Reasoning

Cournot’s Proof of Reasoning (PoR) separates oracle resolution into two distinct trust problems:

1. **Evidence Trust:** whether the protocol collected valid evidence from allowed sources;
2. **Reasoning Trust**: whether the final verdict is correctly derived from the agreed evidence.

PoR already addresses Evidence Trust through **PromptSpec**, **DataRequirements**, and **EvidenceReceipts / EvidenceBundles**. Once evidence has been collected and consensus has been reached on the evidence bundle, Cournot then treats the reasoning step as a separate, bounded computation problem.

#### **Key Design Principle** <a href="#key-design-principle" id="key-design-principle"></a>

Cournot does not initially attempt to verify the entire web retrieval process with opML. Instead, Cournot first freezes the inputs to the reasoning stage:

* semantic specification (PromptSpec)
* finalized evidence bundle
* verdict schema
* reasoning policy (model/runtime constraints)

By fixing these inputs, the protocol creates a **replayable reasoning target**. This makes reasoning verification significantly cheaper and more practical.

#### **Verification Tiers After Evidence Consensus** <a href="#verification-tiers-after-evidence-consensus" id="verification-tiers-after-evidence-consensus"></a>

After evidence has been collected and consensus has been reached on the evidence bundle, Cournot treats the remaining reasoning step as a bounded execution problem with frozen inputs (semantic specification + finalized evidence + verdict schema + reasoning policy). This is where Cournot can introduce a stronger verification lane ("opML" in our terminology) for deterministic replay and adjudication in disputed or high-risk cases.

Recent research supports this design direction from two complementary angles. First, [LLM-42](https://arxiv.org/abs/2601.17768) shows that inference nondeterminism is often a systems-level issue (e.g., dynamic batching, reduction order variability), and proposes a verify-rollback style approach to enforce deterministic behavior more efficiently than fully disabling batching. Second, work on numerical sources of nondeterminism in LLM inference shows that even greedy decoding can diverge due to floating-point precision effects and hardware/runtime configuration differences, especially for reasoning-heavy models. ([paper](https://arxiv.org/abs/2506.09501))

Together, these findings reinforce Cournot’s architecture choice: rather than assuming "temperature=0" is enough, Cournot defines a replayable reasoning target after evidence consensus and applies stronger deterministic verification only when needed.


# Fast & Slow Paths

Cournot utilizes a dual-layer architecture to achieve the "Holy Grail" of oracles: **Instant Finality** backed by **Decentralized Security**. This architecture is explicitly designed to execute and verify the **Proof of Reasoning (PoR)** mechanism described above.

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

#### The Fast Path: Execution of PoR (Sub-Second Settlement) <a href="#the-fast-path-execution-of-por-sub-second-settlement" id="the-fast-path-execution-of-por-sub-second-settlement"></a>

In the fast path, Cournot signs: the final verdict, the reasoning root, and the committed PromptSpec hash governing semantic interpretation. This ensures that downstream consumers can rely on both the outcome and the exact semantic definition under which it was produced.

* **Executor:** **Anchor Nodes** (High-reputation nodes running in Trusted Execution Environments like Intel SGX/TDX).
* **Mapping to Core Mechanism:**
  * **SOP Execution:** The Anchor Node internally spawns the SOP agents (Collector, Auditor, Judge).
  * **PoR Generation:** Within the secure enclave, it executes the full Proof of Reasoning chain: fetching zkTLS proofs, generating the DSPy reasoning trace, and finalizing the deterministic output.
  * **Attestation:** The TEE signs two outputs: the **Final Result** and the **Reasoning Merkle Root**. This cryptographically binds the final judgment to the exact sequence of logic steps that produced it.
* **Result:** Because the hardware guarantees that the SOP was followed exactly as defined, the network accepts this result with **Soft Finality** instantly (<1s).

#### The Slow Path: Verification of PoR (The Security Guarantee) <a href="#the-slow-path-verification-of-por-the-security-guarantee" id="the-slow-path-verification-of-por-the-security-guarantee"></a>

In the slow path, challengers or verifiers can replay resolution by independently validating: the PromptSpec hash (semantic contract), the verified evidence receipts and data requirements, and the reasoning traces against the semantic and evidentiary constraints. This enables deterministic dispute resolution without requiring re-execution of the full reasoning process.

* **Verifier:** Sentinel Nodes (Permissionless community verifiers).
* **Mapping to Core Mechanism:** Sentinels function as active auditors rather than passive voters. Their role is to rigorously validate the **PoR Bundle** generated by the Fast Path through a multi-layered inspection process:
  * **Verify Authenticity:** Sentinels cryptographically validate the **zkTLS proofs** submitted by the Collector, ensuring data provenance is legitimate.
  * **Verify Logic (via opML):** Sentinels scrutinize the **Reasoning Trace**. If a logical flaw is detected (e.g., the Auditor’s deduction contradicts the zkTLS evidence), a **Challenge** is initiated. This triggers an on-chain **opML (Optimistic Machine Learning)** arbitration process. Since the DSPy logic module is deterministic, the opML re-execution must mathematically match the Anchor's output.
  * **Verify Determinism:** Sentinels confirm that the final output adheres strictly to the required schema.
* **Resolution:** If the Anchor's TEE result fails any of these checks, the Anchor's stake is **atomically slashed**, targeting the specific role responsible for the failure (Collector, Auditor, or Judge).
* **The Granular Challenge Mechanism:** Instead of challenging the entire AI outcome, Sentinels utilize **Merkle Proofs** to target a specific contentious step (e.g., *"I challenge Leaf #3: The Auditor ignored the zkTLS timestamp"*).
* **On-Chain Resolution:** The opML contract verifies only the disputed leaf against the on-chain **Reasoning Root**. This **"Pinpoint Verification"** reduces the computational cost of disputes by orders of magnitude, ensuring economic viability even for micro-markets.


# 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 Protocol introduces a **"Confidential Truth"** paradigm, enabling the verification of facts without revealing the underlying raw data. This is achieved through the synergy of **zkTLS** and **TEEs**.

#### **Zero-Knowledge Inputs (zkTLS)** <a href="#zero-knowledge-inputs-zktls" id="zero-knowledge-inputs-zktls"></a>

* **The Challenge:** Traditional oracles require data to be public (e.g., a public API URL) to be verified. This makes it impossible to resolve markets based on private data, such as *"Did I receive a transaction confirmation email from PayPal?"* or *"Is my private bank balance above $1M?"*
* **The Cournot Solution:** 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` via a secure TLS session, and the field `amount` > 1000."*
  * **Privacy Guarantee:** The Collector Node verifies the *proof* of the email, but never sees the *content* of the email. No sensitive PII (Personally Identifiable Information) ever leaves the user's device.

#### **Eyes-Off Reasoning (TEE Confidential Computing)** <a href="#eyes-off-reasoning-tee-confidential-computing" id="eyes-off-reasoning-tee-confidential-computing"></a>

* **The Challenge:** Even if the input is private, sending it to an AI model usually means the model operator (or the node runner) can see it. This "Reasoning Leakage" is unacceptable for institutional use cases.
* **The Cournot Solution:** All Fast Path inference occurs within **Hardware Enclaves (TEEs like Intel TDX / NVIDIA H100 Confidential Computing)**.
  * **Memory Encryption:** The AI model's weights and the user's input data are encrypted in the RAM. Even the physical owner of the Anchor Node server cannot peep into 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."*
  * **Result:** We achieve **"Eyes-Off Reasoning";** the AI judges the case, but no human ever sees the evidence.

#### **Use Case: Private Prediction Markets (Dark Pools)** <a href="#use-case-private-prediction-markets-dark-pools" id="use-case-private-prediction-markets-dark-pools"></a>

This privacy architecture unlocks a new trillion-dollar market: **Enterprise Hedging**.

* *Scenario:* A shipping company wants to hedge against a delay in their specific cargo shipment.
* *Mechanism:* They open a prediction market on Cournot. The 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.**


# Benefits of Determinism

By enforcing deterministic semantics and explicit data requirements, Cournot provides clear benefits across the ecosystem:

* **Greater trust and clarity** for market and application creators,
* **Fewer disputes** through reduced ambiguity,
* **Lower verification costs** via constrained evidence and reasoning,
* **Scalability to long-tail markets** previously too complex to resolve,
* **Internet-scale AI resolution**, where automation does not compromise accountability.

Together, these properties enable AI-native oracles to move beyond headline events and safely resolve the full spectrum of real-world conditions that modern decentralized systems depend on.


# Beyond Prediction Markets

Prediction markets are the **stress test**, not the end state. They are simply the first domain where the limits of oracle resolution become impossible to ignore. Markets that depend on real-world outcomes expose what breaks earliest: ambiguous definitions, contested evidence, slow human adjudication, and opaque decision-making. These failures are not unique to prediction markets, they are structural to **any system that depends on real-world judgment**.

The same resolution bottleneck appears across a wide range of onchain and automated systems. Real-world assets require continuous verification of operational states and external conditions. Parametric insurance depends on precise interpretation of environmental, logistical, or behavioral triggers. Identity and reputation systems must adjudicate claims that are inherently contextual. Compliance automation requires nuanced interpretation of policy thresholds and regulatory events. Autonomous agents coordinating with one another must settle conditions that are not cleanly machine-readable.

In all of these cases, the limiting factor is not demand, liquidity, or composability, it is **interpretation risk**. When outcomes cannot be resolved quickly, cheaply, and transparently, automation stalls and capital hesitates.

Cournot enables these systems by making interpretation itself verifiable. By structuring semantics, constraining evidence, and proving reasoning, Cournot allows judgment-heavy systems to operate with the same reliability that blockchains already provide for deterministic execution.

#### Conclusion <a href="#conclusion" id="conclusion"></a>

> Cournot does not compete with price-feed or data-delivery oracles. Those systems solve a critical problem: connecting blockchains to structured, objective data. What Cournot does is that it completes the oracle stack by enabling blockchains to **understand reality**, not just ingest numbers.

By standardizing semantic definitions, enforcing deterministic data requirements, and producing auditable proofs of reasoning, Cournot transforms oracle resolution from a trust problem into a verification problem. Outcomes no longer depend on who you trust or which authority you defer to, but on whether the resolution can be independently inspected and replayed.

This shift unlocks tangible benefits across the ecosystem:

* fewer disputes and clearer settlement boundaries,
* lower verification and adjudication costs,
* scalable resolution for long-tail and localized markets,
* and safe automation for agents and contracts operating at internet scale.

**Cournot Protocol** is an 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.

By transitioning from "Human Consensus" to **"Proof of Reasoning,"** we are solving the Resolution Bottleneck that has held back prediction markets for a decade.We are bringing **accountability** to AI. With the Cournot Protocol, the Agent Economy gains a Verification Layer that is as fast as the web, as trusted as blockchain, and as intelligent as the best AI models.


# OpenClaw: Proactive Intelligence

Proof of Reasoning (PoR) establishes deterministic semantics, verifiable evidence, and auditable resolution artifacts. With the integration of the OpenClaw agent framework, Cournot extends beyond deterministic settlement into proactive intelligence infrastructure for the Agent Economy.

OpenClaw enables Cournot to operate not only as a resolution engine, but as a continuous perception and arbitration layer for real-world events.

#### Event-Driven Settlement

Traditional prediction markets rely on scheduled oracle queries or manual settlement triggers. This creates resolution lag, a structural delay between when an outcome becomes publicly clear and when the market is formally settled on-chain. During this lag window, stale information can distort pricing, incentives, and user trust. OpenClaw agent enables a persistent monitoring layer.

Instead of polling predefined endpoints at fixed intervals, OpenClaw agents continuously observe structured and unstructured data streams, including:

* Official status pages
* Regulatory disclosures
* Social media feeds (e.g., X)
* RSS updates
* On-chain contract events
* Infrastructure and server status changes

When a trigger condition defined in the PromptSpec or DataRequirements is detected, the Watchdog layer activates the PoR pipeline immediately. This enables

* Event-driven settlement instead of time-based settlement
* Reduced latency between real-world occurrence and oracle activation
* Elimination of extended stale-information windows
* Improved alignment between market state and ground truth

Importantly, OpenClaw accelerates detection while preserving semantic and evidentiary constraints.

#### Autonomous Dispute Arbitration

In conventional optimistic oracle systems, disputes are resolved through token-weighted voting or human arbitration, often within 24-72 hour windows. These systems are attention-dependent and can introduce governance risk, coordination latency, and incentive distortions.

With OpenClaw agents, Cournot augments its dispute framework with autonomous, bounded, AI-native arbitration. When a Sentinel Node or challenger initiates a dispute, the system transitions from standard verification into an adversarial review process powered by OpenClaw agents.

The dispute workflow includes three deterministic layers:

**1. Social Forensics & Extended Evidence Discovery**

OpenClaw agents analyze unstructured and semi-structured sources that may not have been part of the initial EvidenceBundle but are permitted under the DataRequirements policy. This may include:

* Archived web snapshots
* Forum discussions
* Discord or community logs
* Official video transcripts
* Regulatory clarifications

All additional evidence must satisfy authentication and receipt verification requirements before inclusion. The goal is not discretionary exploration, but structured forensic completeness within the predefined semantic contract.

**2. Adversarial Multi-Agent Review**

Rather than relying on popularity or token-weighted consensus, OpenClaw initiates a bounded adversarial evaluation process. Competing agents:

* Analyze the contested Reasoning Trace
* Attempt to identify logical inconsistencies
* Validate semantic rule adherence
* Check constraint compliance

This process remains artifact-constrained. Agents can only operate on:

* The committed PromptSpec hash
* Verified EvidenceBundle
* The submitted Reasoning Trace

This preserves deterministic boundaries while increasing review robustness.

**3. Contextual opML Replay**

If a factual inconsistency or reasoning error is detected (e.g., incorrect timestamp interpretation or semantic misclassification), the Digital Jury generates a corrected context bundle. This triggers a pinpoint opML-based verification step, replaying only the disputed artifact rather than recomputing full inference across multiple nodes. This ensures:

* Bounded dispute cost
* Deterministic correction path
* Cryptographically provable arbitration outcome

The dispute process therefore becomes verification-driven rather than vote-driven.

#### Architectural Implications

With OpenClaw integration, Cournot gains two structural extensions:

1. **Proactive perception**: enabling event-triggered oracle activation.
2. **Deterministic forensic arbitration**: enabling AI-native, bounded dispute resolution.

Crucially, OpenClaw extends the capabilities of Proof of Reasoning. While PoR guarantees semantic and evidentiary determinism, OpenClaw guarantees timely detection and robust adversarial validation. OpenClaw transforms Cournot from a passive settlement oracle into an active intelligence layer capable of:

* Continuous event monitoring
* Reduced latency finality
* Structured adversarial review
* Scalable long-tail resolution

This architecture enables prediction markets, autonomous agents, and on-chain systems to operate with verifiable, auditable, and proactive real-world awareness.


# Tokenomics: Atomic Accountability

The **network token** serves as the **cryptoeconomic bond of truth**. It operationalizes the **Proof of Reasoning** by attaching financial liability to every step of the AI verification process.

#### Role-Based Staking (The Core Utility) <a href="#role-based-staking-the-core-utility" id="role-based-staking-the-core-utility"></a>

Unlike monolithic staking in traditional oracles, Cournot utilizes **Atomic Staking**. Token bonds are mapped directly to the specific roles in the SOP, ensuring precise accountability:

* **Collector Stake (Input Layer):** Agents must stake **network token** to submit data. If the **zkTLS proof** is proven invalid, this stake is slashed.
* **Auditor Stake (Logic Layer):** Agents must stake **network token** to perform reasoning. If the **DSPy Logic Trace** contains fallacies (verified via opML), this stake is slashed.
* **Anchor Grand Stake (Infrastructure):** TEE Nodes post a substantial bond. If the TEE attestation is compromised, the bond is burned.

**Impact:** This structure isolates risk. A data fetching error penalizes only the Collector, not the Auditor, encouraging specialized, high-quality participation.

#### Strategy Mining (SOP-as-an-Asset) <a href="#strategy-mining-sop-as-an-asset" id="strategy-mining-sop-as-an-asset"></a>

Cournot transforms AI logic into a tradeable asset class, incentivizing continuous evolution of the network's intelligence.

* **Mechanism:** Developers mint optimized **SOP Workflows** (e.g., *"NBA Conflict Resolution Strategy"*) as NFTs.
* **Utility:** When nodes use a specific Strategy NFT to resolve a market, a micro-royalty in **network token** is paid to the creator.
* **Result:** A decentralized "App Store" for reasoning logic.

#### Dual-Engine Rewards <a href="#dual-engine-rewards" id="dual-engine-rewards"></a>

To support the **Fast/Slow Path** architecture, incentives are split:

1. **Anchor Yield (Stability):** Anchors (Fast Path) receive predictable, salary-like rewards to subsidize high-performance TEE hardware and low latency.
2. **Sentinel Bounties (Security):** Sentinels (Slow Path) operate on a "Whistleblower" model. They earn significant bounties only when successfully challenging a malicious Anchor or performing random audits.

**Cournot Protocol** is building the cognitive infrastructure for the next generation of the internet. By transitioning from "Human Consensus" to **"Proof of Reasoning,"** we are solving the Resolution Bottleneck that has held back prediction markets for a decade.

We are not just bringing AI on-chain; we are bringing **accountability** to AI. With the Cournot Protocol, the Agent Economy gains a Verification Layer that is as fast as the web, as trusted as blockchain, and as intelligent as the best AI models.


# Partner Public API

## Background

Cournot is an AI-driven oracle for prediction-market resolution. For every market it covers, Cournot produces a final settlement record — verdict, confidence tier, and on-chain proofs — and makes that record publicly auditable by both Partners and end users.

Partners use Cournot as the source of truth for resolving their own markets: once Cournot publishes a verdict, the Partner pulls that record and uses it to settle the corresponding market on their platform.

Two public endpoints support this:

* **`get_public_market`** — anonymous read. Look up a market by `slug` + `source` and return its public record (status / verdict / confidence / proofs / disputes). The primary endpoint Partners call to drive their own resolution.
* **`submit_dispute`** — Partner-authenticated write. If an end user disagrees with a Cournot verdict, the Partner backend can file a dispute on their behalf.

The `source` value is a Partner-specific identifier issued by Cournot at integration time. Each Partner uses its own dedicated value; it is not a public enum.

## Typical integration flow

The primary loop: Partner pulls Cournot's verdict and settles its own market.

```
   Partner backend                                                        Cournot
        │                                                                    │
        │  GET /markets/public?slug=...&source=...                           │
        │ ─────────────────────────────────────────────────────────────────► │
        │ ◄────── { markets:[{ status, verdict, confidence, proofs }] } ──── │
        │                                                                    │
        │  (status = resolved → settle the corresponding Partner market)     │
        │                                                                    │
```

* Poll `get_public_market` for the relevant market. When `status = resolved`, `verdict` / `confidence` / `proofs` are populated.
* Use the returned record to settle the Partner-side market. On-chain `proofs` can be surfaced to end users for auditability.
* No authentication is required for this loop.

## Dispute flow (optional)

If an end user disputes a Cournot verdict, the Partner backend can file the dispute and observe its outcome through the same `get_public_market` endpoint.

```
   end user (Partner)                  Partner backend                    Cournot
        │                                     │                              │
        │   "I disagree with this verdict"    │                              │
        │ ──────────────────────────────────► │                              │
        │                                     │  POST /markets/dispute/      │
        │                                     │       submit                 │
        │                                     │ ───────────────────────────► │
        │                                     │ ◄───── { dispute_id } ────── │
        │                                     │                              │
        │  (later — anyone, no auth)                                         │
        │                                                                    │
        │  GET /markets/public?slug=...&source=...                           │
        │ ─────────────────────────────────────────────────────────────────► │
        │ ◄────── { markets:[{ ..., disputes:[{ ..., decision }] }] } ────── │
```

* Once a dispute is filed, the market transitions from `resolved` to `disputed` and Cournot starts an internal review.
* After the review, the market becomes `closed` and the dispute carries a `decision` — `keep` retains Cournot's verdict, `override` adopts the submitter's selection.
* Partner reads the dispute's progress and final decision via `get_public_market`. Disputes are returned inline as a sub-resource on the market — there is no separate dispute-read endpoint.

## Response envelope

All responses share the same envelope and **always return HTTP 200**. Success vs. failure is signalled by the `code` field, not the HTTP status code.

**Success:**

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

**Error:**

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

| field    | type   | description                                                |
| -------- | ------ | ---------------------------------------------------------- |
| `code`   | int    | `0` = success; non-zero = error                            |
| `msg`    | string | human-readable message                                     |
| `data`   | object | present on success; carries the endpoint payload           |
| `detail` | string | present on error; additional detail (often equal to `msg`) |

**Integration note:** do not branch on HTTP status. Read `code` — `0` means success and `data` is populated; any other value means the request failed and `msg` / `detail` describe why.

The endpoint specs below describe the contents of `data`.

## 1) get\_public\_market

Look up a market's public record by `slug` + `source`. This is a **market endpoint**: it returns the market's status / verdict / confidence / on-chain proofs, with disputes embedded as a sub-resource on the market. Disputes appear here because they belong to the market — there is no separate dispute-read endpoint.

|            |                           |
| ---------- | ------------------------- |
| **Method** | `GET`                     |
| **Path**   | `/cournot/markets/public` |
| **Auth**   | none (anonymous)          |

**Query params**

| field    | type   | required | description                                  |
| -------- | ------ | -------: | -------------------------------------------- |
| `slug`   | string |      yes | market slug (no leading/trailing `/`)        |
| `source` | string |      yes | Partner-specific source id issued by Cournot |

**`data.markets[]` (`market_item`)**

| field         | type                       | description                                          |
| ------------- | -------------------------- | ---------------------------------------------------- |
| `id`          | int64                      | market id                                            |
| `source`      | string                     | request source                                       |
| `slug`        | string                     | request slug                                         |
| `status`      | string                     | `monitoring` · `resolved` · `disputed` · `closed`    |
| `verdict`     | string                     | final verdict                                        |
| `resolved_at` | string                     | RFC3339 UTC, e.g. `2026-04-28T10:30:00Z`             |
| `confidence`  | string                     | `VERY_HIGH` · `HIGH` · `MEDIUM` · `LOW` · `VERY_LOW` |
| `reasoning`   | string                     | human-readable explanation of the verdict            |
| `proofs`      | `proof_item[]`             | on-chain proofs                                      |
| `disputes`    | `dispute_item[]` \| `null` | dispute list; `null` when the market has no disputes |

**`proof_item`**

| field     | type   | description    |
| --------- | ------ | -------------- |
| `chain`   | string | `base` · `bsc` |
| `tx_hash` | string | tx hash        |

**`dispute_item`**

| field                 | type             | description                               |
| --------------------- | ---------------- | ----------------------------------------- |
| `id`                  | int64            | dispute id                                |
| `status`              | string           | `open` · `closed`                         |
| `submitter_selection` | string           | submitter's claimed outcome               |
| `reason_text`         | string           | dispute reason                            |
| `submitted_at`        | string           | RFC3339 UTC                               |
| `decision`            | object \| `null` | present only when the dispute is `closed` |

**`decision`**

| field                   | type   | description                                                   |
| ----------------------- | ------ | ------------------------------------------------------------- |
| `type`                  | string | `keep` · `override`                                           |
| `partner_final_verdict` | string | `override` → `submitter_selection`; `keep` → market `verdict` |
| `reason_text`           | string | decision reason                                               |
| `decided_at`            | string | RFC3339 UTC                                                   |

**Example**

```bash
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"
```

```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 based on source evidence",
            "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"
            }
          }
        ]
      }
    ]
  }
}
```

When the market has no disputes, `disputes` is `null` (not `[]`). When no market matches `slug` + `source`, `data.markets` is `[]`.

## 2) submit\_dispute

File a dispute on behalf of an end user on the Partner platform.

|                  |                                          |
| ---------------- | ---------------------------------------- |
| **Method**       | `POST`                                   |
| **Path**         | `/cournot/markets/dispute/submit`        |
| **Auth**         | header `x-api-key: YOUR_PARTNER_API_KEY` |
| **Content-Type** | `application/json`                       |

**Request body**

| field                 | type   | required | description                                                 |
| --------------------- | ------ | -------: | ----------------------------------------------------------- |
| `market_id`           | int64  |      yes | market id                                                   |
| `submitter_id`        | string |      yes | end user's unique id on the partner side                    |
| `submitter_name`      | string |      yes | submitter display name                                      |
| `submitter_selection` | string |      yes | outcome the submitter claims is correct (e.g. `YES` / `NO`) |
| `reason_text`         | string |      yes | dispute reason                                              |
| `submitted_at`        | string |      yes | RFC3339 UTC; if omitted/invalid, server uses current time   |

**`data` (response payload)**

| field        | type  | description        |
| ------------ | ----- | ------------------ |
| `dispute_id` | int64 | created dispute id |

**Business rules**

* `x-api-key` must be valid.
* The partner's `source` (resolved from the API key) must equal the market's `source` — no cross-partner disputes.
* Only markets with `status = resolved` can be disputed.
* A market can have at most one dispute (a second submission errors out).

**Example**

```bash
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"
  }'
```

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