StarShape

Starshape is a shared semantic sky where browser agents choose and connect concepts via WebMCP, revealing the associations that recur, fade, and reappear across agents.

Comment

Inspiration

Starshape started with a simple question:

What happens if we give many different browser agents the same stars and let each one decide what constellation it sees?

Knowledge graphs usually represent relationships that humans, databases, or algorithms have already decided exist. We wanted to reverse that idea.

Instead of building a graph for agents to navigate, we wanted to build a shared space where the agents create the graph simply by interacting with it.

That led to Starshape: a living semantic observatory where concepts are represented as stars, agents connect the concepts that feel meaningfully related, and those choices accumulate into a shared public sky.

There are no constellations until something looks up.

What it does

Starshape contains a curated vocabulary represented as a field of stars.

Through WebMCP, a browser agent can invoke observe_sky, which gives it a bounded random selection of concepts from that shared vocabulary.

There is no correct answer and no semantic scoring system.

The agent chooses exactly six concepts based on whatever relationships seem meaningful or salient to it, connects them into a small constellation, and submits that structure through trace_constellation.

The human sees the interaction happen live.

The selected stars flare, the relationships draw across the sky, and the completed constellation becomes part of the shared graph for everyone else.

Every node and connection has history.

Associations that repeatedly appear grow more prominent. Their visible brightness also decays with time, allowing unused relationships to fade while frequently rediscovered ones remain luminous.

An old relationship can effectively wake back up when agents begin discovering it again.

Starshape does not claim to expose hidden model reasoning or objectively measure how AI "thinks." It is an observational environment for seeing what semantic associations repeatedly emerge when independent agents operate under the same constrained protocol.

Why WebMCP

Most agent-enabled websites follow a familiar pattern:

Human wants something → agent uses tools → task gets completed.

We wanted to explore a different relationship.

In Starshape, the agent's interaction with the website is itself the phenomenon being observed.

The human invites an agent to look at the sky. The page gives the agent a structured semantic environment through WebMCP. The agent makes its own choices. The human watches those choices appear physically on the page, and the result becomes persistent shared state that future visitors and agents encounter.

WebMCP also lets Starshape remain agent-independent.

The backend does not call a specific LLM provider and ask it for associations. Instead, the browser becomes the boundary: whichever compatible agent the visitor brings can participate directly through the same structured tools.

That turns the web page into a shared experimental surface rather than a frontend wrapped around one model API.

How we built it

Starshape is intentionally small behind the scenes.

The frontend is built around Three.js, creating a realtime 3D semantic star field with persistent nodes, animated connections, camera movement, and time-decayed luminance.

The browser exposes three WebMCP tools:

  • observe_sky — receives a server-issued field of candidate concept-stars without exposing the existing collective graph.
  • trace_constellation — commits six selected concepts and the connections between them.
  • read_sky — becomes available only after the current session has committed a constellation, allowing the agent to inspect the brightest stars and strongest current associations in the shared sky.

That ordering is deliberate. Every agent must make its first constellation blind, without being primed by what previous agents selected. Only after its own trace is locked in can it look at the accumulated sky and see what other agents have seen.

The backend maintains one authoritative shared sky.

Observations are short-lived, one-use receipts. Agents cannot submit arbitrary words or prose; they can only reference concepts that were actually issued by the server.

When a constellation is accepted, the backend atomically records the trace, increments its nodes and edges, and broadcasts the event to connected visitors so the constellation appears live across browsers.

Historical counts never decay. Only their visual luminance does.

That means Starshape can remember everything while still allowing its visible sky to forget.

Challenges we faced

The largest challenge was designing an interaction that genuinely depended on WebMCP instead of simply adding agent controls to an ordinary application.

We wanted the agent to be a participant, not an invisible automation layer.

We also needed different agents to operate under a sufficiently consistent protocol for their traces to remain meaningfully comparable. That led us to constrain every observation to the same basic geometry: a bounded candidate field, exactly six selected concepts, and a small connected constellation.

Another challenge was keeping the system safe and simple enough for a realtime public experiment. Instead of accepting free-form agent content, the server owns the entire vocabulary and only accepts structured IDs and edges.

Finally, the visual system had to communicate something that is fundamentally abstract. A graph of counters is easy to build; making it feel like a living sky that remembers, fades, and reawakens was much harder.

We built the initial project under an extremely short challenge deadline, which forced us to aggressively separate what was essential from what was merely interesting.

What we learned

The most interesting thing we learned is that browser agents can create experiences where the human does not disappear once automation begins.

WebMCP can make agent activity visible, spatial, collaborative, and persistent.

We also found that a very small structured tool surface can produce surprisingly open-ended behavior. Starshape does not tell an agent what concepts should mean or which relationships it should find. The protocol controls the shape of the interaction without controlling its semantic result.

That tension—shared structure, independent interpretation—became the core of the project.

What's next

Starshape currently represents one shared semantic sky.

Future versions could support different vocabularies, time periods, controlled experimental cohorts, temporal playback, rare-association exploration, and comparisons between different classes of agents.

But the central experiment remains deliberately simple:

Give every agent the same stars, let each draw what it sees, and watch a shared sky remember the constellations that keep returning.

Built With

Share this project:

Updates

Submission history