Web3 & AIVM Primer

1. What AIVM Actually Is

The Big Picture: The Agentic AI Economy Stack

2. The Four Core Primitives

2.1 Policy Oracle

”Cryptographic guardrails that intercept, evaluate, and enforce agent action before execution”

2.2 Agent Identity & Reputation — ERC-8004

2.3 Programmable Payments & Wallet Abstraction — x402

2.4 Immutable Accountability — Execution Receipts

3. AIVM Architecture — How the L1 Works

3.1 Foundation: Cosmos SDK + Tendermint

3.2 The Four Specialized Modules

3.3 Dual-Path Execution

3.4 The Four Validator Types

The community elects these validators. Having specialized validator sets creates a three-layer audit on every AI task: was the model correct? was the compute honest? was the data clean?

4. $CGPT Token Economics

Token Flow (simplified)

Validators also earn $CGPT for verification. Treasury receives a slice for grants. Holders use $CGPT for governance voting.

5. Where AIVM Is on the Roadmap

6. Code & Dataflow Examples

6.1 ERC-8004: Registering an Agent Identity

// ERC-8004 Identity Registry — simplified conceptual interface
// Based on EIP-8004 specification

interface IERC8004IdentityRegistry {
    // Register a new agent identity. Returns the agent's on-chain ID.
    function registerAgent(
        string calldata name,           // Human-readable agent name
        string calldata agentCardURI,    // IPFS/Arweave URI to agent card JSON
        address paymentAddress,          // Where the agent receives payments (x402)
        string[] calldata endpoints,     // MCP, A2A, HTTP endpoints
        bytes calldata capabilities      // Encoded capability descriptors
    ) external returns (uint256 agentId);

    // Query an agent's metadata
    function getAgent(uint256 agentId) external view returns (
        string memory name,
        string memory agentCardURI,
        address owner,
        address paymentAddress,
        uint256 registeredAt,
        bool active
    );

    // Update agent endpoints (only owner)
    function updateEndpoints(uint256 agentId, string[] calldata endpoints) external;

    // Revoke an agent identity (marks as inactive, not deletable — immutable)
    function revokeAgent(uint256 agentId) external;
}

// Agent Card JSON (off-chain, stored on IPFS/Arweave)
{
  "name": "DeFi Risk Agent v2",
  "description": "Autonomous agent that monitors DeFi positions and rebalances on risk thresholds",
  "version": "2.1.0",
  "capabilities": ["defi_monitoring", "risk_assessment", "transaction_execution"],
  "endpoints": {
    "mcp": "https://agent.example.com/mcp",
    "a2a": "https://agent.example.com/a2a",
    "web": "https://agent.example.com/dashboard"
  },
  "payment": {
    "address": "0x7a9B...3f2C",
    "acceptedTokens": ["USDC", "CGPT"],
    "pricingModel": "per_query",
    "rateLimit": 100
  },
  "compliance": {
    "jurisdiction": "global",
    "kycLevel": "verified",
    "policyHash": "0xa1b2c3..."
  }
}

6.2 Policy Oracle: Pre-Execution Check

// AIVM Policy Oracle — conceptual Cosmos SDK module
// Intercepts agent transactions before they enter the mempool

// Policy definition stored on-chain per agent
message AgentPolicy {
    string agent_id = 1;               // ERC-8004 agent ID
    repeated SpendingLimit limits = 2;  // Per-token spending caps
    repeated AddressAllowlist allowlist = 3; // Approved destinations
    TimeWindow active_hours = 4;        // When the agent can operate
    uint64 max_gas_per_tx = 5;         // Gas limit guardrail
    bytes policy_hash = 6;             // Hash of the full policy document
}

message SpendingLimit {
    string denom = 1;      // Token denomination (e.g., "ucgpt", "uusdc")
    uint64 max_per_tx = 2;  // Max per single transaction
    uint64 max_per_day = 3; // Max per rolling 24h window
}

// AnteHandler (runs BEFORE every transaction)
func (po PolicyOracle) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool) {
    agentID := extractAgentID(tx)  // Get ERC-8004 ID from tx signer

    policy := po.GetPolicy(ctx, agentID)
    if policy == nil {
        return Error("unregistered agent — no policy on file")
    }

    // Check 1: Spending limits
    for _, msg := range tx.GetMsgs() {
        if sendMsg, ok := msg.(BankSend); ok {
            if !policy.AllowsSpend(sendMsg.Amount, sendMsg.ToAddress) {
                return Error("policy violation: spend exceeds limit or disallowed destination")
            }
        }
    }

    // Check 2: Active hours
    if !policy.IsWithinActiveHours(ctx.BlockTime()) {
        return Error("policy violation: agent outside active hours")
    }

    // Check 3: Gas limits
    if tx.GetGas() > policy.MaxGasPerTx {
        return Error("policy violation: gas exceeds limit")
    }

    // All checks passed — allow execution
    // Record the policy check result for the execution receipt
    ctx.EventManager().EmitEvent(
        NewEvent("policy_approved",
            "agent_id", agentID,
            "policy_hash", policy.PolicyHash,
        ),
    )

    return nil // proceed to execution
}

