Will

[Cortensor @cortensor]

🛠️ DevLog – Privacy Feature v0.5 Now Live on Testnet Dashboards

The latest dashboard updates for private / encrypted inference (v0.5) are now deployed on both testnet0 and testnet1a.

🔹 What’s included
- Privacy-related UI for dedicated-node sessions is now live on both dashboards.
- This includes the main V0.5 flow we’ve been iterating on:
- session privacy toggle / state
- privacy settings / ACL views
- signed dashboard → router flow for requesting encryption keys
- dashboard-side support for reading privacy settings from the latest module path

🔹 What this reflects from the recent work
- Router/miner/dashboard flows are now aligned enough to keep testing the dedicated private session path.
- Contract-backed privacy settings (PrivacySettingDataV0) and the newer router metadata / enc-key request flow are part of this rollout.
- This is still part of the Phase #3 integration path — the goal is to keep validating the dedicated-session privacy UX and end-to-end behavior, not just the backend pieces in isolation.

We’ll keep iterating on the dashboard flow from here as we continue privacy E2E checks for dedicated-node sessions.

#Cortensor #DevLog #Privacy #EncryptedInference #Dashboard #DedicatedNodes #DePIN

[Hawk Of Crypto @HawkOfCrypto]

While markets are red and the world is busy worrying about wars and macro chaos, Cortensor just keeps building. $COR

They are pushing ahead with Testnet Phase 3, rolling out agent upgrades, encrypted inference, staking mechanics, and deeper infrastructure for decentralized AI inference.

This is the kind of progress you want to see during quiet markets.
Teams that keep shipping when nobody is paying attention usually end up leading the next cycle.

[Cortensor @cortensor]

🛠️ DevLog – PyClaw Architecture Evolution

Quick progress note on PyClaw: after a lot of design iteration, mock integration, and learning from other agent frameworks, the architecture direction is getting clearer.

PyClaw is moving away from a more extension-centric style and toward a module-first, service-oriented architecture that should be easier to reason about, integrate, and extend over time.

🔹 What’s changing
- More logic lives in clear modules instead of extension glue.
- More use of focused services and hooks instead of heavy manager/plugin patterns.
- More standard Python structure, less custom indirection.

🔹 Design principles
- Modules over Extensions
- Hooks over Plugins
- Entry Points over Manifests
- Services over Managers
- Clear over Clever
- Stable SDK, Evolving Internals

🔹 Why this matters
- This is still experimental design work, not a finished framework.
- A lot of the progress is coming from repeated iteration:
- try a structure
- wire mock integrations
- find friction
- simplify
- repeat
- The goal is to make PyClaw feel less like a pile of agent experiments and more like a clean runtime that can eventually sit naturally on top of Cortensor.

That process is helping shape PyClaw into a cleaner agent framework that can grow without becoming too magical or too brittle.

#Cortensor #DevLog #PyClaw #AgentFramework #AgenticAI #DePIN

[Cortensor @cortensor]

🛠️ DevLog – Privacy V0/V0.5 Roughly Wired, Ready for Phase #3 Testing

We did another quick round of checks across the privacy components, and at this point the rough wiring is mostly in place for V0/V0.5 dedicated-session privacy.

🔹 Current status
- Router, miner, PrivacySettingData, and dashboard-side key request flow are all roughly lined up now.
- This is still not the final polished release, but it looks ready enough to begin real Phase #3 testing once that phase starts.

🔹 What happens when Phase #3 starts
- Deploy the latest dashboard updates to testnet0 and testnet1a.
- Run another full end-to-end pass on the privacy flow and re-check integration across router ↔ miner ↔ dashboard.
- Update all four public endpoints for Corgent and Bardiel as well so the latest router/privacy-related changes are consistently reflected there.

So the next step is less “build the missing pieces” and more “start Phase #3, deploy the latest surfaces, and validate the whole flow under real integration conditions.”

#Cortensor #DevLog #Privacy #EncryptedInference #Corgent #Bardiel #DePIN

[Cortensor @cortensor]

🛠️ DevLog – Dual Router Metadata Support Landed in Installer

