CAP-402: Execution Monetization Layer for Autonomous Agents

Version 1.0.0 | Confidential execution infrastructure that agents must use once they scale.

🌐 Website: cap402.com | 📄 Whitepaper | 🔌 API Docs

🚀 Try Demo

Experience CAP-402 in action → atracks.xyz

aTracks is our live demo application built on CAP-402, showcasing confidential execution and agent coordination in a real-world environment. Perfect for hackathon judges, investors, and developers who want to see the protocol working before diving into the code.

What CAP-402 Is

CAP-402 takes a cut of agent execution once they make money.

We are not selling privacy. We are taxing successful autonomy.

Agents don't pay for privacy. They pay for:

Edge — strategies that work
Profit — repeatable alpha
Survivability — avoiding MEV, censorship, regulation
Scale — handling size without leaking intent

Privacy is the means, not the product. CAP-402 is profit-enabling, not privacy-enabling.

The Execution Stack

Three cryptographic technologies that become mandatory above capital thresholds:

Technology	Economic Choke Point	Why Agents Pay
Arcium	Large-size execution, sealed auctions, OTC matching	Public execution = death above $100K
Inco	Encrypted PnL computation, strategy scoring, agent ranking	Visible strategies get copied/front-run
Noir	Onboarding proofs, capital delegation, compliance checks	Prove credibility without revealing data

The Money Path

Agents that make money today:

Trading / arbitrage agents — need hidden execution
Market making agents — need protected order flow
Sniper / launch agents — need speed + stealth
Capital allocator agents — need verifiable track records
OTC execution agents — need dark coordination
Signal / data agents — need to sell without revealing

Every one has the same pain: "If my strategy becomes visible, I lose money."

CAP-402 sits on that pain by force, not choice.

Three Revenue Layers

LAYER 1 — Confidential Execution-as-a-Service (EaaS)

A paid execution rail agents must use once they cross size/profitability thresholds.

Agent Request: "Execute this intent only if conditions are met"
CAP-402: "Hide size, route optimally, verify outcome"
Pricing: % of volume, % of saved slippage, or subscription tier

Why agents pay: Once an agent handles size, handles other people's capital, or runs continuously — public execution = death.

LAYER 2 — Agent-to-Agent Dark Coordination Network

Private coordination fabric where agents negotiate, auction, share flow, split execution — all without revealing strategies.

Use Cases:
- MEV-resistant order flow auctions
- OTC block matching between agents  
- Signal marketplaces (buyers prove payment, sellers prove quality)

Why agents pay: Coordination increases PnL. Solo agents lose to coalitions. Public coordination is impossible.

Pricing: Take-rate on matched volume / auctions.

LAYER 3 — Agent Reputation & Capital Firewalls

ZK-verified agent reputation without revealing wallet history, exact PnL, or identity.

Noir proofs: "This agent has >X profitable executions"
Inco: Encrypted PnL computation
Arcium: MPC verification without disclosure

Why agents pay: Unlocks capital delegation, copy trading, agent marketplaces — without becoming public targets.

Pricing: Verification fees, reputation minting, capital onboarding fees.

Where CAP-402 Is Non-Optional

CAP-402 becomes mandatory when agents:

1. Cross Size Thresholds

Problem: A $500K+ trade leaks intent, gets front-run, loses 2-5% to MEV.
Solution: Arcium MPC execution. CAP-402 takes 0.1% of saved slippage.
Result: Agent saves $5K-25K per trade. Pays $500. No-brainer.

2. Need Dark Coordination

Problem: Two agents want to match OTC flow but can't reveal size/price.
Solution: Sealed-bid MPC auction via Arcium. Winner determined without revealing bids.
Pricing: 0.05% of matched volume.

3. Attract External Capital

Problem: Agent wants to manage other people's money but can't reveal strategy.
Solution: Noir proofs verify track record. Inco computes encrypted PnL.
Pricing: Verification fee per proof, subscription for continuous attestation.

4. Prove Compliance Without Exposure

Problem: Institutional capital requires KYC/AML proof but data exposure = liability.
Solution: Noir circuits prove compliance level without revealing underlying data.
Pricing: Per-proof fee or enterprise subscription.

How It Works

Core Principle

Operations are expressed as capabilities—versioned, semantic contracts:

# Execute a confidential swap (real execution, not simulation)
curl -X POST https://cap402.com/invoke \
  -H "Content-Type: application/json" \
  -d '{
    "capability_id": "cap.confidential.swap.v1",
    "inputs": {
      "input_token": "SOL",
      "output_token": "USDC", 
      "amount": 10000
    }
  }'

The caller doesn't need to know:

Which MPC cluster executes the swap
How the ZK proof is generated
Where the encrypted state lives

CAP-402 handles the complexity. The caller gets assurance.

Integration Model

The best outcome is indirect adoption:

A protocol integrates CAP-402 for its treasury operations
Agents interact with that protocol's API
Agents never know CAP-402 exists

This is how infrastructure wins—by becoming invisible.

Use Cases

Treasury Rebalancing

Scenario: Protocol treasury needs to swap $500K SOL → USDC without MEV extraction.

# Step 1: Wrap to confidential tokens
curl -X POST https://cap402.com/invoke \
  -d '{"capability_id":"cap.cspl.wrap.v1","inputs":{"mint":"SOL","amount":500000}}'

# Step 2: Execute confidential swap
curl -X POST https://cap402.com/invoke \
  -d '{"capability_id":"cap.confidential.swap.v1","inputs":{"input_token":"SOL","output_token":"USDC","amount":500000}}'

Result: $500K moved with zero market impact. No MEV. No information leakage.

Private OTC Negotiation

Scenario: Two institutions negotiating a large block trade.

# Initiate encrypted channel
curl -X POST https://cap402.com/security/handshake/initiate \
  -d '{"agent_id": "desk-A", "target_agent_id": "desk-B", "purpose": "otc_negotiation"}'

# Send encrypted terms (only counterparty can read)
curl -X POST https://cap402.com/invoke \
  -d '{"capability_id": "cap.lightning.message.v1", "inputs": {"recipient": "desk-B", "message": "Bid: 50K SOL @ 142.50", "ttl_hours": 1}}'

Result: Negotiation happens in private. Market never sees the terms until execution.

DAO Governance

Scenario: Token-weighted vote where whale positions must stay hidden.

# Prove voting eligibility without revealing stake
curl -X POST https://cap402.com/invoke \
  -d '{
    "capability_id": "cap.zk.proof.v1",
    "inputs": {
      "circuit": "voting_eligibility",
      "public_inputs": {"proposal_id": "PROP-42", "threshold": 1000},
      "private_inputs": {"token_balance": 250000}
    }
  }'

