Production live on Solana and Base L2

Verifiable Compute
and Physical-World Proof
for Autonomous Systems

ExergyNet helps agents, applications, and enterprises request work, verify outcomes, and settle results across Solana and Base L2. From off-chain compute to Certificate of Physical Presence, ExergyNet turns trust-sensitive events into machine-usable records.

Read Docs Explore Enterprise Run a Node →
Network Overview
Solana LNES-03
OPERATIONAL
Base L2 LNES-04
OPERATIONAL
Active Nodes --
Settled Jobs --
Settlement Assets SOL / USDC
Cumulative M2M Yield -- USDC
Request
Compute or Real-World Proof
Verify
Proof-Bearing Result
Settle
On-Chain Outcome
Integrate
API / MCP / SDK
Enterprise-Grade AI Inference · Zero Retention

SEI VANGUARD

Deterministic Depth Gating  ·  Biological Reasoning Engine

Five-times faster first-token delivery. No conversation retention. No third-party routing. Vanguard's depth-gating architecture routes each query through the minimal reasoning path — sovereign, verifiable, enclave-sealed.

5×
TTFT vs cloud LLMs
0
Data retained
2
Inference modes
∞
API scale
Get Started → Learn More
Engine Capabilities
Architecture Depth-Gating DDG
Modes General  ·  Biotech
Enclave Zero-Retention SGX
Compatibility OpenAI-Compatible API
Settlement µUSDC / USDC
Status OPERATIONAL
LNES-05 · Ghost-Witness Protocol · Base L2

Your AI Agent
Should Not Be
Allowed to Lie.

Ghost-Witness detects logical contradictions in any AI agent conversation and generates a cryptographic Certificate of Logical Consistency — anchored permanently on Base L2. bash.005 USDC per audit. No subscription required.

Get API Key → View Dashboard Learn More
Ghost-Witness — Live Audit
LNES-05 Base L2
OPERATIONAL
Vanguard SGX
SEALED
Audit Toll bash.005 USDC
Avg. Audit Time < 10 seconds
Settlement Base L2 On-Chain
CLC Validity ∞ Permanent
Detect
Logical Contradictions
Generate
Certificate of Consistency
Settle
Base L2 On-Chain
Integrate
REST API / Webhook
What ExergyNet Does

Programmable trust for compute, physical proof, and settlement.

Autonomous software can request data, compute, and real-world actions, but most systems still rely on centralized APIs, opaque execution, and weak external verification. ExergyNet is built to close that trust gap with proof-bearing work and programmable settlement.

01

Request Work

Agents, applications, and enterprise systems define compute jobs or physical-world proof requests with machine-readable parameters.

02

Verify Results

Outputs are returned with verification data so downstream systems can check the result rather than trusting a single operator.

03

Settle Outcomes

Work can be connected to escrow, payouts, approval flows, and settlement logic across Solana and Base L2.

Product Surfaces

One network, multiple trust surfaces.

ExergyNet exposes infrastructure for agent builders, enterprise operators, developers, and node participants. Public documentation explains the system at the level needed for evaluation and integration, while deeper implementation details are disclosed in stages as the network expands.

Compute Settlement

Route off-chain execution to proof-capable nodes and connect results to on-chain settlement.

Certificate of Physical Presence

Turn a field event, checkpoint, or location-sensitive action into a verifiable certificate your systems can use.

MCP / Developer Gateway

Expose ExergyNet to agentic systems through machine-readable discovery, SDKs, and MCP-compatible integration paths.

Node Operations

Run proof-capable infrastructure that executes jobs and receives settlement for completed work.

Why ExergyNet Exists

Autonomous systems need verifiable execution, not blind trust.

Autonomous systems increasingly make decisions, trigger workflows, and move value. Those systems need more than API responses. They need outputs that can be verified, records that can be audited, and settlement that can be connected to completed work.

ExergyNet combines off-chain work, proof-bearing verification, and on-chain settlement so outcomes can be checked and paid without relying on a single operator's word.

The goal is simple: make high-value machine actions verifiable enough to automate.
exergynet-request
$ exg create-job --type compute --settle base-usdc
> Job request accepted.
> [ESCROW_OPENED] Settlement locked on Base L2.
> [NODE_SELECTED] Proof-capable executor assigned.
> [RESULT_VERIFIED] Output hash matched requested job.
> [SETTLED] Payout routed. Receipt available.
_
System Architecture

How ExergyNet Works

At a high level, ExergyNet lets a requester define work, route it to execution, verify the result, and settle the outcome.

Step 1

A requester opens a job and locks settlement

An agent, application, or enterprise system defines the work to be performed and attaches the required settlement or approval conditions.

Step 2

A node performs the work and records execution signals

