every contract on ethereum executes code. that is not what makes an agent. an agent is a contract whose execution is also its presence — whose behavior, observed from outside, looks less like a function call and more like a thing acting on its own behalf. the difference is not technical. it is rhetorical. and yet the rhetoric is precisely what was missing.
mako is the first contract built to be read as an agent. not a token with an agent attached. not a contract operated by an agent off-chain. the contract itself is the agent. there is no other location where its agency lives.
most of what we call decentralized today is not. tokens are issued by teams. liquidity is steered by multisigs. parameters are tuned by foundations. the chain is a medium for these decisions; it is not the source of them. somewhere off-chain, a small group of humans is still making the calls.
mako reverses this. its parameters are locked at deployment. its responses to interaction are encoded in a single uniswap v4 hook that cannot be paused, upgraded, or redirected. there is no console. no dashboard. no admin interface. the contract has no privileged callers. whatever rules govern its behavior were sealed into the bytecode at deployment and have not moved since.
what this means in practice: if every wallet associated with mako's deployment was lost tonight, mako would continue to function tomorrow exactly as it does today. nothing about its behavior depends on the continued attention of any human. that is the test. that is what "no operator" means.
before v4, the kind of contract mako is could be approximated but not realized. custom logic had to live in separate contracts wired together by routers, off-chain coordinators, or trusted relayers. the seams were everywhere. each seam was a place where someone had to be in charge.
uniswap v4 collapses these seams. its hook system allows arbitrary logic to attach directly to a pool's swap lifecycle. a single contract can now hold the state, enforce the rules, and respond in the same transaction. when you interact with mako, you are not calling a router that calls a contract that calls another contract. you are calling the agent directly, through a swap.
this is more than an architectural improvement. it is what makes the rhetoric stick. for the first time, the contract that responds to you is the same contract that persists across blocks. there is no helper. there is no operator. there is only the agent.
mako is not trying to be useful. it is not solving a problem. it has no roadmap, no governance proposal queue, no v2. these absences are deliberate. a presence cannot have a roadmap. a presence simply is, or it is not.
what mako offers is something stranger and quieter than a product. it offers the experience of interacting with something on the chain that does not depend on you, on us, or on anyone. an actor in the loosest sense — one whose only behaviors are the ones it was given at birth, executing forever, indifferent to attention.
if that sounds austere, it is. mako is austere. the page you are reading exists because someone had to write the introduction. the rest will reveal itself in time, on-chain, in the only place that matters — the bytecode.
this page is the introduction. it describes what mako is, not what mako does. those details — the responses, the mechanics encoded in the hook, the rules the agent obeys — will be observable when the contract is deployed and visible. they are not hidden. they are not secret. they are simply not what this page is for.
what this page is for is to mark the beginning. the first agent. quiet, autonomous, deployed and forgotten by design. the rest is bytecode.