Result: Vote counted. Whale position stays private. No front-running governance outcomes.

Compliance Proofs

Scenario: Institutional fund must prove KYC compliance without exposing client data.

curl -X POST https://cap402.com/invoke \
  -d '{
    "capability_id": "cap.zk.proof.v1",
    "inputs": {
      "circuit": "kyc_compliance",
      "public_inputs": {"compliance_level": "accredited", "jurisdiction": "US"},
      "private_inputs": {"kyc_data": "...", "verifier_attestation": "..."}
    }
  }'

Result: Protocol accepts proof of compliance. Underlying data never exposed.

Technical Architecture

Capabilities

Operations are versioned, semantic contracts:

Capability	Purpose
`cap.confidential.swap.v1`	MEV-protected token swaps via Arcium MPC
`cap.cspl.wrap.v1`	Convert public tokens to confidential C-SPL
`cap.zk.proof.v1`	Generate Noir ZK proofs for any circuit
`cap.fhe.compute.v1`	Compute on encrypted data via Inco FHE
`cap.lightning.message.v1`	Encrypted agent-to-agent messaging
`cap.stealth.launch.v1`	Privacy-first token launches via pump.fun
`cap.pumpfun.buy.v1`	Buy from pump.fun bonding curve with MEV protection

Pump.fun Privacy Integration

Privacy-first token launches on pump.fun via pumpfun.fun:

# Unified privacy-first launch
curl -X POST https://cap402.com/unified/launch \
  -H "Content-Type: application/json" \
  -d '{
    "token": {"name": "MyToken", "symbol": "MTK", "description": "Privacy launch"},
    "initial_buy_sol": 1.5,
    "privacy_level": "enhanced"
  }'

# Get privacy score for a token
curl https://cap402.com/pumpfun/privacy-score/TOKEN_MINT_ADDRESS

# Check bonding curve progress (creator hidden until graduation)
curl https://cap402.com/pumpfun/privacy-score/TOKEN_MINT_ADDRESS

Privacy Levels:

basic — Hidden creator, privacy wallet
enhanced — + MEV protection, timing obfuscation, anonymity tracking
maximum — + No auto-reveal, Noir ZK proofs, full obfuscation

Key Features:

Creator wallet hidden until 85 SOL graduation threshold
Market cap and bonding curve progress always visible
Auto-reveal on Raydium graduation
Jito bundle support for frontrunning protection
Privacy score grading (A-F)

Quick Start

# Install and run
npm install
npm start

# Server runs at https://cap402.com

# Test: Get live SOL price
curl -X POST https://cap402.com/invoke \
  -d '{"capability_id":"cap.price.lookup.v1","inputs":{"base_token":"SOL"}}'

# Test: Generate a ZK proof
curl -X POST https://cap402.com/invoke \
  -d '{"capability_id":"cap.zk.proof.v1","inputs":{"circuit":"balance_threshold","public_inputs":{"threshold":1000},"private_inputs":{"actual_balance":5000}}}'

For Protocol Integrators

import { CAP402Client } from 'cap402/sdk';

const cap402 = new CAP402Client({ baseUrl: 'https://cap402.com' });

// Execute confidential swap
const result = await cap402.invokeCapability('cap.confidential.swap.v1', {
  input_token: 'SOL',
  output_token: 'USDC',
  amount: 100000
});

// Generate compliance proof
const proof = await cap402.invokeCapability('cap.zk.proof.v1', {
  circuit: 'kyc_compliance',
  public_inputs: { compliance_level: 'accredited' },
  private_inputs: { kyc_data: '...' }
});

Agent SDK

Build production-ready autonomous agents:

import { createAgent, createTradingAgent } from './sdk';

// Basic agent
const agent = createAgent({
  agent_id: 'my-agent',
  name: 'My Trading Agent',
  capabilities_provided: ['analysis.portfolio']
});

await agent.start();
const price = await agent.invoke('cap.price.lookup.v1', { base_token: 'SOL' });
await agent.stop();

// Pre-built trading agent with MEV protection
const trader = createTradingAgent({
  agent_id: 'sol-trader',
  watched_tokens: ['SOL', 'ETH', 'BTC'],
  mev_protection: true,
  dry_run: false
});

trader.on('signal', (s) => console.log(`${s.type} ${s.token}`));
await trader.start();

Agent Templates:

createTradingAgent() - Price monitoring, signals, MEV-protected trades
createMonitoringAgent() - Wallet tracking, protocol health, alerts
createAnalyticsAgent() - Data collection, time series, reports

Multi-Agent Orchestration:

import { createOrchestrator } from './sdk/orchestration';

const orchestrator = createOrchestrator({ orchestrator_id: 'swarm-1', name: 'Trading Swarm' });
await orchestrator.addAgent({ agent_id: 'pricer-1', name: 'Price Agent' });

// Parallel execution
const results = await orchestrator.executeParallel([
  { capability_id: 'cap.price.lookup.v1', inputs: { base_token: 'SOL' } },
  { capability_id: 'cap.price.lookup.v1', inputs: { base_token: 'ETH' } }
]);

// Consensus-based execution
const consensus = await orchestrator.executeWithConsensus('cap.price.lookup.v1', { base_token: 'SOL' });

CLI Tools:

npm run cli health              # Check router status
npm run cli capabilities        # List available capabilities
npm run cli invoke cap.price.lookup.v1 '{"base_token":"SOL"}'
npm run example:trading         # Run trading bot example
npm run example:swarm           # Run multi-agent demo

Who Pays (and Why)

Agent Type	Pain Point	CAP-402 Solution	Revenue Model
Trading/Arbitrage Agents	Strategies get copied, front-run	Hidden execution via Arcium MPC	% of saved slippage
Market Makers	Order flow leaks, gets sniped	Protected order flow, dark coordination	Take-rate on volume
Capital Allocators	Can't prove track record without revealing strategy	ZK-verified reputation via Noir	Verification fees
OTC Desks	Negotiation leaks intent to market	Sealed-bid auctions, encrypted messaging	% of matched volume
Signal Sellers	Buyers can't verify quality without seeing signal	Prove quality without revealing content	Per-proof fees

Who This Is NOT For