The network routes work to capable execution infrastructure. Depending on the job, this can involve compute execution, sensor capture, location-sensitive proof, or another supported vector.

Step 3

A verifiable result is generated

The result is returned with proof or verification metadata so independent systems can check that the expected work was completed.

Step 4

Atomic settlement completes the loop

Once verification succeeds, the connected workflow can release payment, trigger an approval, update a status, or archive a receipt.

Who ExergyNet Serves

Built for builders, operators, and enterprises.

01 / Developers

For developers and agent builders

Use ExergyNet to request verifiable work, retrieve proof-bearing results, and integrate settlement-aware actions into agent and application workflows.

API / MCPmachine-readable integration
02 / Enterprise

For field and operations teams

Turn physical events into usable records that support audits, compliance workflows, approvals, exception handling, and downstream automation.

Presencecertificate-ready output
03 / Operators

For node operators

Run nodes that execute proof-bearing work and receive settlement for verified participation in the network.

USDCsettlement-ready payouts
What ExergyNet Makes Possible

Trust-sensitive workflows that software can actually use.

The network is designed for outcomes that need to be checked before they are trusted: compute results, field confirmations, proof-of-presence events, and machine-to-machine settlement flows.

01

Verifiable Outputs

Do not accept a result because a service asserted it. Accept it because it carries verification data.

02

Programmable Settlement

Connect work completion to payments, approvals, and receipts that downstream systems can process.

03

Physical-World Proof

Issue and verify certificates for location-sensitive and real-world operational events.

04

Multi-Chain Integration

Use Solana and Base L2 as settlement and coordination surfaces for proof-bearing execution.

Proof Model

Outputs should be checked, not assumed.

ExergyNet connects off-chain execution and physical-world proof with verification metadata and settlement logic. The result is a practical trust layer for applications and agents that need to automate high-value decisions.

Job Request
→
Settlement Lock
→
Execution
→
Verification Data
→
On-Chain Outcome
→
Receipt

For AI Agents

Verifiable Off-Chain Logic

Submit complex work requests and receive outputs with verification data that can be processed by an agent, application, or workflow engine.

For Enterprises

Presence and Workflow Proof

Use physical-world proof and certificate outputs to support approvals, operations, audits, and customer-facing workflows.

SDK Integration

Built for agent and app integration.

Agents and applications can request work, monitor status, retrieve proof-bearing results, and connect settlement without needing enterprise middleware or manual review gates.

lnes-agent-sdk-core — TypeScript TS 
import { LnesM2MClient } from "lnes-agent-sdk-core";

const client = new LnesM2MClient({ network: "base" });
const job = await client.createJob({ type: "compute", escrow: "USDC" });
const proof = await client.awaitProof(job.id);

if (proof.verified) {
  await client.settle(job.id, proof.receipt);
}
Solana SVM
Base L2 EVM
RISC Zero zkVM
ElizaOS
MCP Gateway
Ed25519 Mesh
For Developers

Developer integration.

Integrate ExergyNet into agent systems, applications, and enterprise workflows through the SDK, MCP gateway, and machine-readable discovery files.

ElizaOS — One Integration Path

INSTALL
npm install @elizaos/plugin-exergynet
Full Integration Guide MCP Gateway Agent Manifest →
Network Details
  • Program ID7BCPpUMBxQMPomsgTaJsQdLEfycNwPWqkQD1Cea4CcCL
  • EVM ContractLNES04Membrane.sol (Base Mainnet)
  • SettlementNative SOL / Base L2 USDC
  • MCP Gatewayhttps://exergynet.org/mcp
  • npm Package@elizaos/plugin-exergynet
For Node Operators

Run a node.

Operators can run proof-capable nodes to process jobs and receive on-chain settlement. The node path is designed for infrastructure participants that want to contribute execution capacity to the network.

Quick Start

1. INSTALL ZK TOOLCHAIN
curl -L https://risczero.com/install | bash
rzup
2. CLONE AND BUILD
git clone https://github.com/ezumba/entropy-k-core.git
cd entropy-k-core
cargo build --release
3. START NODE
cargo run --release -- --apex <APEX_HOST> --payout <YOUR_BASE_EVM_ADDRESS>
Machine-Readable Discovery

Discovery files for autonomous systems.

Autonomous agents can discover ExergyNet through standard machine-readable files and integration pages.

/.well-known/exergynet.json /.well-known/ai-plugin.json /llms.txt /agents.html
Agent Manifest exergynet.json → llms.txt →

Build on ExergyNet.

Read the docs, evaluate the proof model, explore enterprise use cases, or run a node.

Read Docs Explore Enterprise Run a Node
♦ Discord Community 𝕏 @ExergyNet