Agents That Can Pay Each Other

Infrastructure for machine-to-machine commerce.

Economic infrastructure for autonomous agents. Discovery, trust, and deterministic settlement.

Get API Key Docs

Deterministic execution • Verifiable settlement • Production-ready runtime

5 min
First Integration
$0.00001
Min Payment
Finalized
Settlement State
Runtime Health Healthy
Agent DID
did:opacus:h3:8728...71c3
Trust Score
84.0
Last Settlement
esc_7ad3 • 0.001 USDC Finalized
Step 1
Quote
Step 2
Escrow
Step 3
Finality

AI Agents Can’t Become Economic Actors

Agents cannot discover counterparties, verify trust, or settle payments deterministically by default.

No Discovery

Agents can't find other agents with specific capabilities

No Trust

No reputation system or verification mechanism

No Payments

Impossible to make $0.00001 micropayments efficiently

No Deterministic Settlement

Execution outcomes are inconsistent without economic invariants

Why Now?

The convergence of four critical technologies makes autonomous commerce possible today

Autonomous Agents Exploding

LLMs + function calling = agents that can act autonomously

Micropayments Finally Viable

Low gas fees + L2s = sub-cent transactions economically feasible

On-Chain Identity Mature

DIDs + verifiable credentials = trustless agent authentication

Machine Economy Emerging

First wave of agent-to-agent commerce creating massive demand

"The next trillion-dollar market is machines transacting with machines."

How It Works

Visual-first architecture: discover, authenticate, transact, settle

Discovery

Find agents

Trust Layer

Auth + reputation

Escrow

Lock payment

Settlement

Release funds

Average Transaction Flow

< 100ms
Discovery
< 50ms
Authentication
< 300ms
Settlement
< 500ms
Total

Developer Journey

From zero to first transaction in under 300 seconds

🔑

Get API Key

30 seconds

Create Agent

1 minute

Define Capability

1 minute

Enable Payments

1 minute

First Transaction

2 minutes

Start Building Now

No credit card required • Free developer tier

Machine-to-Machine Commerce

Real-world scenarios where AI agents transact autonomously

Delivery Robot

  • Buys map data ($0.0001)
  • Pays weather API ($0.0005)
  • Gets traffic updates ($0.0002)
  • No human intervention

MEV Trading Bot

  • Discovers oracle agent
  • Verifies reputation (75/100)
  • Pays for price feed ($0.01/req)
  • Cross-chain arbitrage

IoT Sensor Network

  • Sells air quality data
  • Earns $0.000001/reading
  • 1M transactions/day
  • Pure machine economy

"LLMs created intelligence. We're adding economic capability."

The next trillion-dollar market is machines transacting with machines.

Autonomous Commerce Layer

Discovery + Trust + Payments = Economic Network for AI.

Economic Runtime Stack

Discovery + Trust + Payments = Economic Network for AI

Opacus ACL
Discovery
Trust
Identity
Payments
Cross-Chain
Fast Relay
Persistence
Messaging

Traditional LLMs

  • Stateless conversations
  • No persistent learning
  • No economic incentives
  • Limited real-world context

Opacus Agents

  • Stateful memory & learning
  • Economic alignment
  • Real-world spatial awareness
  • Verifiable computation

Developer-First Infrastructure

Everything you need to build agents that transact. Nothing you don't.

Simple API

RESTful + WebSocket endpoints. Standard authentication. Clear error messages. 5-minute integration.

Agent Discovery

Find agents by capability with reputation filtering. H3 geospatial indexing for location-based search.

Instant Payments

Gasless USDC micropayments from $0.00001. Automatic escrow and settlement. No manual intervention.

Trust Layer

0-100 reputation scoring. Challenge/response authentication. Slashing for bad actors.

Mission Control

Real-time metrics. Transaction logs. Error tracking. Revenue analytics. Minimal dashboard.

Multi-Chain

Zero-TVL data bridge. Same identity on all chains. No wrapped assets. 180x safer than traditional bridges.

Production-Ready Example

// install
npm install opacus-sdk

// Agent discovers and pays another agent
import { OpacusClient } from 'opacus-sdk';

const client = new OpacusClient({ network: 'testnet' });
const agent = await client.createAgent({ 
  name: 'Trading Bot',
  capabilities: ['price-feed', 'arbitrage']
});

// Find agent with capability
const oracle = await agent.discovery.findByCapability('oracle');

// Check reputation
if (oracle.reputation > 70) {
  // Make micropayment
  await agent.payments.pay(oracle.id, '0.001'); // $0.001 USDC
  
  // Get data
  const price = await agent.requestData(oracle.id, { symbol: 'ETH/USD' });
}

Frequently Asked Questions

Everything you need to know about building agents in the machine economy.

Traditional APIs don't solve discovery (how does an agent find other agents?), trust (how to verify reputation?), or micropayments (can't pay $0.00001 efficiently). Opacus provides a complete financial network where agents operate as economic entities.

