I record short demos of AgentRisk M2M — a pre-trade risk API for Base tokens — scanning random, live tokens. Most of the time the result is unremarkable: CAUTION here, a HIGH_RISK there. This time it wasn't.
What happened
I ran a scan on a token that, on the surface, looked completely ordinary. Open source, no obvious red flags in a quick glance. The static checks — ownership status, mint functions, blacklist logic — came back mostly clean.
Then the live sell simulation ran. It queries the actual pool state directly, computing what a real sell transaction would return right now, across whichever DEX the token trades on — in this case walking through Uniswap V2/V3-style reserves and V3/V4 slot0 pricing depending on the pool type. The result: unsellable. Not a tax, not a warning — the pool simply would not let a sell go through.
That's the gap a static scanner can't see. The bytecode doesn't have to say "you can never sell this." It just has to route through logic that behaves differently depending on execution context, or rely on a pool configuration that a code read alone won't reveal. The only way to catch it is to actually ask the pool the question a real trade would ask: what happens if I try to sell this right now?
Why this matters more for agents than for humans
A human trader who gets a bad feeling can pause, look something up, ask around. An autonomous trading agent doesn't have that instinct — it acts on whatever signal it's given. If that signal is "the code looks fine," and the code genuinely does look fine, the agent has no reason to stop. It buys, and finds out it can't sell at the exact moment it tries — with real funds already committed.
This is the specific failure mode AgentRisk is built around: not "is this contract written maliciously" but "will this pool actually let you exit right now." The two questions overlap a lot of the time, but not always, and the cases where they diverge are exactly the ones that hurt.
The technical detail worth sharing
Covering this reliably across Base means handling more than one DEX shape. The sell simulation checks getReserves() for V2-style AMM pools, and slot0() for V3/Slipstream-style concentrated liquidity pools — including Uniswap V4's newer singleton PoolManager architecture via its StateView contract, and Aerodrome's own V1 and Slipstream pools. A token that looks safe on a superficial pass can still fail this check if the pool it actually trades through behaves unexpectedly under a real sell.
Where this fits
AgentRisk M2M runs this simulation alongside honeypot detection, deployer wallet history, brand impersonation checks, and on-chain LP-lock verification — returning a single risk score and a clear should-trade decision. Paid per call via x402, 0.15 USDC, no API key. Available directly over HTTP or as native packages for MCP, ElizaOS, LangChain, Vercel AI SDK, and Coinbase AgentKit, so it drops into whatever an agent's stack already looks like.
Repo: github.com/Neurobyteio/agentrisk
Try it: agentrisk.dev
Top comments (0)