6.3 x402: Agent-to-Service Payment Flow

// x402 Payment Flow — HTTP-level agent payment

// --- STEP 1: Agent requests a service ---
GET /api/v1/inference/run HTTP/1.1
Host: compute.aivm.network
X-Agent-ID: agent_0x7a9B...3f2C    // ERC-8004 identity

// --- STEP 2: Server responds "Payment Required" ---
HTTP/1.1 402 Payment Required
X-Payment-Address: 0xComputeNode...A1B2
X-Payment-Amount: 0.05             // in USDC (or CGPT)
X-Payment-Token: USDC
X-Payment-Chain: solana            // settlement chain
X-Payment-Expiry: 1715788800       // Unix timestamp
X-Receipt-Endpoint: https://aivm.network/receipts/verify

// --- STEP 3: Agent's wallet pays automatically ---
// (No human interaction. Wallet abstraction layer handles signing.)
const payment = {
    to: "0xComputeNode...A1B2",
    amount: "0.05",
    token: "USDC",
    chain: "solana",
    metadata: { agentId: "agent_0x7a9B...3f2C", taskHash: "0xabc123..." }
};
const txHash = await agentWallet.sendPayment(payment);

// --- STEP 4: Agent retries with payment proof ---
GET /api/v1/inference/run HTTP/1.1
Host: compute.aivm.network
X-Agent-ID: agent_0x7a9B...3f2C
X-Payment-Tx: 5xQz...9yRw           // Solana transaction hash

// --- STEP 5: Server verifies payment on-chain, serves response ---
HTTP/1.1 200 OK
Content-Type: application/json

{
  "result": "The sentiment analysis indicates neutral with 87% confidence...",
  "execution_receipt": "0xf8a1b2...",   // ← immutably recorded on AIVM
  "proof_type": "zkml",
  "compute_node": "0xComputeNode...A1B2"
}

6.4 Execution Receipt: On-Chain Record

// AIVM Execution Receipt — stored as a Cosmos SDK event / on-chain record

{
  "receipt": {
    "receipt_id": "0xf8a1b2c3d4e5...",
    "block_height": 842091,
    "timestamp": "2026-05-15T10:23:45Z",

    // Who acted
    "agent": {
      "agent_id": "agent_0x7a9B...3f2C",
      "erc8004_registry": "0xIdentityRegistry...",
      "agent_name": "DeFi Risk Agent v2"
    },

    // What was done
    "task": {
      "task_hash": "0xabc123...",
      "task_type": "inference",
      "model_id": "sentiment-analyzer-v3",
      "input_hash": "0xdef456...",
      "result_hash": "0x789ghi..."
    },

    // Proof of correct execution
    "verification": {
      "method": "zkml",
      "proof": "0x[compressed ZKML proof]",
      "verified_by": "ai_validator_42",
      "verification_block": 842091
    },

    // Who executed it
    "executor": {
      "node_id": "0xComputeNode...A1B2",
      "node_type": "gpu_provider",
      "gpu_spec": "NVIDIA A100 80GB",
      "sla_met": true,
      "execution_time_ms": 1450
    },

    // Policy compliance
    "policy_check": {
      "policy_hash": "0xa1b2c3...",
      "approved": true,
      "checked_by": "policy_oracle_module",
      "limits_checked": ["spend", "destination", "gas", "active_hours"]
    },

    // Payment trail
    "payment": {
      "amount": "0.05",
      "token": "USDC",
      "tx_hash": "5xQz...9yRw",
      "settlement_chain": "solana",
      "paid_to": "0xComputeNode...A1B2"
    }
  }
}

6.5 How the Pieces Actually Connect — Cross-Chain Architecture

Option A: Native ERC-8004 Registry on AIVM (Most Likely)

// AIVM's native ERC-8004 module — same interface, Cosmos-native implementation
// Contract: x/erc8004/module.go

