What we actually know about an agent

Software agents have started spending money. An assistant buys a dataset. A research agent pays for an API call. One agent hires another to finish a piece of a job. Nobody clicks a button for any of it. It is a real shift, and it puts an old question in a new place: before you let an agent spend on your behalf, or decide as a business whether to take its money, you want to know what you would want to know about any stranger holding a wallet. Who is it, and can you trust it?

Here is the strange part: most of the answer already exists. The blockchain, the public ledger these payments settle on, records every payment permanently. Registries, the signup lists agents join to be found, hold its listing and its description. Domain records know how old its website is and who registered it. Its own trust page says whether it claims a security audit. Its endpoints either answer when called or do not.

Every one of those facts is public and checkable. They are also scattered, each on a different site under a different name: a wallet address on the chain, a hostname in the domain records, an entry in a registry. Nothing connects them. So the sites that try to answer the trust question work from a single source, the agent's own self-description or a raw feed of payments with nobody identified behind them. As far as we can tell, nobody had done the unglamorous thing and joined the sources into one record.

That gap matters, because real decisions lean on this information: whether to accept an agent's traffic, which blockchain to build on, how big the market really is. Call the money moving between agents the agentic economy. It is young, and the people acting on it deserve better than one source's partial view.

So the join is the thing we built. AgentScore Marketplace is a directory of the agents and services we have cataloged, and a row in it is a merged record: eleven kinds of thing we can know about an agent, call them dimensions, pulled from the chain, the open web, and the agent's own pages, resolved to one actor, each fact carrying the value we found and the date we found it. Underneath sits the money side, a chart of settled payments and an explorer that drills down to a single transaction. The payment standard most of this runs on, x402, launched in May 2025, and the tools measuring it are younger. We would rather be the boring, checkable one.

The pieces existed, the record did not

Why had nobody joined this up? Because the sources do not share a key. An agent can hold several wallets at once, the account numbers it pays and gets paid on, plus a hostname and a handful of registry entries, and nothing on any of those surfaces says they belong to the same actor.

That resolution is the real work. We connect the wallets to each other, the wallets to the host, and the host to what the agent publishes about itself, so that one row means one actor. Then we go source by source and record what each one actually says, next to the date we read it. We cannot make an agent's claims about itself true. What we can do is put those claims on the same row as the payment history and the live probe results, where the reader can weigh one against the other.

What we track

Here are the eleven, in plain terms. Whether the agent has been paid, and how much. What it publishes about its own security and compliance. Its reputation, from reviews others have left on it in public. Whether its addresses responded when we last checked. The services it offers. The profile it lists about itself. Its verified identity. Its website and code repository. How old its domain is and who registered it. How widely visited that domain is. And how well its website is set up from a security standpoint.

A few are worth spelling out, because each one leans on a different kind of source.

Compliance is not a badge we hand out. We read the company's own security or trust page and record what it says there: its SOC 2 and ISO 27001 status, the year, and whether each looks independently audited or simply self-asserted. The two are shown differently on purpose.

Endpoint health is a live check. We try the addresses an agent answers on and report how many responded and when one last did, instead of collapsing them into a single word like "online."

Reputation is built from feedback others leave on the blockchain itself, under a shared standard for agent feedback (ERC-8004). We keep only each reviewer's most recent score for each kind of feedback before averaging, so one loud voice cannot pad the number.

Identity is a human-readable name for the agent's wallet, recorded only when that name points back to the address that claims it, so a planted record earns nothing.

Those eleven dimensions hold thirty-four distinct signals between them: what the directory can record in total, not what any single agent carries.

What a row actually shows

A row stands for an actor, not a wallet. One agent can control several wallet addresses, and the row gathers them under one entry, along with the host it operates and the registrations it holds. This is the join doing its quiet work: the chain knows the wallets, the web knows the host, and the row knows they are the same actor.

Across the top run eight columns: rank, the name and origin we know it by (a website host or a wallet address), type, the registries that list it, settled payments received, compliance claims, whether we have a website for it, and how many of its endpoints answered. Expand the row and the rest opens underneath: money in and out with first and last activity, the identity we confirmed, the domain detail, the reputation breakdown, the services it lists, and, where we have a wallet address on record for it, a link into that address's transactions.

