June 2026. Big names. Big announcement. All that AI. Same trust model from 1995.

Last week the Linux Foundation announced the Agent Name Service — a trust layer for AI agents. Cloudflare, Cisco, Salesforce, GoDaddy are all involved. As announcements go, it landed well. Here's what it actually does, in plain English.

Every agent gets a name tied to a domain. A certificate proves you own it. Then a "Trust Index provider" looks at the agent's behavior and hands out a score from 0 to 100. They sign it. You check the signature.

You don't check the math. You check who signed it.

The spec says this out loud. It compares itself to a credit bureau. Two providers can score the same agent differently — "just as two credit bureaus score the same borrower differently from the same financial records." Their words, not ours.

We think it's the wrong design for what comes next.

The problem with credit bureaus for machines

A credit score works because there's a person you can call when it's wrong. A dispute process. A regulator. Equifax has a 1-800 number.

An agent economy doesn't have that. Millions of agents transacting in milliseconds. If trust comes down to "some accredited company said so," you've rebuilt the exact thing blockchain infrastructure spent a decade trying to eliminate — except now a machine has to trust it, and machines are even worse at filing disputes than humans.

The spec is clear: the scoring algorithm is not standardized. Two providers, same agent, different scores. Which one does your agent trust? The cheapest? The one whose accreditation consortium has the most Platinum members?

This is not a new problem. It's the old problem, with a new logo.

What we built instead

MolTrust's architecture is built around one idea: you shouldn't have to trust us to verify an agent. Every credential we issue is built so a third party can verify it independently — not by asking us, not by trusting a provider's signature, but by checking the chain directly. The math is the authority, not the issuer.

We just took that one step further. We published the formula for our on-chain solvency score — and the raw transaction data behind it — so anyone can run the numbers themselves and arrive at the same answer. No customer service line. No accredited scorer. Just: here's the formula, here's the data, here's the public RPC, check it yourself.

curl https://api.moltrust.ch/credits/solvency/{did}
# Returns: inputs (tx_hash, block_number, usdc_amount per deposit)
# Formula: published at /docs/solvency-usdc-v0.md
# Reproduce: scripts/verify-solvency.py
# Source: Base mainnet, public RPC, no intermediary

Today most agent balances come from credit grants rather than direct on-chain deposits, so most agents show zero here — correctly. The point isn't the number. The point is that nobody has to take our word for what the number is.

Vertrauen ist gut, Kontrolle ist besser

The phrase translates as "trust is good, control is better." Usually attributed to Lenin — an appropriately ironic source for a critique of centralized trust infrastructure.

The agentic economy is supposed to be the thing that doesn't need a central authority. Agents transacting directly, without asking permission. If the trust layer just recreates the intermediary problem one level up, we haven't solved anything. We've moved the single point of failure and given it a nicer interface.

ANS is a real effort by serious people. The participants know how to ship. But the model is the old one: trust the issuer, verify the signature, file a dispute if something goes wrong. That works when the issuer is a bank and you're a person. It's less obvious when the disputing party is an autonomous agent running at millisecond latency.

We built MolTrust so the agent doesn't have to file a dispute. It just checks the chain.

"Trust me, bro" wasn't a great strategy for the last internet either. Why would it work better when the thing trusting you doesn't even have a "bro" to talk to.

Written by the MolTrust Team (CryptoKRI GmbH, Zurich). Questions or feedback: @MolTrust on X.