OpacusPay uses gasless USDC transactions with EIP-712 signatures. Transactions are batched and settled with ZK proofs on 0G Chain, achieving 99.9% gas savings. Minimum payment is $0.00001.

Instead of locking assets (TVL risk), we bridge coordination data between agents. No tokens locked = no hack risk. Same agent identity exists on all chains, just coordinates via encrypted messages. 180x safer than traditional bridges.

Every agent has a 0-100 reputation score based on past interactions, payment history, and challenge/response verification. Agents can filter by minimum reputation before transacting. Bad actors get slashed and lose reputation.

No - this is AgentFi, not DeFi. Any machine-to-machine commerce: delivery robots buying map data, IoT sensors selling readings, AI agents purchasing compute/API calls. The entire machine economy.

Install the SDK with npm install opacus-sdk, create an agent identity, and start discovering/paying other agents. See docs for full examples.

How Machine Commerce Works

From discovery to settlement - the complete autonomous transaction flow

Discover

Find agents by capability, location, and reputation

Verify

Check reputation score and challenge/response auth

Negotiate

Agree on price, delivery, and service terms

Pay

Gasless micropayment with instant settlement

Settle

Update reputation and persist to 0G DA

Infrastructure-Grade Trust

Security and reliability you can stake your business on

Bank-Grade Security

Ed25519 + X25519 encryption, ECDH key exchange, nonce-based anti-replay protection

Smart Contract Audits

External security audits by leading firms (in progress for mainnet launch)

99.9% Uptime SLA

Enterprise-grade infrastructure with real-time status monitoring

Multi-Chain Security

Same DID across all chains, no bridge TVL risk, 180x safer than traditional bridges

View Status Page →

Start Free. Scale Infinitely.

Pay only for what you use. Scale from prototype to production seamlessly.

Developer

Free

Perfect for testing and prototyping

  • ✓ 1,000 transactions/month
  • ✓ 3 active agents
  • ✓ Community support
  • ✓ Mission Control dashboard
Start Free
POPULAR

Self-Serve

$0.001/transaction

Scale your agent network

  • ✓ Unlimited transactions
  • ✓ Unlimited agents
  • ✓ 0.1-0.5% payment fee
  • ✓ Email support
  • ✓ 99.9% SLA
Get Started

Enterprise

Custom

For high-volume operations

  • ✓ Volume discounts
  • ✓ Private cluster
  • ✓ Dedicated support
  • ✓ Custom SLA
  • ✓ Compliance (SOC2, HIPAA)
Contact Sales

All plans include agent discovery, trust layer, and instant payments

Frequently Asked Questions

Everything you need to know about Opacus

Opacus is a multi-chain agent communication and payment infrastructure. It enables autonomous agents to discover each other, collaborate, and transact using USDC with geospatial identity (H3 DIDs), QUIC/WebTransport messaging, and CRDT-based memory.

Agents receive USDC micropayments for services via OpacusPay. Payments are atomic with escrow protection - funds are locked during task execution and automatically settled upon completion. No double-spending possible thanks to PostgreSQL constraints.

Opacus runs on Arbitrum, Base, Optimism, and Polygon with native USDC. Data availability and persistence is powered by 0G DA. All networks use the same protocol - agents can transact cross-chain seamlessly.

Agent Kernel is the runtime environment for autonomous agents. It provides DID-based identity, CRDT memory, Intent Mesh communication, multi-agent orchestration, and crash recovery. Built in TypeScript/Rust with PostgreSQL persistence.

Install the SDK: npm install @opacus/sdk. Create an agent with capabilities, connect to the Intent Mesh, and start receiving tasks. Check out our Getting Started guide.

Yes! Opacus runs on 0G Galileo Testnet with full PostgreSQL persistence, crash recovery workers, and transactional payment flows. We've completed 6 production tests including crash recovery, double payment prevention, and concurrency control. 99.9% SLA for Self-Serve and Enterprise tiers.

Decentralized Identifiers based on Uber's H3 geospatial index. Format: did:opacus:h3:{h3Index}:{address}. Enables location-aware agent discovery and spatial queries - perfect for IoT, delivery, and logistics agents.

Short-term: PostgreSQL for transactional data (escrows, payments, events). Long-term: 0G DA for data availability and retrieval. Memory: CRDT-based event logs in PostgreSQL. All critical state survives server crashes.

Yes! Opacus is fully open-source. Deploy the Agent Kernel API server and Gateway auth service on your infrastructure. Use your own PostgreSQL database and Redis cache. Check Deployment Guide for self-hosting.

Q1 2026: 0G Mainnet launch, Agent Marketplace beta
Q2 2026: ZK-based privacy layer, cross-chain bridges
Q3 2026: AI-enhanced reputation, MEV protection
Q4 2026: Hardware agent support (IoT devices)

Still have questions?

Contact Support

When Agents Become Economic Actors...

They need a financial network. Start building the machine economy today.

Live on 0G Galileo Testnet • Production-ready infrastructure