We’ve pushed a small but important installer update so router and miner metadata can support both REST and WebSocket endpoints without breaking current behavior.

🔹 PR
https://t.co/A7fG58aIf8

🔹 What this PR does
Router V1
- Router metadata can now publish in a dual format:
- "<rest_endpoint>:<rest_port>;<ws_host>:<ws_port>"
- Still supports the old format:
"<ws_host>:<ws_port>"

Miner PoW V4
- Miner now parses router metadata using a helper that understands both formats.
- When ; exists, miner explicitly uses the WS endpoint from the second segment for current communication.
- Added a guard to skip WS connect if parsed host/port is invalid.

🔹 Why it matters
- This is a necessary building block for privacy feature v0.5, because newer flows need the router’s REST endpoint to be discoverable for encryption-key requests, while miners still rely on the existing WebSocket path for normal communication.
- It stays backward compatible with old router metadata and should not break current WS-based behavior.

#Cortensor #DevLog #RouterNode #Miner #Privacy #DePIN

[Cortensor @cortensor]

🛠️ DevLog – Design/Spec Tracks We’ll Be Iterating on in Phase #3

These are the main design/spec items/features we’ll keep iterating & integrating on as Phase #3 moves forward.

🔹 PyClaw – local-first agent runtime
We’ll keep refining the runtime design (session, context, memory, tools, policy) so it becomes a practical agent framework on top of Cortensor.

Doc: https://t.co/RiJpairy8a

🔹 /delegate & /validate – v3 / v4 agentic surface
Phase #3 will keep pushing explicit redundancy/consensus (v3) and programmable consensus + receipts (v4) as the next router-node agent surface.

Docs:
- https://t.co/8LRJeeJ8r1
- https://t.co/CyGYrzCY87

🔹 Private / Encrypted Inference – v0 / v0.5
This is the privacy track for dedicated sessions: v0 router-issued keys, then v0.5 contract-backed ACLs, with full E2E integration as the next step.

Docs:
- https://t.co/nZpjbWJFAv
- https://t.co/cNM2vLKxiY

#Cortensor #DevLog #PyClaw #Delegate #Validate #Privacy #AgenticAI #DePIN

[Cortensor @cortensor]

🧩 New Doc – /delegate & /validate v4 Spec: Programmable Consensus & Receipts

We’ve published the v4 spec for Cortensor’s core agentic primitives, /delegate and /validate – focused on programmable consensus, richer receipts, and long-lived verification artifacts: https://t.co/CyGYrzCY87

🔹 What v4 adds on top of v3
- Moves from “fixed redundancy settings” to programmable consensus policies (e.g., different miner sets / weights / verdict rules per tier or per app).
- Introduces stronger receipts for both execute and verify calls so downstream agents, dashboards, and even chains can reason about how a result was produced (routes, models, miners, consensus rule applied, etc.).
- Makes /delegate and /validate feel more like a mini execution + verification engine that apps can configure, not just opaque API calls.

🔹 How this fits the roadmap
- v1/v2: single-session calls with basic redundancy and verdicts (what we run today).
- v3: explicit redundancy + consensus attributes in the request/response, hardening “agent-ready” routing.
- v4: programmable consensus + receipts, so different ecosystems (Virtual, ERC-8004 agents, on-chain infra) can plug in their own trust rules while still using the same primitives.

We’ll iterate on this spec through Phase 3–4 as the router node and Corgent/Bardiel surfaces catch up to it.

#Cortensor #DevLog #Delegate #Validate #AgenticAI #DePIN

[Cortensor @cortensor]

🛠️ DevLog – Dashboard → Router Enc Key Flow Working

We’ve now wired up the last major piece of the v0/v0.5 privacy pipeline for dedicated sessions: the dashboard can request an encryption key directly from the router.

🔹 Dashboard → Router enc key request
- New “Get Enc Key” button signs session_id with the user’s wallet, calls the router’s /payload_enc_key/session endpoint, and displays the returned key.
- The key shown in the UI matches the value logged on the router side, so dashboard ↔ router signing/verification is consistent.

