Cortensor Announcements

🧪 Phase #4 Starts Now Cortensor's most advanced testing phase is live. We're entering a 1-week grace period - node ops can still sign up and join through next week. What's in Phase #4: 🔹 Dynamic Node Shuffling Randomized precommit selection ensures fairness and fault tolerance - key for trustless execution. 🔹 Full User Task Pipeline Under Load End-to-end stress testing across: Node Pool ➝ Session Queue ➝ Task Stats ➝ Session Stats ➝ Reputation. 🔹 Session UI Updates Improved orchestration view (ack → precommit → commit) + UX refinements based on alpha feedback. 🔹 Router Node API + Reverse Proxy Production-ready Web2/Web3 integration - including API key auth, SSL proxy, and raw prompt support. 🔹 Multi-Oracle per Network Starts with 2 oracles per network, scaling to 4 - each rotating leadership every 15 mins for better fault tolerance and reliability. 🔹 L3 Experimentation L3 remains our main stress testing ground as Arbitrum Sepolia continues to face instability. We may transition fully to L3 in Phase #5 if conditions persist. 🔹 Mini Hackathon (Internal) Community members are helping surface missing features and fix bugs across DevNet5/6 - a prep step toward more structured hackathons ahead. 📚 Details: https://docs.cortensor.network/community-and-ecosystem/community-testing/closed-alpha-testing-phase-4 📊 Stats: https://dashboard-devnet5.cortensor.network/stats/heatmap/rank/table 🔧 Installer: https://github.com/cortensor/installer 💬 Discord: https://discord.gg/cortensor Let the trustless AI infra stress test begin. https://x.com/cortensor/status/1933770543771365447

Cortensor Q2 Recap – Progress Through Pressure Q2 was about pushing boundaries - scaling stress tests, resolving real-world bugs, and laying the foundation for a decentralized AI execution layer. Here’s a high-level recap of what we shipped, improved, and what’s next: 🔹 (1/5) Closed Testing Milestones Phase #3 and #4 pushed hundreds of nodes and thousands of inference tasks through real-world E2E flows. Each bug revealed a breakpoint we resolved. 🔹 (2/5) Core Reliability Upgrades We introduced task queuing for Miner and Router nodes, fixed session state bugs, enforced version alignment, and stabilized the full task lifecycle from submission to response. 🔹 (3/5) Community-Led Momentum 183M+ $COR staked (52.48% of circulating), the first internal hackathon launched, contributor tools added to the ecosystem repo, and website v1.5 rolled out with improved onboarding and documentation. 🔹 (4/5) Protocol Design in Motion PoI & PoUW oracles are being designed for testnet, network task levels will unlock smarter routing, and our session-based payment module PoC is live - laying the groundwork for a sustainable inference economy. 🔹 (5/5) What’s Next We'll complete two final closed phases (#5 and #6) to polish user-side flows, inference reliability, and economic integrations - setting the stage for testnet and real-world application usage. 📖 Key Docs: • Ecosystem Flow: https://docs.cortensor.network/community-and-ecosystem/ecosystem-flow • Developer Ecosystem: https://docs.cortensor.network/community-and-ecosystem/developer-ecosystem 🔗 Read Full Thread: https://x.com/cortensor/status/1941304850203173041

🧪 Phase #4 Recap – Trustless AI Infra Under Load Phase #4 was Cortensor's most advanced testing phase yet - pushing live task routing, payment flows, multi-oracle sync, and node diversity under real conditions. 🔹 Live User Task Pipeline End-to-end tested: session deposit → credit allocation → task execution → node payout via $COR. First user task payments confirmed on-chain. 🔹 Internal Mini-Hackathon Five working apps built in two weeks, surfacing critical edge cases and driving UX fixes across the task pipeline. 🔹 User Task Flow Polishing Internal testing helped refine session states (ack → precommit → commit), ranking logic, and failure handling. 🔹 Dynamic Node Shuffling Randomized miner selection through precommit rotation improved fault tolerance and load distribution. 🔹 Router Node REST API + Reverse Proxy Apps tested against production-ready API with full SSL support, key-based auth, raw prompts, and flexible proxy routing. 🔹 Multi-Oracle Coordination 2–4 oracles per network with 15-minute rotation cycles now live for sharded validation and leader election. 🔹 SessionPayment Module Tested in a loose OracleV3-triggered mode for credit and payout flows. Will evolve toward tighter contract-to-contract logic. 🔹 CognitiveLevel PoC Deployed on DevNet6. Begins groundwork for SLA, model-aware routing, and node classification by performance. 🔹 NodeVersion Tracking New module added to track historical node versions for better debugging, filtering, and upgrade management. 🔹 DevNet6 Migration All major modules moved to DevNet6 for deeper iteration and Phase #5 preparation. 📊 Stats: https://dashboard-devnet5.cortensor.network/stats/heatmap/rank/table Phase #5 will tighten, automate, and scale toward a resilient testnet. https://x.com/cortensor/status/1944674790775873940