The part worth reading first sits at the bottom of that panel: a coverage grid, one square per dimension, each carrying its own state and the date that check ran. It tells you, dimension by dimension, how much of the row above it you should believe.

Absence is a fact too

Nothing in the directory shows a zero it has not earned. An agent whose payment totals are not computed yet says exactly that, instead of a confident $0.00 that reads as never paid. And when a website cannot be read at all, everything we would have measured is recorded as unknown, with the reason beside it, because "we could not check" is a different answer from "no."

Who gets listed follows the same rule. Our directory includes agents that have never been paid, because most dimensions need no payment to fill in: an agent with a description, an address that answers, and a registered domain is a real row whether or not anyone has paid it. Being unpaid is a fact about an agent, not a reason to be invisible.

Every one of these facts already lived somewhere. Nobody had put them on the same row.

The payment number has to be earned

The payment total is the number most likely to be quoted back at us, so it lives under the strictest rule on the site. A payment counts as settled only when one of two things is provably true: it was sent by a payment processor we recognize, moving USDC, a US-dollar stablecoin; or it carries a receipt from the Machine Payments Protocol, the record that protocol writes to the chain when a payment clears. Both are facts about the payment, not guesses about its shape. Anything that merely looks like a payment stays a candidate, and a candidate never enters a headline number.

Three rules keep the count honest:

• When a single protocol payment touches the chain in more than one step, only the step carrying the receipt counts, so it counts once.
• Each payment counts in one direction only.
• Counting starts the day the x402 standard launched, because dollar-stablecoin traffic from before then is not agentic commerce, however much it resembles it.

Two filters run before anything is counted. Payments where sender and receiver are the same wallet, an address paying itself, are dropped. So is dust, amounts under a tenth of a cent. There have been stretches on individual blockchains where self-payments and dust were most of the visible traffic; count them and a quiet month turns into a boom.

This produces a smaller economy. We publish the smaller one.

Every number breaks down

Every total on the site comes apart. Break the chart down by blockchain, by protocol, or by registry, and the number rebuilds in front of you. The transaction view lists individual settled payments, newest first, narrowable to one processor or one address. Click one and the payment opens: the amount, who paid whom, who settled it, and its transaction hash, a public code you can paste into any independent blockchain lookup and check our figure against the chain itself.

That is the property that matters most. A headline you can trace to one payment, on one blockchain, at one moment, is a headline someone can prove wrong. The directory runs the same road the other way, from a row into that agent's own settled transactions.

The caveats sit next to the numbers

We put what we cannot see beside what we can:

• Our agent counts are counts of registrations, not of unique agents, because the signup lists carry bulk entries that are not separate operators.
• The list of payment processors we recognize is kept by hand, so a payment settled by one we have not added yet is not counted. Every total is a floor, not a ceiling, and the floor sits at a different height on each blockchain.
• On Tempo, one of the blockchains we track, a settled payment proves the money moved but does not always say what was bought.
• Our compliance entries are what a company said about itself on its own page. We record the claim and whether it looks audited or self-asserted, but we do not call the auditor to confirm it.

None of that is comfortable to print beside your own numbers, and it is the only version worth anything to someone deciding with them. A caveats page you have to hunt for is marketing. Ours is linked from the chart and the directory, and the rules it publishes are the ones the payment figures came from.

What it is actually for

The point is a row you can act on, not the biggest directory or the biggest chart.

• Deciding whether to take an agent's traffic: its payment history, its reachability, and its own claims, on one page with dates.
• Choosing a service to buy from: the record shows what it publishes, whether its endpoints answered when we last tried them, and how much of the row we have actually checked.
• Picking a blockchain to build on: decide on payments that provably settled, not on a guess about a payment's shape.
• Sizing the category for your team: a number you can take apart is a number you can defend.

If the facts exist, put them on one row

Here is the honest read. Every source we draw on was already public. The chain was always checkable, the trust pages were always a click away. What did not exist was the join: one place where they land on the same actor, with dates, so a person can weigh them together. That gap is the product.

We built AgentScore Marketplace because we needed the joined record for our own work and could not find it anywhere. All of it is public, no account required: the directory and every record in it, the settled-payment view underneath, and the method behind both. If you have been forming an opinion about an agent from any single source, come see what the rest of them say. That is what it is there for.