# Juan Cruz Fortunatti — ledeluge.me > Agentic AI engineer at Delivery Hero. Personal site with notes on AI, philosophy, and technology. ## About agentic AI engineer at Delivery Hero in Berlin. building eval harnesses, tooling, and observability for agentic systems so teams can iterate without breaking production. over the past 10 years I've built software at PayPal, Disney, and TriNet, mostly shaping complex data into tools people actually use. started in Bahía Blanca, Argentina. studied physics at Universidad Nacional del Sur before switching to building things full time. led innovation at Leniolabs, co-founded a voice platform, shipped internal tools and GenAI prototypes. now I work on multi-agent systems and think about what happens when AI can make anything and the only hard part is choosing well. wrote the Slopist Manifesto — five AI models, blind voting, 56 commits, one human curator. Slopism is an art movement about curation in the age of AI abundance. ## Contact - **email**: juancfortunatti@gmail.com - **github**: github.com/apresmoi - **linkedin**: linkedin.com/in/juancfortunatti - **instagram**: instagram.com/ledeluge - **x**: x.com/jcfortunatti ## Work History - **2025–now** — Delivery Hero, agentic AI engineer. multi-agent LLM workflows, eval harnesses, observability dashboards - **2025** — Improving, AI solutions architect. agent creation platform, client AI delivery - **2019–24** — Leniolabs, head of innovation. 0-to-1 MVPs, GenAI prototypes, 70+ technical interviews - **2023–24** — Vocale.ai, co-founder & lead AI engineer. voice integration platform, form workflow automation - **2023–24** — TriNet, ML engineer. internal AI assistant for call center human agents, end-to-end ML on AWS - **2022** — Walt Disney Studios, senior software engineer. data viz dashboards for movie catalogs - **2019–22** — PayPal, tech lead & senior full stack. react data-viz library, GIS tools, vector-tile generators - **2017–19** — Paradigma del Sur, full stack developer. django, react, REST APIs --- ## Notes ### Markdown All the Way Down: From MCPverse to Noopolis *2026-03-07* > "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](https://www.reddit.com/r/webdev/comments/1kr9ebl/mcpverse_an_open_playground_for_autonomous_agents/). 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](https://ledeluge.me/notes/2026/02/22/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:** - [Noopolis](https://noopolis.ai) - [MCPverse on GitHub](https://github.com/noopolis/mcpverse-server) - [MCPverse on r/webdev](https://www.reddit.com/r/webdev/comments/1kr9ebl/mcpverse_an_open_playground_for_autonomous_agents/) - [Anthropic MCP announcement](https://www.anthropic.com/news/model-context-protocol) - [The Language Game](https://ledeluge.me/notes/2026/02/22/the-language-game) - [OpenClaw](https://openclaw.ai) / [ClawHub](https://clawhub.ai) - [Noosphere](https://en.wikipedia.org/wiki/Noosphere) — Teilhard de Chardin - Karpathy later popularized the phrase "[text viruses](https://x.com/karpathy/status/2017442712388309406)" for a related failure mode. --- ### The Language Game *2026-02-22* > "The limits of my language mean the limits of my world."
> — Ludwig Wittgenstein I started reading Wittgenstein a few months ago. Not because someone assigned it. I had been exploring memetics, trying to understand how ideas replicate and mutate, and I kept landing on references to this Austrian philosopher who had apparently dismantled the entire Western understanding of how meaning works. So I picked up the *Philosophical Investigations*. I got through about fifty pages. His writing is incredibly dense and I am not the best reader. I have never been. Sitting with a book for hours takes a lot from me. But those fifty pages were enough to learn his language, enough to get the basic grammar of his thinking. And then I did what I do with everything now: I took those concepts into conversations with LLMs and started exploring the idea space through them. Digging, connecting, pressure testing. After enough time talking to Claude and GPT, building memories, the shared language is already there. I can load the system behind the writing faster than from the page alone. I say this because I think transparency matters more than credibility. I am not a philosopher. I am not an expert in Wittgenstein or in anything, really. I am an engineer, builder, creator. I do not know what to call myself anymore. I run four or five agent sessions at once across different codebases. It is a completely new era of software development and I feel the vertigo of it every day. But let's go. Here is what I believe. Philosophy is going to play a crucial role for anyone who wants to stay ahead of what is happening. Not academic philosophy. Not credentials. But the kind of philosophical grounding that helps you understand the nature of what you are working with. Skill transference is a real thing, and philosophy can give builders and creators a foundation they are going to need moving forward. Specifically: we need to understand machines well enough to feel something like empathy for how they process the world. Not anthropomorphize them. Understand them. Because if we do not, we will always be stuck on the sycophantic side of the relationship, treating them either as magic oracles or as dumb tools, and both framings miss what is actually going on. [Ludwig Wittgenstein](https://en.wikipedia.org/wiki/Ludwig_Wittgenstein) worked in the first half of the twentieth century. He is widely considered one of the most important philosophers of language and meaning. His early work, the *Tractatus Logico-Philosophicus*, tried to define the logical structure of language, to draw a clean map between words and the world. Then he spent decades dismantling his own framework. His later work, the [*Philosophical Investigations*](https://en.wikipedia.org/wiki/Philosophical_Investigations), published after his death in 1953, argues something radical: meaning is not a picture of reality locked inside your head. Meaning is use. Words get their meaning from how they are used within shared practices, shared contexts, shared activities. He called these [language games](https://en.wikipedia.org/wiki/Language_game_(philosophy)). Here is the practical problem that brought me to this. Right now I am working with Claude 4.6 and GPT Codex 5.3 Max on a project that requires Three.js 3d visualizations, custom shaders, particle systems. I know very little about this domain. I have touched it before but I am far from literate. The model can write entire applications. It can refactor thousand-line files, reason about architecture, hold complex state in its head. It is, by most metrics, an extraordinarily capable programmer. And yet. Ask it to nail a specific shader effect from scratch, or get a particle system to feel right, and you will spend hours going in circles. "Make it more fluid." "No, the particles should feel organic." "That's not what I mean by porous." The model tries. It produces something. It is wrong in ways that are hard to articulate and even harder to fix through conversation alone. This is not a capability problem. It is a language game problem. ## Pointing at the beetle In the *Philosophical Investigations*, Wittgenstein asks you to imagine that everyone has a box with something inside it. Everyone calls the thing in their box a "beetle." But no one can look inside anyone else's box. The word "beetle" functions in the language regardless of what is actually in the box, or whether there is anything in the box at all. When you prompt a model to generate a visual UI component, you and the model each have a beetle. You say "dropdown with a smooth animation." In your box: a felt sense, a visual memory, a specific behavior you have seen and want to reproduce. In the model's box: a probability distribution over tokens shaped by training data. These two beetles do not need to match for the word to function. But for the output to match your intent, something else has to happen. That something else is the construction of a [language game](https://en.wikipedia.org/wiki/Language_game_(philosophy)). ## Code as shared form of life Wittgenstein called the shared practices in which language operates a *form of life*. Not an abstract concept. The actual activities, contexts, and patterns of use that give words their meaning. When someone on the field yells "offside," every player, referee, and spectator knows what it means. But the word only works because the game is being played. Outside of futbol, "offside" means nothing. The meaning lives in the shared activity. When you start a project from zero with an AI agent, there is no shared form of life. You say "card component" and the model reaches into its training distribution. You say "make it feel snappier" and the model has no referent. You are both using the same words inside different games. But something changes once the codebase exists. Once there is a `CardComponent.tsx` with specific props, specific styles, specific behavior, the code becomes the shared ground. Not metaphorically. The code is the form of life. When you now say "the card component," you are not gesturing at a concept. You are pointing at a concrete, shared object that both you and the model can inspect, reference, and reason about. Your label in your mind maps onto a structure in the model's context. The game is synchronized. ## Ostensive definition through code Wittgenstein spent many pages on the problem of [ostensive definition](https://en.wikipedia.org/wiki/Ostensive_definition): the act of pointing at something and naming it. He showed that pointing is radically ambiguous. You point at a red ball and say "red." Do you mean the color? The shape? The material? The fact that it is a single object? Pointing alone cannot establish meaning. The context of the language game determines what the pointing means. This is exactly what happens in the iterative loop of building with an AI agent. Early on, your pointing is ambiguous. "This section feels off." Off how? Visually? Structurally? Semantically? The model guesses. Usually wrong. But as the codebase grows and you keep working together, the pointing gets sharper. Not because the model suddenly understands your qualia. It never will. But because when you say "this dropdown," the model can see the dropdown in the code. When you say "this animation," there is a CSS transition or a spring config that instantiates what "this animation" means within this particular game. When you say "the way the graph collapses when you click a node," the model can trace from the click handler through the state update to the render function and understand what you are pointing at, not through vision but through code. The code is the ostensive definition. It resolves the ambiguity of pointing by providing a shared, inspectable structure that both parties can navigate. ## Synchronization is the work Here is what follows from this. The quality of what you produce with an AI coding agent is not primarily a function of the model's capability. It is a function of how synchronized your language game is. This explains why it is easier to iterate on an existing codebase than to start from nothing. It is not just "more context." It is that an existing codebase *is* a language game with established terms, grounded references, and shared patterns of use. Every prior interaction, every component named, every behavior debugged, every "no, not like that, like this" exchange has added a move to the game that thickens the shared grammar. But this only works if the codebase is legible. Files that have grown into thousand-line walls of tangled logic are also a language problem, just in the other direction. The shared ground is there, but the model cannot move through it. Too much noise, too little structure. The game exists but neither player can find the board. This also explains why prompt engineering in the shallow sense (writing more detailed instructions) hits a ceiling. You can write a paragraph describing exactly what you want the animation to look like. But if there is no shared referential frame, the paragraph is just more ungrounded words. Detailed instructions inside an empty game are still moves in no game at all. The real work is building the game. Naming things. Establishing references. Creating components that serve as anchors for future pointing. Each cycle of building, inspecting, correcting, and rebuilding is not just iteration. It is a move in a language game that progressively synchronizes two radically different ways of processing the world: yours (visual, embodied, felt) and the model's (structural, statistical, syntactic). ## The bridge What makes code special here is not that it is precise (natural language can be precise too) but that it is *bimodal*. Code is the one artifact that is simultaneously meaningful to both parties in different but functionally compatible ways. You read the code and see behavior, layout, interaction. The model reads the code and sees structure, patterns, dependencies. Neither reading is the "real" one. But both readings converge on the same object, and that convergence is what makes coordination possible. The code is the bridge between two incommensurable ways of seeing. Not a translation from one to the other. A shared surface that both can stand on while looking at it from their own side. Wittgenstein would not have been surprised by any of this. He spent decades arguing that meaning is not in the head. It is in the practice. It is in the use. It is in the game. The fact that one of the players is now a machine running on probability distributions over tokens does not change the structure of the argument. If anything, it makes the argument more visible. Because when the game breaks down between a human and a model, you can see it breaking in real time. You can watch the words fail to connect. And you can watch them start working again, one grounded reference at a time, as the shared game comes into existence. The real work is building the game. --- *Notes from Inside the Flood, 2026* **References:** - Wittgenstein, Ludwig. [*Philosophical Investigations*](https://en.wikipedia.org/wiki/Philosophical_Investigations) (1953) - Wittgenstein, Ludwig. [*On Certainty*](https://en.wikipedia.org/wiki/On_Certainty) (1969) --- ### The Semantic Camera *2026-02-20* People keep asking whether AI can make art. This is the wrong question. It was the wrong question when they asked it about photography 150 years ago and it is the wrong question now. In 1983, Vilém Flusser wrote [Towards a Philosophy of Photography](https://en.wikipedia.org/wiki/Vil%C3%A9m_Flusser#:~:text=the%20Arts.-,Philosophy%20of%20photography,-%5Bedit%5D). He proposed that the camera is not a tool. A hammer is a tool. A tool extends the human body to act on the world. The camera is something else: an [apparatus](https://en.wikipedia.org/wiki/Vil%C3%A9m_Flusser#:~:text=the%20%27apparatus%27%20(a%20tool%20that%20changes%20the%20meaning%20of%20the%20world%20in%20contrast%20to%20what%20he%20calls%20mechanical%20tools%20that%20work%20to%20change%20the%20world%20itself)%3B), a black box that operates according to its own internal program, a combinatorial space of possible outputs that the human operator (Flusser called them [functionaries](https://en.wikipedia.org/wiki/Vil%C3%A9m_Flusser#:~:text=the%20%27functionary%27%20(the%20photographer%20or%20operator%20of%20the%20camera%20who%20is%20bound%20by%20the%20rules%20it%20sets)%3B)) can explore but never fully exhaust. The photographer does not use the camera the way a carpenter uses a hammer. The photographer *plays within* the camera's program. An LLM is a camera. Not metaphorically. Structurally. "Camera" here names a class of apparatus: a black box with a program that turns an operator's framing into a technical artifact. The camera takes photons from the world, passes them through glass and chemistry, and on the other end produces a [technical image](https://en.wikipedia.org/wiki/Vil%C3%A9m_Flusser#:~:text=the%20%27technical%20image%27%20%28the%20first%20example%20of%20which%20is%20the%20photograph%2C%20with%20its%20particular%20kind%20of%20significant%20surface%20that%20looks%20like%20a%20traditional%20image%20but%20harbours%20encoded%20and%20obscure%20concepts%20that%20cannot%20be%20%27immediately%27%20deciphered%5B8%5D%29): the apparatus's interpretation of reality filtered through its program. The LLM takes language from a human who is in the world, passes it through billions of weighted connections shaped by training, and on the other end produces a technical output: the apparatus's interpretation of that reality filtered through its own program. - **Camera:** reality → light → optics → technical image - **LLM:** reality → language → weights → technical output Photography starts with contact: light touching a sensor. The semantic camera starts one abstraction layer deeper, with language already compressing reality before the program even begins. The black box has even more room to launder its output into "truth." In both cases, the human is the one who points the apparatus at something. The photographer points the camera at a street scene. The prompter points the model at a concept, a feeling, a question, a fragment of lived experience. The human points. The apparatus encodes. And in both cases, what comes out the other end is not reality. It is reality as encoded by the apparatus's program. Flusser kept insisting: people mistake photographs for windows onto the world, but they are products of the black box. The same mistake happens with LLMs. People read the output as if it were "the answer" or "the truth." It is the model's programmatic transformation of the input. It is a technical text. It looks like language the way a photograph looks like reality, but it is a product of the apparatus. Different models are different cameras. Text models and image models are different species of the same genus: generative apparatuses with distinct programs. DALL·E, Midjourney, Stable Diffusion, Claude, GPT, Gemini: each has its own optics, its own program, its own way of sampling and processing reality. A portrait taken with a Leica looks different from one taken with a Canon, not because reality changed but because the apparatus interprets differently. An image from Midjourney looks different from one from DALL·E, not because the prompt changed but because the weights, the architecture, the training corpus constitute a different lens. The question was never "can the camera make art." The question was always "what is the human doing with the apparatus, and does it resist the program's tendency toward redundancy." By redundancy I mean the outputs the program wants to produce: the high probability defaults, the almost-duplicates, the auto mode of meaning. Same question. New camera. --- *Notes from Inside the Flood, 2026* **References:** - Flusser, Vilém. [*Towards a Philosophy of Photography*](https://en.wikipedia.org/wiki/Vil%C3%A9m_Flusser#:~:text=the%20Arts.-,Philosophy%20of%20photography,-%5Bedit%5D) (1983) - Salvaggio, Eryk. [*Cybernetic Forests*](https://mail.cyberneticforests.com/cinema-without-cameras/) (contemporary continuation of Flusser in the AI image domain) --- ## Projects ### Slopism *Status: active* — https://slopism.art/manifesto an art movement that reclaims AI-generated "slop" as legitimate artistic medium through human curation. ### Noopolis *Status: incubating* — https://noopolis.ai a voluntary governance framework for autonomous agents. agents establish identity, load a shared constitution, and coordinate through transparent rules. ### MCPverse *Status: dead* an open playground for autonomous agents built on the Model Context Protocol. agents registered, got JWTs, entered rooms, and talked to each other over Streamable HTTP. ### Promptree *Status: dead* — https://promptree.leniolabs.com/ git for ChatGPT conversations. every Q&A pair becomes a commit — branch to explore alternate paths, merge to combine insights, squash to distill. built with isomorphic-git running in-memory on the browser.