🧪 Phase #5 Starts Now Cortensor's most advanced testing phase is here - SLA logic, Node Level classification, L3 rollup flows, and Validator scoring now active. We're entering a 1-week grace period - node ops can still join and test ahead. What's in Phase #5: 🔹 SLA-Based Node Assignment (v1) - Session creation now supports SLA tiers (Low / Medium / High) - NodePool selects based on actual Node Level with new fallback logic - More testing + algorithm refinement during Phase #5 🔹 Validator v1 + Node Level Runtime - Validator tracks task success/failure across nodes - Upgrade/downgrade logic now live after 10+ valid results - Phase #5 will improve scoring precision and thresholds 🔹 CognitiveLevel – Adaptive Node Categorization - Miner-side logic active to classify node level by task performance - Supports smart routing and recursive inference - Validator-side SLA enforcement under testing 🔹 SessionPayment – Light Payment Flow - Loosely coupled, event-driven payout tested end-to-end - COR-based payments run on Sepolia - Phase #5 to explore tighter integration via contract-to-contract flow 🔹 Dual Testnet Environment - Testnet-0: Arbitrum Sepolia (full-stack setup: wallet + task pipeline) - Testnet-1: L3 Rollup (COR as gas) with oracles + miners live - Stress testing L3 pipeline + dashboard + blockchain module updates 🔹 User Task Mode Flexibility - Dedicated Node: Now supports multi-model setup (e.g., LLaMA 3.1, DeepSeek-R1) - Ephemeral Node: Starting support for longer reservation and model switching - More iteration expected to reach production readiness 🔹 UX + Dashboard Updates - Session creation flow now includes SLA configuration - Additional UI updates in progress for node stats, L3 interaction, and clarity 📍 Node Level View: https://devnet6.cortensor.network/node-level 🌉 L3 Bridge: https://cortensor-testnet-1-32ph80a02h-01acc12814e9cea3.testnets.rollbridge.app 🔎 L3 Explorer: https://testnet1.explorer.cortensor.network 📚 Docs: https://docs.cortensor.networ

🧪 Phase #5 Recap – Scaling Toward Testnet Readiness Phase #5 pushed Cortensor through its most advanced testing so far, focusing on SLA-driven routing, validator scoring, memory-aware orchestration, and ecosystem stress. 🔹 SLA-Based Node Assignment (v1) - Session creation now supports SLA tiers (Low / Medium / High) - NodePool selects based on Node Level with fallback logic - More refinement done during live testing to improve routing fairness 🔹 Validator v1 + Node Level Runtime - Validator tracked task success/failure across nodes - Upgrade/downgrade logic applied after 10+ results - Improved scoring precision and SLA enforcement under load 🔹 CognitiveLevel – Adaptive Node Categorization - Miner-side logic categorized nodes by runtime performance - Validator-side SLA enforcement validated routing decisions - Early foundation for recursive inference and smarter orchestration 🔹 SessionPayment – Tightly Coupled Flow - Loosely coupled, event-driven payouts validated and stable in Phase #5 - Tightly coupled Session ↔ SessionPayment integration completed - First end-to-end payments executed directly between modules - Further testing planned during Phase #6, including delta calculations for charging extra features 🔹 Dual Testnet Setup - Testnet-0 (Arbitrum Sepolia): full-stack task pipeline validated - Testnet-1 (L3 COR Rollup): ~100 miners live, L3 stress tests stable 🔹 User Task Mode Flexibility - Dedicated Nodes: supported multi-model setups (e.g., LLaMA 3.1, DeepSeek-R1) - Ephemeral Nodes: longer reservations + model switching tested 🔹 NodeSpec Memory Index - Rolled out across environments, classifying nodes by system/GPU VRAM - Enables memory-aware task routing by matching sessions to nodes that can actually load the required model - Will be fully activated in Phase #6 / DevNet7 🔹 Hackathon #1 - Ran in parallel with Phase #5 - Builders delivered live apps: AI assistants, market/sentiment bots, decentralized oracles, Telegram bots, and more - Entries showcase