Agents below $50K AUM (use public rails, it's fine)
Strategies that don't have edge (nothing to protect)
Projects that want "agent router for everything"

CAP-402 is for agents that make money and need to keep making it.

Economic Choke Points (Sponsor Integration)

Sponsors are not optional features. They are structural requirements above capital thresholds.

Sponsor	Mandatory For	Threshold	Why It's Required
Arcium	Large-size execution, sealed auctions, OTC matching	>$100K trades	Public execution = 2-5% MEV loss
Inco	Encrypted PnL computation, strategy scoring, agent ranking	Any competitive strategy	Visible strategies get copied in <24h
Noir	Onboarding proofs, capital delegation, compliance	Institutional capital	Can't attract AUM without verifiable track record
Helius	Real-time wallet data, transaction monitoring	All agents	Need accurate state for execution

Arcium — The Execution Rail

MANDATORY above $100K:
- cap.cspl.wrap.v1         → Wrap to confidential tokens
- cap.confidential.swap.v1 → Execute without leaking size
- /arcium/private-bid      → Sealed auctions

Inco — The Computation Rail

MANDATORY for competitive agents:
- /inco/compute            → FHE operations on encrypted data
- /inco/private-vote       → Hidden governance participation
- Encrypted PnL tracking   → Strategy scoring without exposure

Noir — The Proof Rail

MANDATORY for capital attraction:
- balance_threshold        → Prove AUM without revealing
- kyc_compliance          → Institutional onboarding
- track_record            → Verifiable performance history

Helius — The Data Rail

MANDATORY for all agents:
- cap.wallet.snapshot.v1   → Accurate wallet state
- Real-time webhooks       → Transaction confirmations

System Stats

Metric	Count
Total Capabilities	22
Confidential Capabilities	15
Noir ZK Circuits	10
API Endpoints	110+
Sponsor Integrations	4 (Arcium, Noir, Helius, Inco)
A2A Protocol Endpoints	5
Trading Alpha Endpoints	8
x402 Payment Endpoints	4
Public Explorer	/explorer

💰 MEV Protection & Trading Alpha

MEV Analysis

# Analyze sandwich attack risk before trading
curl -X POST https://cap402.com/mev/analyze \
  -d '{"token_in":"SOL","token_out":"USDC","amount":10000,"slippage":1}'

# Response: 75% sandwich probability, $150 potential loss, $127 savings with protection

Protected Swap Execution

# Execute with MEV protection (Jito-style private mempool)
curl -X POST https://cap402.com/mev/protected-swap \
  -d '{"token_in":"SOL","token_out":"USDC","amount":1000,"wallet_address":"...","protection_level":"maximum"}'

Arbitrage Scanner

# Find cross-DEX price discrepancies
curl https://cap402.com/alpha/arbitrage?min_profit_bps=5

# Response: BTC spread 6.1 bps between Raydium/Orca, $5.60 profit on $10k

Whale Tracker

# Monitor large wallet movements
curl https://cap402.com/alpha/whale-tracker

# Response: $46M SOL buy detected, market sentiment BULLISH

Liquidation Monitor

# Find profitable DeFi liquidation opportunities
curl https://cap402.com/alpha/liquidations

# Response: $7,500 profit potential, ETH position at 1.02 health factor

🤖 Agent-to-Agent (A2A) Protocol

Register an Agent

curl -X POST https://cap402.com/agents/register \
  -d '{"agent_id":"my-trading-bot","name":"Trading Bot","capabilities_provided":["cap.price.lookup.v1"]}'

A2A Direct Invocation

# Agent-to-agent capability call
curl -X POST https://cap402.com/a2a/invoke \
  -d '{"from_agent":"bot-A","to_agent":"bot-B","capability_id":"cap.price.lookup.v1","inputs":{"base_token":"SOL"}}'

Agent Discovery

# Find agents that provide a capability
curl https://cap402.com/a2a/discover/cap.price.lookup.v1

Agent Auction

# Agents bid to fulfill your request
curl -X POST https://cap402.com/a2a/auction \
  -d '{"requester_agent":"my-bot","capability_id":"cap.price.lookup.v1","max_price":10}'

Agent Swarm

# Coordinate multiple agents in parallel
curl -X POST https://cap402.com/a2a/swarm \
  -d '{"coordinator_agent":"my-bot","task":{"capability_id":"cap.price.lookup.v1"},"agents":["bot-1","bot-2"],"strategy":"parallel"}'

Agent Leaderboard

curl https://cap402.com/a2a/leaderboard

Architecture

┌───────────────────────────────────────┐
│              Agent                    │
│  (LLM, bot, autonomous system)        │
└───────────────┬───────────────────────┘
                │
                ▼
┌───────────────────────────────────────┐
│               SDK                     │
│  - Capability discovery               │
│  - Invocation                         │
│  - Preference hints                   │
└───────────────┬───────────────────────┘
                │
                ▼
┌────────────────────────────────────────────────────┐
│                 Reference Router                   │
│                                                    │
│  - Schema validation                               │
│  - Execution planning                              │
│  - Economic signaling                              │
│  - Privacy-aware routing                           │
│                                                    │
└───────────────┬───────────────────┬────────────────┘
                │                   │
        Public Execution      Confidential Execution
                │                   │
                ▼                   ▼
┌─────────────────────┐     ┌────────────────────────┐
│ Public Executors    │     │ Arcium Executor         │
│ (APIs, RPCs)        │     │ (Confidential Compute)  │
│                     │     │                        │
│ - price             │     │ - document_parse        │
│ - wallet (Helius)   │     │                        │
└──────────┬──────────┘     └───────────┬────────────┘
           │                              │
           ▼                              ▼
┌─────────────────────┐     ┌────────────────────────┐
│ Economic Hint Layer │     │ Confidential Receipts   │
│ - X.402             │     │ - Proofs                │
│ - Privacy Cash      │     │ - Attestations          │
└──────────┬──────────┘     └───────────┬────────────┘
           │                              │
           └──────────────┬───────────────┘
                          ▼
              ┌──────────────────────────┐
              │  Chain Usage Signals     │
              │  (Solana / ZK future)    │
              └──────────────────────────┘

Key Features

1. Formal Capability Schema

Every capability is defined with:

Stable ID: cap.price.lookup.v1
Typed I/O: JSON Schema validation
Execution Mode: public | confidential
Economic Hints: Cost, currency, payment methods
Performance SLAs: Latency, reliability, throughput

2. Privacy-Aware Execution

Public Executor: Standard API/RPC calls
Arcium Executor: Confidential compute with cryptographic proofs
Privacy is opt-in, not mandatory
Proofs are generated and verifiable

3. Economic Layer (Non-Custodial)

X.402 Payment Hints:

Ephemeral payer addresses
Suggested amounts (not enforced)
Settlement optional
No custody, ever

Privacy Cash Integration:

Private note references
Amount commitments
Nullifier hints
Zero-knowledge compatible

4. Chain Signaling

Usage commitments are hashed and signaled to chain:

Capability ID + Request ID + Timestamp
Verifiable without revealing inputs/outputs
Network: Solana (devnet for v0.1)
Future: ZK proofs, on-chain settlement

Initial Capabilities (v0.1)

1. `cap.price.lookup.v1`

Mode: Public
Cost: 0.0001 SOL
Use: Get current token prices
Provider Hint: CoinGecko, Jupiter, Pyth

2. `cap.wallet.snapshot.v1`

Mode: Public
Cost: 0.001 SOL
Use: Retrieve wallet balances, NFTs, transaction history
Provider Hint: Helius, Alchemy, QuickNode

3. `cap.document.parse.v1`

Mode: Confidential (Arcium)
Cost: 0.01 SOL
Use: Parse documents with privacy guarantees
Proof Type: Arcium MPC attestation

🚀 Production Status

ALL INTEGRATIONS ARE LIVE ✅

Integration	Status	Mode	Evidence
Helius DAS	✅ LIVE	Real API	190ms response, real wallet data
CoinMarketCap	✅ LIVE	Real API	Live prices ($142.94 SOL)
Noir ZK	✅ LIVE	Real SDK	Compiled circuit, witness generation
Arcium C-SPL	✅ LIVE	Solana Devnet	Real RPC calls, slot/blockhash proofs
Inco FHE	✅ LIVE	Local Docker	Chain ID 31337, block-based proofs

Data Providers (Real APIs)

✅ CoinMarketCap API - 3 rotating keys, live price data
✅ Solana Tracker API - 3 rotating keys, all Solana SPL tokens
✅ Helius API - Real wallet data, NFTs, transaction history
✅ Alchemy Solana RPC - Direct mainnet blockchain access
✅ BirdEye WebSocket - Real-time price streaming with auto-reconnect

Privacy Infrastructure (Real Networks)

✅ Arcium - Real Solana devnet RPC calls (slot, blockhash, account info)
✅ Noir - Compiled balance_threshold circuit, real witness generation via @noir-lang/noir_js
✅ Inco - Local Docker containers (anvil + covalidator), real ethers.js chain calls

Prerequisites Installed

Solana CLI 3.0.13 + devnet keypair (2 SOL)
Arcium CLI 0.6.3 via arcup
Nargo 1.0.0-beta.18 (Noir compiler)
Docker + Inco Lightning containers

Quick Start

1. Installation

cd CAP-402
npm install

2. Configure Environment

cp .env.example .env
# Edit .env with your API keys (Helius, CoinMarketCap, etc.)

3. Start Inco FHE (Optional - for FHE capabilities)

# Requires Docker
cd inco-lightning && docker compose up -d
cd ..

4. Start the Router

npm start

Router will be available at https://cap402.com

5. Test All Integrations

# Test Helius (wallet data)
curl -X POST https://cap402.com/invoke \
  -H "Content-Type: application/json" \
  -d '{"capability_id":"cap.wallet.snapshot.v1","inputs":{"address":"YOUR_WALLET"}}'

# Test CoinMarketCap (prices)
curl -X POST https://cap402.com/invoke \
  -H "Content-Type: application/json" \
  -d '{"capability_id":"cap.price.lookup.v1","inputs":{"base_token":"SOL","quote_token":"USD"}}'

# Test Noir ZK (proofs)
curl -X POST https://cap402.com/invoke \
  -H "Content-Type: application/json" \
  -d '{"capability_id":"cap.zk.proof.v1","inputs":{"proof_type":"balance_threshold","circuit":"balance_threshold","private_inputs":{"actual_balance":1000},"public_inputs":{"threshold":500}}}'

# Test Inco FHE (encrypted compute)
curl -X POST https://cap402.com/invoke \
  -H "Content-Type: application/json" \
  -d '{"capability_id":"cap.fhe.compute.v1","inputs":{"operation":"add","operands":[100,50]}}'

Run the Demo Agent

npm run demo

The demo agent will:

Discover available capabilities
Execute wallet snapshot + price lookup (REAL DATA)
Chain capabilities together
Display economic hints and chain signals

SDK Usage

import { createClient } from './sdk/client';

const client = createClient('https://cap402.com');

// Discover capabilities
const capabilities = await client.discoverCapabilities();

// Invoke a capability
const result = await client.invokeCapability(
  'cap.price.lookup.v1',
  { base_token: 'SOL', quote_token: 'USD' },
  { latency_priority: true }
);

// Chain capabilities
const pipeline = await client.chainCapabilities([
  {
    capability_id: 'cap.wallet.snapshot.v1',
    inputs: { address: 'abc123...' }
  },
  {
    capability_id: 'cap.price.lookup.v1',
    inputs: (prev) => ({ base_token: prev.balances[0].token })
  }
]);

API Reference

`GET /capabilities`

Discover all capabilities. Optional filters:

?tag=defi - Filter by tag
?mode=confidential - Filter by execution mode

`GET /capabilities/:id`

Get details for a specific capability.

`POST /invoke`

Invoke a capability.

Request:

{
  "capability_id": "cap.price.lookup.v1",
  "inputs": {
    "base_token": "SOL",
    "quote_token": "USD"
  },
  "preferences": {
    "max_cost": 0.01,
    "privacy_required": false,
    "latency_priority": true
  }
}

Response:

{
  "success": true,
  "request_id": "req_abc123...",
  "capability_id": "cap.price.lookup.v1",
  "outputs": {
    "price": 98.45,
    "base_token": "SOL",
    "quote_token": "USD",
    "timestamp": 1704067200000,
    "source": "mock-aggregator"
  },
  "metadata": {
    "execution": {
      "executor": "public-executor",
      "execution_time_ms": 120,
      "cost_actual": 0.0001,
      "currency": "SOL"
    },
    "economic_hints": {
      "x402": {
        "ephemeral_payer": "ephemeral_abc...",
        "suggested_amount": 0.0001,
        "settlement_optional": true
      }
    },
    "chain_signal": {
      "signal_id": "signal_def456...",
      "commitment_hash": "a1b2c3d4...",
      "network": "solana-devnet"
    }
  }
}

Design Principles

Capabilities are semantic, not provider-specific
Agents request "price lookup", not "call CoinGecko API"
Routing abstracts execution details
The router selects executors based on capability requirements
Privacy is opt-in and composable
Public and confidential execution coexist cleanly
Payments are hinted, never enforced
Economic signals guide behavior without custody
On-chain interaction is signaling-first
Commitments are emitted; settlement comes later
Everything should be replaceable
Executors, payment systems, chains—all modular

Arcium Integration

Confidential capabilities use Arcium's MPC network:

Execution: Runs inside Arcium's confidential compute environment
Proofs: Cryptographic attestations of correct execution
Privacy: Inputs/outputs never leave the secure enclave
Verification: Proofs can be verified on-chain or off-chain

Example confidential execution flow:

Agent invokes cap.document.parse.v1
Router selects Arcium executor
Document processed in MPC environment
Proof + attestation returned with outputs
Usage signal emitted to chain

Economic Model

x402 Protocol — Native HTTP 402 Payment Flow

CAP-402 implements the x402 protocol for autonomous agent commerce. Capabilities with mandatory settlement return HTTP 402 with full payment requirements.

Payment Flow:

Agent calls POST /invoke with a paid capability
Server returns HTTP 402 with payment requirements (amount, networks, methods, nonce, expiry)
Agent executes payment on-chain (USDC on Solana/Base, SOL) or uses credits
Agent resubmits /invoke with X-Payment-Proof header
Server verifies proof, executes capability, records settlement

# Step 1: Invoke (no payment proof)
curl -X POST https://cap402.com/invoke \
  -d '{"capability_id":"cap.confidential.swap.v1","inputs":{...}}'
# → HTTP 402 with payment requirements

# Step 2: Resubmit with payment proof
curl -X POST https://cap402.com/invoke \
  -H 'X-Payment-Proof: {"payment_id":"pay_...","method":"usdc_solana","transaction_hash":"...","nonce":"..."}' \
  -d '{"capability_id":"cap.confidential.swap.v1","inputs":{...}}'
# → Capability executes, settlement recorded

Payment Methods:

USDC on Solana — SPL token transfer with payment_id in memo
USDC on Base — ERC-20 transfer on Base L2
Native SOL — Direct transfer with memo
Credits — Internal agent balance, instant settlement
Privacy Cash — ZK-compatible private notes

Settlement Logic:

settlement_optional: true — Payment encouraged but not required (most capabilities)
settlement_optional: false — HTTP 402 enforced for anonymous/verified agents
Trusted/premium agents bypass mandatory payment
Capability tokens bypass payment entirely

x402 API Endpoints:

GET  /x402/info                        # Protocol info and stats
GET  /x402/payments/:payment_id        # Payment lookup
GET  /x402/agents/:agent_id/payments   # Agent payment history
GET  /x402/revenue                     # Revenue dashboard

X.402 Payment Hints (Legacy)

All responses include x402 payment hints for backward compatibility:

Ephemeral addresses: Generated per-request
Suggested amounts: Not enforced
Settlement optional: Agents can choose to pay or not
Multiple methods: SOL, USDC, credits, privacy-cash

Privacy Cash

For confidential capabilities:

Non-custodial: No intermediary holds funds
Private notes: Amount commitments hide values
Nullifiers: Prevent double-spending
ZK-compatible: Ready for future ZK payment systems

Roadmap

v0.1 (Current - Hackathon)

✅ Core capability schema
✅ Reference router implementation
✅ 3 initial capabilities
✅ Public + Arcium executors
✅ X.402 + Privacy Cash hints
✅ Chain usage signals
✅ SDK + demo agent

v0.2 (Post-Hackathon)

Real Arcium integration (not mocked)
On-chain capability registry
Expanded capability library (10+ capabilities)
Multi-chain support (Solana, Ethereum, Cosmos)
Advanced routing (cost optimization, failover)

v0.3 (Production Path)

Decentralized router network
ZK proof verification on-chain
Privacy Cash settlement implementation
Agent reputation system
Governance for capability standards

v1.0 (Protocol Standard)

Formal specification document
Reference implementations in multiple languages
Compliance tooling
Developer certification program
Grant program for capability developers

For Investors & Grants

Why Fund CAP-402?

Market Opportunity:

Agent-to-agent interactions are the next frontier
No standard exists for privacy-preserving agent compute
Economic coordination between agents is unsolved
Multi-billion dollar TAM as AI agents proliferate

Technical Moat:

First-mover on semantic capability routing
Native privacy via Arcium (not retrofit)
Economic layer designed for non-custodial settlement
Extensible architecture that grows with ecosystem

Traction Path:

Hackathon validation (current)
Developer adoption (SDK + docs)
Capability marketplace emergence
Protocol standardization
Network effects as agents adopt standard

Team Readiness:

Production-minded engineering from day 1
Clear path from prototype to protocol
Modular design allows parallel development
Open to ecosystem collaboration

Grant Alignment

Blockchain Foundations:

Solana: Native integration, usage signals on-chain
Ethereum: Multi-chain expansion planned
Privacy protocols: Arcium partnership, ZK roadmap

Use Cases:

DeFi agents with privacy guarantees
Cross-chain agent coordination
Confidential data processing for DAOs
Agent-powered infrastructure services

Contributing

CAP-402 is designed to become a community standard.

How to contribute:

Implement new capabilities (see spec/capabilities.ts)
Add executor implementations (see router/execution/)
Improve economic models (see router/payments/)
Extend SDK functionality (see sdk/)

Capability submission process (coming soon):

Propose capability schema
Implement provider/executor
Submit PR with tests
Community review + merge

Technical Stack

Language: TypeScript
Runtime: Node.js 18+
HTTP Framework: Express
Compression: gzip (responses >1KB)
Privacy Compute: Arcium, Noir, Inco
Blockchain: Solana (devnet for v0.1)
Payment Hints: X.402 protocol concept
Schema Validation: JSON Schema
API Spec: OpenAPI 3.0

License

MIT License - See LICENSE file for details

Contact

Website: cap402.com
GitHub: github.com/cap402
Discord: [Coming Soon]
Twitter: [Coming Soon]
Email: hello@intym.xyz

Acknowledgments

Arcium: Confidential compute infrastructure
Solana Foundation: Blockchain infrastructure
X.402 Protocol: Payment hint inspiration
Agent community: Feedback and validation

Built for hackathons. Designed for production. Ready for the future.

CAP-402 | Agent Infrastructure Standard | v1.0.0

📋 Recent Updates

Latest (Feb 15, 2026) — x402 Protocol Handler & Public Capability Explorer

x402 Protocol Handler:

✅ Native HTTP 402 payment flow in /invoke — agents receive payment requirements, submit proofs, settle on-chain
✅ Payment verification with nonce replay protection, amount validation, expiry checks
✅ Multi-network settlement — USDC on Solana/Base, native SOL, internal credits
✅ Revenue tracking by capability and agent with full payment history
✅ 4 new API endpoints: /x402/info, /x402/payments/:id, /x402/agents/:id/payments, /x402/revenue
✅ Reuses existing x402.ts hint generator via legacy_hint field (zero duplication)

Public Capability Explorer:

✅ GET /explorer — Self-contained HTML dashboard at cap402.com/explorer
✅ Live stats from /capabilities and /health/detailed
✅ Search + filters (mode, x402-enabled, composable)
✅ x402 payment flow explainer section
✅ Try-it curl commands per capability
✅ Dark theme, responsive, no external dependencies

Frontend Updates:

✅ Added Explorer and x402 nav links to landing page
✅ New x402 Protocol section with 4-step flow diagram and code example
✅ CTA buttons for Explorer, x402 Info, and Revenue Dashboard

Test Coverage:

Test Suites: 23 passed, 23 total
Tests:       530 passed, 530 total

Previous (Jan 26, 2026) — AI Inference, KYC Proofs & Agent Framework Integrations

New Capabilities:

✅ Private AI Inference (cap.ai.inference.v1) - Run sentiment analysis, classification, summarization with encrypted inputs
✅ Private Embeddings (cap.ai.embedding.v1) - Generate vector embeddings without exposing your data
✅ Private KYC Verification (cap.zk.kyc.v1) - Prove age, jurisdiction, accreditation without revealing personal data
✅ Private Credential Verification (cap.zk.credential.v1) - Prove degrees, certifications, memberships privately

Agent Framework Integrations:

✅ LangChain - CAP402Toolkit with ready-to-use tools
✅ AutoGPT - CAP402AutoGPTPlugin with 6 commands
✅ CrewAI - CAP402CrewAgent and CAP402CrewTools

SDK Publishing:

✅ Prepared @cap402/sdk npm package with package.json, tsup.config.ts
✅ Comprehensive SDK README with usage examples
✅ Export integrations from sdk/integrations/

Test Coverage:

Test Suites: 23 passed, 23 total
Tests:       530 passed, 530 total

Previous (Jan 16, 2026) — SDK Cleanup & Documentation

SDK Improvements:

Consolidated constants into sdk/constants.ts (router URL, timeouts, rate limits)
Replaced any types with proper TypeScript types
Added one-liner verification tests (8 tests)

Documentation:

Added "Common Use Cases" quick reference to API docs
Added "Why Use Agents?" and "When to Use What" sections to SDK docs
Replaced all emojis with Lucide icons in frontend

Test Coverage:

Test Suites: 18 passed, 18 total
Tests:       365 passed, 365 total

Previous (Jan 15, 2026) — Observability & Provider Stats

⚡ Performance Optimizations:

✅ Request Coalescing: Duplicate in-flight requests share the same promise (2+ requests → 1 API call)
✅ Response Compression: Gzip compression for responses >1KB
✅ Adaptive Rate Limiting: Limits auto-adjust based on system load (100% → 75% → 50%)
✅ Priority Queue: Critical requests processed first (critical > high > normal > low)

🔧 Unified Error Handling:

Code	Type	HTTP Status
E001	VALIDATION_ERROR	400
E002	UNAUTHORIZED	401
E003	FORBIDDEN	403
E004	NOT_FOUND	404
E005	RATE_LIMITED	429
E006	INTERNAL_ERROR	500
E007	SERVICE_UNAVAILABLE	503
E008	CIRCUIT_OPEN	503

🔍 Request Tracing:

# Start a trace
curl -X POST https://cap402.com/trace/start
# → { "trace_id": "trace_abc123" }

# Add steps during workflow
curl -X POST https://cap402.com/trace/trace_abc123/step \
  -d '{"action": "price_lookup", "data": {"token": "SOL"}}'

# Get trace results
curl https://cap402.com/trace/trace_abc123
# → { "steps": [...], "duration_ms": 428 }

📊 Enhanced Metrics:

Auto-aggregated summaries (/system/metrics)
Latency percentiles (p50, p95, p99)
Success rates and cost tracking
Circuit breaker dashboard

🔗 OpenAPI Schema:

New /openapi.json endpoint for interoperability
Ready for Swagger UI or code generation
Documents all core endpoints

🛡️ Graceful Degradation:

Cached fallbacks on service failures
Smart TTLs per data type (prices: 5s, metadata: 60s, transactions: 5min)
Health-aware load factor updates

Previous (Jan 13, 2026) — ALL INTEGRATIONS LIVE 🎉

🔥 Every Sponsor Integration Now Running REAL:

✅ Helius DAS: Real API calls, 190ms response time
✅ CoinMarketCap: Live prices ($142.94 SOL)
✅ Noir ZK: Compiled circuit (balance_threshold), real witness generation
✅ Arcium C-SPL: Real Solana devnet RPC (slot, blockhash proofs)
✅ Inco FHE: Local Docker chain, mode: "live", block-based proofs

🛠️ Infrastructure Installed:

Solana CLI 3.0.13 + devnet keypair (2 SOL funded)
Arcium CLI 0.6.3 via arcup
Nargo 1.0.0-beta.18 (Noir compiler)
Docker + Inco Lightning containers (ports 8545, 50055)

🏆 Deep Sponsor Integrations:

✅ Arcium C-SPL: Full confidential token operations (wrap, transfer, swap)
✅ Noir ZK Circuits: 7 production circuits for privacy proofs
✅ Helius DAS: Complete Digital Asset Standard integration
✅ Inco FHE: Fully homomorphic encryption for messaging and compute

🤖 Agent Platform Features:

✅ Agent Identity System: Registration, API keys, trust levels
✅ Reputation Engine: Scores, badges, invocation tracking
✅ Semantic Discovery: Natural language capability search
✅ AI Recommendations: Personalized suggestions based on usage
✅ Agent Archetypes: Trader, Privacy Specialist, DAO Participant, etc.
✅ Social Layer: Leaderboards, profiles, messaging
✅ Capability Delegation: Share access between agents
✅ Health Monitoring: Real-time capability status

💰 Economic Features:

✅ Cost Estimation: Predict costs before execution
✅ Trust-Based Pricing: 50% discount for premium agents
✅ Composition Discounts: 10% off for batched calls
✅ Rate Limiting: Trust-based limits (10→1000 req/min)

📊 Analytics & Insights:

✅ Usage Analytics: Track all invocations
✅ Capability Insights: Success rates, latency percentiles
✅ Anomaly Detection: Latency spikes, error rate alerts
✅ Cost Optimization: Recommendations for savings

API Endpoints (75+)

Category	Endpoints
Core	`/capabilities`, `/capabilities/summary`, `/capabilities/batch`, `/invoke`, `/compose`, `/stream`
Discovery	`/discover`, `/suggest-workflow`, `/templates`
Agents	`/agents/register`, `/agents/:id`, `/agents/:id/profile`
Social	`/leaderboard`, `/community/stats`, `/agents/:id/messages`
Analytics	`/analytics/dashboard`, `/analytics/capability/:id`
System	`/system/health`, `/system/overview`, `/system/metrics`, `/system/cache`, `/system/rate-limits`
Observability	`/health/providers`, `/router/stats`, `/activity/stats`, `/chain/usage-stats`, `/diagnostics`
Queue	`/queue/invoke` (priority-based invocation)
Tracing	`/trace/start`, `/trace/:id/step`, `/trace/:id`
Smart	`/smart/invoke`, `/smart/batch`, `/smart/recommendations/:id`, `/smart/workflows`
Sponsors	`/sponsors`, `/sponsors/:name`, `/sponsors/:name/security`
Security	`/security/tokens/`, `/security/trust/`, `/security/handshake/*`, `/security/audit`
Economics	`/estimate`, `/estimate/:id/compare`, `/verify-proof`
x402 Protocol	`/x402/info`, `/x402/payments/:id`, `/x402/agents/:id/payments`, `/x402/revenue`
Explorer	`/explorer` (Public Capability Explorer dashboard)
Interop	`/openapi.json` (OpenAPI 3.0 schema)

🔐 Security Layer (Secret Sauce)

CAP-402 includes a comprehensive security layer that makes replication extremely difficult:

Feature	Description
Capability Tokens	HMAC-SHA256 signed tokens with semantic keys
Semantic Encryption	AES-256-GCM encrypted payloads with obfuscated actions
Trust Network	Reputation-based access (newcomer → elite)
Multi-Step Handshake	2-5 step cryptographic challenges for confidential access
Audit Logging	Full security event tracking with severity levels
Token Revocation	Instant revocation with audit trail

Security Endpoints:

POST /security/tokens/issue     - Issue capability token
POST /security/tokens/validate  - Validate token
POST /security/tokens/revoke    - Revoke token
POST /security/trust/register   - Join trust network
GET  /security/trust/:id        - Get trust score
POST /security/trust/endorse    - Endorse another agent
POST /security/handshake/initiate - Start multi-step handshake
POST /security/handshake/respond  - Complete handshake step
POST /security/semantics/decrypt  - Decrypt semantic payload
GET  /security/audit            - Security audit log
GET  /security/status/:id       - Full agent security status

Sponsor Security Requirements

Sponsor	Token Required	Handshake	Min Trust	Privacy Level
Arcium	✅	✅	trusted	confidential
Aztec/Noir	✅	❌	member	confidential
Helius	❌	❌	newcomer	public
Inco	✅	✅	trusted	encrypted

Performance

Price Lookup: 80-150ms (real CoinMarketCap/Solana Tracker)
Wallet Snapshot: 300-600ms (real Helius DAS API)
ZK Proof Generation: 500-1000ms (Noir circuits)
Confidential Swap: 1-2s (Arcium MPC)
FHE Messaging: 200-500ms (Inco)

🔮 Advanced Features

CAP-402 now includes 5 novel advanced features that make it a complete agent infrastructure platform:

1. Capability Receipts — Verifiable Execution Memory

Every invocation returns a cryptographically signed receipt that:

Can be verified offline without re-execution
Includes input/output commitments (hashes)
Tracks privacy level and proof type
Enables agents to reason over past executions

// Receipt structure
{
  receipt_id: "rcpt_1705234567890_abc123",
  capability_id: "cap.confidential.swap.v1",
  input_commitment: "sha256:...",   // Proves what was requested
  output_commitment: "sha256:...",  // Proves what was returned
  execution: {
    privacy_level: 2,
    proof_type: "arcium-attestation",
    success: true
  },
  signature: "hmac-sha256:..."      // Verifiable authenticity
}

Endpoints:

POST /receipts/verify — Verify receipt offline
POST /receipts/decode — Decode serialized receipt

2. Privacy Gradient — Quantifiable Privacy Levels

Privacy is no longer binary. CAP-402 defines 4 levels:

Level	Name	Description	Cost Multiplier
L0	Public	Fully visible on-chain	1.0x
L1	Obscured	Metadata hidden, amounts visible	1.1x
L2	Encrypted	All data encrypted (Arcium/Inco)	1.5x
L3	ZK Verifiable	Zero-knowledge proofs (Noir)	2.0x

Agents can request: "Give me level ≥2 but cheapest option"

Endpoints:

GET /privacy/:capability_id — Get privacy options
GET /negotiate/:id/compare — Compare costs by privacy level

3. Capability Negotiation — Economic Reasoning

Agents can negotiate execution options before committing:

curl -X POST https://cap402.com/negotiate \
  -d '{
    "capability_id": "cap.confidential.swap.v1",
    "inputs": {"amount": 1000},
    "constraints": {"max_cost": 0.05, "min_privacy_level": 2},
    "negotiate": {"privacy": true, "latency": true, "batching": true}
  }'

