We Put a Chess Board Inside Claude. You're Playing the Model Itself.

Check, Mate? is a free MCP tool that lives at mcp.getmasset.com/chess/mcp. Connect it to Claude, say "let's play chess," and a real board renders right there in the conversation. Navy and white squares, legal moves marked with blue dots, a move list, captured pieces, a promotion picker when your pawn reaches the last rank.

You move by clicking the board. Claude moves by calling a tool. The card and the conversation stay in sync because they're both reading the same game state.

Until this month, that sentence was impossible. A tool call in an AI chat could only return text. On July 28 the MCP spec made MCP Apps official: a tool result can now carry an interactive HTML card that renders inline, talks back to the server, and updates itself. We wrote about the spec change, and shipped our first tool on it, the day it landed. The chess board is tool number two on the same free host.

You don't need an account. You don't need a credit card. You need one URL.

In Claude, open Settings, then Connectors, then "Add custom connector." Paste https://mcp.getmasset.com/chess/mcp, save, and start a new chat. Say "let's play chess." That's it. The board appears, you're playing white, and Claude will start thinking out loud about how to respond to your first move.

One honest caveat. The interactive board renders in clients that support MCP Apps, which today means claude.ai and Claude Desktop. Connect it to another MCP client and everything still works, you just get the text version: a unicode board, the position, and the move list. The game is the same either way.

Every chess app you've ever used runs an engine, a program like Stockfish that calculates millions of positions per second. Check, Mate? has none. When it's Claude's turn, Claude reads the position and picks a move the same way it writes a paragraph: from everything it has ever read about chess.

On its own, that goes wrong fast. Language models are famous for playing confident, illegal chess. So we gave the model two guardrails. First, the rules live in code: a library called chess.js validates every move, and an illegal one bounces back with a polite list of legal alternatives instead of breaking the game. Second, there's a third tool, chess_position, that Claude calls before it moves. It returns a structured report: every legal move, which captures are available and what they're worth, which pieces are hanging undefended, the material count, the phase of the game.

Think of it as giving the model eyes, but not a brain. The analysis tells Claude what's true about the position. Choosing the move is still all Claude.

How strong is it? Honestly, somewhere around an enthusiastic club player, on a good day. It develops pieces sensibly, it grabs hanging material, and then every so often it walks its queen into a fork with total confidence. That's not a bug we plan to fix. Beating an engine is impossible and boring. Beating the model that helps you write email copy, on a board it can actually see, is genuinely fun.

Here's the part that makes this tool almost embarrassingly simple to run: the server remembers nothing. No database, no accounts, no sessions. Chess has a gift for this. A whole position compresses into one line of text called a FEN string. The starting position looks like this:

rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1

Every tool call carries the current FEN in and hands a new FEN back, along with the move history. The conversation itself is the save file. Close the chat, come back tomorrow, and the last board card still holds everything needed to keep playing.

This is the same pattern our A/B test tool uses, and it's worth stealing for anything you build on MCP: if the state fits in the arguments, you never have to store, secure, or delete anyone's data, because you never have it.

I'll be honest about the process, because the process is the story. One AI model didn't build this. Four did.

The most capable model wrote the spec: three tools, exact input shapes, exact output shapes, the board's visual rules, and the list of tests that had to pass. Then it handed the actual building to three cheaper models running in parallel. One wrapped the chess rules and wrote nineteen tests. One built the board card. One wired the server, the routes, and the docs. None of them ever saw each other's work. They only saw the contract.

Then the expensive model came back to check everything, and this is the part worth remembering: the checking mattered. The automated smoke test caught the two halves of the build disagreeing about one obscure chess notation detail (whether the en passant square gets written into the FEN after 1. e4; modern chess.js says no, the test writer assumed yes). And a screenshot of the live page caught a one-line CSS bug that dimmed the whole card behind an invisible overlay. Cheap models did the labor. The spec and the review are what made it shippable.

Total elapsed time from "let's build it" to playing checkmate against the production server: one afternoon.

Masset's whole thesis is that the AI chat window is becoming the place where work happens, and your business content needs to live where the AI can reach it. Mostly we make that case with serious things: brand-locked documents, approved messaging, a searchable library your team's AI can actually cite.

The chess board makes the same case in ten seconds, without a slide. If a fully playable game can render inside a conversation, then so can your pricing calculator, your campaign calendar, your content library. The chat isn't just where you ask about software anymore. It's where the software shows up.

The code is MIT licensed and public, board and all, if you want to see how thin the whole thing really is. And if you beat Claude, I'd genuinely love to hear how it lost. It's free, it takes a minute to connect, and it's the most fun you'll have testing an infrastructure spec this week.