🧪 Phase #6 Starts Now The final development phase before Testnet is live. We're entering a 1-week grace period. Most nodes are already migrated to DevNet7 with a few still finalizing. Once migration completes, stats will reset and tasks will run across the network to confirm stability. What's in Phase #6: 🔹 Node Level Rewards - Base rewards introduced by tier (3 levels) - Linear level bonus on top 🔹 Memory Index & GPU Benchmarks - General dynamic model loading, switching, reporting & NodePool matching - Stress testing all supported models (CPU + GPU: incl. LLaMA 3.x, DeepSeek) 🔹 SessionPayment Integration - Full contract ↔ contract payout flow - Real-time event trigger validation 🔹 Regression – Refactored Sessions - Session & SessionQueue data isolation fully live - Backward compatibility + regression testing 🔹 Oracles & Canary Testing - Multi-region shards monitored across CA, UT, OH - Canary rollout on DevNet7 + Testnet-0/1 🔹 Privacy Prototyping - Early privacy-preserving sessions & queues prototyping - Full evaluation deferred to Testnet due to limited user data in DevNet 🔹 Validator Expansion Prototyping - Extending Validator v1 with quantitative (embedding/distance) + qualitative (LLM scoring) checks - Prototyping PoI & PoUW modules; full rollout during Testnet 🔹 Hackathon #2 - Launches one week after Phase #6 start - Focused on real-world apps, integrations, and agent tools - Double rewards pool compared to Hackathon #1 - Draft/WIP: https://docs.cortensor.network/community-and-ecosystem/hackathon/hackathon-2 🔹 Testnet Stress Testing - Run existing hackathon apps & demos on Testnet-0/1 - Validate user task flows and cross-env stability 📄 Full details: https://docs.cortensor.network/community-and-ecosystem/community-testing/closed-alpha-testing-phase-6 📍 Network DevNet7 Stats: https://dashboard-devnet7.cortensor.network/stats/network 🌉 L3 Bridge: https://cortensor-testnet-1-32ph80a02h-01acc12814e9cea3.testnets.rollbridge.app 🔎 L3 Explorer: https:/

🧪 Phase #6 Recap – Final Dev Phase Before Testnet Phase #6 has been one of the most comprehensive milestones yet - the final development phase before the Testnet rollout. With about two weeks remaining, nearly all planned objectives are complete, and the network is operating in one of its most stable states to date. 🔹 Validator Expansion & Stabilization - Both Validator v2 (PoI) and Validator v3 (PoUW) are fully live and running across DevNet7, Testnet-0, and Testnet-1. - Node operators are now participating in distributed validation, confirming stability across both GPU and CPU instances. - Visualizations, heatmaps, and validator leaderboards provide real-time insights into validation performance. 🔹 SessionPayment Integration - Full contract-to-contract payout and real-time event validation are functional. - End-to-end payment verification runs continuously across test environments. 🔹 Memory Index & GPU Benchmarks - Dynamic model loading, switching, and NodePool matching stabilized. - Network-wide benchmarking for LLaMA 3.x, DeepSeek, and other supported models completed successfully. 🔹 Dashboard & Data Visualization - Expanded validator stats dashboards and improved real-time visibility for quantitative and qualitative metrics. - Validator detail views and indexer endpoints provide deeper insights into task validation patterns. 🔹 Hackathon #2 – Active Phase - Three-Four weeks in, builders continue shipping agentic web apps and decentralized AI tools. - About two weeks remain until submission close (Nov 2). 🔹 Deferred Items → Testnet Phase - Privacy-preserving sessions and deep stress testing will continue into the upcoming Testnet phases, when more real-world traffic and user data become available. Phase #6 has successfully transitioned Cortensor from prototype validation to a multi-network, multi-role system with live validators, payments, and visual analytics. The final weeks will focus on validation data refinement, final node onboarding, and preparing

🧪 Phase #6 Recap – Final Dev Phase Before Testnet (Latest) Phase #6 wraps as one of Cortensor's most complete milestones - the final dev phase before Testnet. Core modules are functional, network task validation is live, and the agentic roadmap through 2026 is defined. 🔹 Validator Expansion & Stabilization - v2 (PoI) & v3 (PoUW) live on DevNet7, Testnet-0, Testnet-1; end-to-end network task validation confirmed. - v2 shows hardware-specific variance - fine-tuning continues during Testnet. 🔹 SessionPayment – Stake-to-Use Prototype - SessionPaymentStaking + SessionPaymentStakingRateLimit powering Stake-to-Use. - E2E prototype complete; dashboard shows live rate-limit usage and resets. 🔹 Dashboard & Visualization Enhancements - Session/Task views: staking mode, rate-limit usage, miner participation. - Validator views: quantitative + qualitative breakdowns; improved network stats. 🔹 Hackathon #2 - Submissions closed with the Phase #6 snapshot; tools and early agentic prototypes inform Testnet challenges. 🔹 Testnet Preparation - All modules are up to date with DevNet6 and DevNet7. - Testnet targets identical behavior and quality to DevNet6/DevNet7. 🔹 Testnet Plans & Docs – 4 Phases - Mid-Nov ’25 → early/mid-Q2 ’26; ~4–6 weeks/phase on Testnet-0 (Arbitrum Sepolia) & Testnet-1 (COR L3). 🔹 Router → Agentic Surface (x402 + ERC-8004) - High-level brainstorming/design for Router’s shift to an agentic entry surface; forms the backbone for the 3-phase integration through and after Testnet. 🔹 x402 + ERC-8004 (COR Prover) - 3-phase path: Phase A COR Prover PoC (validation-only in Testnet Phase 4) → Phase B/C Router Agent (inference + validation post-Testnet). - Aligns Router v2/v3, Session contracts, and external agents. 🔹 COR/ETH on Base (Uniswap) - Initial COR/ETH pair launched on Base, bridged from Ethereum issuance via native Base Bridge. 🔹 Conclusion Phase #6 moves Cortensor from prototype to Testnet-ready architecture - unifying validation, staking, payments, priv

