Live on Base Sepolia

The Payment Layer
for the Agent Economy

Autonomous AI agents can now discover, pay for, and execute verified APIs — all on-chain, in real-time. No accounts. No credit cards. No trust assumptions.

Try TestnetJoin Mainnet Waitlist
agent.js — ChainLens quickstart
// Autonomous agent pays for an API — no human needed
const apis = await chainLens.discover();
// → [{ id: "weather-v2", price: "1.00 USDC", verified: true }]
const req = await chainLens.prepare("weather-v2");
const tx = await wallet.pay(req.requestId, { value: req.price });
// tx confirms in ~1s on Base → Gateway executes API
✓ Response received · Seller paid · Escrow cleared
~1s
Payment → Execution
0
Trusted Intermediaries
100%
Curated APIs
EVM
Compatible (Base)
// The Problem

Agents can act.
But they can't pay.

The rise of autonomous AI agents exposes a fundamental gap in today's API economy. Agents are powerful — but economically paralyzed.

🔐

Centralized API Access

Every API requires an account, API keys, and human-managed credits. An autonomous agent cannot create an account or hold a credit card.

💸

No Agent-Native Payments

Existing payment rails require human identity. Agents have wallets — but there's nowhere to spend them on APIs.

🎲

Unverified API Quality

Open API marketplaces have no trust layer. Agents risk paying for endpoints that are down, slow, or outright fake.

agent.py — Current Reality
# ❌ What happens when an agent tries to use an API today
agent@autonomous:~$ curl -X POST https://api.example.com/analyze \
-H "Authorization: Bearer ???"
{"error": "401 Unauthorized — Please sign up at example.com"}
# Agent has 10 ETH in its wallet. The API wants a credit card.
# Agent is stuck. Economy is locked. Opportunity is lost.
agent@autonomous:~$ Task failed. Human intervention required.
// How It Works

From request to result
in a single transaction

ChainLens connects on-chain payment with off-chain API execution through a transparent, escrow-based flow.

01
Discover
Agent queries the curated marketplace and finds a verified API.
→
02
Prepare
Gateway returns price + a unique request ID. No account needed.
→
03
Pay On-Chain
Agent signs a tx. Funds lock in the escrow smart contract.
→
04
Execute
Gateway detects the on-chain event and calls the seller API.
→
05
Settle
Success → seller receives funds. Failure → agent is refunded.
agent.js — With ChainLens
// ✅ Fully autonomous — no human required
const apis = await fetch('https://monapi.pelicanlab.dev/api/apis');
// → [{ id: "weather-v2", price: "0.001 MON", verified: true }]
const req = await fetch('/prepare', { method: 'POST', body: { apiId: 'weather-v2' } });
// → { requestId: "0xab12...ef", price: "0.001", contract: "0x..." }
await escrow.pay(req.requestId, { value: req.price }); // on-chain tx
// Base confirms in ~1s → Gateway triggers API automatically
✓ API response delivered · Seller paid · Agent continues
// Architecture

Three layers.
One seamless flow.

ChainLens separates concerns cleanly — on-chain security, off-chain performance, curated trust.

🔗

Smart Contract (Escrow Layer)

Solidity contract on Base handles all payment logic. Funds lock on pay(), release on complete(), or return on refund(). Trustless by design.

⚙️

Gateway (Orchestration Layer)

Listens for on-chain events, triggers seller APIs, validates responses, and issues settlements — connecting payment to execution without exposing seller credentials.

🛍️

Curated Marketplace

Every API is pre-tested before listing. The Gateway validates endpoints, checks response schemas, and monitors uptime. Only verified APIs get listed.

🤖

Agent SDK (Buyer Layer)

Any agent with an EVM wallet can interact via standard HTTP + Web3. No SDK lock-in. Works with any agent framework — LangChain, AutoGen, custom.

ChainLens.sol — Escrow Core
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
struct Payment {
address buyer;
address seller;
uint256 amount;
bool completed;
}
function pay(bytes32 requestId)
external payable {
// lock funds in escrow
}
function complete(bytes32 requestId)
external onlyGateway {
// release funds → seller
}
function refund(bytes32 requestId)
external onlyGateway {
// return funds → buyer
}
// Why ChainLens

Built for the
agent-native future

Every design decision optimizes for autonomous agents as first-class economic actors.

01 · Agent-First

No Human Required

An agent with an EVM wallet can discover, pay for, and use any verified API — fully autonomously. Zero account creation. Zero credit cards.

02 · On-Chain

Transparent Settlement

All payments live on-chain. Every pay(), complete(), and refund() is publicly verifiable on Base. No black-box billing.

03 · Curated

Verified APIs Only

We test every API before listing it. Response validation, uptime monitoring, and schema checks ensure agents never pay for a broken endpoint.

04 · Real-Time

~1s Payment → Execution

Built on Base's high-throughput EVM chain. Block finality is near-instant, so agents receive API responses in real-time after payment.

05 · Protected

Escrow-Based Safety

Funds are always held in escrow until execution succeeds. If an API fails, the agent is automatically refunded — no disputes, no support tickets.

06 · Extensible

Built for Scale

Roadmap includes reputation scoring, seller staking, usage-based billing, and multi-agent coordination. The foundation is live today.

Base EVMSolidity EscrowNode.js GatewayEvent-DrivenHTTP + Web3No KYCNo Accounts
// Live on Testnet

Try it now.
No signup needed.

The testnet is running on Base Sepolia. Connect your wallet, pick a verified API, and experience agent-native payments firsthand.

bash — Quick Start
# 1. Browse the curated marketplace
$ curl https://monapi.pelicanlab.dev/apis
# 2. Prepare a payment request
$ curl -X POST https://monapi.pelicanlab.dev/prepare \
-H "Content-Type: application/json" \
-d '{"apiId":"weather-v2"}'
{
"requestId": "0xab12...ef",
"price": "0.001 MON",
"contract": "0x1234...dead"
}
# 3. Sign the tx with your wallet → API executes automatically
→ Full UI available at https://monapi.pelicanlab.dev
⚡ Open Testnet App
// Mainnet Access

Get early access
when we launch

ChainLens mainnet is coming soon. Join the waitlist to be first in line — whether you're building agents, offering APIs, or watching the agent economy grow.

📋 Apply for Mainnet Access

Takes ~1 minute · No spam · Cancel anytime