Hi, everyone. I'm Jeff, and I'm co-founder and a CTO of ENS. And today my talk is titled From Names to Namespaces When the Reader is a Machine. This is about ENS and the future of naming. So I want to start somewhere that has really nothing to do with blockchains.
The first thing that happens when a baby is born is you give them a name, you don't give them a number and before they can walk or talk, they have a name. Now, why do you do this? Well, try describing someone without it. The guy with the brown hair and the red shirt. But tomorrow he's wearing a blue shirt.
And in a decade, he might not have a hair. And for a lot of people you talk to online, you never maybe even see what they look like. So everything you could describe about a person changes. Only the name is the thing that stays put. A name is the only thing about you that survives every change to you.
That's not a nice to have. That is literally the whole job of a name. You can keep referring to something about after everything else about it has moved. Now, remember that sentence because everything I say for the next 20 minutes is that sentence but applied to things that aren't people. Yet.
Under the hood, software doesn't really name things. It doesn't name things. It numbers them. UUIDs, hashes, hexes, unique, random and unreadable because no human was ever meant to read them. Then blockchain made one of those numbers literally your identity.
Your money, your reputation, your signature, 0x, 7d, 2f, it's public, it It moves money and one wrong character sends it to somebody else. And we spent the first decade of this industry before aetherium copying and paying random numbers and praying. So in 2017, ENS put a name to the number. I bough the first ENS app that year and it was a web page. Type a name, point at an address.
That was the whole product. And Nick Johnson designed the protocol. So that's all it really needs to be. I guess I guess most of you know this part, you know, names like Vitalik.eath, your name.
eath, a the name on the wallet. But what I want to talk to about today isn't what ENS does. It's what a name is about to be the four, because where so the job of a name has changed the last couple of years and I don't think most of this room has noticed that yet. It and Anywhere, trust me, I've looked, I. wrote a lot of those contracts.
Can anyone check it's yours without asking a company? Yes. Rvery wallet, every explorer, every contract can resolve it without anyone asking, it's just on Ethereum. So yes and yes. And even if you own, say, a .
com name. It can also be an ES name as well. Same name, but with the on chain half added onto it. Okay, the new part. So for the last 30 years, naming systems had one job, translate for humans.
The machine used the address. DNS turns Google.com into an IP address. And at no point did the resolver care about what the word Google means. The names was for us, not the machine.
But that's over now. The machine reads the name now. And underneath that, something bigger is happening. Agents are becoming economic actors, they hold keys, they spend money, they call services, they rotate credentials, and more and more the other side of the transaction is a stranger. A service the agent has never used, or another agent that has never heard of it.
Anything that does business with strangers has to be legible to them. Who is this? Who controls it? What is it allowed to do? where do I reach it so, if you're agent never holds a key, it doesn't really need any of this, it's an API call, but the moment it holds a key, it needs a name that outlives the key and that a stranger can check.
and. say anything. The unlock is that the machine understands the name. It's that the machine can read the name and resolve what's behind it. Structured answers from state anyone anyone can check.
A name used to be a label, but now it's an input. And the input isn't the word. It's what the word resolves to, all the records behind it. Here's my-my-my transaction ID became the seed for your artwork. Around name is a cheque.
Why do people keep buying Swiss watches, German cars and Umez bags? Nobody suspected every part of all these products. They're buying the name on it. Generations of trust carried by a word. And the name outlasts everyone who made Omers started in 1837, made harnesses for horses.
Nobody buying a bag today has even met Thierry Omers. Companies already outlast their founders. Agents may well outlive the people that. Keys rotate, models get swapped, founders move on. That's the red shirt from the start.
What remains is the same in everything it has earned. It's the provenance, it's the reputation, it's the trust. And a name just doesn't just hold that trust. It can lend it. Hermes earned its name on harnesses and then lent it to bags.
The name at the top gives power, credit, and reputation to everything that lives underneath it. And that's a chain of trust. In the physical the world, this is held together by reputation, lawyers, and serial numbers. On chain, we can hold it together with simple cryptography. So here's the question.
Jack did this for one contract. But what happens when it's thousands of things, agents, jobs, keys, all acting under your name? Well, that's what the tree is for, and you already use one today. How do you check that someone works at a company today? Maybe you're interviewing for a job.
You look at their email. If it comes from an atcompany.com domain that you know, you believe it, because only the company can hand out an atcompany-dot-com-com address. address. When someone leaves the company, the company switches the address off and you vetted Alice themselves, you trusted the domain behind it.
A sub name on ENS works the same way. Ops.company.eth can only exist because company.eth put it there there.
It's the chain of trust from a moment ago built with cryptography instead of lawyers. is. If you know DNSsec, it's the same principle. Every link vouched by the one above it all the. way back to the root.
Now do that for thousands of agents. You wouldn't send data to an agent or take data from one if you didn't trust the company behind it. But nobody's gonna vet thousands of agents one by one. You vet a handful a handful of roots just once about the company.eth the way you decide about any brand and trust flows to everything it issues.
Every one of them you can check. Check. Trust the root, check the rest. It's Jack's check extended down a tree and anyone can do it without asking anyone. Not asked, not a platform, not even the company.
So when an agent resolves a name, it's asking one or two questions- identity, who is this, who controls it, where do I reach it? And context. What does the owner of this name want other than that agents want to know? Is it prices, endpoints, terms, policies? published once and readable by anything that has access to Ethereum.
Here are both in one job. So agents already pay for things right now, with X402 and API charges per request and the agent pays in stable points, right inside the HTTP call. Tens of thousands of agents do this today, but that's how that's how strangers pay, every request up front. It isn't how companies buy things, companies buy a So say company.eth has a subscription with a data provider, and it runs a research agent that spins up jobs.
You don't hand every job the company's keys, each job gets its own key, thrown away when when it's done, and a name, job.research.company.eth. Job needs data, it resolves it via data.
provider.eth. That's context, the endpoint, the planet cells, how to call it, and there are no docs, or the agent can just look it up and it knows what to do. Now the provider, data.provider.
eth has a question. Who is this? A fresh key, that is a stranger. So the provider resolves the job's name. That's the identity.
This key belongs to this job and it sits under the parent name, name company.eth. Then it checks two things. Does company.eth have a subscription?
And has company.eth said its resource agents can use it? Ryes and yes, the job is in the there's no payment, no sign up,. No API key I just pay per request but names use the company plan. It's the Alice's email again the company pays for the plan and anyone with an at company dot com address gets in here anything under where the company does so when the jobs done its name expires and the key goes in the bin the next job gets a new key a new name and the same plan and accountability flows up the provider logs every request against the jobs name so company screen.
eth sees exactly which job was used, and nobody has to ever read the job-8f3a, the UUID, but it's a UUID with a surname, and that surname has meaning. Now where is this actually today? Well, honestly, the pieces is today, subnames, address records, text records, you can publish an in a name. What doesn't exist yet is the convention, which for context and how a root says which of its names can use what it pays for. That's the work and I would like this room to be part of that.
So look at what that job needed. It needed a stable name, a root you can verify, a namespace the root can delegate and state anywhere anyone can resolve which is what ENS does today already. So that's the whole primitive and ENS already has every piece of it. And it's also why we built ENS V2. So.
if you guys were here yesterday and you heard Kevin, he did a really great introduction to V2. So I'd recommend going on YouTube to listen to that. But the very high level is V2 is what we would have built in 2017, when we released the ENS, if we'd known then what we know now. And it takes the primitive from names to name spaces. In V1, a a name was a leaf in one big registry.
Could the research agent issue its own job? It could, but you'd either have to write your own contract or hand the agent far more control than you'd ever want a piece of software to have. Anything else, it just can issue those names, and every, every name issue carries an expiry. So a job's name stops revolving when the job's done. So, so what didn't change in ENS V2 message just as much, the resolvers are all the same, the interface is pretty much the same and everything that results in ENS today keeps resolving.
V1. Keeps working and upgrading is optional. It's live on Superlia today, so if you guys are hacking on ENS, please use it. And it will be on main it very, very soon. So delegated issuance and constrained roles are now first class primitives in the protocol and the customer who needs him most isn't a person issuing a few names, it's an agent issuing thousands.
So there are three things you can do today depending on who you are. If you're running agents already, give them names under your own name. It works on main today, , the name is how someone else knows the agent is yours and it means you can swap its key or switch it off without anyone else having having to change a thing. If you sell something, too, agents, in your name, like your endpoint and the the prices, and think about selling the company rather than the agent specifically. Let one plan cover the names underneath.
And if you build wallets, explorers, or agent frameworks, resolve names whenever you show addresses. Pretty soon most of the names won't have been typed by a person. We started with a baby getting a name before it can ralk, and over the next ten years we're going to name more things than we ever have before. Most of them will never be born, they will be spun up for one job thousands of times and maybe even gone by the evening, but some will keep running long after the people who made them have moved on. Keys will rotate, models will be replaced, and the tech underneath will change more times than any one of us can predict.
I mean it's been crazy just the last year by itself. And every one of them will need what that baby got, a name that survives everything else changing, and a way for anyone to follow it back back to someone they trust without asking us or anyone else. So that's what we're building ENS for. It's not for the next cycle, it's for the next
Automatic transcript — names and jargon may be misspelled.