# 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.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.cortensor.network/roadmap/technical-roadmap-2026-network-launch-and-agentic-ai-infrastructure/corgent-2026-roadmap-virtual-trust-oracle-on-cortensor.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.