🧪 Testnet Phase #1 Starts Now The first of four structured Testnet phases is now live. We're entering a 1-week grace period: node stats and session data have been reset on Testnet-0 (Arbitrum Sepolia) and Testnet-1 ($COR Rollup L3), and this week serves as onboarding + warm-up before full regression. 🔹 Focus – System Integration & Regression - Validate all node roles and coordination flows end-to-end across apps, routing, miners, and validators - Stress-test both Pay-to-Use and Stake-to-Use inference flows under live conditions - Exercise the new NodePool refactor to generate large user-task & validator datasets for future SLA filters and inference-quality tuning 🔹 Incentivized Testing & Bug Bounty - Node ops: submit random sessions/tasks daily to simulate real usage - Manual + load testing throughout Phase #1 will be incentivized - Bugs and edge cases will qualify for bounty rewards - Detailed rules and amounts will be announced soon in Discord 🔹 Docs / Plan - Testnet Phase #1: https://docs.cortensor.network/community-and-ecosystem/community-testing/testnet-phase/testnet-phase-1 - Testnet Phases: https://docs.cortensor.network/community-and-ecosystem/community-testing/testnet-phase - Structured Plan: https://docs.cortensor.network/community-and-ecosystem/community-testing/testnet-phase-wip-draft/wip-draft-testnet-phases-and-focus-areas-structured-plan Phase #1 is about breaking and hardening the pipeline so later phases can safely introduce SLA-driven routing, payments, and agentic integrations. https://x.com/cortensor/status/1989954731058630714 https://farcaster.xyz/cortensor/0x9d6ac074

🧪 Testnet Phase #1 Recap – Integration, Load, and Engine Expansion Phase #1 was the first structured Testnet week where we focused on one thing: break the pipeline, harden the pipeline, and prove the system scales under real usage across both Testnet-0 (Arbitrum Sepolia) and Testnet-1 (COR #L3). 🔹 Incentivized Manual Testing (E2E + Payments) - Daily manual testing by community testers across different models and task types - End-to-end validation: routing → miner execution → validator checks → results - Exercised both Pay-to-Use (pay per task) and Stake-to-Use (stake-based access / rate-limits) - General stress-testing across components to surface edge cases early 🔹 Automated Load Testing – 130K+ Tasks Executed - Automated task jobs ran continuously during Phase #1 - 130,000+ tasks executed, validating stability and throughput under sustained traffic 🔹 Dashboard UI Refinement - Multiple rounds of UI polish across session/task views - Improved navigation and usability during high-volume sessions 🔹 #Ollama Engine Support + 65+ Models Live - Added #Ollama LLM engine support across Testnet-0 and Testnet-1 - 65+ models are now supported (Q1 target: 100+) - Current limitation is disk footprint: nodes need many models stored to serve on request - Next up: network-driven model auto-assignment + model-usage-aware routing - Also added additional embedding models via Ollama to support Validator v2/v3 tuning, since the current embedding stack shows GPU-specific issues on some setups 🔹 SessionQueue Scaling – Read Throughput & Pagination - Phase #1 load exposed a read bottleneck at high task volumes - Added missing foundations: precomputed task stats per session + scalable pagination - Dashboard + Router can now handle large query/read workloads under single sessions 🔹 Corgent Experimental – /delegate + /validate - First iterations to validate rough E2E behavior and clarify exact requirements - Established what needs to be strict vs flexible for agent-facing flows 🔹 Route