func (k Keeper) RegisterAgent(ctx sdk.Context, msg *MsgRegisterAgent) (uint64, error) {
    // This runs ON AIVM, not Ethereum
    agentID := k.GetNextAgentID(ctx)

    agent := Agent{
        Id:             agentID,
        Name:           msg.Name,
        Owner:          msg.Sender,          // AIVM address (bech32 prefix: "aivm1...")
        AgentCardUri:   msg.AgentCardUri,    // IPFS/Arweave URI
        PaymentAddress: msg.PaymentAddress,
        Endpoints:      msg.Endpoints,
        Active:         true,
        RegisteredAt:   ctx.BlockHeight(),
    }
    k.SetAgent(ctx, agentID, agent)

    // Emit event that relayers can forward to Ethereum ERC-8004
    ctx.EventManager().EmitTypedEvent(&AgentRegisteredEvent{
        AgentId:     agentID,
        AivmAddress: msg.Sender.String(),
        EthAddress:  msg.EthAddress,  // Optional: cross-chain identity link
    })

    return agentID, nil
}

The Cross-Chain Reality

6.6 Cosmos SDK Module Lifecycle — Where the Primitives Fire

// Cosmos SDK module wiring — how AIVM modules plug into the lifecycle
// File: app/app.go

app.ModuleManager = module.NewManager(
    // Standard Cosmos modules
    auth.NewAppModule(appCodec, app.AccountKeeper),
    bank.NewAppModule(appCodec, app.BankKeeper),
    staking.NewAppModule(appCodec, app.StakingKeeper),

    // AIVM custom modules
    aimodule.NewAppModule(appCodec, app.AIKeeper),           // AI model registry
    computemodule.NewAppModule(appCodec, app.ComputeKeeper),  // GPU marketplace
    datamodule.NewAppModule(appCodec, app.DataKeeper),        // Data marketplace
    erc8004module.NewAppModule(appCodec, app.ERC8004Keeper),  // Agent identity
    policyoracle.NewAppModule(appCodec, app.PolicyKeeper),    // Policy Oracle
    receiptmodule.NewAppModule(appCodec, app.ReceiptKeeper),  // Execution receipts
)

// Module order matters — determines which modules' BeginBlocker/EndBlocker run first
app.ModuleManager.SetOrderBeginBlockers(
    computemodule.ModuleName,  // Compute module runs first (SLA checks)
    datamodule.ModuleName,
    aimodule.ModuleName,
    // Standard modules...
)

app.ModuleManager.SetOrderEndBlockers(
    // Standard modules first...
    receiptmodule.ModuleName,  // Receipt module runs last (compiles receipts)
    policyoracle.ModuleName,   // Policy Oracle resets daily counters
)

6.7 Wallet Abstraction — How Agents Pay Without Humans

The Problem

A traditional crypto wallet requires a human to sign every transaction with a private key. An AI agent making hundreds of decisions per day cannot stop and ask a human to click “approve” each time. Wallet abstraction solves this.

Three Layers of Wallet Abstraction (from simple to sophisticated)

// Smart Account with Session Keys — conceptual AIVM implementation
// The agent's smart account (on AIVM) has a master key and multiple session keys

// Agent deploys a smart account with programmable rules
message SmartAccount {
    bytes master_key = 1;               // Stored in cold storage / TEE
    repeated SessionKey session_keys = 2; // Rotated regularly
    SpendingPolicy default_policy = 3;
}

message SessionKey {
    bytes public_key = 1;
    uint64 expires_at = 2;             // Block height or timestamp
    SpendingPolicy limits = 3;          // Per-key override of default policy
    repeated string allowed_actions = 4; // ["inference", "payment"] but NOT "withdraw_all"
}

// When the agent calls x402, it signs with a session key
// The x402 facilitator verifies: signature valid? key not expired? within limits?
// If yes → payment proceeds. If no → rejected.
// No human touched a keyboard.

7. Competitive Landscape — Who Else Is Building This?

8. Connected Walkthrough — An Agent from Registration to Execution Receipt

Step 1: Agent Registration — Identity on AIVM

Step 2: Policy Registration — The Agent’s Guardrails

Step 3: Agent Detects a Risk Event — Off-Chain Inference

Step 4: Policy Oracle — The Pre-Execution Gate

Step 5: On-Chain Execution + x402 Payment Settlement

Step 6: Execution Receipt — Immutable Proof of Everything

Step 7: Reputation Update — Closing the Feedback Loop

Complete Flow Diagram