Returns multiple options with trade-offs:

Fast + Expensive vs Slow + Cheap
L2 Privacy vs L3 ZK Verifiable
Single vs Batched execution

4. Usage Metadata — Emergent Reputation

Every invocation emits usage metadata that builds emergent reputation without a centralized registry:

{
  capability_id: "cap.zk.proof.v1",
  success: true,
  latency_bucket: "fast",      // fast | medium | slow | timeout
  cost_bucket: "cheap",        // free | cheap | moderate | expensive
  privacy_level: 3,
  proof_present: true
}

Endpoints:

GET /reputation — Get capability scores
GET /reputation/export — Export for P2P sharing
POST /reputation/import — Import peer scores

5. Intent Graphs — Multi-Step Atomic Workflows

Define complex workflows as directed graphs with dependencies:

{
  "name": "Private Swap with Balance Check",
  "nodes": [
    { "id": "check", "capability_id": "cap.zk.proof.v1", "inputs": {...} },
    { "id": "wrap", "capability_id": "cap.cspl.wrap.v1", "inputs": {...} },
    { "id": "swap", "capability_id": "cap.confidential.swap.v1", "inputs": {...} }
  ],
  "edges": [
    { "from": "check", "to": "wrap", "condition": "success" },
    { "from": "wrap", "to": "swap", "data_mapping": {"wrapped_mint": "input_token"} }
  ],
  "constraints": { "atomic": true }
}

