A 3D multiplayer world built from a book, with AI characters, on Ethora chat and agents, in one weekend

Overview

A chat server is already a map: the project just lets you walk it

The idea started as a question about Ethora itself. A chat room is a place. People are in it or not, they arrive and leave, and in Ethora an AI agent can live there too. What if a visitor could only be in one room at a time, had to walk to the next one, and saw the others in the room around them instead of a list of messages? And what if the rooms and the characters came from a book?

The challenge. Four things had to be true at once. Presence had to feel like a world: one room at a time, doors between adjacent rooms, a system line in the chat when someone walks in or out. Characters had to stay in character for hours in a public room and answer from the text of the book, not from a model’s general memory. A new world had to come from any text in minutes, not from hand-written content. And a public world must not run up an unbounded AI bill.

The approach. Three small pieces around an unchanged Ethora. A world service that knows where every visitor stands and which door leads where. A 3D client in the browser that renders the room, the avatars and the characters, with the standard Ethora chat panel pinned to the current room. And a generator plus provisioner that reads a book, writes a world file, and then creates the Ethora app, the rooms, the agents and their knowledge over the hosted MCP server. Ethora is used only through its public surface; anything it lacked was written down for the Ethora team instead of patched.

From book to world

What the generator made

The first generated world was Alice in Wonderland with six rooms and three characters. The model chose the Rabbit Hole, a Long Hall with three exits, the Mushroom Wood with the Caterpillar, the Mad Tea Party as an open panorama room, the Queen’s Croquet Ground and the Court of Justice; it wrote personas that quote the book, gave the Queen a schedule that takes her to the court every two hours, and put “Off with their heads!” on the three-quarter hour. The Tempest followed as a seven-room island with four characters and seven scheduled scenes, then A Christmas Carol, made through the “your own book” form on the join screen in four minutes.

The live test

Monday morning: the team walks into the tea party

On Monday 19 October the project went up on the shared server that already hosts Ethora’s smaller websites, as a fifth small service behind the same reverse proxy, and the link went into the weekly team call. Within a couple of minutes five people were in the Tea Party at once. The Hatter greeted each of them by name as they came through the door (“Oh, very well, Nick. There is plenty of room. Your hair wants cutting.”), speech bubbles appeared over the avatars as people typed, and the chat on the right carried the same conversation as an ordinary Ethora room. The group then moved to The Tempest, switched on spoken lines, and listened to Caliban complain about Prospero from the text of the play.

The questions and ideas that came out of the session are the useful part. The real-time movement does not go over XMPP: the chat does, while positions and doors go over the project’s own WebSocket service, which raised the idea of a version that carries movement over Ethora so that a student could host a world on a free static tier with nothing but an Ethora account. The team asked for voice chat that fades with distance (Ethora already has WebRTC calls to plug in), for holding the next team meeting inside the world, and for multimodal models so characters can see what they are shown. The founder’s children, who tested it over the weekend, asked for weapons.

What we learned about our own product

Nineteen notes for the Ethora roadmap

Building on nothing but the public surface is the point of a showcase like this: it is the same experience an outside builder gets. The project kept a running list of everything Ethora should do that it does not do today, each with the workaround used here, and that list now feeds the roadmap. A few of them:

• The App Secret stays in the dashboard. The provisioner can create an app, its rooms, agents and knowledge over MCP, but the secret that signs server tokens is only shown to the app owner in the web dashboard, so a world made by a visitor through the form has rooms and characters but no chat until the owner pastes one line. Returning it once to the creating owner would make the whole flow unattended.
• Rooms created over MCP are public app chats. Every app user is a member of all of them, so one-room-at-a-time cannot be enforced by membership yet; group chats with per-user access are the fix.
• Rooms carry no custom metadata, so a world cannot live entirely inside Ethora; the world file holds the map, wallpapers and exits.
• No outbound webhooks per app. A server that wants to react to chat events still needs a client in the loop; the world service drives its scripts on its own timer instead.
• Agent schedules are stored but not run, so character life is simulated by the world service rather than by Ethora.
• Guests need a last name. A visitor who types one name shows as “Alice (guest)”; a display-name field would fix it.

None of these blocked the project, which is the other half of the finding: a chat server, a hosted MCP server, an agent model with mention gating and retrieval, and a backend SDK for guest identities were enough to stand up a multiplayer world with living characters in a weekend.

Where it goes next

A place to study groups of agents and groups of people together

Beyond the demo, the project is a test bed for a research question Ethora cares about: what happens when several AI agents with different roles share an environment with several people over a long time. Stanford’s Generative Agents work showed agents with memory and reflection forming plans and relationships in a small simulated town; here the town is a book, the agents are Ethora agents, and the other inhabitants are real people. Ethora agents already have a long-term memory they can write to themselves; the next step is social memory, so that a character remembers who asked it for a song, who was kind and who was rude, and behaves differently with each of them, inside a world and in an ordinary team chat alike.

Also on the list: the source on GitHub under MIT, a name that is not a working name, worlds described in a prompt rather than taken from a book, a 2D client on the same world file, voice between visitors that fades with distance, and a self-hosted guide for running the whole thing against Ethora Core.