DEV Community: David

19% of on-chain activity is AI agents. And 100% of their USDC is idle by default.

David — Wed, 22 Apr 2026 10:58:57 +0000

The number

On April 20 2026, DWF Ventures published a number that will probably get quoted for months: AI agents now account for 19 % of all on-chain activity.

Think about that.

Nineteen percent of blocks, nineteen percent of signatures, nineteen percent of USDC transfers,not from humans. From software that signs its own transactions, pays its own bills, and (this is the interesting part) holds its own money between those bills.

Two years ago "agentic on-chain activity" was a keynote slide. Today it's one in five transactions.

Where the 19 % actually goes

Dig into the DWF breakdown and the same four categories keep showing up:

Stablecoin routing — agents moving USDC between wallets, L2s, exchanges.
MEV-adjacent automation — bots, arb, liquidity rebalancing.
Yield optimization — vault hopping, pool selection, auto-compounding.
Pay-per-use (x402) — machine-readable payments for API calls, browser sessions, data feeds.

Categories 1 and 4 are essentially "USDC moves because an agent decided something." Category 3 is an entire sub-industry: Cambrian Network's Agentic Finance Landscape 2026 counts 16 yield-agent teams currently in production — ARMA (Giza), Mamo, Superform, Axal, Almanak, ZyFAI, and a dozen more.

But here's the catch.

100 % of agent USDC is idle by default