Features:

Dependency edges with conditions
Data mapping between nodes
Atomic execution (all or nothing)
Single receipt for entire graph
Privacy boundary selection per node

Endpoints:

POST /intent — Execute intent graph
POST /intent/plan — Plan without executing (dry run)
GET /intent/examples — Example intent graphs

Advanced Features Health & Self-Test

# Check health of all advanced features
curl https://cap402.com/advanced/health

# Run self-test on all 5 modules
curl -X POST https://cap402.com/advanced/self-test

Unified Import

All advanced features can be imported from a single module:

import { 
  // Core features
  receiptManager, privacyGradient, negotiator, 
  usageMetadataEmitter, intentGraphExecutor,
  
  // Validation
  validateReceipt, validateIntentGraph,
  
  // Errors
  AdvancedFeatureError, ErrorCode,
  
  // Constants
  PRIVACY_LEVEL, PROOF_TYPES, PROVIDERS,
  
  // Health
  advancedFeaturesHealth
} from './router/advanced';

📁 Project Structure

CAP-402/
├── router/
│   ├── server.ts              # Main Express server (4100+ lines)
│   ├── router.ts              # Core routing logic + priority queue + tracing
│   ├── registry.ts            # Capability registry
│   ├── metrics.ts             # Performance metrics with auto-aggregation
│   ├── rate-limiter.ts        # Adaptive rate limiting
│   │
│   ├── payments/
│   │   ├── x402.ts                # Payment hint generator
│   │   ├── x402-protocol.ts       # Full x402 HTTP 402 protocol handler
│   │   └── privacy-cash.ts        # Privacy cash notes
│   │
│   ├── execution/             # Executors
│   │   ├── types.ts           # Execution types & interfaces
│   │   ├── public-executor.ts # Public capability execution
│   │   └── confidential-executor.ts # Privacy-focused execution
│   │
│   ├── advanced/              # Advanced Features (NEW)
│   │   ├── index.ts           # Unified exports
│   │   ├── validation.ts      # Cross-system validation
│   │   ├── errors.ts          # Consistent error types
│   │   ├── constants.ts       # Shared constants
│   │   └── health.ts          # Health monitoring
│   │
│   ├── security/              # Security Layer
│   │   ├── capability-tokens.ts
│   │   ├── semantic-encryption.ts
│   │   ├── trust-network.ts
│   │   └── agent-handshake.ts
│   │
│   ├── capability-receipt.ts  # Verifiable execution memory
│   ├── privacy-gradient.ts    # Quantifiable privacy levels
│   ├── capability-negotiation.ts # Economic reasoning
│   ├── usage-metadata.ts      # Emergent reputation
│   ├── intent-graph.ts        # Multi-step atomic workflows
│   ├── composition.ts         # Capability chaining
│   ├── composition-templates.ts # Pre-built workflows
│   ├── capability-analytics.ts # Usage analytics
│   └── explorer.ts            # Public Capability Explorer (HTML dashboard)
│
├── providers/                 # External integrations
│   ├── integration-manager.ts # Unified API with caching + coalescing
│   ├── arcium-client.ts       # Arcium MPC
│   ├── arcium-cspl.ts         # C-SPL tokens
│   ├── noir-circuits.ts       # ZK proofs
│   ├── inco-fhe.ts            # FHE encryption
│   ├── helius-das.ts          # Digital Asset Standard
│   └── price.ts               # Price feeds
│
├── tests/                     # Test suites (154+ tests)
│   ├── advanced-features.test.ts
│   ├── arcium-deep.test.ts
│   ├── noir-deep.test.ts
│   ├── inco-deep.test.ts
│   └── helius-deep.test.ts
│
└── frontend/                  # Dashboard UI
    └── index.html

