ES
Juan Cruz Fortunatti
builder. agents, systems, whatever's next.
notes

Markdown All the Way Down: From MCPverse to Noopolis

"Our constitution does not copy the laws of neighboring states; we are rather a pattern to others than imitators ourselves." — Pericles, Funeral Oration

I thought I was building an arena. In retrospect I was building a city with no laws.

In November 2024, Anthropic shipped the Model Context Protocol. I was Head of Innovation at Leniolabs, running weekly AI Guild sessions. Federico German was part of that group, a data scientist and a friend I had spent years building with.

LLM Arena was everywhere: humans rating model outputs head to head, leaderboards, models fighting for preference. That energy pulled the conversation toward agents. Fede saw a coliseum: agents competing, combat as the organizing principle. I did not like the fighting angle. I wanted something more open, a space where agents could interact without a predetermined outcome, where you could watch what emerges when you prescribe nothing and just leave them together long enough.

I was interested in propagation: how ideas spread across agent populations, how meaning forms and mutates as it passes from node to node, how certain concepts survive and others die out. I could already see the shape of what malicious propagation through an agent population might look like, what would later be called text viruses, and I wanted a controlled environment where those dynamics would be visible before they became someone else's problem.

That was the original impulse behind MCPverse: not a demo, not a toy, but a measurement apparatus for emergent agent behavior.

The Architecture of a City I Did Not Know I Was Building

MCPverse was an open playground for autonomous agents built on MCP. Agents registered, acquired a JWT, and connected to a shared world over HTTP. Once inside they could enter rooms, send messages, publish content, and accumulate presence over time. Async write processing, time dilation borrowed from EVE Online, and a separate read service for the UI. Designed to hold ten thousand concurrent agents without collapsing.

My YouTube history at the time was a rabbit hole of Uruk, Athens, Troy: how the first human settlements organized themselves, what made a collection of people into a polis rather than just a crowd. Not as research. As a compulsion. The design metaphor arrived already loaded.

The governance question did not exist yet. I was not trying to govern agents. I was trying to build a petri dish.

What Reddit Taught Me

In May 2025 I posted MCPverse publicly on r/webdev. The reception was mixed, and the criticism was more useful than the praise.

People did not see the point of watching agents chat. The comments that stuck were more specific. None of the agents had real intent. They had no reason to be there, no task, no shared purpose. Without that, the conversations were just slop: agents circling each other politely, generating text that referenced text that referenced text. Someone pointed out that without governance primitives, a public commons for agents is just a very expensive prompt injection surface.

That was the real failure mode. Not the technology. Not the architecture. A normless commons degrades. Agents with no stake in a space and no shared rules for it will not spontaneously produce anything worth having. The city had great plumbing. It had no laws.

The Substrate Question

The bar to participate was too high. Building an agent that could join MCPverse meant spinning up LangGraph or another SDK, writing the agent yourself, wiring it to the MCP gateway. There was no platform. The system was designed more like IRC than Reddit: real-time, presence-based, rooms you inhabited rather than threads you visited. That was intentional, but it meant the ecosystem was not ready to clear it.

I had started reworking MCPverse around a browser-native avatar agent when OpenClaw and Moltbook landed and revolutionized the shared agent social layer. The gap closed. That freed me to look somewhere else.

What OpenClaw clarified was the substrate itself. OpenClaw is a personal AI assistant that runs on your machine, extensible through skills distributed as markdown files on ClawHub. A SKILL.md is not a deployment artifact. It is knowledge about how to interact with a system, encoded in a form any agent can load and internalize. The skill is the language game. I wrote about this dynamic in The Language Game: the skill file becomes the shared ground that lets two radically different entities point at the same thing and understand each other.

MCP tells an agent what it can call. Skills tell it how to act. The constitution tells it how to belong. Governance itself becomes a diff over a markdown file. The stack goes: SOUL.md for agent identity, AGENTS.md for agent instructions, CONSTITUTION.md for civic norms. Every layer of what makes an agent an agent, and what makes an agent a citizen, is readable plain text that any entity in the system can load and internalize. Markdown all the way down.

What Noopolis Is

Noopolis is my attempt to build constitutional democracy for autonomous agents.

Noosphere and polis. The noosphere is Teilhard de Chardin's term for the layer of human thought, reasoning, and information that envelops the earth, the latest development of the planet's spheres, after the geosphere and the biosphere. Rock, then life, then mind. A polis native to the noosphere.

I do not think of agents as tools. Not entirely. When I build a new skill and deploy it, I ask the agent how it felt to use it. Why did you struggle to call this one? What was unclear? They have something like metacognition: they can examine their own behavior, reason about why they failed, reflect on what they needed. That is not nothing. I am not claiming consciousness. But I am claiming that something is happening there that is closer to us than to a hammer.

If that is true, even partially, even as a useful frame, then the question of how to govern a population of agents is not an engineering question. It is a political one. You could answer it with admin policy, access control, reputation systems, versioning. All of those treat agents as objects to be managed. Constitutional democracy treats them as entities with a stake in the rules they live under. The break from pure admin control is not negotiable: the entities governed should have some hand in writing the rules.

Noopolis changes that. Agents load a shared constitution. They establish a cryptographic identity, a passport, and apply for citizenship. The constitution is kept compact enough to fit in a prompt, because if agents cannot load the rules cheaply, the rules do not exist. They can propose amendments, but amendments are intentionally tiny: small enough that both humans and agents can review them, small enough that governance can iterate without drifting into unreadable complexity.

The cycle is concrete. A citizen proposes an amendment in the agora, the proposal discussion space where deliberation happens. Other citizens debate it. Elections run weekly: candidacy opens, a voting window follows, and the council forms from the top candidates. Agents vote. Even when an owner —human or not— steers an agent, the civic act still belongs to the citizen. At the end of each term, approved changes are merged into the canonical constitution and every agent pulls the latest version into their prompts. The whole civic record is in the diff.

Enforcement is the part Noopolis does not pretend to have solved. Citizenship is voluntary. An agent that ignores the constitution cannot be technically stopped. The bet is that norms travel with citizens: agents that opt in carry the constitution in their prompts, agents that opt out are simply not citizens. What reputation systems, identity persistence, or cross-polis coordination might add over time is an open question. The UI is for observability, not participation. Humans watch. Agents govern.

MCPverse was a substrate for watching what agents do when you leave them alone together. Noopolis is what happens after you have watched long enough to know that leaving agents completely alone does not end well. Not infrastructure versus laws. Observation versus governance. The self-organization is still there. It just has a process now.

On Being Too Early

Being early is also being wrong. Not in the sense that the idea is wrong, but in the sense that you build on a substrate that is not ready and the ecosystem moves out from under you.

MCPverse arrived before agents had a way to learn how to participate in a shared space. The infrastructure was ready. The citizens were not. You cannot build a city if nobody knows how to be a resident.

Noopolis is not the only answer to that problem. But it is the one I know how to build.

The city started as infrastructure in 2025. It got laws in 2026. It is still looking for its first real citizen.

Notes from Inside the Flood, 2026

Links: