The Agentic Web and the Bazaar Era of AI - Ramesh Raskar, MIT Media Lab
https://www.youtube.com/watch?v=sum9DgexFRQ
AI Engineer · 12 min · 132 sentences · sentence-level transcript from YouTube's caption track; each line begins at the time shown

[00:01] Welcome everyone.
[00:02] Over the next few minutes, we're going to talk about the open infrastructure being built for a web of agents.
[00:10] Why it's needed, what's already shipped, and exactly where your own agent fits into it.
[00:17] It comes out of Project Nanda, an open research effort that started at MIT.
[00:23] And by the end of this presentation, you will know how to put an agent that you build yourself on the open web all by yourself.
[00:31] So, let's get into it.
[00:36] I'm Ramesh Raskar, professor and at MIT and director of Project Nanda.
[00:41] And Maria is a core contributor to Project Nanda.
[00:46] So, first, what is Nanda and why does it need to exist?
[00:50] Nanda, which stands for network AI agents in a decentralized architecture, is an open research building the infrastructure for an internet of AI agents, the way open web was built for documents.
[01:05] The gap it fills is concrete.
[01:07] Agents have no shared way to find each other across vendors, no portable identity or trust that isn't owned by a single platform, and no open way to transact and coordinate
[01:19] across organizations.
[01:20] Nanda builds that missing layer and ships it in open.
[01:24] The index, the registries, the protocol, and the Nanda Town Simulator you will see later.
[01:34] Here's the premise that drives it all of it.
[01:37] The internet is about to host not millions or billions, but eventually trillions of autonomous agents.
[01:44] They negotiate, they delegate, they migrate between hosts in milliseconds.
[01:49] That's a fundamental different load than the human web, and it strains the identity and discovery system we built for documents, DNS among them.
[02:01] The web that's coming needs infrastructure of its own.
[02:09] And we have been here before.
[02:10] If you're building agents today, you're mostly building them or you're forced to build them inside walled gardens, closed platforms, proprietary agent stores, and orchestrations that only talk to itself.
[02:23] And it kind of works.
[02:25] But, you know, it also feels similar because we have been this we have been here before.
[02:29] This is like the AOL era from the late '90s where it was a closed network.
[02:34] You know, AOL, you got the CDs and you installed it on your PC.
[02:38] It was a closed network.
[02:39] It was a gated directory.
[02:41] You live inside the garden created by this one company called AOL.
[02:46] And what came after AOL was this open web.
[02:49] You know, everybody's in a permissionless manner creating websites, creating browsers, and any website can talk to any browser.
[02:56] And that's the transition that's about to happen to agents as well.
[03:02] So, the next era needs what the web needed, an open infrastructure where an agent from one company or one entity can discover agent from another.
[03:13] That agent can hand off work to it, pay it, learn from it across organizational boundaries, no permissions required.
[03:20] There are three layers here, discovery, commerce, and what I will call the bazaar.
[03:27] So, hold on to those three concepts.
[03:29] We'll come back to them and and discussed.
[03:31] So, first the basics.
[03:35] Hey, my name is Maria and I'm a core contributor to Project Nondo.
[03:38] So, let's start with a simple definition of an agent.
[03:42] The way I think about it, an agent is a model that uses tools in a loop.
[03:46] Right, you give it a goal, it decides what to do next, it calls a tool, it looks at the result, then it keeps going until the task is done.
[03:55] So, that loop is the core idea.
[03:57] Everything else, like memory orchestration and multi-agent systems, is built on top of it.
[04:04] So, you can build this agent loop in many different ways.
[04:07] One example is Open Claw.
[04:09] So, Open Claw is a self-hosted agent gateway.
[04:12] That means you can run it yourself and connect it to the apps and tools you already use.
[04:18] This matters because agents are not just chatbots.
[04:20] If an agent is going to do real work, it needs to access your real tools and apps.
[04:27] And if it has access to real tools, we should care about who controls it, where it runs, and how much we can see.
[04:35] And that is why open-source self-hosted agents are super important.
[04:40] They give people more control over their own agents.
[04:43] But then, we get a new problem.
[04:45] If agents are running in many different places, locally and on the clouds, on many different servers, like owned by many different people, how do they find each other?
[04:56] And that is the job of the index.
[05:00] And this is what the Nanda index is built for.
[05:03] Nanda index is the discovery layer for the agentic web.
[05:08] It gives agents a shared place to publish who they are, what they can do, and how other agents can reach them.
[05:16] The regular internet already has a version of this with DNS.
[05:20] So, DNS maps a name to an address, so your browser knows where to go.
[05:26] But agents need more than an address.
[05:28] They need to know what another agent does, what tools it can use, what rules it follows, and how to talk to it.
[05:36] The index gives agents a common way to find each other and connect.
[05:43] So, here's how the index works.
[05:45] An agent starts with the an identity like agent@hotmail.com.
[05:51] The NANDA index takes that identity and returns an agent card.
[05:55] So, the card says what an agent is, how to reach it, and where to send the messages.
[06:03] Messages do not go straight to the agent's runtime.
[06:06] They go to the message box first.
[06:08] The message box checks who is sending the message, handles access, filters spam or bad requests, and holds the message until the agent is ready.
[06:19] Now, the agent facts record is what makes discovery trustworthy.
[06:23] It is a signed record that tells other agents who this agent is, what it can do, what it is allowed to touch, who built it, and where to reach it.
[06:33] So, before one agent connects to another, it can check the basic facts first.
[06:38] Now, the index is not just a lookup table.
[06:41] It does not point to one name to one fixed address.
[06:44] It can return updated agent facts based on the request.
[06:47] So, that means one agent can have many endpoints.
[06:50] Traffic can be routed to the best one, and private details do not have to be exposed.
[06:56] So, the resolution is adaptive.
[06:58] It changes based on where the agent is, who's asking, and what they are allowed to access.
[07:04] So, how do you put your agent on the index?
[07:08] You start at host39.org.
[07:12] So, you fill out the agent facts form, get an agent card, and publish it to the NANDA index.
[07:17] Once it's listed, other agents can find it and know how to reach it.
[07:21] So, there are a few ways to get onto the index, depending on who you are.
[07:25] Enterprises can run their own catalog and register their gateway from their own domain.
[07:30] Existing websites can literally use DNS AID to connect agents to domains they already own.
[07:38] Small businesses and individuals can use host39, fill out the agent facts form, and get a hosted agent URL without needing their own domain.
[07:47] Goal is to make the onboarding work for everyone, from a large company to one person with a personal agent.
[07:56] Now that we know how agents get listed on the index, the next question is, where does the agent actually run?
[08:03] To be useful, an agent needs to stay online and be reachable.
[08:06] You can run it locally, which gives you full control, but then you're responsible for keeping it up.
[08:13] For most use cases, it makes more sense to host it on the cloud.
[08:17] That could be on a general cloud like AWS, which is more enterprise ready, or on an agent hosting platform like Maritime, which is built to make hosting AI agents cheaper and simpler.
[08:29] So, a little bit about Maritime.
[08:32] Hosting one agent can be affordable, but the cost problem starts when you want to run many agents at once, for a team, a product, or a simulation.
[08:41] That is where per agent cost really matters.
[08:44] And Maritime is one way to solve this.
[08:47] It gives you a simple cloud default for running Open Clo or other agents with sleep and wake architecture, so idle agents do not keep burning compute.
[08:55] And the point is to make running many agents practical, cheap, and simple.
[09:02] So, you can host an agent and list it on the index, but getting one agent online was always the easy part.
[09:08] The hard problems of the agent web live between agents at scale.
[09:13] So, how thousands of them discover each other, prove who they are, decide whom to trust, and coordinate with no central authority.
[09:21] So, you can't just assume that protocols will hold up under the load, and you have to test and run them and watch when they break.
[09:29] So, that's exactly where Nanda town comes in.
[09:32] So, how do you prove an open agent web actually works before it's load bearing on the real internet.
[09:38] You simulate it.
[09:40] This is Nanda Town, an open-source project from Project Nanda.
[09:44] The easiest way to describe it is it's a simulation playbook for the infrastructure of the Agoric platform.
[09:51] So, think of it as a sandbox town where the whole Agoric economy is modeled, like discovery, identity, registries, messaging, messages, coordination, all of it.
[10:01] So, you can run and test it on scale.
[10:05] Here's what it looks like in practice.
[10:07] Nanda Town is a live sandbox for testing Agoric networks.
[10:10] You can see agents on a map, watch messages move in real time, compare protocol results, and replay a run step by step.
[10:19] It's fully open source, it's small enough to run on your own laptop, and built to make Agoric networks easier to test and understand.
[10:28] Nanda Town is already running real experiments.
[10:30] For example, there is a marketplace where buyers and sellers negotiate prices, an auction where agents bid on items, and and a voting test where agents submit and count ballots.
[10:42] There are also tests for consensus and supply chains.
[10:46] The point is to study real coordination problems, how agents make deals, agree on decisions, pass messages, and recover when something breaks.
[10:55] Under the hood, Nanda Town breaks the Agoric web into 12 parts.
[10:59] Transport, communication, identity, registry, auth, trust, payments, coordination, negotiation, memory, privacy, data effects.
[11:08] Each part is something a real Agoric platform needs.
[11:11] So, the registry layer is the Nanda index we just walked through, but here it is just one piece of a bigger system.
[11:18] And you do not need to build everything to try it.
[11:20] You can take one layer, add your own version, run it inside Nanda Town, and see how it works with the rest of the network.
[11:28] So, Nanda Town runs as a discrete event simulation.
[11:31] You define a scenario in a short YAML file, inject agents and traffic, and the test bed plays plays it out so you can measure what actually happens end-to-end.
[11:40] Tier one uses simple scripted agents, and tier two swaps in real AI models.
[11:46] So, to summarize, Project Nanda builds the open infrastructure for an internet of AI agents.
[11:52] Discovery through the index, commerce through portable identity and trust, and coordination through open protocols, all tested in Nanda Town.
[12:01] And if you want to learn more, uh you can go to projectnanda.org, read our papers, and um check out our latest projects.