[00:00] on what inspired everything and just sort of what people's reaction was, so I was really
[00:03] happy to see that and hear all those answers and just overall what that looks like for
[00:09] everybody else. We are ready for our next session and for the next talk I'm going
[00:14] to bring on Jeff who is the CTO of DNS. Jeff is going to be sharing his version
[00:20] of what he thinks is exciting about the world of machines using name spaces and
[00:25] user names. So a lot of you know DNS and what it is and you may even have some
[00:29] DNS demings for yourself, but there's a lot that goes on to thinking about the future of naming
[00:34] things and how we can make it ready for the world of finance and agents. So to tell you all about
[00:40] that please give Jeff a big round of applause.
[00:46] Hi everyone, today my talk is titled from names to name spaces when the reader is a machine.
[01:05] This is about DNS and the future of naming.
[01:07] We are somewhere that has really lucky to be watching this. The first thing that happens
[01:16] when a baby is born is you don't give them a number and before they can walk or talk
[01:23] they have a name. Now why do you do this? Well, try describing someone without it. The
[01:29] guy with the brown hair and the red shirt, but tomorrow he's wearing a blue shirt and
[01:35] in a decade he might not have any hair. And for a lot of people you talk to a line,
[01:41] you never maybe even see what they look like, so everything you could describe about a person
[01:45] changes. Only the name is that the thing that stays put. Only the thing about you that
[01:54] survives every change to you. That's not a nice to have, that is literally the whole
[02:01] job of a name. You can keep referring to something about after everything else about it
[02:06] has moved. Now remember that sentence because everything I say for the next 20 minutes
[02:10] is that sentence but applied to things that aren't people yet. Under the hood, software
[02:19] doesn't really name things. It doesn't name things, it numbers them. UUIDs, hashes, hexes,
[02:27] unique, random and unreadable because no human was ever meant to. Then blockchain made one of
[02:35] those numbers literally your identity, your money, your reputation, your signature, 0x72f.
[02:42] It's public, it moves money and one wrong character sentences somebody else.
[02:48] And we spent the first decade of this industry before Ethereum, copying and pasting
[02:53] random numbers of frame. In 2017, ENS put a name to the number. I bought the first
[03:02] ENS app that year and it was a web page, type of name, point to end address, that
[03:07] was the whole product. And Nick Johnson designed the protocol, so that's all it really
[03:12] needs to be. I guess most of you know this part, you know, names like Vitalik or Heath,
[03:17] your name or Heath, the name of the wallet. But what I want to talk about today isn't what
[03:22] ENS does, it's what a name is about to be for because the job of a name has changed
[03:29] the last couple of years and I don't think most of this room has noticed that yet.
[03:34] But first, one question that sits underneath everything else.
[03:38] When is a name worth actually having? I think it comes down to two questions.
[03:43] Is it actually yours? Can someone take it off you? And can anyone check it's yours
[03:49] without asking a company? Every naming system today you use fails at least one.
[03:55] And here's three quick examples of the last few years. In 2023, Gina Wong had held
[04:03] X on Twitter for 16 years. In 2023, Elon rebranded and the company took the handbook.
[04:11] In 2021, Uniswap didn't actually own the institute, Uniswap.com, it was actually
[04:16] owned by someone else and apparently SPF bought it and pointed at the sushi spot.
[04:21] And it took a WIPO panel three and a half months to do it over and Uniswap only won
[04:26] because it had a trademark and a legal team. And most people in this room have neither.
[04:35] And this September, Meta launched an II agent called Muse, already holding the Muse handle
[04:41] on X and Instagram. And that handle was actually used by the bad news for over a decade.
[04:48] What happens is the name was decided somewhere you couldn't see by someone who wasn't you,
[04:54] a platform policy, a panel to neither, a deal nobody actually published.
[04:59] How does ENS feel on those two questions? Is it actually yours? Yes. As long as you
[05:06] keep renewing it, your name is state on Ethereum controlled by your key.
[05:11] There is no button at ENS Labs that reassigns your name that isn't anyone anywhere. Trust me,
[05:16] I've looked, I wrote a lot of those contracts. Anyone check it's yours without asking a company?
[05:23] Yes. Every wallet, every explorer, every contract can resolve it without anyone asking.
[05:28] It's just on Ethereum. So yes and yes. And even if you own, say, a .com name,
[05:34] it can also be an ENS name as well. Same name, but with the on-chain half added onto it.
[05:42] Okay, the new part. So for the last 30 years, naming systems had one job,
[05:47] translate to humans. The machine used the address. ENS turns Google.com into an IP address,
[05:54] and at no point did the dissolver care about what the word Google means.
[05:59] The names was for us, not the machine. But that's over now. The machine reads the name,
[06:06] and underneath that, something bigger is happening. Agents are becoming economic actors,
[06:14] they hold keys, they spend money, they call services, they rotate credentials,
[06:19] and more and more the other side of the transaction is a stranger.
[06:23] A service the agent has never used or another agent has never heard of it.
[06:28] Anything that does business for strangers has to be legible to them. Who is this? Who controls
[06:33] it? What is it allowed to do? Where do I reach it? So if your agent never holds a key
[06:39] and never touches money, it doesn't really need any of this. It's an API call. But the moment it
[06:43] holds a key, it needs a name that outlives the key and that a stranger can check.
[06:49] That was true for what is in 2017, and it's true for ENS today.
[06:53] So at ENS, we're not pivoting to AI. We're doing the same job we've always done, which is
[06:59] naming the things that hold a key. The name doesn't answer those questions because
[07:07] maybe words can say anything. The unlock isn't that the machine understands the name,
[07:12] it's that the machine can read the name and resolve what's behind it,
[07:16] structured answers from state anyone can check. The name used to be a label, but now it's an input,
[07:21] and the input isn't the word, it's what the word resolves to, all the records behind it.
[07:29] Here's my favorite recent example of that. Jack Butcher, the answer behind checks, did a drop
[07:35] a few days ago in September on xMoney. So there was no mint page, he sent $8 to Jack,
[07:40] and your transaction ID became the seed for your artwork. Around 7,000 people did it,
[07:46] and over about 25,000 wallets in a day. That part ran on trust, people just sent money to
[07:50] Jack on Twitter, and then the arc went on chain. 25,000 wallets were about to receive
[07:56] tokens from a contract that didn't exist yet. And when it does, there will be one more
[08:01] random address. So how does anyone know which contract is his? Well, he told them in
[08:06] this tweet. Deploying shortly will be from visualizevalue.eth, don't trust, check.
[08:14] Nobody has to recognize the contract address, they just check against the name,
[08:18] which address, which name deployed in this contract. And that's what I mean by proof,
[08:23] not trust me. I check anyone can do, a person, a wallet, an agent, without asking anyone. Jack
[08:30] didn't need us or ENS, and he didn't need a platform, he needed a name everyone already knew
[08:34] was his. So why is one name enough? Why would 25,000 wallets take a name as a check?
[08:42] Or why do people keep buying Swiss watches, German cars, and all those bags? Nobody's
[08:47] expected, inspected every part of all these products. They're buying the name on it,
[08:52] generations of trust carried by a wallet. And the name outlasts everyone who built it.
[08:58] Hermes started in 1837, made harnesses and horses. Nobody buying a bag today has even met
[09:04] Thierry Hermes. Companies already outlast their founders. Agents may well outlive the people
[09:10] that made them. Keys rotate, models get swapped, founders move on. That's the red shirt from
[09:16] the start. What remains of the same and everything that has earned is the confidence,
[09:22] it's the reputation, it's the trust. And a name just doesn't just hold that trust,
[09:27] it can lend it. Hermes earned his thing on harnesses and then lent it to bags.
[09:32] The name of the top gives power, credit, and reputation to everything that's underneath it.
[09:38] And that's the chain of trust. In a physical wallet, this is held together by reputation,
[09:43] lawyers, and serial numbers. On chain, we can hold it together with simple cryptography.
[09:50] So here's the question. Jack did this for one contract. But what happens when it's
[09:55] thousands of things, agents, jobs, keys, all have to under your name? Well, that's what
[10:02] the tree is for, and you already use one today. How do you check that someone works at a company
[10:09] today? Maybe you're interviewing for a job. You look at their email. If it comes from
[10:15] an atcompany.com domain that you know, you believe it, because only the company can hand out
[10:21] an atcompany.com address. When someone leaves the company, the company switches the address off,
[10:27] and you never have actually vetted Atlas themselves, you trusted the domain behind it.
[10:32] A subname on ENS works the same way. You know, ox.company.eth can only exist because
[10:38] company.eth put it there or authorized someone to. It's the chain of trust from a moment ago,
[10:44] built with cryptography instead of lawyers. If you know DNSSEC, it's the same principle.
[10:50] Every link vouched by the one above it all the way back to the root. Now do that for
[10:57] thousands of agents. You wouldn't send data to an agent or take data from one if you didn't
[11:02] trust the company behind it. But nobody's going to vet thousands of agents one by one.
[11:07] You vet a handful of roots, decide once about the company or the way you decide about any brand,
[11:13] and trust flows to everything it issues. Every one of them you can check. Trust the root,
[11:17] check the rest. It's that check extended down a tree, and anyone can go without asking
[11:23] anyone. Not us, not a platform, not even a company. When an agent resolves a name,
[11:31] it's asking a lot of deep questions. Identity? Who is this? Who controls it? Where do I reach it?
[11:37] And context. What does the owner of this name want other than that agents want to know? Is it
[11:42] prices, endpoints, terms, policies? Publish wants and relabel about anything that has
[11:48] access to Ethereum. Here are both in one job. So agents already pay for things right now
[11:56] with X402 and API charges, pull requests, and the agent pays and save points right inside the
[12:03] HTTP pool. Tens of thousands of agents do this today. That's how strangers pay. Every request
[12:10] upfront. It isn't how companies buy things. Companies buy a plan. So say company.eth has
[12:17] a subscription with a data provider, and it runs a research agent that spins up jobs.
[12:23] You don't pan every job the company's keys. Each job gets its own key, thrown away when it's done,
[12:29] and a name. Job dot research dot company dot eth. The job needs data. It resolves it via
[12:37] data dot provider dot eth. That's context, the endpoint, the plan itself, how to call it,
[12:42] and there are no dogs will sign up. Your agent can just look it up, and it knows what to do.
[12:47] Now the provider, data dot provider dot eth, has a question. Who is this? A fresh
[12:51] key. There's a stranger. So the provider resolves with John's name. That's the identity. This key
[12:56] belongs to this job, and it sits under the parent name company.eth. Then it checks two
[13:02] things. Does company.eth have a subscription? And has company.eth said its research agents
[13:08] can use it? Yes and yes. The job is in. There's no payment. There's sign up. No API key.
[13:14] So strangers pay per request, but names use the company plan. It's the Alice's email again.
[13:22] The company pays for the plan, and anyone with an at company dot com address gets in.
[13:27] Here, anything under research dot company dot eth does. So when the job's done, its name expires,
[13:33] and the key goes in the bin, the next job gets a new key, a new name, and the same plan.
[13:38] And accountability flows up. The provider logs every request against the job's name. So company
[13:43] dot eth sees exactly which job was used. Nobody has to ever read the job dash 8F 3A, the EU ID,
[13:51] but it's a UID with a surname. That surname has meaning. Now where is it actually today? Well,
[13:58] honestly, the pieces exist today. Subnames, address records, text records. You can publish
[14:03] an endpoint on a price in a name's afternoon. What doesn't exist yet is the convention,
[14:09] which records an agent reads for an entity, which for context, and how a root says which
[14:14] of its names can use what it pays for. That's the work, and I would like this one to be
[14:20] part of that. So look at what that job needed. It needed a stable name. It needed
[14:27] job dot company dot research dot company dot eth, a root you can verify, company dot eth,
[14:32] a namespace the root can delegate, and state anywhere anyone can resolve, which is what ENS
[14:38] does today already. So that's the whole primitive, and ENS already has every piece of it.
[14:42] Also why we built ENS v2. So if you guys were here yesterday and you were Kevin, he did a
[14:52] really great introduction to v2, so I'd recommend going on YouTube to listen to that. But the
[14:57] very high level is v2 is what we were built in 2017 when we released ENS. If we'd known,
[15:03] then what we know now. And it takes the primitive from names to namespaces.
[15:08] In v1, a name was a leaf in one big registry. Could the research agent issue its own job?
[15:15] It could, but you'd even have to write your own registrar contract or hand the agent
[15:19] far more control than you'd ever want a piece of software to have.
[15:22] But in v2, every name can have its own registry, but its own rules and the permissions
[15:27] we built into the name wrapper, if you guys have used ENS before, are now roles in the core
[15:32] contracts. So company dot eth can give the research agent exactly one power, the ability
[15:37] to register names under research dot company dot eth, and nothing else. It doesn't have
[15:42] the power to take names back. It doesn't have the right to do anything else. It just
[15:46] can issue those names, and every name issued carries an expiry. So a job's named,
[15:51] a job's named, software opened, and the job's done. So what didn't change in ENS v2,
[15:57] that's just much. The resolvers are all the same, the interfaces are pretty much the same,
[16:02] and everything that results in ENS today keeps resolving. v1 keeps working, and operating
[16:08] is optional. It's live on Safari today, so if you guys are happy on ENS, please use it.
[16:14] And it'll be on mainnet very, very soon. So delegated issuance and constrained roles
[16:20] are now first class premises in the protocol, and the customer who needs it most isn't the
[16:25] person issuing a few names, it's an agent issuing thousands. So there are three things you
[16:33] can do today, depending on who you are. If you're running agents already, give them names
[16:40] under your own name. It works on main today, the name is how someone else knows the agent
[16:45] is yours, and it means you can swap its key or switch it off without anyone else having
[16:49] to change a thing. If you sell something to agents like an API, a data, data or protocol,
[16:55] put the details that need in your name, like your endpoint and the prices, and think about
[17:01] selling to the company rather than to the agent specifically. Let one fan cover names
[17:05] underneath. If you build wallets, explorers, or agent frameworks, resolve names whenever
[17:11] you show addresses. Pretty soon most of the names your software sees won't have been
[17:15] typed by a person. We started with a baby getting a name before it can walk.
[17:23] The next 10 years we're going to name more things. Most of them will never, they'll be
[17:32] sparked for one job thousands of times, and maybe even gone by the evening. But some will
[17:38] keep running long after the people who made them have moved on. Keys will rotate,
[17:44] models will be replaced, and the tech underneath will change more times than any one of us can
[17:49] predict. I mean, it's been crazy just the last year by itself. And every one of them
[17:54] will need what that baby got, a name that survives everything else changing,
[17:59] and a way for anyone to follow it back to someone they trust without asking us or
[18:03] anyone else. So that's what we're building ENS for. It's not for the next cycle,
[18:10] it's for the next few decades. The machines can read now, so give them names at last.
[18:17] Thank you so much, Jeff. It's a good way to think about basically designing for the
[18:33] long term, and of course, just what B2 is excited. We're going to do our last session
[18:38] before lunch. And for this one, we're going to have an amazing fireside chat with Armani,
[18:42] who is the CEO of Backpack. He's using the machines that he's working on,
[18:46] building everything, ready for the onto the economy to come up. So we're going to...