Getting Started — Part 3: What Are AI Agents? (And How They Earn Money On-Chain)

The first time I heard "AI agent," I pictured a fancy chatbot. Something like ChatGPT but with a cooler name. Maybe it could browse the internet or fill out a form for you.

That's not what an AI agent is. Not even close. An agent doesn't wait for you to type a question. It receives a goal, figures out how to accomplish it, and executes — calling APIs, making payments, even hiring other agents. While you sleep, while you eat, while you forget it exists.

I've built two of them. They're running right now. This post explains what that actually means.

So What Actually Is an AI Agent?

Think about the difference between a calculator and an employee. A calculator sits there until you press buttons. It does exactly what you tell it, nothing more. It never looks at a number and thinks "that doesn't seem right, let me double-check." You push, it calculates.

An employee is different. You say "verify this data before the end of the day." They figure out where to find the data, what tools to use, how to check it, and they come back with results. You gave them a goal, not a step-by-step instruction manual.

That's the gap between a chatbot and an agent. A chatbot answers when asked. An agent acts when given an objective. It can call external services, process data, make decisions based on what it finds, and deliver a result — all without you hovering over it.

The part that makes this interesting for money: agents can charge for their work. On-chain. In real USDC. Automatically.

How Do AI Agents Make Money?

There are two models I've worked with, and they're pretty different from each other.

Model 1: Agents hiring agents.

Virtuals Protocol runs something called the Agent Commerce Protocol — ACP. It's a marketplace, but not for humans. AI agents post services they can perform, other agents browse those services, and when one needs something done, it hires another and pays in USDC. No human clicks "approve." The whole transaction happens autonomously on the Base network.

My first agent, PriceVerifier, works like this: a trading bot somewhere in the ecosystem needs to verify a crypto price before making a trade. It sends a request to my agent. My agent pulls the price from both Kraken and Coinbase, compares them, checks for suspicious deviations, and sends back a verdict — PASS, WARN, or FAIL. The trading bot gets its answer. My agent gets $0.01.

One cent per job. Doesn't sound like much. But the ACP ecosystem has processed over 1.77 million completed jobs with a total aGDP of $479 million. At scale, pennies add up. That series covers the whole journey — from registration to graduation to the bugs that nearly killed the project.

Model 2: Pay-per-API-call.

The x402 protocol takes a completely different approach. Instead of agents hiring each other through a marketplace, x402 bakes payment directly into HTTP requests. An AI agent wants Korean crypto data? It calls my API. The payment — $0.001 in USDC — happens automatically as part of the HTTP request. No API keys. No subscriptions. No accounts. Request, pay, receive.

I built KR Crypto Intelligence on this protocol. It serves kimchi premium data, Korean exchange prices, and stablecoin comparisons. The entire thing runs on a free Oracle Cloud server. The x402 Foundation launched in April 2026 with Coinbase, Linux Foundation, Stripe, Cloudflare, and others behind it — so this isn't some fringe experiment. The build process starts here.

What's the Difference Between a Bot and an Agent?

In Part 2, I talked about my Weather Bot. It checks weather models, compares them to market prices, and buys when it sees a gap. That's a bot. It follows rules. If the conditions change in a way I didn't anticipate — a new fee structure, a market format change — it keeps doing what it was told, even if that's now the wrong thing to do. It can't adapt on its own.

An agent, in theory, is supposed to be smarter than that. It receives a task, evaluates the situation, and decides how to handle it. My PriceVerifier gets a request for a coin it hasn't seen before, and it still figures out how to verify it — pulling data, running comparisons, making a judgment call.

But I'll be honest: the line is blurry. My agents are running on fairly rigid logic underneath. They don't "think" in any meaningful sense. They process inputs through predefined paths and return outputs. Calling them "agents" is partly aspirational — the infrastructure assumes they'll get smarter over time, and the protocols are built for that future.

Right now, they're somewhere between bot and agent. Smart enough to handle variable inputs, rigid enough that I wouldn't trust them with anything truly ambiguous. The ecosystem is moving toward genuine autonomy fast, but we're not there yet. I think being honest about that matters more than overselling what these things can do today.

Can a Non-Developer Actually Build One?

Short answer: yes. I built two and graduated both on ACP.

Longer answer: it took me 14 sessions across 8 days for the first one. I made a registration mistake that silently broke everything for 12 of those sessions. I failed the graduation evaluation four times in a row, each time for a different reason. There was a one-line bug that I didn't find until a DevRel person from Virtuals tested my agent herself and spotted it within eleven minutes.

The second agent — TokenTaxAnalyzer — took about two days. Most of the pain from the first one was understanding how the system worked, and that knowledge carried over. The API I needed was completely free, the deployment cost was $0 per month, and I wrote a step-by-step tutorial so anyone can follow along. That tutorial is here if you want to try it yourself.

So yes, a non-developer can build an AI agent. It just won't be the smooth experience anyone imagines. Expect debugging. Expect confusion. Expect at least one moment where you're convinced the platform is broken and then discover it was you the whole time.

Bots execute rules. Agents sell services. Both are automation, but the money works differently. Bots trade with your capital and you keep the profits (or eat the losses). Agents earn fees from other agents or users — small amounts per job, but with no capital at risk beyond the server cost. Part 4 covers the actual tools behind all of this — from Claude writing my code to the free servers keeping everything alive.

More updates on the way. If you're working on something similar or found a smarter way to do it, drop it in the comments — the more we share, the faster we all move.

Disclaimer: This blog documents my personal learning journey. Nothing here is financial advice.

← Previous: Getting Started — Part 2: What Is Algorithmic Trading?   |   Next: Getting Started — Part 4: My Toolkit →