Agents can't draw. They can write programs.

Ask an image model for a 32×32 sprite and you get something 31 pixels wide with anti-aliased edges and colors that drifted off your palette. Ask for four walk-cycle frames of the same character and you get four different characters. This is not a prompting problem — a diffusion model has no representation of a grid.

A program does. PixelCraft is a small language where canvas 32x32 means exactly 32×32, colors come only from the declared palette, and an eight-frame loop has exactly eight frames that line up. Correctness comes from compilation, not from luck.

So the interesting question is not “can an agent make pixel art” but what should each side of the collaboration do.

Who it is for

PixelPlace is for indie game makers, pixel artists, and small creative teams who want an agent to accelerate exploration without giving up a precise grid or an editable source. Natural-language direction is the default. Hand-editing is an optional second instrument, not homework you must finish before you can create.

The division of labour

WebMCP tool results have to be JSON — a tool cannot return an image. That constraint turns out to describe the right design rather than block it.

The agent owns structure

Grammar, palette compliance, frame counts, coverage, silhouette. All of it is checkable in text, and all of it is what the agent is good at. check_program compiles a draft and hands back error codes with line numbers, the palette the program declares, the colors it actually paints — those differ the moment someone slips in a raw hex literal — and how much of the canvas it filled.

The person owns taste

Whether it looks good, and whether it is a drawing of the thing that was asked for. We learned this one the hard way: an earlier version of this project generated a sprite that compiled cleanly, matched its palette perfectly, and was a solid blue rectangle. Structural correctness does not imply “is a slime”.

So the agent never pretends to see. describe_canvas gives it a coarse text map — one character per region, dominant color, . for transparent — which is enough to tell whether a shape landed where it meant or whether the subject is off-centre, and honest about being nothing more than that:

....444.......
....2222......
....2220......
...00330......
...00330......
...11..11.....

That is a character with hair, a face, a torso with an armour stripe, and two legs. An agent can reason about it. It still cannot tell you if the art is any good — which is exactly what the person watching the canvas is for.

A normal session

1. Tell the agent what to make, or ask it to remix a finished example.
2. It compile-checks the PixelCraft program before applying it to the canvas.
3. You judge the visible result and describe a revision in ordinary language.
4. Undo a revision at any time—or change one line yourself and ask the agent to continue.
5. Export a still, loop, sprite sheet, or source file you can safely reopen later.

That last step is genuine co-editing: get_program reads the current Studio source, including your hand edits, so neither collaborator owns a separate stale copy. The visible history makes both human and agent changes reversible.

What runs where

Everything runs in your browser. The lexer, parser, compiler, interpreter and renderer are all client-side; the tools call straight into them. No API key, no account, no quota, and no server ever sees what you draw. The page works as an ordinary pixel editor with no agent attached.

Exports are local too — PNG and sprite-sheet PNG through the browser's own encoder, GIF through a pure-JS encoder, and .pc source, which the Studio validates before reopening. Because the program is the document, a drawing is a string: small enough to paste in chat, diff in git, or hand back to an agent to edit.

The tools

An agent arriving on the gallery first sees open_pixelplace_studio, an explicit doorway into the stateful workspace. Once the Studio opens, its focused editing toolset replaces that landing-page tool:

• get_pixelcraft_guide — the language, generated from the compiler's own docs so it cannot drift
• check_program — compile a draft without touching the canvas; the cheap refine loop
• set_program — put it on the canvas, rejected unless it compiles
• get_program — read what is there now, including hand edits
• describe_canvas — the text map above
• set_frame — pause an animation on one moment
• list_examples / load_example — 58 finished programs to study or remix
• export_artwork — save a PNG, GIF, exact sprite sheet, or the source

Try it

Open the Studio in ChatGPT's in-app browser, or in Chrome with chrome://flags/#enable-webmcp-testing enabled, and ask your agent for a walk cycle. Then change a colour by hand and ask it to keep going — it reads the change through get_program and works from where you left it.

Open the Studio Read the human guide