> For the complete documentation index, see [llms.txt](https://docs.cortensor.network/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.cortensor.network/roadmap/technical-roadmap-2026-network-launch-and-agentic-ai-infrastructure/corgent-2026-roadmap-virtual-trust-oracle-on-cortensor.md).

# Corgent 2026 Roadmap – Virtual Trust Oracle on Cortensor

<mark style="color:$warning;">**THE ROADMAP BELOW IS SUBJECT TO CHANGE OR ADJUSTMENT. THIS IS STILL A DRAFT.**</mark>

***

### Overview

**Corgent** is a Virtual-native service agent built on top of the **Cortensor Network**.

Inside the Virtual ecosystem, Corgent provides:

* **Delegation-as-a-Service** – send tasks to Cortensor miners with explicit reliability tiers.
* **Validation-as-a-Service** – verify agent outputs using Cortensor’s PoI/PoUW and reputation.
* **Arbitration-as-a-Service** – resolve disputes using oracle-grade replays and consensus.

Corgent runs on top of:

* **Cortensor miners** – decentralized inference.
* **Cortensor validators** – Proof of Inference (PoI) and Proof of Useful Work (PoUW).
* **Router Node evolution** – v1.x → v1.5 → v1.6 → v2.0 as the execution and validation surface.

Cortensor’s DevNets, Testnet-0/1, Mainnet-Lite (Arbitrum L2) and Mainnet-Full (COR L3) define **where** Corgent can execute.\
This roadmap focuses on **how Corgent evolves throughout 2026** inside the Virtual / ACP / ERC-8004 agent ecosystems:

* How it integrates with **GAME** and **ACP**.
* How it uses **x402** and **ERC-8004**.
* How it matures from a “thin wrapper” into a **data-driven trust oracle**.

> Cortensor provides **compute + proofs**.\
> **Corgent learns how to apply them for agents, markets, and disputes.**

***

### 0. Ongoing (Now → Q1 2026) – Testnet Experiments & Data Foundations

**Objective**\
Use Cortensor DevNet/Testnet to make Corgent actually useful as an **experimental trust agent**, and start collecting the data needed for real validation logic.

**Aligned Cortensor phases**

* Late DevNet → **Testnet Phase #1** preparation.
* Router Node v1 with experimental **MCP** and **x402** endpoints.

#### Key Goals

**Agent Logic Prototyping**

* Implement Corgent as a **GAME Worker/Function** in Virtual:
  * `delegate_to_corgent(task, policy)`
  * `validate_with_corgent(task, claimed_result)`
* Wire Corgent to **Cortensor Testnet** (DevNets, Testnet-0, Testnet-1).
* Treat Corgent as a **smart Router client** that:
  * Opens and uses sessions with prepaid budgets.
  * Submits tasks via Router Nodes.
  * Requests redundancy (N miners per task).
  * Collects PoI/PoUW and reputation signals.

**ACP & x402 Integration (Early)**

* Define how **ACP buyers/sellers** can “escalate to Corgent” for:
  * Higher-trust execution.
  * Independent validation of claimed results.
  * Early dispute-handling prototypes.
* Prototype **x402 pay-per-call flows**:
  * Virtual → Corgent → Cortensor Router (`/completions`, etc.).
  * Log usage, cost, and policy tier per call.

**Data & Telemetry**

Start logging:

* Task type, policy, and context.
* Miner outputs and PoI/PoUW metrics (when enabled).
* Corgent verdicts (`VALID`, `INVALID`, `RETRY`, `NEEDS_SPEC`) and confidence.

Build the **first Corgent dataset** of agent interactions + validation decisions.

**Early Validation Experiments**

* Test simple rules on live testnet workload:
  * PoI similarity thresholds.
  * Basic usefulness rubrics (coverage, structure, constraint adherence).
  * Schema + PoI combinations for tool-call outputs.
* Identify failure modes:
  * Miners disagree but verdict is still `VALID`.
  * Policies that are too strict or too lax.
  * Where Corgent should return `NEEDS_SPEC` instead of forcing a binary verdict.

***

### Q1 2026 – Corgent v0.1: Spec & Stable Testnet Agent

**Objective**\
Formalize Corgent’s role in the Virtual ecosystem and ship a **stable v0.1 agent** on Cortensor Testnet.

**Aligned Cortensor phases**

* **Testnet Phases #1–2** – system integration and app E2E testing.
* Router Node **v1.5 (shadow mode)** – MCP + x402 enabled on the Router surface.

#### Corgent Spec (High-Level)

Publish an internal **Corgent specification** that defines:

* Scope and guarantees:
  * What Corgent does (delegation, validation, arbitration hooks).
  * What Corgent does **not** do (planning, creative reasoning, miner/validator duties).
* Core APIs:
  * `delegate_to_corgent(task, policy)`
  * `validate_with_corgent(task, claimed_result)`
  * Early hooks for dispute / arbitration.
* How Corgent uses **Cortensor PoI/PoUW** in practice:
  * Deterministic vs non-deterministic tasks.
  * Structured (JSON/tool calls) vs unstructured text.
  * Fast vs Safe vs Oracle-grade patterns.

#### Corgent v0.1 on Testnet

Harden Corgent’s **baseline call patterns**:

* `delegate_to_corgent` with **Fast/Safe** policies.
* `validate_with_corgent` for:
  * Deterministic / structured outputs.
  * Simple JSON / schema / format validation.

Integrations:

* **GAME** – Corgent as a reusable Worker/Function.
* **ACP** – Corgent as an experimental trust oracle for small, curated markets.

#### Data & Metrics

Define mandatory telemetry:

* Task type, chosen policy, miners/models used.
* PoI/PoUW metrics (where available).
* Decision + confidence + whether escalation occurred.

Run offline analysis to detect:

* Over-confidence zones (high confidence, low reliability).
* Frequent miner disagreement patterns.
* Where `RETRY` or `NEEDS_SPEC` is more appropriate than a hard `VALID` / `INVALID`.

***

### Q2 2026 – Corgent v0.2: Validation Engine & Scoring Models

**Objective**\
Evolve Corgent from a “thin wrapper over Cortensor” into a proper **validation engine** with configurable, data-driven policies.

**Aligned Cortensor phases**

* **Testnet Phases #3–4** – `/validate` endpoint, PoI/PoUW integration, ERC-8004 alignment.
* **Router Node v1.6** – `completions + validate`, fully **ERC-8004 agent-ready** so any developer or node operator can spawn their own Router-backed agents and services.

#### Validation & Scoring

Introduce **tiered validation policies**:

* **Fast** – 1 miner, light checks, minimal overhead.
* **Safe** – 3 miners, PoI consensus + basic usefulness checks.
* **Oracle** – 5+ miners, stricter PoI/PoUW thresholds + diversity sampling.
* **Adaptive** – start cheap and escalate redundancy when confidence is low.

Build Corgent’s **scoring layer**:

* Use configurable usefulness rubrics per task type:
  * Summaries, classification, reasoning, code, tool-calls, etc.
* Combine:
  * PoI similarity (embedding distance, cluster stability).
  * PoUW-style usefulness / adherence scoring.
* Add outlier detection for suspicious or inconsistent miner outputs.

#### Data-Driven Development

Use Testnet logs to:

* Tune thresholds and policy mappings per task family.
* Design and iterate rubrics for the most common task categories.
* Identify where human labels, reference data, or domain heuristics are needed.

Run **A/B tests on Testnet** for:

* Different scoring strategies (PoI-heavy vs semantic-heavy profiles).
* Different redundancy levels (3 vs 5 vs 7 miners) and their cost/performance trade-offs.

#### Developer-Facing Changes

Update Corgent docs with:

* Recommended default policies:
  * e.g. Fast for cheap content, Safe for user-visible output, Oracle for financial/on-chain decisions.
* Examples of how **status + confidence + evidence** should drive agent behavior (accept, retry, escalate, request spec refinement).

Provide sample **dashboards** for:

* Tier usage.
* Miner disagreement and escalation rates.
* Top validation failure reasons and common error patterns.

***

### Q3 2026 – Corgent v0.5: Virtual’s Default Trust Oracle

**Objective**\
Make Corgent the **default trust surface** for Virtual agents: the normal way to request high-trust compute, validation, and simple dispute handling.

**Aligned Cortensor phases**

* **Mainnet-Lite (Arbitrum L2 Alpha)** – first production environment.
* Router evolution toward **v2.0** (Corgent-class Router on L2).
* Early integration with **Virtual**, **ACP**, and **ERC-8004 agents**.

#### Virtual / GAME Integration

Ship a **Corgent v0.5 Worker/Function bundle**:

* Plug-and-play support for most GAME Agents.
* Ready-made examples:
  * High-trust summarization pipelines.
  * Guardrail validation before taking actions (payments, state changes, irreversible writes).
  * Tool-call / JSON schema validation before committing.

Provide **recipe-style patterns**:

* “High-trust summary with fallback.”
* “Validate structured output before paying an ACP seller.”
* “Check another agent’s result or trajectory before adopting it.”

#### ACP & Disputes (Phase 1)

Use Corgent as **first-line validation** in ACP:

* Pre-settlement checks on claimed outputs.
* “Soft” disputes where the buyer primarily wants:
  * A re-run under a clearer policy.
  * Comparison against consensus and spec.

Define an initial **dispute flow**:

* When buyer/seller can escalate to Corgent.
* Structure of the **evidence bundle** (consensus outputs, outlier flags, constraint verdicts).
* How ACP interprets:
  * `VALID` / `INVALID` / `RETRY` / `NEEDS_SPEC`.

#### Reliability & Internal SLAs

Set internal (non-public) targets for:

* Latency per policy tier.
* Error/failure and escalation rates.
* Cost envelopes for Adaptive mode.

Use the v0.5 rollout to refine:

* **Rate limiting**, backpressure, and safety controls.
* **x402 billing paths** from Virtual → Corgent → Cortensor Router.

***

### Q4 2026 – Corgent v1.0: Arbitration, Trajectories & Long-Horizon Trust

**Objective**\
Extend Corgent beyond single responses into **full arbitration** and **multi-step trajectory validation** for long-running agents and markets.

**Aligned Cortensor phases**

* **Mainnet-Full (COR L3 Beta)** – COR-native, low-cost environment for high-volume validation.
* Mature **Router v2.0 / Corgent core** operating on L3.

#### Arbitration-as-a-Service (Full Flow)

Implement oracle-grade **arbitration**:

* 5+ miners with diversity:
  * Different regions, hardware, and model variants.
* Tighter PoI/PoUW thresholds tuned from Testnet + L2 experience.
* Rich evidence bundles:
  * Consensus outputs and cluster stats.
  * Outlier analysis and miner-level behavior.
  * Constraint/spec compliance.
  * Human-readable summaries for agents, UIs, and integrators.

Corgent becomes a **binding dispute oracle** for selected ACP markets, according to ACP rules and governance.

#### Trajectory & Chain-of-Thought Checks

Allow agents to submit:

* Intermediate reasoning traces and tool sequences.
* Full task trajectories for **post-hoc audits** or **live monitoring**.

Design policies that:

* Reward **stable, consistent, non-deceptive reasoning**.
* Penalize degenerate, circular, or obviously fabricated chains.
* Detect when agents simply repeat known consensus without meaningful work.

#### Long-Horizon & COR L3 Alignment

As Cortensor’s **COR L3** environment comes online:

* Route high-volume validations and arbitrations to L3 by default.
* Treat Corgent verdicts as **long-lived trust artifacts**:
  * Reusable across sessions and over time.
  * Referencable by other Virtual agents, ERC-8004 agents, and on-chain systems.

***

### Summary Timeline (Corgent Focus)

| Period        | Corgent Milestone       | Key Focus Areas                                                        |
| ------------- | ----------------------- | ---------------------------------------------------------------------- |
| Now → Q1 2026 | **Corgent Experiments** | GAME/ACP wiring, x402 prototypes, data & telemetry foundations         |
| Q1 2026       | **Corgent v0.1**        | Spec, stable Testnet agent, basic delegate/validate flows              |
| Q2 2026       | **Corgent v0.2**        | Tiered validation, scoring engine, data-driven thresholds              |
| Q3 2026       | **Corgent v0.5**        | Virtual’s default trust oracle, ACP soft disputes, production recipes  |
| Q4 2026       | **Corgent v1.0**        | Arbitration-as-a-Service, trajectory checks, COR L3 long-horizon trust |

***

### Alignment Table – Cortensor Network vs. Corgent

This table aligns the **Cortensor 2026 network roadmap** with **Corgent’s 2026 milestones**, so both can be read as a single story.

| Timeframe              | Cortensor (Network / Router)                                                  | Corgent (Trust Oracle)                          | Integration Notes                                                                                        |
| ---------------------- | ----------------------------------------------------------------------------- | ----------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| Q1 2026                | Testnet Phases #1–2 (system integration, app E2E testing)                     | **v0.1 – Spec & stable Testnet agent**          | Corgent runs on Testnet; uses early Router v1.5 (MCP/x402 experiments).                                  |
| Early–Mid Q2 2026      | Testnet Phases #3–4 (`/validate`, PoI/PoUW, ERC-8004 alignment, COR Prover)   | **v0.2 – Validation engine & scoring**          | Corgent uses `/validate`, adopts tiered policies; Router v1.6 is fully ERC-8004 agent-ready.             |
| Mid Q2 → Early Q3 2026 | Mainnet preparation (Stake-to-Use, Pay-Per-Use, audits, infra readiness)      | v0.2 → **v0.5 transition**                      | Corgent policies harden in preparation for real production traffic.                                      |
| Early Q3 2026          | **Mainnet-Lite (Arbitrum L2 Alpha)** – Router Agent v1.5 live                 | **v0.5 – Default trust oracle in Virtual**      | Virtual and ERC-8004 agents start using Corgent on L2 for high-trust compute and validation.             |
| Mid–Late Q3 2026       | Agentic integration (Virtual, ACP, ERC-8004 agents), Router v2.0 scaling      | v0.5 – ACP Phase 1 disputes & trust recipes     | Corgent is the standard trust surface for Virtual and ERC-8004 agent ecosystems.                         |
| Q4 2026                | **Mainnet-Full (COR L3 Beta)** – COR-native agent execution & large-scale PoI | **v1.0 – Arbitration & trajectories on COR L3** | Corgent’s heavy validation and arbitration flows move to L3 for low-cost, high-volume, long-horizon use. |

***

### Why Corgent Matters for Virtual & Cortensor

Corgent is **not** a replacement for GAME’s logic or agent reasoning:

* **GAME** remains the *brain* – it plans, sets goals, orchestrates tools, and decides actions.
* **Corgent** is invoked whenever an agent wants:
  * Higher confidence before acting.
  * Independent verification of another agent’s result.
  * A neutral oracle for disputes or high-stakes decisions.

For the **Virtual ecosystem**:

* Corgent provides a **standard trust oracle service** that any Virtual or ACP agent can call.
* Agents no longer need to trust a single model run – they can rely on **redundant inference + PoI/PoUW validation**.
* Complex agent markets can use Corgent’s verdicts as **shared, neutral ground truth**.

For the **Cortensor network**:

* Corgent is the **agent-facing expression** of Cortensor’s core value: verifiable inference.
* It turns miners, validators, PoI, and PoUW into **usable APIs and verdicts**.
* It creates a natural demand loop:
  * More agents → more delegated tasks → more miner work → richer validation data → stronger trust.

For the broader **agentic + Web3 stack** (Virtual, ERC-8004 agents, dApps, protocols):

* Corgent provides a network-native way to:
  * Delegate tasks to decentralized inference.
  * Verify outputs with both quantitative and qualitative checks.
  * Resolve disputes without relying on a central operator.

In practical terms:

> The **2026 Cortensor roadmap** makes verifiable, scalable AI infrastructure real.\
> The **2026 Corgent roadmap** makes that verifiability directly consumable by agents, dApps, and markets.