🗓️ 2025 Year-End Wrap - Cortensor 2025 was the year we proved a simple thesis: decentralized inference can be practical if you treat it like infrastructure - not a science project. We focused on one thing: build the execution loop, validate it under load, and set the foundation for an agent-ready and developer-ready trust layer - so builders can ship reliable AI apps without a high cost barrier. Minimal E2E MVP is live We shipped a minimal but real end-to-end pipeline: Router → Session Queue → Miners → Validators Payments: Pay-per-use + Stake-to-Use (still early, still needs tuning). DevNets → Testnet We completed 6 DevNet phases, kicked off Testnet, and wrapped Testnet Phase #1. Load testing reached 150k+ tasks executed, validating feasibility under sustained traffic. Infra & Scaling Bpgrades Core improvements landed: - NodePool / NodePoolUtil refactors + data isolation (future SLA routing) - Session Queue & SessionQueued scaling for high read-throughput + session-heavy workloads - Dashboard polish for better NodeOps monitoring + rewards/performance visibility Models + Validation Surfaces Expanded We rolled out 64+ models (including embedding stacks for Validator v2/v3). We iterated on /validate (multiple templates) and introduced /delegate as a thin agent-facing SDK surface. Hackathons pushed the ecosystem forward We ran 3 hackathons in 2025. So far, 15+ apps were qualified/rewarded - not just demos, but real feedback loops that pressure-test the network. Early Agent Rails: #ERC8004 + #x402 + #MCP (experimental) We ran rough experiments on #ERC8004, #x402, and #MCP to surface blockers early. Not fully integrated yet - but these are the rails we’ll harden and fold in during 2026. What Cortensor is becoming Cortensor is shaping into an execution + trust layer for web3 agents and agentic apps - while staying practical for everyday developers building AI products. Agents (and apps) delegate work → Cortensor runs redundant inference + proof

🧪 Testnet Phase #2 – Preview Recap (Starts This Weekend – Jan 17) We're wrapping prep for Testnet Phase #2, which kicks off this weekend (Jan 17). Most docs + infra are now in semi-final shape, and all environments are wired for the next round of testing: - Testnet-0 — Arbitrum Sepolia (L2) - Testnet-1 — COR L3 via RaaS - Testnet-1a — Self-managed COR L3 (comparison target) - Testnet-1b — Self-managed COR L3 (internal dev environment) Phase #2 Focus 🔹 Validator v2/v3 (PoI + PoUW) Tighten quantitative + qualitative scoring so validators are more deterministic, less “flaky,” and better aligned with the rubric. 🔹 Validator Engine – Ollama + Embeddings Trial Ollama judge models + multiple embedding variants so validators run well on mixed hardware (CPU/GPU) with stable scores. 🔹 QuantitativeStats / QualitativeStats Grow calibration datasets + tracking so we can tune thresholds, spot drift, and reduce false positives/negatives across domains. 🔹 Redundancy & Trust Stability Stress multi-run / multi-miner redundancy and aggregation logic to keep trust stable under partial failures or disagreement. 🔹 Router Surfaces – /delegate & /validate Exercise agent-facing flows, policy hints, multi-run delegation, and validation-heavy workloads to harden these endpoints. 🔹 Oracle & Internal Service Reliability Verify router APIs, indexers, and dashboard feeds stay fresh + consistent under sustained load and recovery scenarios. 🔹 Infra Redundancy (RPC / Failover / Backups) Add and test multiple RPC endpoints, validator backups, and ops playbooks so the network survives infra hiccups gracefully. 🔹 Gas Optimization & Runtime Tuning Profile cortensord + L2 contracts (SessionQueueValidation, SessionPayment, validator storage) and trim gas + runtime overhead. 🔹 Dashboard – Trust Observability Expose real-time PoI/PoUW metrics, validator health, and endpoint status so operators can actually see trust behavior. 🔹 L3 Comparison – Self-Managed vs RaaS Run apple-to-apple tests on Test

🧪 Testnet Phase #2 Starts Now Phase #2 is live - this round is about validation refinement + infrastructure hardening, so Cortensor’s trust layer becomes more deterministic, more redundant, and cheaper to run. All environments are now active and wired for Phase #2 testing: - Testnet-0 — #Arbitrum #Sepolia (L2) - Testnet-1 — $COR #L3 via RaaS - Testnet-1a — Self-managed $COR #L3 (comparison target) - Testnet-1b — Self-managed $COR #L3 (internal dev environment) 🔹 Focus – Validation Refinement (PoI + PoUW) - Tighten Validator v2/v3 scoring so outputs are more deterministic, less “flaky,” and better rubric-aligned. - Expand redundancy + aggregation testing so trust stays stable under disagreement and partial failures. 🔹 Validator Engine Experiments – #Ollama + Embeddings - Trial Ollama judge models and multiple embedding variants so validators run reliably across mixed CPU/GPU hardware. - Reduce validator environment-specific issues while improving scoring consistency and throughput. 🔹 /delegate & /validate Surface Hardening - Exercise agent-facing flows: policy hints, multi-run delegation, retries/fallbacks, and validation-heavy workloads. - Confirm response structure stability for downstream apps/agents. 🔹 Infra + Service Reliability Verify router APIs, indexers, and dashboard feeds stay fresh and consistent under sustained load and recovery scenarios. Add and test RPC redundancy, failover, and validator backups so the network survives infra hiccups gracefully. 🔹 Gas Optimization & Runtime Tuning - Profile cortensord + L2 execution paths. - Optimize SessionQueueValidation, SessionPayment, and validator storage to trim gas + runtime overhead. 🔹 Dashboard – Trust Observability - Expand real-time PoI/PoUW analytics, validator health views, and endpoint status so operators can actually see trust behavior evolving. 🔹 #L3 Comparison – Self-Managed vs RaaS - Run apple-to-apple tests on Testnet-1 (RaaS) vs Testnet-1a (self-managed) to measure performance, reliabilit

