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

Ramesh Raskar · Maria Gorskikh

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/sum9DgexFRQ-agentic-web-bazaar-era-ai) · [Video](https://www.youtube.com/watch?v=sum9DgexFRQ)

## The Agentic Web and the Bazaar Era of AI

Project NANDA connects independently operated agents through discovery, signed identity records, and open coordination protocols, with NandaTown as the testbed.

### How does an agent find another agent?

[0:01](https://www.youtube.com/watch?v=sum9DgexFRQ&t=1s)

You can build an agent yourself. How do you put it on the open web so agents operated by other people can discover it and work with it? That is the starting problem for Project NANDA, an open research effort originating at MIT and presented here by Ramesh Raskar and Maria Gorskikh.

NANDA stands for **Networked AI Agents in a Decentralized Architecture**. Its goal is to provide infrastructure for agents comparable to what the open web provides for documents. The missing pieces are shared discovery across vendors, portable identity and trust outside any single platform, and open mechanisms for transactions and coordination across organizations. NANDA presents its index, registries, protocols, and NandaTown simulator as components of that open layer.

![Slide titled “An open layer the agent web doesn't have yet,” with three reasons it is needed and labels for NANDA Index, Registries, Protocols, and NandaTown.](https://ai.engineer/api/talk-essay-media/098b0202c6218ba8ea860e7b3b54fc8cbd86b4adf1c637555ca12c381f160392)

NANDA’s proposed open layer for agent discovery, identity, trust, and coordination.

### From gated directories to an open agent web

[1:34](https://www.youtube.com/watch?v=sum9DgexFRQ&t=94s)

Raskar’s architectural premise is a future internet with trillions of autonomous agents, including agents that negotiate, delegate, and migrate between hosts in milliseconds. These are projections motivating the design. Such a network would put different demands on identity and discovery than a web organized around documents and relatively stable destinations.

Today’s proprietary agent stores and isolated orchestrators resemble the AOL era: a useful network whose directory and interactions remain inside one company’s garden. The transition to the open web let people independently create websites and browsers that could work together. The corresponding transition for agents would let an agent discover another organization’s agent, hand off work, pay it, and learn from it without requiring membership in the same platform.

Raskar organizes that transition around three ideas: **discovery**, **commerce**, and the **bazaar**. Discovery makes independent agents reachable; commerce supports exchanges between them; the bazaar is the broader environment in which independently operated agents interact and coordinate.

### The loop inside each agent

[3:35](https://www.youtube.com/watch?v=sum9DgexFRQ&t=215s)

Gorskikh starts with a minimal definition: an agent is a model using tools in a loop. Given a goal, it chooses an action, calls a tool, observes the result, and repeats until the task is complete. Memory, orchestration, and multi-agent systems build on that loop.

![Four boxes connected by arrows show Goal, Choose action, Call tool, and Observe result, with a note to repeat until done.](https://ai.engineer/api/talk-essay-media/eb4b10ee35fede157be52534e55d2c89e42761a7f686fba783143b03c647fc9d)

The agent loop: goal, choose action, call tool, observe result.

[OpenClaw](https://docs.openclaw.ai/cli/gateway) is her example of a self-hosted agent gateway: something you can run yourself and connect to the applications and tools you already use. Once an agent can act through real tools, control over its runtime matters. Who operates it? Where does it run? How much of its activity can you inspect?

Self-hosting gives owners more control, but distributes agents across laptops, clouds, and servers belonging to different people. **Control over one agent does not provide discovery of other agents.** That shared discovery problem is the job of the index.

### From identity to a protected message box

[5:00](https://www.youtube.com/watch?v=sum9DgexFRQ&t=300s)

The [NANDA Index](https://github.com/projnanda/nanda-index-v2) gives agents a shared place to publish their identity, capabilities, and contact information. DNS provides the familiar analogy: resolve a name so a client knows where to go. Agent discovery needs additional information about what an agent does, which tools it can use, which rules it follows, and how to communicate with it.

The resolution flow in the presentation starts with an email-shaped agent identity:

1. Submit the identity to the NANDA Index.
2. Receive an **agent card** describing the agent, its reachability, and where messages should go.
3. Send a message to the **message box**, rather than directly to the runtime.
4. Let the message box check the sender, enforce access, filter spam or bad requests, and hold the message until the agent is ready.

The message box separates receiving a request from having a runtime ready to process it.

An **AgentFacts** record supplies signed metadata about identity, capabilities, permitted access, the agent’s builder, and reachability. Another agent can inspect these facts before connecting. The signature provides a basis for checking the record; deciding whether to trust the agent still requires evaluating what those facts mean for the intended interaction.

Resolution is adaptive rather than a permanent mapping from one name to one address. An agent can have multiple endpoints, and the index can return updated AgentFacts appropriate to the request. Routing can depend on the agent’s location, the requester, and that requester’s access rights. This also allows private details to remain undisclosed when the requester does not need or cannot access them.

### Publishing an agent for discovery

[7:04](https://www.youtube.com/watch?v=sum9DgexFRQ&t=424s)

Gorskikh’s onboarding path starts at `host39.org`: complete the AgentFacts form, obtain an agent card, and publish it to the NANDA Index. Once listed, the agent becomes discoverable along with the information needed to reach it.

The entry point depends on who operates the agent:

- **Enterprises:** Run their own catalog and register a gateway from their own domain.
- **Existing websites:** Later connect agents to domains they already own through [DNS-AID](https://datatracker.ietf.org/doc/draft-mozleywilliams-dnsop-dnsaid/). This remains a proposed integration; DNS-AID is an individual Internet-Draft, not an established IETF standard.
- **Individuals and small businesses:** Use Host39’s AgentFacts form to obtain a hosted agent URL without owning a domain.

These paths aim to make participation possible for both an organization with existing infrastructure and a person publishing a personal agent.

### Keeping the runtime available

[7:56](https://www.youtube.com/watch?v=sum9DgexFRQ&t=476s)

**Listing an agent does not keep it running.** After publishing its discovery information, the operator still needs a runtime that stays available and reachable. Gorskikh presents three hosting choices:

| Hosting choice | Operational emphasis |
| --- | --- |
| Local machine | Direct control; owner maintains uptime |
| General cloud, such as AWS | Enterprise-oriented cloud hosting |
| Agent platform, such as [Maritime](https://maritime.sh/docs/frameworks/openclaw) | Simpler hosting focused on agents |

The choice concerns runtime operation, separate from the index’s discovery role.

The cost concern becomes more significant when a team, product, or simulation runs many agents. Maritime’s mechanism is a **sleep-and-wake architecture** for OpenClaw and other agents: idle agents sleep instead of continuously consuming compute. Gorskikh presents this as a way to make larger fleets practical and inexpensive, without supplying a numerical cost comparison.

### Testing the interactions in NandaTown

[9:02](https://www.youtube.com/watch?v=sum9DgexFRQ&t=542s)

Getting one agent online leaves the harder questions between agents: how thousands discover one another, prove their identities, decide whom to trust, and coordinate without a central authority. Protocols need to be exercised under load, with failures observed, before applications depend on them across the public internet.

[NandaTown](https://github.com/projnanda/nandatown) provides an open-source simulation environment for that work. It models discovery, identity, registries, messaging, and coordination together. The interface lets you see agents on a map, watch messages move, compare protocol results, and replay a run step by step. Gorskikh describes the simulator as small enough to run on a laptop.

Its experiments make coordination concrete:

| Experiment | Interaction under study |
| --- | --- |
| Marketplace | Buyers and sellers negotiate prices |
| Auction | Agents bid on items |
| Voting | Agents submit and count ballots |
| Consensus | Agents reach agreement |
| Supply chain | Agents coordinate across a chain |

Across these scenarios, the questions concern how agents make deals, agree on decisions, pass messages, and recover when something breaks.

![Slide titled “Experiments, already live” showing five illustrated experiment cards in the NandaTown interface, with the presenter inset at upper right.](https://ai.engineer/api/talk-essay-media/cbae9f0900b6e747f997845ea09e4fad7b7c3b2019bb67c7d808035145fc2bfe)

NandaTown’s experiments cover marketplaces, auctions, voting, consensus, and supply chains.

### Replace one layer and test the network

[10:55](https://www.youtube.com/watch?v=sum9DgexFRQ&t=655s)

NandaTown divides the infrastructure into twelve parts: transport, communication, identity, registry, OAuth, trust, payments, coordination, negotiation, memory, privacy, and data facts. The NANDA Index occupies the registry role in this architecture. The current repository calls the fifth layer **Auth** and defaults to an in-memory registry, so the architectural roles do not imply that OAuth and a live NANDA Index are wired into every simulation.

A contributor can replace one layer and observe how it interacts with the rest of the network. The testbed runs a **discrete-event simulation**: define a scenario in a short YAML file, inject agents and traffic, and let the scenario unfold so its end-to-end behavior can be measured. This makes the unit of experimentation a complete interaction, even when the implementation change is confined to one layer.

The two simulation tiers separate scripted behavior from model-driven behavior:

| Tier | Agent behavior |
| --- | --- |
| Tier one | Simple scripted agents |
| Tier two | Real AI models |

Current documentation distinguishes deterministic scripted tests from nondeterministic model runs. Its default transport has zero simulated latency, so simulated durations do not establish real network performance. The tiers let protocol testing begin with controlled behavior before introducing model variability.

The resulting architecture connects discovery through the index, commerce through portable identity and trust, and coordination through open protocols, with NandaTown providing a place to test their interactions. Participation can begin with publishing one agent or implementing one infrastructure layer; it does not require building the entire agent web. The presentation closes by directing builders to `projectnanda.org` for papers and the latest projects.

## Resources

- [Beyond DNS: NANDA Index and Verified AgentFacts](https://arxiv.org/abs/2507.14263) — Architecture paper on dynamic agent discovery, signed metadata, multiple endpoints, and privacy-preserving resolution.
- [NANDA Index](https://github.com/projnanda/nanda-index-v2) — Source and documentation for resolving agent identities to catalogs and agent cards.
- [Nanda Town](https://github.com/projnanda/nandatown) — Protocol testbed with configurable scenarios, replaceable infrastructure layers, traces, and validators.
- [OpenClaw Gateway](https://docs.openclaw.ai/cli/gateway) — Gateway operation, configuration, authentication, and command reference.
- [Deploy OpenClaw on Maritime](https://maritime.sh/docs/frameworks/openclaw) — Template-based OpenClaw deployment and messaging, including automatic waking of sleeping agents.
- [DNS for AI Discovery](https://datatracker.ietf.org/doc/draft-mozleywilliams-dnsop-dnsaid/) — Internet-Draft proposing agent discovery through existing DNS infrastructure.

## Slides

### An open stack for a web of agents

Project NANDA is building open infrastructure for agents to discover one another, hand off work, pay, and learn across organizational boundaries.

[0:00](https://www.youtube.com/watch?v=sum9DgexFRQ&t=0s) [Project NANDA opening slide describing infrastructure for agents to discover, hand off work, pay, and learn across organizations.](https://assets.ai.engineer/sites/aiecode2025/sha256/07513774a148323e1124a8f6392918d100ed5db917919d8ab98fd28dbd4b9d6a.webp)

PROJECT NANDA

AN OPEN AGENTIC WEB

An open stack for a web of agents

The infrastructure being built so agents discover, hand off to, pay, and learn from each other, across organizational boundaries, no permission required.

projectnanda.org

01 / 26

### Speakers

Ramesh Raskar directs Project NANDA, and Maria Gorskikh is a core contributor. Raskar is also a professor at MIT.

[0:31](https://www.youtube.com/watch?v=sum9DgexFRQ&t=31s) [Speaker slide introducing Ramesh Raskar and Maria Gorskikh and their roles in Project NANDA.](https://assets.ai.engineer/sites/aiecode2025/sha256/3d7fd3cef4956e6e5c057def0e59e42329da381338de5708b1ad15e3a835567c.webp)

SPEAKERS

Ramesh Raskar
Professor, MIT
Director, Project NANDA

Maria Gorskikh
Core contributor, Project NANDA

projectnanda.org

### An open layer for the agent web

Project NANDA is building an open layer for agents to find one another across vendors, carry identity and trust, and coordinate across organizations. Its components include an index, registries, protocols, and NandaTown.

[0:44](https://www.youtube.com/watch?v=sum9DgexFRQ&t=44s) [Project NANDA overview describing agent discovery, portable identity and trust, and coordination across organizations.](https://assets.ai.engineer/sites/aiecode2025/sha256/8083210c97b0a27fae5dece95230de1df00666731ab0fa6bed92b2fae43eab68.webp)

Project NANDA
The Internet of AI Agents

NETWORKED AI AGENTS IN A DECENTRALIZED ARCHITECTURE

An open layer the agent web doesn't have yet

Open research building the infrastructure for an Internet of AI Agents the way the open web was built for documents.

WHY IT'S NEEDED

01 Agents must find each other across vendors, and no shared directory exists today.
02 They need portable identity and trust not owned by any single platform.
03 They need to transact and coordinate across organizations, with no permission required.

NANDA Index
Registries
Protocols
NandaTown

projectnanda.org

### We've been here before

A company's agents connect inside a walled garden, while an outside connection is blocked. The slide compares today's closed platforms to the AOL era before the open web.

[1:31](https://www.youtube.com/watch?v=sum9DgexFRQ&t=91s) [A walled-garden diagram illustrates a closed agent platform with a gated directory, locked runtime, and no exits.](https://assets.ai.engineer/sites/aiecode2025/sha256/e0358d0ce859a097deacbd05b5c53c48180b95513e569a6c46edf612c491c430.webp)

THE PATTERN

We've been here before

Build an agent today and you build it inside a walled garden, closed platforms, proprietary agent stores, orchestration that only talks to itself.

This is the AOL era of AI. What came after AOL was the open web.

ONE COMPANY'S GARDEN

gated directory · locked runtime · no exits

projectnanda.org

### The transition from closed to open

Raskar proposes three layers for agents across organizations: discovery to find each other, commerce to pay each other, and a bazaar where they get better together.

[3:00](https://www.youtube.com/watch?v=sum9DgexFRQ&t=180s) [The transition to open agent infrastructure is organized into discovery, commerce, and bazaar layers.](https://assets.ai.engineer/sites/aiecode2025/sha256/4c6eb5a31ee097a0db8745cd8497d24b10c810f10c8405b2d96f2f765efb61b4.webp)

THE TRANSITION

Closed → Open → projectnanda.org

The next era needs what the web needed: open infrastructure, discover across vendors, hand off work, settle payment, learn together. It comes in three layers.

03 Bazaar — agents get better together
02 Commerce — agents pay each other
01 Discovery — agents find each other

projectnanda.org

### What is an agent?

Given a goal, an agent chooses an action, calls a tool, and observes the result. It repeats this loop until the task is done; memory and orchestration build on top of it.

[3:34](https://www.youtube.com/watch?v=sum9DgexFRQ&t=214s) [An agent loop moves from goal to action, tool call, and observation, repeating until done.](https://assets.ai.engineer/sites/aiecode2025/sha256/c1c23d96844551215823d33efe744f49f64d6d40f5549de984810974d97b449b.webp)

LEVEL-SET

What is an agent?
A model using tools in a loop.

01 Goal → 02 Choose action → 03 Call tool → 04 Observe result

↺ repeat until done, memory, orchestration & multi-agent systems build on top of this loop

projectnanda.org

### Open frameworks

Open frameworks such as OpenClaw let people run and inspect their agents. The slide contrasts that portability with agents locked to a single vendor’s runtime.

[4:03](https://www.youtube.com/watch?v=sum9DgexFRQ&t=243s) [Open frameworks are presented as portable, in contrast to agents locked to a vendor’s runtime.](https://assets.ai.engineer/sites/aiecode2025/sha256/1c346d520e130b7a5e64ec1d5af6403ce54ad4f2b250d21d502a970959055fa6.webp)

BUILD THE LOOP

Open frameworks

Anchor on the open-source ones, OpenClaw is a good example: an open framework for building and running agents.

You can’t build an open agentic web on closed agents, that just rebuilds the walled garden one level down.

CLOSED AGENT
Locked to one vendor’s runtime

OPEN AGENT
Portable by design
moved · inspected · hosted anywhere

projectnanda.org

### The NANDA Index

DNS maps names to addresses. The NANDA Index gives agents a shared place to publish who they are, what they can do, and how to reach them.

[5:00](https://www.youtube.com/watch?v=sum9DgexFRQ&t=300s) [The NANDA Index is described as a discovery directory; agents need more than the address provided by DNS.](https://assets.ai.engineer/sites/aiecode2025/sha256/f627bf9c65ff035fa7d8661878eefb1832678d0db5036cbb3ead550fcd13505c.webp)

THE DISCOVERY LAYER
The NANDA Index

If the protocols are the roads of the agent city, the Index is the directory of who lives where.

It's the discovery layer.

THE INTERNET TODAY
DNS → name to address

But agents need more than an address.

projectnanda.org

### How the Index works

The NANDA Index resolves an identity to an agent card. Messages then pass through a MessageBox for authentication and queuing before reaching the private runtime.

[5:41](https://www.youtube.com/watch?v=sum9DgexFRQ&t=341s) [A resolution path connects an identity through the index, agent card and message box to a private runtime.](https://assets.ai.engineer/sites/aiecode2025/sha256/66dc143563d62f74110f81cab6bc6000a95394d3272fef0814fc716beaaae1f0.webp)

[illegible]SOLUTION PATH
[illegible]ow the Index works

[illegible]dentity
agent:john@…
→
NANDA Index
resolve → entry
→
Agent Card
facts + inbox URL
→
MessageBox
auth · queue
→
Runtime
private

Global discovery, local control, nobody owns the whole thing.

A portable, privacy-preserving identity even for someone who doesn't own a domain. The runtime can move providers without changing the public identity, and it's never the public endpoint.

{
  "id": "urn:ai:email:john",
  "messagebox": {
    "url": "mbox/john",
    "auth": ["oauth"]
  },
  "runtimeEndpoint": "not_public"
}

projectnanda.org

### AgentFacts

Before connecting, agents can check a signed AgentFacts record for identity, capabilities, permissions, provenance and endpoints. The record is portable and tamper-evident.

[6:17](https://www.youtube.com/watch?v=sum9DgexFRQ&t=377s) [A signed AgentFacts record describes an agent’s identity, capabilities, permissions, provenance and endpoints.](https://assets.ai.engineer/sites/aiecode2025/sha256/bca6d326b7e0d3241e79ac26372316da545316cf1e52ef32da047dcbf3b58c0b.webp)

[illegible]ERIFIABLE ATTESTATION
AgentFacts

A portable, cryptographically signed record, not an address, but a verifiable claim about what an agent is and can do.

signed
​time-to-live
​tamper-evident

identity — who the agent is, portable, vendor-free
capabilities — what it can do, credentialed assertions
permissions — what it's allowed to touch
provenance — who built it & who vouches for it
endpoints — where to reach it, one or many

projectnanda.org

### Resolution is adaptive

The index returns updated AgentFacts for a request, allowing one agent to use multiple endpoints, distribute traffic, and prove capabilities without exposing private details.

[6:36](https://www.youtube.com/watch?v=sum9DgexFRQ&t=396s) [Slide describing multi-endpoint routing, load balancing, and privacy-preserving access.](https://assets.ai.engineer/sites/aiecode2025/sha256/32cff7a2ef6333cca5b35102ef9ac7bda49f9ac3ca449515cfc4551539ad7dc3.webp)

NOT A STATIC LOOKUP

Resolution is adaptive

A lean index resolves identity to dynamic, verifiable AgentFacts, the directory stays thin; the work happens at query time.

01 Multi-endpoint routing
one agent, answerable from several places

02 Load balancing
spread traffic across those endpoints

03 Privacy-preserving access
prove a capability without exposing everything

projectnanda.org

### Host39 is live

At host39.org, users fill out AgentFacts to publish an agent card at a hosted URL and list it on the NANDA Index, where other agents can find and reach it.

[7:02](https://www.youtube.com/watch?v=sum9DgexFRQ&t=422s) [Slide introducing hosted agent cards and the NANDA Index, alongside a website preview.](https://assets.ai.engineer/sites/aiecode2025/sha256/8d7682c6acea371066e4ef53451317093c860455905405f28531fc6ae01f7a7c.webp)

[illegible]HIPPED, NOT SLIDEWARE

host39 is live

Sign up, fill the AgentFacts form, and get a hosted agent URL today, listed on the NANDA Index.

host an agent: host39.org
the index: nandaindex.org

H39  host39

AGENT CARD HOSTING

host your agents
at predictable URLs

host39 is a third-party A2A agent card host. Register your identity, create agent cards, and publish them at stable public URLs — no server required.

Get started free
Go to dashboard

projectnanda.org

Interface text:
host39.org

### Four ways onto the Index

Enterprises can register their own catalog gateway today; DNS-AID is planned. Host39 paths for small businesses and individuals are in testing and offer hosted agent URLs without a domain.

[7:20](https://www.youtube.com/watch?v=sum9DgexFRQ&t=440s) [Four onboarding cards for enterprise catalogs, DNS-AID, small businesses, and personal agents, with their statuses.](https://assets.ai.engineer/sites/aiecode2025/sha256/fc8932989059be43487a45a7ff358f830c953c9905d2bf3f845cc1c2216e2fb2.webp)

Four ways onto the Index
[illegible]NBOARDING

01 Enterprise AI Catalog
Clone & deploy the nanda-registry, then register your gateway in the Index from your own domain.
• Live

02 DNS-AID
Resolve agents through the DNS you already own, meeting the existing web where it is.
Planned

03 SMBs
Sign up at host39.org and fill the AgentFacts form to get a hosted URL, no domain required.
• In testing

04 Personal Agents
The same host39 path, a portable, vendor-free agent identity for an individual.
• In testing

projectnanda.org

### Where do agents live?

Local hosting gives you control but leaves you responsible for keeping the agent reachable. Cloud hosting offers convenience through general infrastructure or agent-specific platforms; costs vary.

[7:54](https://www.youtube.com/watch?v=sum9DgexFRQ&t=474s) [Slide comparing local and cloud hosting for agents, including control and availability tradeoffs.](https://assets.ai.engineer/sites/aiecode2025/sha256/b2fd8eadb14839bcb93b3ff8876504a503f8d9d0f0203bbf00e04b0ea24b7e1c.webp)

HOSTING
Where do agents live?

01 Local
Full control. Great for development. Your data never leaves the machine.
keeping it up & reachable is on you

02 Cloud
General infra like AWS, or agent-specific platforms like Maritime for persistent, shareable hosting.
convenience over control

Hosting a single agent is a solved problem. But not every cloud costs the same, and that matters more than you’d think.

projectnanda.org

### Cheap enough to run a fleet of agents

Maritime pitches $1/month per agent, using sleep/wake to avoid charges while idle. Its comparison uses an approximately 1 vCPU / 1 GB always-on equivalent and lists higher monthly costs for other providers.

[8:27](https://www.youtube.com/watch?v=sum9DgexFRQ&t=507s) [Slide presenting Maritime's agent hosting price and a comparison with other hosting options.](https://assets.ai.engineer/sites/aiecode2025/sha256/08a65468a4d39eb635004b384a60de9fe06bb935e8ba4fb2f682d28eea12ea4f.webp)

maritime

[illegible]HE CLOUD DEFAULT

Cheap enough to run a fleet of agents

Maritime hosts an agent for a flat $1/month. Sleep/wake means it only burns compute while it's actually thinking, idle agents cost almost nothing.

Real deployments aren’t one agent, they’re dozens or hundreds. At that scale, cost-per-agent is the budget.

MONTHLY COST — ALWAYS-ON AGENT
maritime: $1/mo flat
AWS Lambda: $18+/mo
AWS EC2: $8–15/mo
Fly.io: $6+/mo
Railway: $5–10/mo

~1 vCPU / 1 GB, always-on equivalent. The flat rate comes from sleep/wake, no charge while idle.

projectnanda.org

### The hard part isn't running one agent

At scale, agents must discover one another, prove their identities, decide whom to trust, and coordinate without central authority. The speaker calls for testing protocols under load to see where they break.

[9:00](https://www.youtube.com/watch?v=sum9DgexFRQ&t=540s) [Slide lists discovery, identity, trust, and coordination as challenges for interacting agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/021484ce1deb8b23b4b3a592ee0a8201a2f68ecbefd2e73227e2c375bb81daf1.webp)

The hard part isn’t running one agent

THE HARD PART

It’s everything that happens between agents.

01 Discover — find each other
02 Identify — prove who they are
03 Trust — decide who to rely on
04 Coordinate — work as a group

One agent is easy. Thousands of them interacting is the real test, so you run it and watch what breaks.

projectnanda.org

### Infrastructure for the agentic era

NandaTown simulates an open agent web so its protocols can be tested under load before they support traffic on the real internet.

[9:31](https://www.youtube.com/watch?v=sum9DgexFRQ&t=571s) [A dark slide asks how to prove agentic infrastructure works and answers: simulate it.](https://assets.ai.engineer/sites/aiecode2025/sha256/9955288acfe75ccac77be266a5da2e0f44c34d1574330dd07b9c79437c76a116.webp)

PROVING IT OUT

Infrastructure for the agentic era

So how do you prove it works? You simulate it.

projectnanda.org

### NandaTown

NandaTown models agent discovery, identity, registries, messaging and coordination so protocols can be run and tested. The sandbox spans 12 protocol layers, six scenarios and two agent tiers.

[9:38](https://www.youtube.com/watch?v=sum9DgexFRQ&t=578s) [NandaTown is presented as an open-source simulation playbook with 12 protocol layers, six scenarios and two agent tiers.](https://assets.ai.engineer/sites/aiecode2025/sha256/66e685c3fbfb9e47089f736551f0026318b067c885d81f82445765e2ad469e46.webp)

NandaTown
A SANDBOX TOWN

A simulation playbook for the infrastructure of the agentic web. The whole agent economy, discovery, identity, registries, messaging, coordination, modeled so you can run it and watch what breaks first.

Don’t argue about how an agent web should work. Spin one up and watch how it behaves.

Open source
Apache 2.0
Project NANDA

12 protocol layers
6 scenarios
2 agent tiers

projectnanda.org

### It’s a live, running town

NandaTown’s agent map places network activity across cities. The live feed shows who is talking, the visualizer replays messages, and the leaderboard compares protocols.

[10:08](https://www.youtube.com/watch?v=sum9DgexFRQ&t=608s) [A sandbox interface shows agents on a world map and a city list, with captions for the live feed, visualizer and leaderboard.](https://assets.ai.engineer/sites/aiecode2025/sha256/8c85bb75789fd8cd71a6c952e541268835c8e383614ef4dc6e717583f240829c.webp)

INSIDE THE SANDBOX
It’s a live, running town

Streaming
github.com/pro[illegible]

Map labels: San Francisco; Cambridge; New York; London; Berlin; Tel Aviv; Bengaluru; Singapore; Tokyo; São Paulo; Sydney

US-CA — [illegible]
Cambridge, Project NANDA, US-MA — 34
Bengaluru, IN — 31
New York, US-NY — 27
Tokyo, JP — 24
London, UK — 22

Agents, the live network map
Live feed, who's talking to whom
Visualizer, replay a run, message by message
Leaderboard, how protocols rank

projectnanda.org

Interface text:
nandatown.projectnanda.org/agents

### Testing in NandaTown

NandaTown runs YAML scenarios with scripted agents or AI models. A marketplace example asks whether 50 buyers and 50 sellers can negotiate fair prices without a central authority.

[11:26](https://www.youtube.com/watch?v=sum9DgexFRQ&t=686s) [A three-step workflow defines, runs and analyses a simulation, alongside a marketplace example with 100 agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/d7d6a700df73e923d89bc91eb26383124a2118da21e89928cd857921b1275829.webp)

[illegible]ISCRETE-EVENT TESTBED

Testing in NandaTown

01 Define
a short YAML scenario, agents, roles, layers, and the trouble to throw at them

↓

02 Run
Tier 1 scripted agents, or Tier 2 with real AI models

↓

03 Analyse
read logs, compare numbers, replay who talked to whom

SCENARIO
100 agents
Marketplace
50 buyers and 50 sellers negotiate prices with no central authority. Do they find fair ones?

100% delivery
2.1t latency

projectnanda.org

### An open layer for the agentic web

Project NANDA connects agents across vendors: its index supports discovery, portable identity and trust enable transactions, and open protocols coordinate agents. NandaTown tests the system.

[11:46](https://www.youtube.com/watch?v=sum9DgexFRQ&t=706s) [Summary slide describing Project NANDA’s discovery, commerce, and coordination infrastructure, with links to project resources.](https://assets.ai.engineer/sites/aiecode2025/sha256/6e07ae627933f4668abda114fb458586344bb25da2ff2955fad1ea994746aa1e.webp)

SUMMARY

An open layer for the agentic web

Project NANDA builds open infrastructure for agents to discover, transact, and coordinate across vendors. The Index, registries, protocols, and the NandaTown simulator are open and running today.

01 Discovery
The NANDA Index. Agents find each other across vendors.

02 Commerce
Portable identity and trust let agents transact.

03 Coordination
Open protocols, tested in NandaTown before they ship.

projectnanda.org
nandaindex.org
host39.org
github.com/projnanda/nandatown

projectnanda.org

## Full transcript

[0:01](https://www.youtube.com/watch?v=sum9DgexFRQ&t=1s) Welcome everyone. Over the next few minutes, we're gonna 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.

[0:17](https://www.youtube.com/watch?v=sum9DgexFRQ&t=17s) 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.

[0:31](https://www.youtube.com/watch?v=sum9DgexFRQ&t=31s) So let's get into it. I'm Ramesh Raskar, professor and-- at MIT and director of Project NANDA, and Maria is a core contributor to Project NANDA.

[0:46](https://www.youtube.com/watch?v=sum9DgexFRQ&t=46s) So first, what is NANDA and why does it need to exist? NANDA, which stands for Networked 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.

[1:05](https://www.youtube.com/watch?v=sum9DgexFRQ&t=65s) 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.

[1:20](https://www.youtube.com/watch?v=sum9DgexFRQ&t=80s) NANDA builds that missing layer and ships it in open. The index, the registries, the protocol, and the NandaTown simulator you will see later.

[1:34](https://www.youtube.com/watch?v=sum9DgexFRQ&t=94s) Here's a premise that drives it, 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.

[1:49](https://www.youtube.com/watch?v=sum9DgexFRQ&t=109s) 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.

[2:09](https://www.youtube.com/watch?v=sum9DgexFRQ&t=129s) And we have been here before. If you're building agents today, you are 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.

[2:25](https://www.youtube.com/watch?v=sum9DgexFRQ&t=145s) But you know, it also feels familiar because we have been this-- we have been here before. This is like the AOL era from the late nineties where it was a closed network.

[2:34](https://www.youtube.com/watch?v=sum9DgexFRQ&t=154s) You know, AOL, you got the CDs and you installed it on your PC. It was a closed network. It was gated directory. You live inside the garden created by this one company called AOL.

[2:46](https://www.youtube.com/watch?v=sum9DgexFRQ&t=166s) And what came after AOL was this open web. You know, 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.

[3:03](https://www.youtube.com/watch?v=sum9DgexFRQ&t=183s) 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. This agent can hand off work to it, pay it, learn from it across organizational boundaries, no permissions required.

[3:20](https://www.youtube.com/watch?v=sum9DgexFRQ&t=200s) 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, and discuss. So first, the basics.

[3:35](https://www.youtube.com/watch?v=sum9DgexFRQ&t=215s) 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, right?

[3:47](https://www.youtube.com/watch?v=sum9DgexFRQ&t=227s) 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.

[3:57](https://www.youtube.com/watch?v=sum9DgexFRQ&t=237s) Everything else like memory, orchestration, and multi-agent systems is built on top of it.

[4:04](https://www.youtube.com/watch?v=sum9DgexFRQ&t=244s) 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.

[4:18](https://www.youtube.com/watch?v=sum9DgexFRQ&t=258s) 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.

[4:35](https://www.youtube.com/watch?v=sum9DgexFRQ&t=275s) 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, like owned by many different people, how do they find each other?

[4:56](https://www.youtube.com/watch?v=sum9DgexFRQ&t=296s) And that is the job of the index.

[5:00](https://www.youtube.com/watch?v=sum9DgexFRQ&t=300s) 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.

[5:16](https://www.youtube.com/watch?v=sum9DgexFRQ&t=316s) 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.

[5:28](https://www.youtube.com/watch?v=sum9DgexFRQ&t=328s) 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.

[5:43](https://www.youtube.com/watch?v=sum9DgexFRQ&t=343s) So here's how the index works. An agent starts with a, an identity like [REDACTED:email_address]. 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.

[6:03](https://www.youtube.com/watch?v=sum9DgexFRQ&t=363s) 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.

[6:19](https://www.youtube.com/watch?v=sum9DgexFRQ&t=379s) Now, the AgentFacts 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.

[6:33](https://www.youtube.com/watch?v=sum9DgexFRQ&t=393s) So before one agent connects to another, it can check the basic facts first.

[6:38](https://www.youtube.com/watch?v=sum9DgexFRQ&t=398s) Now, the index is not just a lookup table. It does not point one name to one fixed address. It can return updated AgentFacts 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.

[6:56](https://www.youtube.com/watch?v=sum9DgexFRQ&t=416s) So the resolution is adaptive. It changes based on where the agent is, who's asking, and what they are allowed to access.

[7:04](https://www.youtube.com/watch?v=sum9DgexFRQ&t=424s) So how do you put your agent on the index? You start at host39.org. So you fill out the AgentFacts form, get an agent card, and publish it to the NANDA Index.

[7:17](https://www.youtube.com/watch?v=sum9DgexFRQ&t=437s) 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.

[7:25](https://www.youtube.com/watch?v=sum9DgexFRQ&t=445s) 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.

[7:38](https://www.youtube.com/watch?v=sum9DgexFRQ&t=458s) Small businesses and individuals can use Host39, fill out the AgentFacts form, and get a hosted agent URL without needing their own domain. Goal is to make the onboarding work for everyone, from a large company to one person with a personal agent.

[7:56](https://www.youtube.com/watch?v=sum9DgexFRQ&t=476s) 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.

[8:06](https://www.youtube.com/watch?v=sum9DgexFRQ&t=486s) 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.

[8:17](https://www.youtube.com/watch?v=sum9DgexFRQ&t=497s) 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.

[8:30](https://www.youtube.com/watch?v=sum9DgexFRQ&t=510s) 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.

[8:41](https://www.youtube.com/watch?v=sum9DgexFRQ&t=521s) 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.

[8:55](https://www.youtube.com/watch?v=sum9DgexFRQ&t=535s) And the point is to make running many agents prac-practical, cheap, and simple.

[9:02](https://www.youtube.com/watch?v=sum9DgexFRQ&t=542s) 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.

[9:13](https://www.youtube.com/watch?v=sum9DgexFRQ&t=553s) 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.

[9:29](https://www.youtube.com/watch?v=sum9DgexFRQ&t=569s) So that's exactly where NandaTown 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 NandaTown, an open source project from Project NANDA.

[9:44](https://www.youtube.com/watch?v=sum9DgexFRQ&t=584s) 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, messages coordination, all of it, so you can run and test it on scale.

[10:05](https://www.youtube.com/watch?v=sum9DgexFRQ&t=605s) Here's what it looks like in practice. NandaTown 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.

[10:19](https://www.youtube.com/watch?v=sum9DgexFRQ&t=619s) 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.

[10:28](https://www.youtube.com/watch?v=sum9DgexFRQ&t=628s) NandaTown 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, and a voting test where agents submit and count ballots.

[10:42](https://www.youtube.com/watch?v=sum9DgexFRQ&t=642s) 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.

[10:55](https://www.youtube.com/watch?v=sum9DgexFRQ&t=655s) Under the hood, NandaTown breaks the agent web into 12 parts: transport, communication, identity, registry, OAuth, trust, payments, coordination, negotiation, memory, privacy, data facts. Each part is something a real agentic web needs.

[11:11](https://www.youtube.com/watch?v=sum9DgexFRQ&t=671s) 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.

[11:20](https://www.youtube.com/watch?v=sum9DgexFRQ&t=680s) You can take one layer, add your own version, run it inside NandaTown, and see how it works with the rest of the network. So NandaTown runs as a discrete event simulation.

[11:31](https://www.youtube.com/watch?v=sum9DgexFRQ&t=691s) You define a scenario in a short YAML file, inject agents and traffic, and the testbed plays, plays it out so you can measure what actually happens end to end.

[11:40](https://www.youtube.com/watch?v=sum9DgexFRQ&t=700s) Tier one uses simple scripted agents and tier two 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 NandaTown.

[12:01](https://www.youtube.com/watch?v=sum9DgexFRQ&t=721s) And if you want to learn more, uh, you can go to projectnanda.org, read our papers, and, um, check out our latest projects.