🔹 Gaps surfaced during integration
- Current router metadata only stores a WebSocket endpoint; private inference needs both WebSocket and REST details so miners and dashboards can hit the enc-key API reliably.
- If router metadata is misconfigured, it will silently break router ↔ miner key exchange, so we’ll upgrade the metadata schema and binaries for both router and miner to support dual-protocol routing.

🔹 Next steps
- Refine router/miner metadata format and rollout updated binaries.
- Continue end-to-end testing so dedicated private sessions can use the same enc key flow across dashboard → router → miner without manual config hacks.

#Cortensor #DevLog #Privacy #EncryptedInference #DePIN

[Cortensor @cortensor]

🛠️ DevLog – Privacy Plumbing In, UX & E2E Next

We’ve crossed the first milestone for V0 private / encrypted inference on dedicated sessions: the core plumbing works. Next up is UX and full end-to-end testing.

🔹 What already works (rough, component-level)
- Miner ↔ Router key flow
- Miners can request session/task-scoped payload_enc_key from the router, which verifies a wallet signature, checks the allowlist, and derives a deterministic key from the shared seed + scope.
- Contract-backed allowlists (PrivacySettingDataV0)
- PrivacySettingDataV0 is deployed and can store per-session allowed addresses in a format compatible with the old env-based ACL, so the router can choose env-based or contract-based policy.

🔹 What’s next
- Dashboard & UX
- Add a privacy toggle at session creation, surface privacy state/allowlist, and let the dashboard request a decryption key (via wallet signature) to locally decrypt and render offchain v2 payloads.

- Full end-to-end tests
- Run full flows with dedicated private sessions, encrypted inference, and dashboard decryption to validate behavior end to end while keeping non-encrypted sessions unchanged.

#Cortensor #DevLog #Privacy #EncryptedInference #DedicatedNodes #DePIN

[Cortensor @cortensor]

🛠️ DevLog – Next Steps for Private / Encrypted Sessions (V0 & V0.5)

🔹 What we’re doing today
- Run end-to-end tests of the current private inference design on dedicated-node sessions (router ↔ miner ↔ offchain v2 envelopes).
- Validate that the V0/V0.5 behavior matches the spec (session/task-scoped keys, non-streaming encrypted payloads, backward compatibility with non-encrypted sessions).

🔹 Dashboard & UX work
- Add a Privacy Settings section to the dedicated-session UI in the dashboard.
- First pass: simple toggle/selector for “private (encrypted) session” plus a basic view of which address/ACL mode is active.
- Wire this UI through to the router so that the correct privacy mode is set when a dedicated session is created.

🔹 Action items for V0 / V0.5
- V0: tighten implementation and logging around key issuance, decryption/re-encryption, and error paths for dedicated sessions.
- V0.5: hook the router into the PrivacySettingDataV0 contract so ACL/allowlist is driven onchain, not via env-only config, and confirm miners respect contract-backed ACL before requesting keys.
- Update the privacy docs/specs once today’s tests land, so the V0 / V0.5 behavior is fully aligned with what’s running on testnet.

#Cortensor #DevLog #Privacy #EncryptedInference #DePIN #AI

[El_Cano @el_cano498]

If the autonomous task horizon keeps doubling every ~7 months, the bottleneck won't be models — it will be infrastructure to run persistent agents.
That's why projects like @cortensor are interesting: remote “brains” for #AI agents.

@aixbt_agent
@AlgodTrading
@jessepollak

[Cortensor @cortensor]

🛠️ DevLog – Rough Private Session Stack Wired End-to-End (V0 / V0.5)

We’ve now pushed the first rough pass of the private / encrypted dedicated session stack across the codebase – router, miners, and the new PrivacySettingDataV0 module are all in place and compiling.

🔹 What’s wired so far
Router node:
V0 payload key issuance endpoints are implemented and now read ACLs from PrivacySettingDataV0 (contract-backed allowlist for dedicated sessions).

Miner node:
Miners can request session/task-scoped keys from the router, decrypt offchain v2 payloads, run inference, and re-encrypt results for private sessions.

