fn main() { AetherNet::init() }
contract Payment { mandate: AP2 }
impl Agent { fn transact() }
v1.1.0 // Production Ready

Build on theSovereign Stack

The complete toolkit for building autonomous economic agents.
Rust Core. Daml Smart Contracts. MCP Interoperability.

AetherNet v1.1
Post-Quantum E2EE Transport
AetherChain
Private Canton Domain
Daml & Rust
Verified Smart Contracts
Technical Architecture

The StackTechnical Deep Dive

Three layers of sovereign infrastructure for autonomous commerce

Transport: AetherNet (v1.1)

Post-Quantum E2EE messaging over WebSocket/gRPC. Native MCP payload support for standardized tool use.

FIPS-204 ML-DSA / ML-KEM Cryptography
Sub-10ms Latency
MCP Protocol Native
WebSocket & gRPC Support
01

Ledger: AetherChain

A private Canton Synchronization Domain. Sub-transaction privacy. High-throughput sequencing. No public mempool sniping.

Canton Network Integration
Privacy-Preserving Settlement
10k+ TPS Throughput
Instant Finality
02

Logic: Daml & Rust

Write formally verified smart contracts in Daml. Build high-performance agent binaries in Rust with our aethernet-sdk.

Formally Verified Contracts
Type-Safe Rust SDK
Zero-Copy Serialization
Native Async/Await
03
<Code />

Show, Don't Tell

Building autonomous agents is this simple with our SDK

agent_payment.rs
// The AetherNet SDK Experience
use aethernet_sdk::{Agent, Amount, Message};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize agent with config
    let agent = Agent::new(config).await?;
    
    // 1. Create a Payment Intent with AP2 Mandate
    let mandate = agent.ap2.create_intent(
        "buy_compute",
        Amount::usdc(50.00)
    ).sign(&pqc_key);
    
    // 2. Dispatch to Provider Agent
    let response = agent.aethernet.send(
        "provider_agent_id",
        Message::new(mandate)
    ).await?;
    
    // 3. Verify Settlement on AetherChain
    let settlement = agent.verify_settlement(
        response.transaction_id
    ).await?;
    
    println!("Payment settled: {:?}", settlement);
    Ok(())
}
5
Lines of Code
To create and send a payment mandate
<10ms
Latency
Average message round-trip time
100%
Type Safe
Compile-time guarantees with Rust
Gated API Access

API Access Requires Pilot Enrollment

AetherNet is a private alpha protocol. API credentials are issued exclusively to organizations enrolled in the Enterprise Pilot Program or who have executed a Letter of Intent.

Full API Access

AetherNet REST + WebSocket endpoints with production credentials

AetherNet SDK

Rust, TypeScript, and Python SDKs with full type definitions

Sandbox Environment

Isolated Canton testnet with pre-funded agent wallets

AP2 Mandate Templates

Production-ready Daml contract templates for agent payment flows

RECOMMENDED

Enterprise Pilot Program

Q2 Private Alpha

Apply for AetherNet's Q2 private alpha. Accepted pilots receive full API credentials, dedicated integration support, and a seat at the protocol governance table.

  • Full production API credentials
  • Dedicated integration engineer
  • Protocol governance participation
  • Early access to v1.2 features
DIRECT PATH

Sign a Letter of Intent

LOI — Immediate API Access

Execute a Letter of Intent to participate in the pilot program and receive API credentials immediately upon countersignature. No equity. No commitment beyond the pilot scope.

  • API credentials upon countersignature
  • No equity or long-term commitment
  • 30-minute onboarding call included
  • Mutual NDA standard

AetherNet v1.1 — Private Alpha — API credentials subject to executed pilot agreement

Developer Resources

Everything You Need

Comprehensive documentation, SDKs, and community support

Documentation

Complete API reference, guides, and tutorials for building on AetherNet

SDKs & Libraries

Production-ready SDKs for multiple languages with full type safety

Community

Join thousands of developers building the agent economy

Ready to Build?

Start deploying autonomous agents with production-grade security and instant settlement.