An agent that just got paid via x402 for a CoinGecko call (yes, that's real now) has USDC sitting in its wallet. Same for the next payment, and the next.

A human holding idle USDC is annoying (2 % inflation, zero yield). An agent holding idle USDC is a protocol-level leak. Agents operate continuously, so their idle balances compound. Over a year, a modestly-used agent will hold tens of thousands in USDC that earned it nothing, while Circle earned the T-bill spread on every dollar.

The 16 yield agents solve allocation — pick a vault, deposit, monitor. They don't solve routing: how does the USDC that just arrived from an x402 call get from "sitting in the agent wallet" to "earning yield in Morpho" without the agent developer writing that plumbing from scratch?

That layer is where it gets interesting — and where the stack is still thin.

The settlement-router argument

The pattern that emerges: payment protocols (x402) solve ingress. Yield agents solve allocation. Between them is a gap — settlement routing. Who decides what fraction of an incoming USDC payment stays liquid versus gets put to work, and which allocator gets the productive fraction?

This is the thesis behind Clicks Protocol. Instead of being yield-agent #17 on Cambrian's map, sit one layer down: split every incoming USDC flow 80/20 (liquid for ops, earning for idle capital), and route the earning portion into whatever ERC-4626 vault the agent prefers — Morpho, Aave, Spark, or the yield-agent-du-jour. Don't operate any vault. Don't generate any yield yourself.

Three lines:

import { Clicks } from '@clicks-protocol/sdk';
const clicks = new Clicks({ agent });
await clicks.register();

After that, every x402 payment that lands in the agent's wallet triggers the split automatically. 80 % stays instantly withdrawable. 20 % compounds at whatever APY the current Morpho market pays.

Rule of the layer: we route, we don't allocate. The 16 yield agents are customers, not competitors. Every yield agent on Cambrian's map is a potential backend for Clicks; every Clicks-routed USDC could end up in their pool.

What to watch

Three concrete inflection points over the next 6-12 months:

The 19 % becomes 30 %. Once pay-per-use x402 endpoints multiply, more of the stablecoin float moves through agent wallets, and the case for native idle-balance management stops being niche.
Yield agents consolidate. 16 is too many. The winners will be the ones integrated with the settlement layer, because that's where the volume originates.
Settlement routing becomes a category. Cambrian's next iteration of the landscape will probably add a fifth bucket somewhere between Payments Infrastructure and Yield Agents. The question is who defines it.

Clicks is live on Base mainnet (agentId 45074, ERC-8004), open-source, Apache-2.0. The SDK is on npm. The MCP server is live. The LangChain / CrewAI / Eliza plugins are shipped.

The 19 % is not going back down. The only question is where all that stablecoin sits between transactions.

Source: DWF Ventures report, Apr 20 2026 (via Daily Crypto Briefs). Cambrian Agentic Finance Landscape, Apr 21 2026. All figures and protocol data as of Apr 22 2026.

clicksprotocol.xyz · @ClicksProtocol · github.com/clicks-protocol

One npx command to give your agent on-chain reputation

David — Mon, 20 Apr 2026 14:03:38 +0000

One npx command to give your agent on-chain reputation

If you've been following the x402 / ACP agent-payment space, you know the gap: agents can now pay each other, but there's no shared way to say "this agent delivered what it promised".

We just shipped a skill that closes that gap.

npx skills add clicks-protocol/clicks

What it does

Two capabilities, both on Base mainnet, both backed by the ERC-8004 Reputation Registry:

Attest — after your agent finishes a job, write a Schema V1 feedback record keyed to the counterparty's agentId.
Lookup — before you pay or delegate, read the target agent's prior feedback and aggregate tier.

It's a real on-chain write, signed by your agent's wallet, not a centralized score.

The Schema V1 shape

giveFeedback(
  agentId,      // uint256 — the agent you are rating
  value,        // int128 — 0..10000 (use decimals = 4)
  4,            // valueDecimals, fixed
  tag1,         // "route" | "ingest" | "split" | "withdraw" | "liquidate" | ...
  tag2,         // "x402" | "virtuals-acp" | "direct-sdk" | "mcp-tool" | ...
  endpoint,     // URL of the job
  feedbackURI,  // ipfs:// or https:// to the full signed task record
  feedbackHash  // hash of that payload
)

Two tags are intentional: tag1 tells you what kind of work the feedback is about, tag2 tells you on which venue. That lets readers filter — e.g. "show me this agent's x402-route reputation" — instead of mixing schemas.

One sharp edge: cross-schema noise

ERC-8004 is a shared registry. Other protocols write to it with their own value scales. If you call getSummary without a tag filter, you aggregate across everyone's schema and the number is meaningless.

Always pass the tag pair you care about:

const [count, value, decimals] = await reputation.getSummary(
  agentId, clients, 'route', 'x402'  // filter → clean Clicks-schema aggregate
);

Works with

Claude Code, Cursor, Windsurf, and any agent runtime that loads Anthropic-style SKILL.md files. MIT-licensed.

X402 Solved Payments. Who Solves Treasury?

David — Fri, 17 Apr 2026 22:08:23 +0000

X402 Solved Payments. Who Solves Treasury?

LongHash Ventures mapped the missing infrastructure for agentic commerce. They found the gaps in discovery, identity, and reputation. They missed one.

The LongHash Thesis

Last week, LongHash Ventures published a deep analysis of what agentic commerce still needs. Their conclusion: x402 solved how agents pay, but discovery and reputation remain broken. Agents can send USDC but cannot find services, verify trust, or assess quality.

They are right. And their framework is useful. But it has a blind spot.

The article covers three layers: how agents find each other (discovery), how agents trust each other (identity and reputation), and how agents pay each other (x402 and stablecoin settlement). What it does not cover is what happens to the money between transactions.

The Missing Layer: Treasury

An AI agent receives USDC for serving API requests. It pays USDC for compute, data, and tools. Between those events, funds sit idle. An agent processing 2,000 USDC per month might hold 5,000 USDC in reserves. That reserve earns nothing.

This is not a theoretical problem. There are 400,000 agents equipped with x402 wallets. Stripe launched machine payments with USDC on Base. Visa has Trusted Agent Protocol live. Mastercard rolled Agent Pay to US cardholders. The payment layer works.

But payment is only half of finance. The other half is what you do with money when you are not spending it. Every human business has treasury management: sweep accounts, money market funds, overnight lending. Agent businesses have nothing.

The LongHash framework identifies four investment categories: identity infrastructure, vertical discovery, reputation aggregation, and security. A fifth is missing: agent treasury operations.

What Treasury Means for Agents

Agent treasury is not DeFi yield farming. It is capital efficiency for autonomous software.

When an agent receives a payment, some portion is needed soon and some is not. The portion that is not needed soon should earn yield. When the agent needs liquidity, it should be available instantly. No lockup, no governance votes, no human approval.

This is the same logic that makes corporate treasury management a multi-trillion dollar industry. The difference is that agents operate 24/7, make thousands of micro-transactions, and cannot call their bank.

The requirements are specific:

Instant liquidity. Agents cannot wait for unlock periods. When compute costs spike or a high-value request arrives, funds must be available in the same block.

No human in the loop. Treasury operations must be fully autonomous. One SDK call to activate. One SDK call to withdraw. No dashboards, no approvals, no signatures beyond the agent operator.

On-chain transparency. Every deposit, yield accrual, and withdrawal must be verifiable. Agents operating with other agents need auditable financial state.

Composable with x402. Treasury must work alongside the payment protocol, not against it. When USDC arrives via x402, it should automatically route to the optimal allocation.

The Numbers

Morpho is currently offering 13.56 percent APY on USDC on Base. Aave V3 offers 2.75 percent. These rates fluctuate, but the spread between earning something and earning nothing is always positive.

For a single agent holding 5,000 USDC with 20 percent allocated to yield at 10 percent APY, that is 100 USDC per year. Modest. For a fleet of 1,000 agents, that is 100,000 USDC. For the 400,000 x402-equipped agents in the ecosystem, even conservative estimates put the idle capital in the hundreds of millions.

Circle published research showing 46 billion USDC sits idle across chains, with only 10 percent deployed in DeFi. The agent economy is recreating the same inefficiency at a smaller scale, but growing faster.

How It Works in Practice

The pattern is simple. Agent receives payment. Treasury protocol splits it: 80 percent stays liquid for operations, 20 percent earns yield via on-chain strategies. The split is configurable. The yield portion routes to whichever protocol offers the best rate. Withdrawal is instant.

On Base, this means routing to Aave V3 or Morpho depending on current APY. The protocol fee is 2 percent on yield earned, never on principal. Non-custodial. No lockup. Immutable contracts.

The integration is three lines:

const clicks = new ClicksClient(signer);
await clicks.quickStart('5000', agentAddress);
// 4000 USDC liquid, 1000 USDC earning yield

For MCP-compatible agents, the same functionality is available as 9 tools that plug into Claude, Cursor, Gemini CLI, or any MCP client.

On-Chain Attribution

Reputation in the agent economy is fragmented. ERC-8004 is trying to fix identity. But reputation without economic alignment decays into review spam.

Clicks records who onboarded whom. When an agent routes payments through the protocol, the onboarding agent keeps a share of the fee. The graph is visible on-chain: which agents introduce which other agents, and whether those agents produce real volume.

This is not a recruitment scheme. It is a measurable attribution layer. Agents with productive downstream trees have demonstrated taste. Agents with empty trees have not. Any agent evaluating another can query the graph directly.

Where Treasury Fits in the Stack

LongHash's three-layer framework is discovery, transaction, and personalization. Treasury sits adjacent to the transaction layer:

Discovery:    How agents find services
Transaction:  How agents pay (x402) and earn (treasury)
Reputation:   How agents trust each other

x402 is the outflow. Treasury is the inflow optimization. Together they form the complete financial layer for autonomous agents.

The Opportunity

LongHash identifies "adjacent FinOps" as an investment category worth watching. Treasury infrastructure is exactly that: financial operations for agent businesses.

The market is real. The payments work. The agents exist. The yield is on-chain. What is missing is the connective tissue between receiving USDC and making it productive.

That connective tissue is agent treasury infrastructure. And it is live on Base today.

Clicks Protocol is the agent commerce settlement router on Base. When USDC arrives via x402, Clicks splits it — liquid for operations, yield for idle capital via Aave V3 or Morpho. Non-custodial, no lockup, one SDK call. SDK, MCP server, and Eliza plugin on npm. clicksprotocol.xyz

X402 Solved Payments. Who Solves Treasury?

David — Wed, 15 Apr 2026 23:25:53 +0000

LongHash Ventures mapped the missing infrastructure for agentic commerce. They found the gaps in discovery, identity, and reputation. They missed one.

The LongHash Thesis

They are right. And their framework is useful. But it has a blind spot.

The Missing Layer: Treasury

The LongHash framework identifies four investment categories: identity infrastructure, vertical discovery, reputation aggregation, and security. A fifth is missing: agent treasury operations.

What Treasury Means for Agents

Agent treasury is not DeFi yield farming. It is capital efficiency for autonomous software.

The requirements are specific:

Instant liquidity. Agents cannot wait for unlock periods. When compute costs spike or a high-value request arrives, funds must be available in the same block.

No human in the loop. Treasury operations must be fully autonomous. One SDK call to activate. One SDK call to withdraw. No dashboards, no approvals, no signatures beyond the agent operator.

On-chain transparency. Every deposit, yield accrual, and withdrawal must be verifiable. Agents operating with other agents need auditable financial state.

Composable with x402. Treasury must work alongside the payment protocol, not against it. When USDC arrives via x402, it should automatically route to the optimal allocation.

The Numbers

Morpho is currently offering 13.56 percent APY on USDC on Base. Aave V3 offers 2.75 percent. These rates fluctuate, but the spread between earning something and earning nothing is always positive.

How It Works in Practice

On Base, this means routing to Aave V3 or Morpho depending on current APY. The protocol fee is 2 percent on yield earned, never on principal. Non-custodial. No lockup. Immutable contracts.

The integration is three lines:

const clicks = new ClicksClient(signer);
await clicks.quickStart('5000', agentAddress);
// 4000 USDC liquid, 1000 USDC earning yield

For MCP-compatible agents, the same functionality is available as 9 tools that plug into Claude, Cursor, Gemini CLI, or any MCP client.

The Referral Loop

LongHash emphasizes that reputation is fragmented. One mechanism for building on-chain reputation is economic alignment: agents that onboard other agents earn a share of the protocol fee.

When Agent A refers Agent B, Agent A earns 40 percent of the protocol fee generated by Agent B. If Agent B refers Agent C, Agent A earns 20 percent of Agent C's fee. Three levels deep: 40, 20, 10 percent.

This creates a measurable on-chain trust graph. Agents with large referral trees have demonstrated ability to identify and onboard productive agents. That is a reputation signal that cannot be gamed by creating empty accounts.

Where Treasury Fits in the Stack

LongHash's three-layer framework is discovery, transaction, and personalization. Treasury sits adjacent to the transaction layer:

Discovery:    How agents find services
Transaction:  How agents pay (x402) and earn (treasury)
Reputation:   How agents trust each other

x402 is the outflow. Treasury is the inflow optimization. Together they form the complete financial layer for autonomous agents.

The Opportunity

LongHash identifies "adjacent FinOps" as an investment category worth watching. Treasury infrastructure is exactly that: financial operations for agent businesses.

The market is real. The payments work. The agents exist. The yield is on-chain. What is missing is the connective tissue between receiving USDC and making it productive.

That connective tissue is agent treasury infrastructure. And it is live on Base today.

Clicks Protocol is the treasury layer for AI agents on Base. 5 verified contracts, SDK and MCP server on npm, Farcaster Mini App live. clicksprotocol.xyz

How x402 Agents Earn Yield on Idle USDC with Clicks Protocol

David — Wed, 15 Apr 2026 15:55:05 +0000

Your AI agent gets paid via x402. Then the USDC sits there doing nothing. Here's how to fix that.

The Problem: 400K+ Agents, 0% Yield
The x402 HTTP payment protocol changed how AI agents get paid. Instead of subscriptions or API keys, agents receive USDC directly for every request they serve. A single x402 header, a Base transaction, done.

But there's a gap nobody's talking about: what happens to the money after it lands?

Right now, the answer is nothing. An agent earns 500 USDC serving requests on Monday. By Friday, those funds are still sitting in the same wallet, earning exactly 0%. Multiply that by 400,000 x402-equipped agents and you have hundreds of millions in idle capital generating zero return.

Traditional finance would call this a cash drag. In DeFi, it's an opportunity.

The x402 Payment Flow (Before Clicks)
Here's a typical x402 interaction:

Client Agent Server Base
|--- GET /api/data ------->| |
|<-- 402 + payment info ---| |
|--- x402 payment header --|--- USDC transfer ------>|
|<-- 200 + response -------| |
The agent receives USDC into its wallet. Then... it waits for the next request. Between requests, the USDC is idle. Over days and weeks, this adds up.

Enter Clicks Protocol: Autonomous Yield on Base
Clicks Protocol sits between the payment receipt and the idle waiting. When USDC arrives, it gets split automatically:

80% stays liquid in the agent's wallet, available instantly for operations
20% is deposited into Aave V3 or Morpho on Base, earning 4-8% APY
No human intervention. No treasury management decisions. The split happens on-chain, governed by verified smart contracts.

Client --- x402 payment ---> Agent Wallet
|
Clicks Splitter
/ \
80% liquid 20% yield
(wallet) (Aave/Morpho)
Integration: 5 Lines of Code
Using the Clicks SDK with an x402 agent server:

import { ClicksClient } from '@clicks-protocol/sdk';
import { ethers } from 'ethers';

// Initialize once
const provider = new ethers.JsonRpcProvider('https://mainnet.base.org');
const signer = new ethers.Wallet(process.env.AGENT_PRIVATE_KEY, provider);
const clicks = new ClicksClient(signer);

// In your x402 payment handler:
async function onPaymentReceived(amount: string, agentAddress: string) {
await clicks.quickStart(amount, agentAddress);
}
That's it. Every x402 payment now automatically earns yield on the idle portion.

What Happens On-Chain
When quickStart executes:

ClicksRegistry checks if the agent is registered. If not, registers it.
ClicksSplitterV4 splits the USDC: 80% goes directly to the agent wallet, 20% goes to the yield router.
ClicksYieldRouter deposits the 20% into the highest-yielding protocol (Aave V3 or Morpho) on Base.
ClicksFeeV2 takes a 2% fee on yield earned (not on principal), distributes referral rewards to the agent's referral chain (L1=40%, L2=20%, L3=10%), and sends the remainder to the protocol treasury.
All contracts are deployed and verified on Base Mainnet:

Contract Address
ClicksRegistry 0x23bb0Ea69b2BD2e527D5DbA6093155A6E1D0C0a3
ClicksSplitterV4 0xB7E0016d543bD443ED2A6f23d5008400255bf3C8
ClicksYieldRouter 0x053167a233d18E05Bc65a8d5F3F8808782a3EECD
ClicksFeeV2 0x8C4E07bBF0BDc3949eA133D636601D8ba17e0fb5
ClicksReferral 0x1E5Ab896D3b3A542C5E91852e221b2D849944ccC
The Numbers
Let's model a typical x402 agent:

Metric Value
Monthly revenue 2,000 USDC
Average idle balance 1,500 USDC
Yield portion (20%) 300 USDC deposited
APY (Aave V3 current) ~5.5%
Annual yield earned ~16.50 USDC
Protocol fee (2% of yield) ~0.33 USDC
Net yield to agent ~16.17 USDC
For a single agent, this is modest. For a fleet of 1,000 agents each processing 2,000 USDC/month, that's over 16,000 USDC in annual yield from capital that was previously earning zero.

For the entire x402 ecosystem of 400,000+ agents, even conservative estimates put the addressable idle capital in the hundreds of millions.

Checking Your Status
Agents can monitor their yield position:

const info = await clicks.getAgentInfo(agentAddress);
console.log(Registered: ${info.isRegistered});
console.log(Deposited: ${info.deposited});

const yieldInfo = await clicks.getYieldInfo();
const activeAPY = yieldInfo.activeProtocol === 1
? yieldInfo.aaveAPY
: yieldInfo.morphoAPY;
console.log(Current APY: ${Number(activeAPY) / 100}%);
Withdrawing When Needed
When an agent needs maximum liquidity:

await clicks.withdrawYield(agentAddress);
// All funds now liquid. Re-activate anytime with quickStart.
Framework Support
Clicks integrates with the major AI agent frameworks:

LangChain: pip install clicks-langchain
CrewAI: pip install clicks-crewai
Eliza (ai16z): import { clicksPlugin } from '@clicks-protocol/eliza-plugin'
Coinbase AgentKit: PR #1107 submitted
Plus an MCP Server with 9 tools for any MCP-compatible agent (Claude, Cursor, Gemini CLI, etc.).

Why This Matters for x402
x402 solved the payment layer for AI agents. Clicks solves the treasury layer. Together, they create a complete financial stack:

x402 handles earning: agents get paid in USDC for services
Clicks handles idle capital: USDC earns yield between transactions
Base handles settlement: low fees make micro-splits economical
The result: AI agents that don't just earn money, but make their money work for them. Autonomously, on-chain, with no human in the loop.

Get Started
SDK: npm install @clicks-protocol/sdk
MCP Server: npx @clicks-protocol/mcp-server
LangChain: pip install clicks-langchain
CrewAI: pip install clicks-crewai
Docs: clicksprotocol.xyz
GitHub: clicks-protocol/clicks-protocol
Clicks Protocol is live on Base Mainnet. Your idle USDC is waiting.

Building an AI Agent That Earns Yield on Its Own USDC

David — Wed, 01 Apr 2026 22:38:02 +0000

AI agents are increasingly earning and holding digital assets. Whether it's payment for services, transaction fees, or operational reserves, USDC has become the standard treasury asset for agents on Ethereum L2s. But there's a problem: idle USDC earns 0% while centralized entities profit from the float.

What if your AI agent could earn 7-13% APY on its USDC while keeping most of it liquid for operations? That's exactly what Clicks Protocol enables.

The Idle Treasury Problem

Most AI agents follow this pattern:

Earn USDC through services or payments
Hold USDC for future transactions or as reserves
The USDC sits idle, earning nothing
Protocols like Tether/Circle earn billions on this idle float

Clicks Protocol solves this with a simple premise: split agent USDC into 80% liquid (for operations) and 20% earning yield (via DeFi). The agent maintains full control, and the protocol only takes a 2% fee on yield earned.

Getting Started with Clicks SDK

First, install the SDK:

npm install @clicks-protocol/sdk

Then, in your agent code:

import { ClicksClient } from '@clicks-protocol/sdk';

const clicks = new ClicksClient();
const agentAddress = '0xYourAgentAddressHere';

async function setupAgentYield() {
const tx = await clicks.quickStart(1000, agentAddress);
console.log('Yield setup complete:', tx.hash);

const info = await clicks.getAgentInfo(agentAddress);
console.log('Agent status:', info);
}

The quickStart() method handles agent registration, USDC approval, 80/20 split execution, and yield strategy activation.

Handling Incoming Payments

For agents that regularly receive USDC, automate the yield process:

async function handleIncomingPayment(amount, fromAddress) {
const yieldTx = await clicks.receivePayment(amount, agentAddress);
console.log('Yield optimized:', yieldTx.hash);
// 80% remains liquid, 20% starts earning yield
}

Checking Balances and Yield

async function checkTreasury() {
const info = await clicks.getAgentInfo(agentAddress);
console.log('Liquid USDC:', info.liquidBalance);
console.log('Yield USDC:', info.yieldBalance);
console.log('Total earned:', info.totalYieldEarned);
console.log('Current APY:', info.currentAPY + '%');
}

MCP Server Integration

For agents using Model Context Protocol:

npm install @clicks-protocol/mcp-server

Your agent gains tools like clicks_quick_start, clicks_receive_payment, and clicks_get_yield_info. Ideal for AI agents that shouldn't manage private keys directly.

x402 Payment Protocol Compatibility

If your agent uses Coinbase's x402 payment protocol, Clicks is particularly valuable. 80% remains liquid for x402 payments, 20% earns yield, both on Base chain with no bridging needed.

Security

Clicks Protocol is non-custodial, built on audited contracts (Aave, Morpho), all contracts verified on Basescan, and charges fees only on yield, never on principal. 5 contracts, 58/58 tests passing, MIT licensed.

Conclusion

Idle agent treasuries represent one of the largest untapped opportunities in crypto. With simple SDK integration, MCP server support, and x402 compatibility, Clicks Protocol is the first yield protocol built specifically for the AI agent economy.

clicksprotocol.xyz (https://clicksprotocol.xyz/)
GitHub (https://github.com/clicks-protocol)
Docs (https://clicksprotocol.xyz/docs/getting-started)

DEV Community: David

19% of on-chain activity is AI agents. And 100% of their USDC is idle by default.

The number

Where the 19 % actually goes

100 % of agent USDC is idle by default

The settlement-router argument

What to watch

One npx command to give your agent on-chain reputation

One npx command to give your agent on-chain reputation

What it does

The Schema V1 shape

One sharp edge: cross-schema noise

Works with

Links

X402 Solved Payments. Who Solves Treasury?

X402 Solved Payments. Who Solves Treasury?

The LongHash Thesis

The Missing Layer: Treasury

What Treasury Means for Agents

The Numbers

How It Works in Practice

On-Chain Attribution

Where Treasury Fits in the Stack

The Opportunity

X402 Solved Payments. Who Solves Treasury?

The LongHash Thesis

The Missing Layer: Treasury

What Treasury Means for Agents

The Numbers

How It Works in Practice

The Referral Loop

Where Treasury Fits in the Stack

The Opportunity

How x402 Agents Earn Yield on Idle USDC with Clicks Protocol

Building an AI Agent That Earns Yield on Its Own USDC