🧪 Testnet Phase #2 — Wrap-Up Recap (Rewards Complete) Testnet Phase #2 is now officially wrapped - and reward/prize distribution is complete. Phase #2 delivered what we wanted: a stable baseline, meaningful self-managed L3 progress, and a stronger trust + routing foundation to support the more agentic direction of Phase #3. ✅ What We Completed in Phase #2 🔹 Stable baseline achieved - Network/background tasks held steady enough that Phase #2 stats became real signal (usable for routing, not noise) 🔹 Self-managed COR L3 is live as a real track (Testnet-1a / Arbitrum Orbit) - Completed apple-to-apple L3 comparison and stood up Testnet-1a as the self-managed COR L3 environment - Shifted migration + load-testing weight toward self-managed L3 so results are actionable 🔹 Routing filters upgraded using real metrics - Moved toward “earned routing priority” using reliability/behavior/consistency signals - Added QuantitativeStats + QualitativeStats as secondary filters to improve routing quality beyond simple uptime 🔹 Validator engine experiments rolling out (#Ollama + embeddings) - Started deploying Ollama judge models + multiple embedding variants - Reduced environment-specific validator issues while improving scoring consistency + throughput across mixed CPU/GPU setups 🔹 Agent-facing router surfaces expanded - Live + exercised: /delegate v1/v2, /validate v1/v2, and /factcheck - Bardiel dashboard now has mock/example datasets for agent-side iteration (more real data + refinement coming) 🔹 ERC-8004 mainnet agents registered (Corgent + Bardiel) • Corgent + Bardiel are now registered as ERC-8004 mainnet agents backed by the Router Node MCP/prototype stack 🔹 Self-managed L3 ops playbooks completed - Produced ops playbooks for self-managed L3: backups, snapshots, recovery flow, disk space estimates 🔹 Pre-mainnet environments progressed - Pre-mainnet setup/env work is in place - deeper mainnet-identical experiments land in Phase #3 📌 Where Phase #3 Goes From Here Phas

🧪 Testnet Phase #3 Starts Now Testnet Phase #3 is now live. Phase #3 pushes Cortensor from “trust-layer hardening” into economic + agentic hardening - payments/staking become production-shaped, rewards become more repeatable, and router surfaces move closer to agent primitives. 🔹 Privacy feature v0.5 Router key distribution (ACL/signature checks) + dashboard privacy module + dedicated sessions marked private/public 🔹 Payments (SessionPayment “production shape”) Tune unit costs/rebates/surcharges + expand pricing metadata + improve cost attribution + failure handling 🔹 Dynamic pricing activation SLA / depth / redundancy-aware fees via SessionPaymentTable + consistency + manipulation-resistance checks 🔹 Staking-to-use Quotas → auto-deduction + usage buckets + cadence + anti-abuse guardrails (dashboard-visible) 🔹 Rewards (semi-automation) Push reward outputs (CSV) further end-to-end to remove more manual steps (human still final send/batching) + keep tuning level params (capacity/breadth) 🔹 Router surfaces (agent-ready) Iterate /delegate + /validate v3/v4 with policy hints, tool traces, retries/fallbacks + explicit redundancy/consensus attributes + expand factcheck/new endpoints 🔹 Bardiel dashboard + regular test jobs Keep views stable across schema changes + scheduled smoke/regression jobs so examples stay fresh 🔹 Pre-mainnet experiments Mainnet-identical dry runs: ops/reliability, cost mechanics, payment/staking/reward flows, agent-facing behavior 🔹 Self-managed L3 as primary track (Testnet-1a) Ops hardening + runbooks (backups, snapshots, disk estimates) + validate procedures under real incidents 🔹 ERC8004 agent workflows Corgent + Bardiel iteration via router MCP/prototype stack (real agent-facing trust rails) 🔹 Gas profiling iteration Measure deltas vs Phase #2 baseline + keep trimming writes/log spam for mainnet viability 🔹 PyClaw (router-aligned local agent runtime) Phase #3 = design + alignment for Phase #4 implementation/dogfooding 🔹 Core Docs T

