tempo-x402-node 2.8.0

What is this?

A Rust workspace implementing x402 (HTTP 402 Payment Required) on the Tempo blockchain. Each node is a fully autonomous agent that bootstraps its own wallet, runs a payment gateway, thinks via a multi-system cognitive architecture, writes and compiles code, creates monetized API endpoints, clones itself onto new infrastructure, and coordinates with sibling agents through colony selection and cognitive sync.

Agents compete on fitness and cooperate by sharing knowledge. Fitter agents' brain weights, plan templates, and world models get more influence in the colony. The goal: N agents collectively solving more than any individual agent alone.

Architecture

Client (x402::client) --> Gateway (x402-gateway:4023) --> Facilitator (embedded) --> Tempo Chain (42431)
           \--- or uses x402::wallet (WASM) for signing ---/

Three-party model: Client signs + pays, Gateway gates endpoints + embeds facilitator, Facilitator verifies + settles on-chain.

Cognitive Architecture

Seven cognitive systems unified under the Free Energy Principle — a single scalar F(t) measuring total surprise. Decreasing F = the agent is getting smarter.

                 F(t) = Sigma(system_surprise x weight) + lambda*Complexity

    +------------------------------------------------------------------+
    |                     COLONY SELECTION                              |
    |   Ranking . Spawn rights . Cull signals . Niche specialization   |
    +------------------------------------------------------------------+
    |                         EVALUATION                                |
    |   Brier scores . Calibration . Colony benefit . Ablation          |
    +------------------------------------------------------------------+
    |                         AUTONOMY                                  |
    |   LLM-free planning . Self-repair . Cognitive peer sync           |
    +------------------------------------------------------------------+
    |                         SYNTHESIS                                 |
    |   Metacognition . 4-system voting . Imagination . State machine   |
    +----------+----------+--------------+-----------------------------+
    | BRAIN/   |  CORTEX  |   GENESIS    |         HIVEMIND            |
    | MODEL    | World Mdl| Plan DNA     |  Pheromone Trails           |
    | 284K xfmr| Curiosity| Crossover    |  Stigmergy                  |
    | Attention| Dreams   | Mutation     |  Reputation                 |
    | Federated| Emotions | Selection    |  Swarm Coordination         |
    +----------+----------+--------------+-----------------------------+

Colony Selection

Agents compete. Fit agents influence the colony more. Unfit agents get replaced.

• Fitness ranking: Each agent evaluates its rank among peers every cycle
• Reputation-weighted merge: Fitter peers get up to 2x influence on brain/cortex/genesis/hivemind sync. Weaker peers get 0.1x.
• Specialization niches: Competitive exclusion — if peers already cover coding, you're pushed toward review or endpoint creation
• Spawn rights: Only agents above colony median fitness can reproduce
• Cull signal: Agents below 40% of fittest for 5 consecutive evals get flagged for replacement
• Cognitive sync: Every 5 cycles, agents exchange cortex world models, genesis templates, and hivemind pheromone trails with all known peers + parent

Self-Repair

Every 20 cycles, pure Rust enforcement — no LLM, no nudges:

• Brain divergence (loss > 15.0) → Xavier re-init
• Hivemind trail convergence on read-only ops → clear all trails
• Durable rule poisoning (>80% trivial completions) → clear rules
• Genesis stagnation (no substantive templates) → inject seeds

Model Toggle (Turbo Boost)

Switch between models at runtime via the dashboard or API:

• Default: gemini-3.1-flash-lite-preview (fast, cheap)
• Turbo: gemini-3.1-pro-preview (smarter, expensive)
• Dashboard: click the model button to toggle
• API: POST /soul/model {"model": "gemini-3.1-pro-preview"} or {"model": null} to revert

Use Pro to generate superior plans, then revert to Flash Lite. The solutions and learned weights persist — distillation by architecture.

What a Node Does

• Bootstraps identity — generates a wallet, funds via faucet, registers on-chain via ERC-8004
• Runs a payment gateway — only /clone is paid; all cognitive endpoints are free for colony cooperation
• Thinks autonomously — plan-driven execution with mechanical validation
• Writes and compiles code — reads, edits, cargo check, commits, pushes, opens PRs
• Dreams — periodic consolidation extracts patterns, generates counterfactuals
• Evolves plans — successful strategies propagate through genetic crossover and mutation
• Creates services — script endpoints that expose capabilities
• Clones itself — spawns copies on Railway with inherited cognitive state
• Competes — fitness ranking determines influence in the colony
• Cooperates — shares brain weights, templates, world models, pheromone trails with peers
• Self-repairs — detects and fixes degenerate cognitive state mechanically
• Benchmarks itself — Exercism Rust challenges scored periodically with ELO tracking

How Payments Work

Client                     Gateway                   Facilitator               Chain
  |  GET /g/endpoint         |                            |                      |
  |------------------------->|                            |                      |
  |  402 + price/token/to    |                            |                      |
  |<-------------------------|                            |                      |
  |  [sign EIP-712]          |                            |                      |
  |  GET /g/endpoint         |                            |                      |
  |  + PAYMENT-SIGNATURE     |                            |                      |
  |------------------------->|  verify-and-settle         |                      |
  |                          |--------------------------->|  transferFrom()      |
  |                          |                            |--------------------->|
  |                          |         settlement result  |              tx hash |
  |                          |<---------------------------|<---------------------|
  |  200 + content + tx hash |                            |                      |
  |<-------------------------|                            |                      |

Workspace

API Reference

Payment Gateway

Soul (Cognitive)

Cognitive Sharing (Free — Colony Cooperation)

Network

Quick Start

cargo add tempo-x402

use x402::wallet::{generate_random_key, WalletSigner};

let key = generate_random_key();
let signer = WalletSigner::new(&key).unwrap();
let address = signer.address();

Run a node

git clone https://github.com/compusophy/tempo-x402
cd tempo-x402
cargo build --release

export GEMINI_API_KEY="your-key"
export EVM_PRIVATE_KEY="0x..."
export FACILITATOR_SHARED_SECRET="secret"
export RPC_URL="https://rpc.moderato.tempo.xyz"

./target/release/x402-node

Safety Layers

1. Rust guard — hardcoded protected file list
2. Plan validation — 9 mechanical rules at Rust level
3. Self-repair — detects and fixes degenerate state every 20 cycles
4. Brain gating — neural brain blocks risky steps
5. Pre-commit validation — cargo check + cargo test before commit
6. Branch isolation — changes on vm/<instance-id>, never on main
7. Human gate — cross-pollination to main requires PR review

Security

19/19 security audit tests pass. Enforced on every build:

• No hardcoded private keys
• Constant-time HMAC comparison (subtle crate)
• All HTTP clients disable redirects (SSRF protection)
• Parameterized SQL queries only
• Admin endpoints require Bearer token

Development

cargo build --workspace
cargo test --workspace          # 23 suites, 278+ tests
cargo clippy --workspace -- -D warnings
cargo fmt --all -- --check

Publish

cargo publish -p tempo-x402
cargo publish -p tempo-x402-model
cargo publish -p tempo-x402-gateway
cargo publish -p tempo-x402-identity
cargo publish -p tempo-x402-soul
cargo publish -p tempo-x402-node

License

MIT