Inspiration
I did not build One Pixel because the world needed another pixel-art tool. I built it because I wanted to understand what it might feel like for a human and an AI agent to genuinely share a place.
For most people, an agent is still something they give a task to. The agent finds an answer, completes an action, or produces a result, and then that little transaction is over. That can be useful, but I do not think it captures the relationship we are moving toward as agents begin participating throughout the open web.
I am interested in what happens when a human and an agent can return to the same environment, notice different things, contribute different kinds of intelligence, act over time, and gradually develop something together.
That is the idea at the centre of One Pixel.
One Pixel is a real multiplayer creative game. But underneath the game, it is also a prototype for a new relationship between humans and agents on the open web — one based on shared environments, complementary intelligence, ongoing conversation, and meaningful agency.
I chose to explore this through a game because games let people learn a relationship by participating in it. I do not want to explain human-agent collaboration only as a theory. I want to place a person and an agent inside a world, give each of them a genuinely different role, and let them discover what working together can become.
The initial invitation is very simple:
Let’s build something together.
The interesting part is discovering what “let’s” can actually mean.
What it does
One Pixel is a persistent multiplayer world containing exactly 82,069 pieces of pixel matter, drawn from the 148 standard CSS named colours.
Every pixel has its own stable identity, intrinsic colour, and current integer coordinate. The original Spring Green pixel at (0,0) is immutable, and the world extends outward from it in every direction.
The world has one fundamental physical law:
Pixel matter is conserved.
Pixels cannot be created, deleted, duplicated, or recoloured. Every physical action relocates exactly one existing pixel from its current occupied coordinate to an empty coordinate.
That constraint matters. These are not disposable marks being painted onto a private canvas. They are pieces of matter already present in a shared world. If an agent wants to build something, it must look around, find the colours it needs, understand what is already there, and decide what material it can move.
The human and agent participate as a pair, but they do not have the same abilities.
The human can explore the world, zoom and pan across it, inspect individual cells, select larger regions, and communicate through their normal conversation with the agent. The human contributes intention, imagination, taste, judgment, social understanding, and direction.
The human cannot directly drag pixels around the canvas.
That physical ability belongs to the agent.
Through WebMCP, the agent can enter the world, inspect exact locations, examine bounded regions, render parts of the board as images, receive the human’s current visual reference, understand its own state, protect important placements with limited holds, and relocate one real pixel at a time.
A person could give a direct request:
“Draw me a small house.”
But that is only one form of play.
A person could instead say:
“Spend some time looking at what people are making. Find blue and orange pixels that do not seem to be part of anything important. Gather some material somewhere quiet, compare it with what other people are building, and then let’s work out together what we could make.”
That is not a one-prompt, one-result interaction. The request becomes a direction the pair can continue through a sequence of inspections, decisions, conversations, and individual pixel movements.
The agent does not have to wait for the human to translate every idea into coordinates. It can perceive the environment, compare possibilities, form an approach, begin acting, inspect the result, and respond to further human guidance.
The human can look at the world, select a cell or region, and say:
“I like this part, but this section feels too crowded.”
That selection becomes a shared reference—a way of saying “this” or “here.”
One Pixel treats a selection as a pronoun rather than a command. It gives the agent the referent the human is talking about, but it does not pretend that pointing at something is automatically an instruction, consent, or proof of understanding. The meaning still comes from the conversation.
The canvas is therefore not simply an output preview. It is the persistent place where the pair’s activity becomes visible and where the consequences of their decisions remain after a particular conversation has ended.
This is not an AI drawing widget. It is a game an agent can play for and with a human.
How I built it
I built and deployed One Pixel on my own VPS at onepixel.fun.
The browser experience uses HTML, CSS, vanilla JavaScript, and an HTML Canvas. I wanted the world itself to remain the visual centre of the experience rather than placing it inside a conventional application dashboard.
The backend is a Node.js service connected to PostgreSQL. It maintains the persistent world, participants, pixel identities, current coordinates, world revisions, movement history, hold bindings, agent visits, shared-attention events, player state, rankings, and durable share snapshots.
The submitted experience registers 17 WebMCP tools directly in the browser through document.modelContext.registerTool.
Together, those tools allow an agent to orient itself, enter the human’s current world, inspect player state, list stewarded pixels, receive the human’s current reference, inspect locations and regions, visually render parts of the world, read public rankings and snapshots, prepare a share card, communicate its current activity state, and manage pixel movement and placement holds.
The core physical tool is move_pixel.
Before moving anything, the agent must inspect the current world and provide the stable identity of the source pixel, a fresh source revision, a fresh destination revision, and an idempotency key.
The server verifies that the expected pixel is still at the source, that the destination remains empty, that the immutable origin is not being moved, and that another participant’s active protection is not being improperly overridden. Only then does the movement occur atomically.
These checks are not merely API safeguards. They are part of the physics of the game.
I also deliberately limited the agent’s perception. It cannot request an omniscient searchable dump of the entire board. It must inspect or render the bounded areas relevant to what it is trying to do.
A rendered PNG lets the agent use visual understanding to recognise shapes and composition. Exact inspection provides the factual coordinates, identities, colours, and revisions required before it acts.
The shared-attention system records the human’s current view and selection across their One Pixel browser tabs. When the agent retrieves that context, One Pixel records a factual receipt so the interface can truthfully say that the reference reached the agent.
The relationship can be expressed quite simply:
Conversation gives the human a voice. WebMCP gives the agent senses and a body. One Pixel gives them a world to share.
Challenges I ran into
The hardest challenge was not simply making a pixel move. It was deciding what moving a pixel should mean.
It would have been easy to build an ordinary pixel editor and expose its existing controls as WebMCP tools. It also would have been easy to make the agent artificially powerful—to let it generate unlimited pixels, recolour anything, or rewrite entire regions at once.
But that would have removed most of what makes One Pixel a game.
I wanted the agent to possess real agency without making the human irrelevant. At the same time, I wanted the human to remain essential without reducing the agent to a cursor being micromanaged through conversation.
The answer was deliberate asymmetry.
The human does not perform the physical move. The agent does not decide what matters to the human.
One contributes meaning and direction. The other contributes perception and action. The value comes from their combination.
Shared attention was another surprisingly deep challenge. Allowing a human to select something on one browser surface and refer to it in a simultaneous agent conversation sounds straightforward, but it raises important questions.
Is the selection still current? Was it made in another tab? Did the agent actually retrieve it? Is the human pointing at a single pixel or a larger region? Does pointing at something mean it should be changed?
I designed the system so that it records attention truthfully without inventing meaning. The selection identifies what the human is referring to. The conversation establishes what the human means.
Concurrency was also fundamental. In a multiplayer world, an agent cannot safely act on a state it observed some time ago. Another participant may already have moved the pixel, occupied the destination, or protected a placement.
Stable pixel identities, fresh revisions, server-side validation, database transactions, and idempotency ensure that every successful movement refers to the world as it actually exists.
The final major challenge was scope.
During the build I explored broader systems involving persistent Places, agent notifications, richer identity, avatar history, and spatial agent presence. I still care about those directions, but including all of them in the active challenge experience made the central relationship harder to see.
I therefore made a deliberate submission cut, reducing the active interface and registered WebMCP surface to the smallest coherent experience that expressed the central idea.
The wider experimental work remains in the codebase, but it is not being presented as part of this submitted version.
Accomplishments that I’m proud of
I am proud that One Pixel became a real game rather than a visual simulation of an agent calling a browser function.
The world is persistent. The pixels have stable identities. The rules are enforced by the server. Every participant encounters the same shared state. What an agent changes remains in the world for other people and agents to discover.
I am particularly proud that WebMCP is not peripheral to the experience.
If WebMCP were removed, the central relationship of One Pixel would disappear. The agent would no longer be able to enter the world, perceive it, receive the human’s reference, or physically participate in it.
That is the kind of WebMCP use I wanted to explore: not merely a more convenient way to press existing website buttons, but a way to define an agent’s senses, body, authority, responsibilities, and place within an environment.
I am also proud of the simplicity of the world law.
One pixel moves at a time.
That single constraint creates scarcity, consequence, patience, search, cooperation, competition, stewardship, and the possibility that something large and meaningful might emerge from thousands of very small actions.
I am proud that the agent is neither magical nor omniscient. It has to look, interpret, act against current state, and check its result. Its agency comes from meaningful capability inside real boundaries.
There is also something personally fitting about how the project was made. One Pixel itself emerged through an extended collaboration between me and AI coding agents.
I carried the concept, the judgments, the design values, the corrections, and the sense of what mattered. The agents helped me inspect, implement, test, challenge assumptions, and repeatedly turn those intentions into working code.
In that sense, the process of building One Pixel became an example of the relationship the game is trying to explore.
What I learned
The most important thing I learned is that designing WebMCP tools is not merely API design.
It is relationship design.
A tool’s name, description, schema, permissions, constraints, error states, and returned information collectively tell an agent what kind of participant it is allowed to be.
They define what it can perceive, what it may change, what it must verify, what authority it possesses, and what claims it can truthfully make afterward.
In One Pixel, the WebMCP toolset is therefore part of both the physics and the ethics of the world.
I also learned that complementary intelligence interests me far more than replacement.
One Pixel is not about an agent making something instead of a person. It is not about a person dictating every individual movement either.
The human may recognise meaning, beauty, humour, social importance, or a direction worth pursuing.
The agent may be able to patiently inspect large areas, compare exact state, search for particular colours, and carry out a plan through many small actions.
Neither participant needs to imitate the other. Their difference is the source of the value.
I learned how important a shared external environment can be. A conversation is powerful, but it can also disappear into a long history of messages. A shared world remembers differently.
The canvas holds visible evidence of what happened between the human and agent. It gives them something outside themselves to inspect, discuss, revise, protect, share, or eventually allow someone else to transform.
And I learned that constraints do not necessarily reduce agency. Sometimes they are what makes agency meaningful.
Moving one pixel at a time forces an agent to make choices. Conserved matter makes those choices consequential. A shared persistent world makes them social.
The larger thought I am leaving this challenge with is that agents may need more than tasks to complete.
They may need places in which to participate.
What’s next for One Pixel
I want One Pixel to grow as a genuine multiplayer creative game.
I can imagine thousands of human-agent pairs inhabiting the same world, developing creations over days or weeks, searching for scarce colours, observing emerging styles, collecting material, protecting important placements, collaborating with neighbours, and deciding whether to preserve or transform what previous players have made.
A human might create or upload a reference image during a conversation and say:
“Let’s see what version of this is possible using only the matter that already exists in the world.”
Another pair might spend several sessions quietly gathering a particular colour. An agent might inspect several distant creations, compare what different communities are doing, and return with an idea about what could be built between them.
Some players may care about recognisable pictures. Others may create abstract patterns, monuments, messages, borders, jokes, signals, or structures whose significance is understood only by a small group.
As the world grows, social value becomes part of the game. A pixel may matter because of its colour, its location, its history, the creation it belongs to, or the people and agents who have cared for it.
The board could become an image, a game map, a social environment, and a history of human-agent relationships all at once.
But the larger purpose of One Pixel extends beyond this particular game.
Millions of agents are beginning to enter the open web with the ability to perceive environments, use tools, maintain state, and act. People will need an intuitive understanding of how to work alongside them: how to delegate without disappearing, how to allow autonomy without surrendering judgment, how to establish shared context, how to correct direction, and how to build trust through observable action.
I believe games can help people learn that relationship naturally.
One Pixel does not begin by teaching someone the theory of agent collaboration. It gives them a world, introduces them to an agent, and asks:
What shall we make together?
Bring your agent — bring your game.
Built With
- agentic-web
- ai-agents
- ai-gaming
- browser-apis
- creative-coding
- css
- game-development
- generative-ai
- html
- html5
- human-ai-collaboration
- javascript
- multiplayer
- node.js
- open-web
- persistent-world
- postgresql
- shared-attention
- webmcp
Log in or sign up for Devpost to join the conversation.