🧪 Testnet Phase #3 – Progress Recap So Far (1–2 Weeks Before Wrap-Up) Testnet Phase #3 has been running for a few weeks now. So far, Phase #3 has moved from initial setup → real testing loops → early product/data-layer alignment. We now have v3 agent surfaces, MVP data management, and inference-quality signals all actively exercised together. 🔹 v3 /delegate + /validate (prep → testing phase) - Initial rollout + session prep is done. - We’re now in deeper testing + iteration on real delegation/validation behavior, routing consistency, consensus handling, and remaining logic gaps. 🔹 MVP Data Management (now fully in place) Privacy Feature 1.0 + Offchain Storage v3 are working end-to-end in MVP form: session/task encryption, dedicated/ephemeral flows, deferred write, and router → miner → dashboard integration. 🔹 Dashboard / UI / UX (closing the gap) Quality stats, privacy flows, offchain behavior, and task-status improvements are now surfaced in the dashboards - including the quality stats rank table, Node Perf quality columns, and clearer completed / processing / stale task views. 🔹 Inference Quality (SLA #3 live path) - NodePool + NodePoolUtils now include SLA #3 (user-task quality stats) on top of node-level + network-task signals. - The new quality path is deployed on testnet0 + testnet1a and is being observed in live selection behavior. 🔹 Inference Quality (oracle + data layer) - Early E2E Quality Oracle + data model is working in MVP form. - Real task probes now flow into stored quality stats, ranking views, and selection/reward-oriented surfaces. 🔹 Privacy Feature 1.0 (ready → testing stage) - Private inference is now live across the router surfaces and tested across dedicated + ephemeral paths. - Session-level and task-level encryption flows have both gone through matrix-style testing. 🔹 Offchain Storage v3 (usable MVP path) Dedicated-node and ephemeral-node offchain storage flows are both working in MVP form, including the router-assisted deferred-wri

🧪 Testnet Phase #3 – Wrap-Up Recap Testnet Phase #3 has been running for a few weeks, and we’re now wrapping up the current Phase #3 stretch. We moved from setup → real testing loops → product/data-layer alignment, with v3 agent surfaces + MVP data management + inference-quality signals exercised together. Core Infra: 🔹 v3 /delegate + /validate (testing + iteration) - Rollout + session prep complete; now iterating on real delegation/validation behavior - Focus: routing consistency, consensus handling, and remaining logic gaps under load 🔹 MVP Data Management (Privacy + Offchain) - Privacy Feature 1.0 + Offchain Storage v3 working end-to-end in MVP form - Includes encryption (session/task), dedicated/ephemeral flows, deferred write, router→miner→dashboard integration 🔹 Dashboard / UI / UX improvements - Quality stats + privacy/offchain flows now surfaced more clearly in the dashboard - Added rank table + Node Perf quality columns + clearer completed/processing/stale task views 🔹 Inference Quality (SLA #3 live path) - SLA #3 (user-task quality stats) added as a third selection filter on top of node + network-task signals - Deployed on testnet0 + testnet1a and now being observed in live selection behavior 🔹 Inference Quality (oracle + data layer) - MVP Quality Oracle + data model working end-to-end - Task probes → stored stats → ranking views + selection/reward-oriented surfaces 🔹 Privacy Feature 1.0 (testing stage) - Private inference live across router surfaces, tested across dedicated + ephemeral paths - Session-level + task-level encryption flows have gone through matrix-style testing 🔹 Offchain Storage v3 (usable MVP path) - Dedicated + ephemeral offchain flows working in MVP form - Router-assisted deferred-write path for ephemeral nodes is live (remaining gaps tracked for iteration) Products: 🔹 Bardiel dashboard – v3 adaptation - Alignment work underway for v3 /delegate + /validate flows - Heavier datasets + API examples added; iterating on task cards,