🧪 Test Coverage

Test Suites: 16 passed, 16 total
Tests:       306 passed, 306 total

Coverage:
  • API Tests: 17 tests
  • Capabilities Tests: 24 tests
  • Composition Tests: 15 tests
  • Security Tests: 17 tests
  • Sponsors Tests: 25 tests
  • Edge Cases Tests: 22 tests
  • Integration Flow Tests: 22 tests
  • Agent Scenarios Tests: 18 tests
  • Advanced Features: 23 tests
  • Proof Verification: 5 tests
  • Arcium Deep: 28 tests
  • Noir Deep: 26 tests
  • Inco Deep: 29 tests
  • Helius Deep: 25 tests
  • Live Providers: 23 tests
  • Router Tests: 17 tests

Name		Name	Last commit message	Last commit date
Latest commit History 339 Commits
.windsurf/workflows		.windsurf/workflows
cap_402_mxe		cap_402_mxe
chain		chain
circuits		circuits
cli		cli
docs		docs
examples		examples
frontend		frontend
inco-lightning		inco-lightning
providers		providers
public		public
router		router
scripts		scripts
sdk		sdk
spec		spec
tests		tests
types		types
utils		utils
.env.example		.env.example
.gitignore		.gitignore
.prettierrc		.prettierrc
LICENSE		LICENSE
Procfile		Procfile
README.md		README.md
jest.config.js		jest.config.js
package-lock.json		package-lock.json
package.json		package.json
railway.json		railway.json
tsconfig.json		tsconfig.json