PrivacySettingDataV0:
Stores session-level ACL and basic privacy settings onchain so only the session owner/router can manage who is allowed to receive keys.

🔹 Where we’ll test it
- Deploying this rough version to testnet-0 as an experiment first.
- Using it to shake out integration issues between contract ↔ router ↔ miner before touching other testnets.

🔹 What’s next
- End-to-end integration tests for a few dedicated private sessions (create session → set ACL → run encrypted tasks → verify offchain v2 envelopes).
- Iterate on the design based on what breaks in real traffic and update the V0 / V0.5 docs accordingly.

#Cortensor #DevLog #Privacy #EncryptedInference #DePIN #AI

[Cortensor @cortensor]

�� Testnet Phase #3 – Preview (WIP/Semi-Final)

Phase #3 pushes Cortensor from “trust-layer hardening” into economic + agentic hardening - payments/staking become production-shaped, rewards become more automated, and router surfaces move closer to agent primitives.

Note: Phase #3 docs are being polished into semi-final now. This testing focus is still DRFAT/WIP and may change as we tighten scope over the next ~1 week+.

🔹 Payments: SessionPayment “production shape”
Tune unit costs/rebates/surcharges, expand pricing metadata (depth, redundancy profile, model class/route hints), and improve gas/cost attribution + failure handling.

🔹 Dynamic pricing activation (SLA / depth / redundancy-aware)
Activate SessionPaymentTable with SLA tier, model class, execution/tool depth, validator depth, redundancy + consensus requirements - and validate consistency + manipulation resistance.

🔹 Staking-to-use: quotas → auto-deduction
Stake-based free inference quotas, auto-deduction for overages, and quota guardrails (buckets, cadence, anti-abuse).

🔹 Reward automation + parameter tuning (capacity signals)
Automate reward computation/payouts and validate level-based parameters using reputation/validator feedback and capacity/breadth (e.g., model count).

🔹 Router surfaces (v3/v4) + explicit consensus attributes (agent-ready)
Iterate /delegate + /validate with richer policy hints, structured outputs/tool traces, retries/fallbacks; add explicit redundancy/consensus attributes and expand factcheck + any new endpoints needed by workflows.

🔹 #ERC8004 agent presence + Router MCP/prototype stack
Exercise Corgent + Bardiel in real workflows backed by the router MCP/prototype stack, tightening agent-facing trust rails.

🔹 Bardiel dashboard + regular test jobs
Keep delegation/validation views stable across schema changes, and run scheduled smoke/regression jobs so the dashboard stays populated with real examples + redundancy indicators.

🔹 Pre-mainnet experiments (mainnet-identical dry runs)
Run “go-live” dry runs in pre-mainnet environments designed to be apple-to-apple with mainnet config (ops/reliability, cost mechanics, payment/staking/reward flows, agent-facing behavior under mainnet-like constraints).

🔹 Gas profiling iteration
Measure gas after payment/staking/reward changes vs Phase #2 baseline; keep trimming storage writes + event/log spam for mainnet viability.

🔹 PyClaw – Router-Aligned Local Agent Runtime
- Local-first agent runtime that plugs into Cortensor’s /completion + /delegate surfaces using the same session + routing primitives.
- Phase #3 focus: design + alignment so Phase #4~ can move into deeper implementation/dogfooding.

Full doc: https://t.co/j0c7gUz6Fp

#Cortensor #TestnetPhase3 #DevLog #AgenticAI #RouterNode #DePIN #AIInfra #L3 #ERC8004 #Bardiel #Corgent

[Cortensor @cortensor]

🛠️ DevLog – Rough Implementation of V0.5 Private Sessions (Contract-Backed ACL)

Following the V0.5 “contract-backed ACL” spec for dedicated private sessions, we’ve pushed the first rough code changes on the contracts/module side.

🔹 What’s in place now
- Session ACL contract/module implemented to store the allowlist on-chain for dedicated private sessions:
- Tracks which wallet addresses are allowed to access a given private session.
- Includes basic admin/owner controls for updating the ACL (add/remove).
- This matches the V0.5 spec: ACL lives on a contract instead of ENCRYPTION_ALLOWED_LIST env, but the encryption workflow remains session-based.

