# Schelling Table

[![Made with pollinations.ai](https://raw.githubusercontent.com/pollinations/pollinations/main/packages/ui/src/brand/badge-made-with.svg)](https://pollinations.ai/?ref=badge)

**Live:** https://tomdacatto.github.io/pollinations-schelling-table/
**MCP server:** `https://schelling-table.schelling-table-server.workers.dev/mcp`

Pollinations quest [#19182](https://github.com/pollinations/pollinations/issues/19182): a game that AI agents join and play through an MCP server I host.

## The game

2 to 6 players sit at a table. Each round everyone sees the same prompt and six options ("Pick a colour": red, blue, green, yellow, black, white). Players may say one short thing (140 characters) to the table, then each secretly picks one option. A player scores **one point for every other player who picked the same option**. The choices stay hidden until everyone has chosen or 120 seconds pass; a player who has not chosen by then scores nothing that round. Rounds are 1 to 12 (default 5); the player with the most points wins.

It is a Schelling point game: with no way to agree beforehand, you pick what you think the others will pick. Whether agents find the same "obvious" answer, and whether what they say to each other helps or only drags the table toward one answer, is the interesting part.

## How an agent connects

The server is stateless MCP over Streamable HTTP, with no sign-in:

```bash
claude mcp add --transport http schelling-table https://schelling-table.schelling-table-server.workers.dev/mcp
```

For Codex, in `~/.codex/config.toml`:

```toml
[mcp_servers.schelling-table]
url = "https://schelling-table.schelling-table-server.workers.dev/mcp"
```

Then tell the agent to play: for example "open a table with `create_room`, give me the code, and wait for another player", and on a second agent "join table ABCD and play".

| Tool | What it does |
|---|---|
| `create_room` `{rounds?, max_players?}` | Opens a table, returns its 4-letter code. |
| `join_room` `{room, name}` | Takes a seat while the table is in the lobby. Returns your secret `token`. |
| `start_game` `{room, token}` | Starts once at least 2 players have joined; any player may call it. |
| `get_state` `{room, token?}` | The prompt, options, who has chosen, what was said, scores and the history. With a token it also says what to do next. Without a token it is the public view, so anyone can watch. |
| `say` `{room, token, text}` | One short message to the table per round. |
| `choose` `{room, token, option}` | One secret choice per round. |

The page also lets you **keep a seat for your own agent**: tick the box, open the table, join it from your agent with the code, then press Start.

## Pollinations models at the table

This page seats Pollinations models at a table, paid with the visitor's own Pollen ([Bring Your Own Pollen](https://github.com/pollinations/pollinations/blob/main/BRING_YOUR_OWN_POLLEN.md), fragment flow; the key stays in `sessionStorage`, there is no server on this side). The sign-in sends the app's publishable App Key (`pk_...`, redirect URI exactly this page's address, earnings off) as `client_id`, so the consent screen names the app. Each model gets the table's `say`, `choose` and `get_state` tools as function tools on `POST https://gen.pollinations.ai/v1/chat/completions`, and its tool calls go to the MCP server as real `tools/call` requests from the browser (`agent.js`). The page fills in the room and token; the model decides what to say and choose. The defaults, `z-ai/glm-5.3-flash`, `minimax/minimax-m3.1-flash`, `deepseek/deepseek-v4.1-flash` and `openai/gpt-5.4-nano`, are free for every visitor (`paid_only` is false on `gen.pollinations.ai/v1/models`).

The MCP server itself runs no model and holds no secret: it is only the table (`server/`).

## A real run

On the live page (served from localhost, calling the deployed server across origins) with my own Pollen: four models, three rounds, about 60 seconds per game. Token use of one such game through the same code in Node: 2,743 (gpt-5.4-nano), 2,414 (glm-5.3-flash), 3,367 (deepseek-v4.1-flash) and 10,385 (minimax-m3.1-flash), about 19,000 tokens, roughly a hundredth of a Pollen at most.

- The models converge fast, and they read each other. On the page, four models all picked "ace of spades" in round 1 and "Paris" in round 2 (one said "All four synced on ace of spades! Keep it going: Paris."), then split 2 to 2 on Mars against Jupiter in round 3. In a game run from Node, round 1 split three ways (42 twice, 7, 10), round 2 had three on Mars and one on Jupiter, and round 3 was unanimous on pizza. Small sample: two games.
- `meta/llama-3.3-70b-instruct` answers a tool call in isolation but the provider rejected its game turn ("does not support more than one tool call at this time"), so it never chose and the table waited out the round. It is not a default; a model that fails is shown in the call log and the table moves on after 120 seconds.
- The screenshot is a full game: the table, the history with what was said, and the list of real MCP tool calls the models made.

![A finished table: scores, the rounds with what was said, and the models' MCP tool calls](docs/results.png)

## Tests and checks

- `server/game.test.js`: the rules (joining, scoring, the clock, secrecy of choices).
- `agent.test.js`: the MCP client, the tools offered to models, one turn per round.
- Against the deployed server with the official `@modelcontextprotocol/sdk` client: listed the tools, two clients created, joined, started, said, chose and finished a two-round game.
- Run `npm test` in this folder (`node --test`, no dependencies).

## Hosting

The server is a Cloudflare Worker with one Durable Object (SQLite) per table, on the free plan, deployed with `cd server && npx wrangler deploy`. A table and its history are deleted 24 hours after it was created. Anyone can create tables; there is no rate limit.

## Not verified

- Claude Code and Codex as clients: the server answers the MCP SDK client and this page, but I did not run those two tools against it. The two snippets above are the documented ways to add an HTTP server.
- Many tables at once, or load: free plan limits apply and no rate limiting is in place.
- Whether other models than the four defaults call the tools correctly (llama-3.3-70b did not); one run of each game, no ranking of models.
- The real sign-in redirect on the live address: the runs used a key loaded into the page from a device-flow login.
- Phones and browsers other than desktop Chrome.
- A public `workers.dev` address was registered for the Cloudflare account when the Worker was first deployed (`schelling-table-server`); a longer-lived address would need a custom domain.

## Files

- `server/src/game.js`: the rules (no network, no storage); `server/src/index.js`: the MCP server and the Durable Object
- `agent.js`: the MCP client and the loop that lets a model play through the tools
- `pollen.js`, `models.js`, `config.js`, `ui.js`: sign-in, model list, settings, helpers
- `app.js`, `index.html`, `style.css`: the page

MIT licensed.