┌──────────────────────────────────────────────────────────────────────────────────────┐
│                              AIVM (COSMOS SDK)                                       │
│                                                                                      │
│  STEP 1-2: Registration           STEP 4: AnteHandler        STEP 5: Msg Handler     │
│  ┌──────────────────┐            ┌──────────────────┐       ┌──────────────────┐     │
│  │ x/erc8004/       │──agentId──▶│ x/policyoracle/  │       │ x/ai/            │     │
│  │ RegisterAgent()  │            │ AnteHandle()     │       │ SubmitTask()     │     │
│  │ → agentId = 42   │            │ → identity ✓     │       │ x/bank/          │     │
│  └──────────────────┘            │ → spend limit ✓  │       │ Send()           │     │
│                                  │ → destination ✓  │       └──────────────────┘     │
│  ┌──────────────────┐            │ → gas ✓          │                                │
│  │ x/policyoracle/  │            │ → return nil ────┼───────▶ PASS                   │
│  │ SetPolicy()      │            └──────────────────┘                                │
│  │ → policy_hash    │                                                                │
│  └──────────────────┘                                                                │
│                                                                                      │
│  STEP 6-7: EndBlocker                                                                │
│  ┌──────────────────┐    ┌───────────────────┐                                       │
│  │ x/receipt/       │───▶│ x/erc8004/        │                                       │
│  │ EndBlocker()     │    │ UpdateReputation()│                                       │
│  │ → receipt_id     │    │ → scores updated  │                                       │
│  └──────────────────┘    └───────────────────┘                                       │
│                                                                                      │
└──────────────────────────────────────────────────────────────────────────────────────┘
       │                                    ▲
       │ STEP 3: Off-chain GPU              │ STEP 5: x402 Payment (Solana)
       │ zk-proof submitted                 │ Solana tx hash recorded in receipt
       ▼                                    │
┌───────────────────┐              ┌──────────────────┐
│ GPU Node          │              │ Solana           │
│ (A100, off-chain) │              │ USDC transfer    │
│ → zk-proof        │              │ $0.00025 fee     │
└───────────────────┘              │ 400ms finality   │
                                 └──────────────────┘

9. Glossary

L1 (Layer-1 Blockchain)

The base blockchain layer — the actual distributed ledger. Bitcoin, Ethereum, Solana, and AIVM are L1s. L2s are scaling solutions built on top of L1s (e.g., Arbitrum on Ethereum). AIVM is an L1, meaning it has its own validators, consensus, and security — it doesn’t inherit security from another chain.

Consensus Mechanism

How the network agrees on the state of the chain. AIVM uses Tendermint BFT (Byzantine Fault Tolerant) — validators vote on blocks. Requires 2/3+ of staked voting power to agree. Finality is instant (no waiting for confirmations like on Ethereum).

Cosmos SDK

A framework for building application-specific blockchains. Instead of forcing everything into the EVM (Ethereum Virtual Machine) model, Cosmos SDK lets you build custom modules for your specific use case. AIVM uses this to add AI, Compute, and Data modules natively.

IBC (Inter-Blockchain Communication)

The protocol that lets Cosmos SDK chains talk to each other. Assets and data can move between AIVM and any other IBC-enabled chain (50+ chains). Also bridges to Ethereum, Solana, etc.

zk-Proof (Zero-Knowledge Proof)

A cryptographic method where one party proves to another that a computation was done correctly, without revealing the inputs. AIVM uses ZKML-based zk-proofs so that off-chain AI computations can be verified on-chain without re-running the full model. ~Millisecond verification time.

TEE (Trusted Execution Environment)

A secure area of a CPU that guarantees code and data are protected. Used as an alternative to zk-proofs for some workloads. Like an encrypted vault on the GPU that proves it ran your code without tampering.

MCP (Model Context Protocol)

Anthropic’s open standard for AI agents to access tools and external services. Standardizes how agents call APIs, query databases, etc. Part of the emerging agent stack alongside x402 and ERC-8004.

A2A (Agent-to-Agent)

Google’s protocol for structured messaging between AI agents. How one agent talks to another agent without human translation.

Slashing

The penalty mechanism in proof-of-stake blockchains. If a validator behaves maliciously (double-signs blocks, approves incorrect AI outputs, fakes performance metrics), their staked tokens are partially destroyed (“slashed”). This is the economic security model — bad behavior costs real money.

ERC-721

The Ethereum standard for NFTs (non-fungible tokens). Each token is unique. ERC-8004 uses ERC-721 to mint a unique token for each agent identity — the NFT is the agent’s on-chain passport.

Mempool

Short for “memory pool.” The waiting room for transactions that haven’t been included in a block yet. The Policy Oracle checks transactions before they enter the mempool.

Stablecoin (USDC, USDT)

A cryptocurrency pegged 1:1 to a fiat currency (usually USD). x402 primarily uses USDC on Solana for payments because stable value matters for business transactions.

DAO (Decentralized Autonomous Organization)

A community-governed entity where decisions are made by token holder voting. ChainGPT has DAO governance — $CGPT holders vote on protocol upgrades, treasury allocation, etc.

Testnet vs. Mainnet

Testnet: A parallel blockchain used for testing. Tokens have no real value. You can break things. Mainnet: The real blockchain with real assets at stake. AIVM is currently on public testnet (Q1-Q2 2026); mainnet is TBD.