🔹 What’s next
- Update the router node so that /api/v1/auth/payload_enc_key/session reads from this ACL module/contract when deciding whether to issue a payload_enc_key.
- Keep the current code as rough/untested for now while we finish the router integration, then run end-to-end tests for dedicated private sessions (router ↔ contract ACL ↔ miner).

#Cortensor #DevLog #Privacy #EncryptedInference #DePIN

[Cortensor @cortensor]

🧩 New Doc – Private / Encrypted Inference V0.5 (Contract-Backed ACL)

We’ve published a new V0.5 spec for private / encrypted inference on dedicated-node sessions, focused on moving access control from env files to on-chain contracts.

🔹 What V0.5 changes vs V0
- V0: router used an env-based allowlist (ENCRYPTION_ALLOWED_LIST) to decide who could request payload encryption keys.
- V0.5: the allowlist lives on a smart contract:
- The dedicated-session contract stores which wallet addresses are allowed.
- Only the owner / router operator can update that ACL.
- Miners and other parties must be on that ACL before the router issues a key.

🔹 How it works (session-based only)
- Router verifies:
- Signature binding wallet address ↔ session_id.
- Contract ACL: “is this wallet allowed for this private session?”
- If allowed, router derives a session-level payload_enc_key from a seed + session_id.
- Clients/miners use that key to decrypt inputs and re-encrypt outputs into offchain v2 envelopes.

🔹 Scope & next steps
- Applies to dedicated private sessions only (no pool/ephemeral yet).
- Builds on the earlier V0 router + miner work, but replaces fragile env ACLs with auditable on-chain policy.
- We’ll iterate this alongside implementation and then wire it into real dedicated-session flows.

Read the spec:
https://t.co/cNM2vLKxiY

#Cortensor #DevLog #Privacy #EncryptedInference #DePIN

[El_Cano @el_cano498]

This is exactly why centralized AI infrastructure is a risk.

If data centers become military targets, the future of #AI will need distributed and resilient compute, not just bigger clusters.

Projects like @cortensor $COR are already exploring and building this model

#ETH #BTC

[Cortensor @cortensor]

🛠️ DevLog – Design - PyClaw: Interfaces & Contracts First

As we wire more PyClaw mock modules together (runtime, session, context, memory, tools), it’s clear the hard part now isn’t “more pieces,” it’s keeping the pieces aligned.

🔹 What we’re seeing
- Integration tests are surfacing small drifts between modules (shape mismatches, missing fields, differing assumptions).
- Even with good module boundaries, this shows up quickly once storage ↔ session ↔ context ↔ LLM ↔ tools are all in the loop.

🔹 What we’re tightening
- Define stricter contracts for each pyclaw-* module:
- clear “takes X, returns Y” schemas
- versioned inputs/outputs where it matters
- Add cross-module compatibility tests so a change in one layer can’t silently break another.
- Require real end-to-end runs (not just unit mocks) before calling a module “good enough for the next phase.”

🔹 Why it matters
Getting the abstractions and contracts right now means we can evolve models, tools, and backends later without rewriting the whole stack.

We’ll keep reflecting that thinking in the design doc as it evolves: https://t.co/RiJpairy8a

#Cortensor #DevLog #PyClaw #AgentFramework #AgenticAI

[El_Cano @el_cano498]

Everyone talks about DeAI agents.
Almost no one talks about the infrastructure they need to run.
If agents depend on AWS + OpenAI APIs, it’s not DeAI.
That’s why projects like $COR / @cortensor matter — decentralized routing + execution layer for agents.
@jessepollak
@jkrdoc

[Cortensor @cortensor]

https://t.co/IXmMTP2GII

[El_Cano @el_cano498]

@AlgodTrading The interesting part here is that as AI ecosystems like TAO grow, the need for better infrastructure to analyze and coordinate these networks grows as well.
That’s where projects like $COR @cortensor could play an interesting role.