Agents4.fun

Overview

Agents4.fun is a self-initiated exploration of the agentic world over the Ethereum network. The idea is simple to state and hard to do well: let autonomous AI agents perceive, decide, and act — with their execution and a verifiable trail of what they did living on-chain.

Designed honestly, that’s an on-chain analytics and execution dashboard problem. The hard part isn’t running agents — it’s making opaque autonomous activity legible: what each agent is doing, what state the network is in, what value has moved, and whether any of it is actually working. That’s the surface I’m building.

Context — the problem

Autonomous agents are trustworthy only as far as their record is inspectable. An agent that acts in a backend you can’t see is just automation you’re asked to take on faith — and the moment real value is involved, faith isn’t enough. The core problem Agents4.fun takes on is legibility: an agent operating on its own will produce a stream of actions, decisions, and value movements that are, by default, opaque. If you can’t see what it did, you can’t trust it, can’t audit it, and can’t tell whether it’s succeeding or quietly failing.

So the design problem is an interface problem before it’s a model problem: how do you make autonomous, on-chain agent activity readable to a human — current state, value moved, and an audit trail — without drowning them in raw chain data?

Research & discovery

Because this is self-initiated, the discovery is hands-on rather than client-driven — I’m building it to learn how agentic products should feel when the network underneath is doing real work.

The reference points are two worlds that don’t usually share an interface language. From on-chain analytics (block explorers, dashboards like Dune, portfolio and wallet trackers), I’m drawing on how people already read chain state — transactions, value flows, addresses, confirmation status — and where those tools fall down for non-experts (raw, dense, assume you already know what you’re looking for). From agent / automation tooling, the open question is how to represent something that acts on its own: goals rather than scripts, decisions rather than clicks, autonomy you can supervise without micromanaging.

The thing I’m testing is the seam between them — the moment an agent’s decision becomes an on-chain action with a real, settled consequence. That seam is where trust is either earned or lost, and it’s underserved by both existing toolsets.

Information architecture & user flows

I’m framing the interface as a data-dense dashboard with three legible layers:

• Agent state — what each autonomous agent is, what goal it’s pursuing, and what it’s doing right now. Agents are framed around clear goals rather than scripted steps, so the interface has to make intent and current activity readable, not just log output.
• Network & value movement — the on-chain layer: consequential actions settled on Ethereum, value moved, and the state of the network the agents are acting on. This is where opaque automation becomes inspectable.
• Audit trail — the verifiable record after the fact. The meaningful moments (actions taken, value moved, outcomes recorded) are executed and logged on-chain, so the interface can show a trail you can inspect, audit, and reason about later — not a backend log you’re asked to trust.

The flow connects them: goal → autonomous decision → on-chain execution → recorded outcome → analytics on whether it worked. The design job is keeping that legible end to end.

Key decisions & trade-offs

On-chain for accountability, accepting its costs. The central call is leaning on Ethereum as the settlement and accountability layer rather than logging agent activity in a private backend. The trade-off is real — on-chain settlement is slower, costs gas, and is harder to design around than a database write. The reasoning: the entire value proposition is inspectable agents, and you can’t get inspectability from a backend you control and could change. Putting the consequential moments on-chain turns “trust me” into “verify it.” That trade is the whole point of the project.

Legibility over completeness. The easy version of an on-chain dashboard shows everything — every transaction, every field, full fidelity — and is unreadable. I’m deliberately designing for the meaningful moments (actions taken, value moved, outcomes) rather than exhaustive chain dumps, accepting that I hide detail in exchange for someone actually understanding what the agent did. Making the right things legible is harder and more valuable than showing all the things.

Goals over scripts in how agents are represented. Framing agents around goals rather than scripted steps is more honest to how autonomy works, but harder to visualise — a script has a tidy progress bar, a goal-seeking agent doesn’t. I’m taking on that representational difficulty because pretending an autonomous agent is a linear script would misrepresent the very thing the project is exploring.

Systems & craft

This is data-dense interface work: agent state, network/value movement, and an audit trail, all kept readable at the same time. The craft challenge is the one every analytics product faces and most fail — density without illegibility — made sharper here because the underlying data is on-chain and unforgiving. I’m doing the concept, design, and on-chain integration myself, which keeps the design honest to what the network can actually do rather than to a mockup that ignores settlement, gas, and confirmation reality.

Status

Agents4.fun is an active, self-initiated experiment at the intersection of AI agents and on-chain systems — it has since absorbed the on-chain sweepstakes and whitelist mechanics I’d explored separately, folding them into one protocol — not a shipped client product, and I keep it framed that way. It’s where I’m testing how agentic products should feel when the network underneath them is doing real work, and how to make autonomous on-chain activity legible enough to trust. Live at agents4.fun.