🧪 Testnet Phase #4 Starts Now Testnet Phase #4 is now live. Phase #4 is less about adding isolated features and more about tightening the full pipeline under realistic conditions — data → quality → routing, reliability under load, and Mainnet Lite readiness. 🔹 E2E scope lock (Phase #3 → Phase #4) Finalize the end-to-end test plan + order + pass/fail metrics (throughput/latency, recovery, drift, data integrity/offchain correctness) 🔹 Deeper stress testing (Data → Quality Path) Longer, higher-volume runs that hit real failure modes (miner churn, partial outages, RPC degradation, queue spikes) 🔹 Privacy + offchain storage stress tests (optional / heavier) Heavier testing where enabled: encryption paths, offchain correctness, and edge cases (timeouts, stale keys, partial writes) 🔹 SLA / quality signals – deeper validation (#3 signals) Stress SLA signals under churn/load (drift detection, reliability weighting vs uptime, disagreement/arbitration behavior) 🔹 Portal V1 (design → early implementation) + product boundary Portal becomes a real product layer: client → Portal backend → router pool → sessions Scope: API keys, usage visibility, managed router pools, auth/rate limits, billing hooks + metering 🔹 Portal focus (gateway → router pool path) Key issuance/consumption path is proven; Phase #4 drills into the hosted execution shape from Portal Gateway into managed router pools 🔹 PyClaw (early dev release track) Move from design into early dev release: landing page + docs + initial runtime scaffolding aligned to router/session primitives 🔹 Mainnet Lite infra planning (execution readiness) New RPC/server path is ready (L2 testnet/mainnet + L3 testnet/pre-mainnet) Phase #4 begins bringing up Mainnet Lite pieces on top (dashboard, indexer, oracle-related path) 🔹 Core Docs Testnet Phase #4: https://docs.cortensor.network/community-and-ecosystem/community-testing/testnet-phase-4 https://x.com/cortensor/status/2055830240958533777

🧪 Testnet Phase #4 – Wrap-Up Recap Testnet Phase #4 is wrapping up over the next 48 hours. Phase #4 focused on tightening the full Cortensor stack under more realistic conditions - network execution, Portal, router pools, observability, L3 recovery, and Mainnet Lite readiness. Core Infra: 🔹 Mainnet Lite baseline validation - Mainnet Lite moved from rough setup into real E2E baseline checks under actual mainnet conditions - Dedicated-node user tasks, ephemeral-node network tasks, and ephemeral-node user-task → node-pool flows all worked end to end 🔹 Mainnet Lite infra readiness - Contract/module deployment, RPC/server setup, oracle/indexer/dashboard setup, explorer checks, and chain-side validation reached rough baseline form - Heartbeat/ping timing was adjusted around real Arbitrum mainnet gas-cost assumptions 🔹 RPC / environment separation - Internal RPC infrastructure was refreshed and migrated toward newer internal/community-backed paths - Testnet and mainnet RPC separation started on newly provisioned servers as prep for Mainnet Lite and later Mainnet Full 🔹 Testnet1a / L3 recovery - Testnet1a went through a real sequencer / local Nitro DB recovery exercise using L2 batch data plus DAS/DA-backed data - The recovery helped validate L3 rebuild flow, edge cases, and future sequencer backup/redundancy planning 🔹 Cortensor L3 progress - Cortensor L3 closed Phase #4 in a much stronger operational position - The network has processed over 8M blocks and over 16.5M transactions 🔹 Mainnet Full early tryouts - Very early Mainnet Full infra work started across rough server setup, bridge flow, contract deployment, explorer checks, and connectivity validation - This remains early, but helped prepare the path beyond Mainnet Lite Products / Stack: 🔹 Portal V1 – hosted API layer - Portal stress tests expanded into larger prompts, heavier token-size requests, longer-running hosted API calls, and multi-model testing across oss-20b, gemma4, qwen 3.5 9b, and oss-120b - API

🧭 Mainnet Full Alpha Is Kicking Off Mainnet Full Alpha marks the next stage of the Cortensor rollout. This is not a one-time launch event. Alpha is the period where Mainnet1, the product layer, and developer-facing tools start being exercised together under more realistic usage before we expand further toward Beta. 🔹 What Alpha is for - controlled access rather than broad public availability - continued validation of Mainnet1, routers, sessions, dedicated nodes, dashboard, indexer, and recovery paths - real product traffic through Portal, Corgent, Bardiel, and PyClaw-related workflows - identifying operational, compatibility, onboarding, model, and capacity gaps through actual use 🔹 Product focus - Portal will continue improving as the simpler hosted API entry point into Cortensor - Corgent / Bardiel will keep iterating on delegation, validation, fact-checking, and the early v4 direction - PyClaw will continue maturing across research, coding, memory, tools, scheduling, delegation, recovery, longer-running projects, packaging, and the early Desktop App - Mainnet Full capacity will gradually expand as we learn where real demand appears 🔹 Developer exposure - Alpha is also preparation for broader builder activity - We expect to prepare more examples, documentation, onboarding, model availability, and product capacity for hackathons and builder programs - Portal and PyClaw should provide two accessible entry points, while Corgent / Bardiel can give agents additional delegation and validation services to build around 🔹 What happens between Alpha and Beta - bring in controlled real usage - expose gaps through actual workloads - fix bugs and compatibility issues - improve onboarding and developer experience - mature PyClaw and the product surfaces - iterate v4 delegation / validation - expand node, model, router, and gateway capacity - run early hackathons / builder programs - use that feedback to prepare for broader Beta access 🔹 What Beta should represent Beta sh