Apraxus Official Brand Mark
Apraxus
Phase 02: Core Blockchain PrototypeBuilding in Public

Infrastructure for the Autonomous Economy.

A high-throughput blockchain engineered in native Rust for AI agents, programmable payments, and secure machine-to-machine transactions under deterministic cryptographic policy bounds.

LATEST BLOCKSLIVE

Live blockchain height

Live Apraxus Network
TOTAL SUPPLYAPXS

Current APXS supply

Live Apraxus Network
NETWORK STATUSLIVE API
LOADING

Connecting to Apraxus

Live Apraxus Network
CHAIN VALIDITYVERIFIED

Cryptographic chain verification

Live Apraxus Network
02 / The Core Problem

AI can think. But it still lacks infrastructure to act safely.

Today’s AI models can plan multi-step workflows, generate software, and orchestrate complex tasks. But when given a private key or API token, existing blockchains provide binary authority — either total access or none. If an agent experiences a prompt injection or hallucinates, funds are irreversibly drained.

Agent Identity Primitives

Cryptographic sub-identities derived via Ed25519 linked to human master keys with mathematical boundaries on authorized signing domains.

Deterministic Envelopes

Hard protocol bounds enforcing spend rates, destination address allowlists, asset constraints, and auto-revocation triggers.

Verifiable State Receipts

Cryptographic execution proofs and audit logs sealed directly into the Apraxus Merkle state tree for offline dispute resolution.

03 / Protocol Thesis

The Autonomous Execution Pipeline

How human intent safely translates into verifiable, bounded machine execution.

01
INTENTHuman defines objective & budget
02
AGENTAutonomous loop generates steps
03
POLICYEnvelope validates spend ceiling
04
WALLETEphemeral sub-key signs digest
05
EXECUTIONRust validator verifies & commits
06
RECEIPTState Merkle proof generated
04 / Agent Infrastructure Layer

Cryptographic Policy Envelopes

Inspect the native cryptographic primitives, delegated key hierarchies, and deterministic spend ceilings powering Apraxus agent sandboxes.

UNDER DEV

Delegated Key Derivation

Human master operators sign cryptographic root delegations. The agent executes via ephemeral Ed25519 sub-keys with cryptographic boundaries bound to its public key digest.

`master_key.derive_agent_envelope()`

Time-Lock Spending Ceilings

Prevents infinite drain loops. Each envelope limits maximum cumulative spending across rolling windows (e.g. 50 USDC/hr), validated deterministically on-chain before transaction queueing.

`spend_window.enforce_ceiling()`

Instant State Revocation

In the event of an anomalous prompt injection or aberrant model behavior, operators broadcast a single-byte revocation payload that instantly invalidates the envelope across all active network nodes.

`revocation_registry.invalidate_id()`
05 / Programmable Settlement

Machine-to-Machine Payment Channels

High-throughput, sub-second payment primitives designed for autonomous agent delegation and hardware settlement.

Agent → API Service

Designed for M2M

Autonomous compute and LLM token purchases governed by per-hour micro-budget policies.

AI Research Agent
Signed Policy
Inference Gateway
Policy: Max 10 USDC/hr • Auto-Revoke on Error

Agent → Autonomous Agent

Designed for M2M

Decentralized task delegation where one orchestrator agent subcontracts work to specialized worker nodes.

Orchestrator Agent
Signed Policy
Data Scraper Agent
Policy: Milestone Escrow • Cryptographic Proof

Agent → Smart Contract

Designed for M2M

Automated treasury rebalancing, liquidity provision, and protocol interactions under multi-sig thresholds.

Treasury Agent
Signed Policy
DEX Router Contract
Policy: Slippage < 0.5% • Allowlisted Pools Only

Machine → Machine (Hardware)

Designed for M2M

Edge compute nodes, IoT devices, and autonomous hardware executing trustless settlement over native channels.

Autonomous Drone
Signed Policy
Charging Station
Policy: Hardware Attestation • Pay-per-Watt
06 & 07 / Technology & Architecture

Real Engineering vs Target Architecture

We strictly separate completed Rust prototype deliverables from the long-term protocol specification.