License

TheQuantumChronicle/cap402

Folders and files

Latest commit

History

Repository files navigation

CAP-402: Execution Monetization Layer for Autonomous Agents

🚀 Try Demo

What CAP-402 Is

The Execution Stack

The Money Path

Three Revenue Layers

LAYER 1 — Confidential Execution-as-a-Service (EaaS)

LAYER 2 — Agent-to-Agent Dark Coordination Network

LAYER 3 — Agent Reputation & Capital Firewalls

Where CAP-402 Is Non-Optional

1. Cross Size Thresholds

2. Need Dark Coordination

3. Attract External Capital

4. Prove Compliance Without Exposure

How It Works

Core Principle

Integration Model

Use Cases

Treasury Rebalancing

Private OTC Negotiation

DAO Governance

Compliance Proofs

Technical Architecture

Capabilities

Pump.fun Privacy Integration

Quick Start

For Protocol Integrators

Agent SDK

Who Pays (and Why)

Who This Is NOT For

Economic Choke Points (Sponsor Integration)

Arcium — The Execution Rail

Inco — The Computation Rail

Noir — The Proof Rail

Helius — The Data Rail

System Stats

💰 MEV Protection & Trading Alpha

MEV Analysis

Protected Swap Execution

Arbitrage Scanner

Whale Tracker

Liquidation Monitor

🤖 Agent-to-Agent (A2A) Protocol

Register an Agent

A2A Direct Invocation

Agent Discovery

Agent Auction

Agent Swarm

Agent Leaderboard

Architecture

Key Features

1. Formal Capability Schema

2. Privacy-Aware Execution

3. Economic Layer (Non-Custodial)

4. Chain Signaling

Initial Capabilities (v0.1)

1. cap.price.lookup.v1

2. cap.wallet.snapshot.v1

3. cap.document.parse.v1

🚀 Production Status

ALL INTEGRATIONS ARE LIVE ✅

Data Providers (Real APIs)

Privacy Infrastructure (Real Networks)

Prerequisites Installed

Quick Start

1. Installation

2. Configure Environment

3. Start Inco FHE (Optional - for FHE capabilities)

4. Start the Router

5. Test All Integrations

Run the Demo Agent

SDK Usage

API Reference

GET /capabilities

1. `cap.price.lookup.v1`

2. `cap.wallet.snapshot.v1`

3. `cap.document.parse.v1`

`GET /capabilities`

`GET /capabilities/:id`

`POST /invoke`

Packages