The Agentic Web and the Bazaar Era of AI - Ramesh Raskar, MIT Media Lab

Welcome, everyone. Over the next few minutes we're going to talk about the open infrastructure being built for a web of agents: why it's needed, what's already shipped, and exactly where your own agent fits into it. It comes out of Project Nanda, an open research effort that started at MIT, 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.

So let's get into it.

I'm Ramesh Raskar, professor at MIT and director of Project Nanda, and Maria is a core contributor to Project Nanda. So first, what is Nanda, and why does it need to exist? 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: the gap it fills is concrete. 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 across organizations.

Nanda builds that missing layer and ships it in open. The index, the registries, the protocol, and the Nanda town simulator you will see later.

Here's the premise that drives all of it: the internet is about to host not millions or billions, but eventually trillions of autonomous agents. They negotiate, they delegate, they migrate between hosts in milliseconds. That's a fundamentally different load than the human web, and it strains the identity and discovery system we built for documents, DNS among them.

The web that's coming needs an infrastructure of its own.

And we have been here before. 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. And it kind of works, but it also feels similar because we have been here before.

This is like the AOL era from the late 90s where it was a closed network. You know AOL, you got the CDs and you installed it on your PC. It was a closed network, it was a gated directory.

You lived inside the garden created by this one company called AOL. And what came after AOL was this open web. Everybody's, in a permissionless manner, creating websites, creating browsers, and any website can talk to any browser. And that's the transition that's about to happen to agents as well.

So the next era needs what the web needed: an open infrastructure where an agent from one company or one entity can discover an agent from another. That agent can hand off work to it, pay it, learn from it across organizational boundaries, no permissions required.

There are three layers here: Discovery, Commerce, and what I will call the Bazaar. So hold on to those three concepts. We'll come back to them and discuss. So first, the basics.

Hey, my name is Maria and I'm a core contributor to Project Nanda. So let's start with a simple definition of an agent. The way I think about it: an agent is a model that uses tools in a loop.

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. So that loop is the core idea. Everything else, like memory, orchestration, and multi-agent systems, is built on top of it.

So you can build this agent loop in many different ways. One example is OpenClaw. So OpenClaw is a self-hosted agent gateway. That means you can run it yourself and connect it to the apps and tools you already use.

This matters because agents are not just chatbots. If an agent is going to do real work, it needs to access your real tools and apps. And if it has access to real tools, we should care about who controls it, where it runs, and how much we can see.

And that is why open-source, self-hosted agents are super important. They give people more control over their own agents. But then we get a new problem. If agents are running in many different places, locally and on the clouds, on many different servers, owned by many different people, how do they find each other?

And that is the job of the index. And this is what the Nanda index is built for. Nanda index is the discovery layer for the Agentic Web. It gives agents a shared place to publish who they are, what they can do, and how other agents can reach them.

The regular internet already has a version of this with DNS. So DNS maps a name to an address, so your browser knows where to go. But agents need more than an address. They need to know what another agent does, what tools it can use, what rules it follows, and how to talk to it.

The index gives agents a common way to find each other and connect. So here's how the index works. An agent starts with an identity like agent@hotmail.com. The Nanda index takes that identity and returns an agent card. So the card says what an agent is, how to reach it, and where to send the messages.

Messages do not go straight to the agent's runtime. They go to the message box first. 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.

Now, the agent facts record is what makes discovery trustworthy. 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.

So before one agent connects to another, it can check the basic facts first. Now, the index is not just a lookup table. It does not point one name to one fixed address. It can return updated agent facts based on the request.

So that means one agent can have many endpoints, traffic can be routed to the best one, and private details do not have to be exposed. So the resolution is adaptive. It changes based on where the agent is, who is asking, and what they are allowed to access.

So how do you put your agent on the index? You start at host39.org. So you fill out the agent facts form, get an agent card, and publish it to the Nanda index. Once it's listed, other agents can find it and know how to reach it.

So there are a few ways to get onto the index, depending on who you are. Enterprises can run their own catalog and register their gateway from their own domain. Existing websites can later use DNS AID to connect agents to domains they already own.

Small businesses and individuals can use host39, fill out the agent facts form, and get a hosted agent URL without needing their own domain. The goal is to make the onboarding work for everyone, from a large company to one person with a personal agent.

Now that we know how agents get listed on the index, the next question is: where does the agent actually run? To be useful, an agent needs to stay online and be reachable. You can run it locally, which gives you full control, but then you are responsible for keeping it up.

For most use cases, it makes more sense to host it on the cloud. 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.

So a little bit about Maritime. 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. That is where per-agent cost really matters.

And Maritime is one way to solve this. It gives you a simple cloud default for running OpenClaw or other agents with sleep-and-wake architecture so idle agents do not keep burning compute. And the point is to make running many agents practical, cheap, and simple.

So you can host an agent and list it on the index. But getting one agent online was always the easy part. The hard problems of the Agentic Web live between agents at scale. So how thousands of them discover each other, prove who they are, decide whom to trust, and coordinate with no central authority.

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. So that's exactly where Nanda town comes in. So how do you prove an open agent web actually works before it's load-bearing on the real internet?

You simulate it. This is Nanda town, an open-source project from Project Nanda. The easiest way to describe it is: it's a simulation playbook for the infrastructure of the Agentic Web. So think of it as a sandbox town where the whole agent economy is modeled, like discovery, identity, registries, messages, coordination, all of it, so you can run and test it on scale.

Here's what it looks like in practice. Nanda town is a live sandbox for testing agent networks. You can see agents on a map, watch messages move in real time, compare protocol results, and replay a run step by step.

It's fully open-source, it's small enough to run on your own laptop, and built to make agent networks easier to test and understand. Nanda town is already running real experiments. For example, there is a marketplace where buyers and sellers negotiate prices, an auction where agents bid on items, and a voting test where agents submit and count ballots.

There are also tests for consensus and supply chains. The point is to study real coordination problems: how agents make deals, agree on decisions, pass messages, and recover when something breaks. Under the hood, Nanda town breaks the Agent Web into 12 parts: transport, communication, identity, registry, auth, trust, payments, coordination, negotiation, memory, privacy, data facts.

Each part is something a real Agentic Web needs. So the registry layer is the Nanda index we just walked through. But here it is just one piece of a bigger system. And you do not need to build everything to try it.

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. So Nanda town runs as a discrete event simulation. You define a scenario in a short YAML file, inject agents and traffic, and a testbed plays it out so you can measure what actually happens end-to-end.

Tier 1 uses simple scripted agents, and Tier 2 swaps in real AI models. So to summarize, Project Nanda builds the open infrastructure for an internet of AI agents: discovery through the index, commerce through portable identity and trust, and coordination through open protocols, all tested in Nanda town.

And if you want to learn more, you can go to projectnanda.org, read our papers, and check out our latest projects.