Full Technical Breakdown
Rust Blockchain CoreSHIPPED

Native Rust crate implementing immutable block data structures, cryptographic hashing, and genesis validation.

`apraxus-core::block::Block`
Ed25519 SignaturesSHIPPED

Cryptographic transaction signing and verification pipeline with replay attack prevention and nonce ordering.

`apraxus-crypto::verify_sig()`
State Persistence EngineTESTING

Local embedded key-value state tree storing account balances, policy envelopes, and execution receipts.

`apraxus-state::merkle_tree`
TCP Peer NetworkingUNDER DEV

Point-to-point node communications, transaction mempool propagation, and block broadcast protocol over asynchronous Tokio runtime.

`apraxus-net::tokio_tcp`
Agent Policy Envelope DaemonUNDER DEV

Pre-flight execution layer verifying budget limits, asset allowlists, and execution permissions before submitting block payloads.

`apraxus-policy::eval_tx()`
Local Single-Node TestbedTESTING

CLI suite and integration test harness validating end-to-end block production and transaction lifecycle locally.

`cargo test --package apraxus-node`
Developer Experience

Built for Modern Agent Frameworks

Integrate Apraxus policy-controlled wallets seamlessly into LangChain, AutoGen, CrewAI, or standalone Rust/Python pipelines in less than 10 lines of code.

1Sub-second cryptographic verification
2Deterministic zero-trust spend ceilings
3Instant multi-sig human escalation triggers
use apraxus_sdk::prelude::*;
use apraxus_policy::{PolicyEnvelope, SpendLimit};

#[tokio::main]
async fn main() -> Result<(), ApraxusError> {
    // 1. Connect to local Apraxus testbed node
    let client = ApraxusClient::connect("http://127.0.0.1:8545").await?;

    // 2. Initialize Agent Wallet under Human Operator Root Key
    let operator_key = Keypair::from_secret_env("MASTER_OPERATOR_SECRET")?;
    let mut agent = AgentWallet::new("research-crawler-09", &operator_key);

    // 3. Define and seal strict autonomous policy bounds
    let policy = PolicyEnvelope::builder()
        .max_hourly_spend(25.0) // USDC
        .allow_destination("0x71C...OpenAIComputeGateway")
        .allow_asset("USDC")
        .require_multi_sig_above(100.0)
        .build()?;

    agent.bind_policy(policy).await?;

    // 4. Autonomous Agent executes sub-second M2M micro-payment
    let receipt = agent.transact_m2m(
        "0x71C...OpenAIComputeGateway",
        4.20,
        "BATCH_INFERENCE_PAYMENT",
    ).await?;

    println!("Transaction Committed! TxHash: {}", receipt.tx_hash);
    println!("State Merkle Root Sealed in Block #{}", receipt.block_number);
    Ok(())
}
09 & 10 / Building in Public

Engineering Milestone Evidence

Every release links directly to commits, PRs, and verifiable technical deliverables.

View Full 9-Phase Roadmap
Filter:
Development #03SHIPPED

Ed25519 Cryptographic Verification Pipeline & Replay Defense

August 2026
Cryptography

Implemented deterministic signature verification routines and sequential nonce ordering inside the transaction validation pool to eliminate replay vectors.

Next step: Complete asynchronous TCP peer handshake protocol in Tokio.
View Commit Evidence
Development #02SHIPPED

Immutable Block Data Structures & Merkle Tree Root Hashing

July 2026
Core

Built the core Rust block header representation, bincode transaction serializer, and Merkle tree state accumulator for sub-second receipt generation.

Next step: Integrate cryptographic transaction verification.
View Commit Evidence
Development #01SHIPPED

Genesis Architecture & Protocol Master Specification

June 2026
Specification

Authored the formal Apraxus technical blueprint detailing autonomous agent policy bounds, tokenless initial testbed, and M2M settlement thesis.

Next step: Initialize core Rust blockchain repository.
View Commit Evidence
13 / Final Principle

The autonomous economy needs infrastructure.

Apraxus is being engineered in public, one layer at a time. Join the developers, researchers, and builders shaping the machine layer.