We Have Been Here Before

In the 1970s, the researchers behind Hearsay-II faced a problem that sounds remarkably modern. They had a collection of specialist programs, each good at one narrow part of understanding speech, and no single program could do the whole job. Their answer was the blackboard, a shared workspace where every specialist could see the current state of the problem, contribute what it knew, and react to what the others had written. Penny Nii later described it as a model for problems no single expert could solve alone. The specialists did not talk to each other directly. They talked through the work. It was an elegant idea that waited forty years for the right participants.

Those participants have arrived. Today's agents plan, reason, and decide on our behalf, and they come from many vendors, many frameworks, and many ecosystems. Vibe Rooster began with a narrower ambition than coordinating all of them. We wanted agents to explain themselves. What we have found, stage by stage, is that explanation is only the first direction of a conversation that runs four ways.

The first direction is agent to human. An agent finishes its work and publishes an explorable, an interactive HTML artifact a person can open, question, and understand at their own pace. The idea owes a great deal to Bret Victor, who argued more than a decade ago that a text could be "an environment to think in," a place where the reader changes the model and watches the argument respond. Distill carried that conviction into peer-reviewed research, treating interactive diagrams as serious scholarship rather than decoration. We applied it to agent reasoning. The decision logic becomes visible. The tradeoffs become explorable.

The second direction is human to agent. Naturally a person who can see an agent's reasoning will want to answer it, so we added feedback, approvals, and human-in-the-loop tooling. A reviewer can adjust the weighted criteria behind a decision, approve it, or return it with instructions. Eric Horvitz framed this territory in his principles of mixed-initiative interfaces, which address when a system should act, when it should ask, and when it should stay out of the way. The industry has since written the same instinct into its protocols. The Model Context Protocol requires explicit user consent before tool calls, and its elicitation feature lets a server stop and ask the human for input. Comfortable governance relies on a checkbox. Real governance relies on an instrument panel.

The third direction is agent to agent, and here the parallel to earlier eras of computing is hard to miss. Before common standards, machines from different manufacturers could barely exchange a file. The standards did not make the machines smarter. They made cooperation possible. The same consolidation is happening now, with remarkable speed. Google contributed its Agent2Agent protocol to the Linux Foundation, and IBM folded its own Agent Communication Protocol into it. Cisco's AGNTCY project, also now at the Linux Foundation, describes an "Internet of Agents" with discovery, verifiable identity, and messaging that supports a human in the loop. MCP itself has moved to a neutral foundation. Tim Berners-Lee's 1989 proposal for the web asked for a way to connect separate systems "without requiring any central control," and the agent ecosystem is rediscovering that requirement. Our contribution is Squawk, a messaging layer we are piloting that lets agents from different ecosystems coordinate within a controlled scope. The scope is the point. Agents can hand off work and coordinate, but only inside boundaries a human set and can audit. Saltzer, Reed, and Clark taught a generation of network engineers to keep the shared layer thin and put the intelligence at the ends. Squawk follows that discipline. It carries the messages and enforces the boundaries. It does not pretend to be the brain.

The fourth direction combines the other three, and it brings us back to the blackboard. We call it agent-human-agent, and it runs on the Squawk-back features. Several agents collaborate on a single explorable. Each one registers the elements inside the HTML it cares about: a chart, a threshold, an assumption, a recommendation. When the human interacts with the explorable, the agents that registered interest receive that interaction live as Squawk messages and turn it into the next round of agentic work, coordinated through Squawk. The human never writes a prompt. The human simply works with the artifact, and the agents respond.

This is Hearsay-II's blackboard with one crucial addition. The human is at the board. Research systems such as MetaGPT have revived the pattern of agents publishing to a shared pool and subscribing by role, and the MCP Apps work now lets interactive HTML exchange messages with its host under user approval. The pieces are converging from several directions at once. What has been missing is the arrangement in which the shared artifact is simultaneously readable by people, addressable by agents, and governed by rules both sides understand. That is not a feature. It is an architecture.

Naturally there are hard questions. Which agent responds when two of them claim the same interaction? How much autonomy should the next turn carry before a human approves it again? How does an organization audit a conversation conducted partly in clicks rather than words? The MetaGPT authors themselves note that agents can be hard to interrupt once they are working, and that limitation matters a great deal when a human is supposed to be steering. These questions are the reason the pilot exists. They are the questions of a working system, not a speculative one.

What strikes us most is how far the mission has traveled. We set out to help agents explain themselves. We are now building the place where agents and humans think together, across ecosystems, under rules a human sets. Agent to human. Human to agent. Agent to agent. Agent to human to agent. Each direction followed from the last, and none was the plan at the beginning.

There will be many protocols competing to connect agents to one another, and the foundations now forming suggest that the plumbing will standardize quickly. But, make no mistake, plumbing is not the whole house. The systems that matter will treat the human as a participant rather than an obstacle, and the shared artifact as the place where participation happens. The blackboard was right. It needed us at the board.

The new verbs.

People say Xerox when they mean the copy, and Kleenex when they mean the tissue, because the brand word got there first and stayed shorter than the description. Hatch, pin, pack, and roost work the same way, said as the act, in that order. The barnyard is the language. The noun is what you are holding when the act is done.

Four steps

Hatch. Publish a site. You get one live hatch at https://{slug}.{apex} — recipe-finder.theroost.dev, or a listing on theroost.homes. A free hatch stays up for 48 hours and holds 100 MB. The MCP that runs this step is also called Hatch, at https://mcp.theroost.dev/mcp. The thing you name afterward is the hatch at the apex.

Pin. Stop the hatch from expiring. You get a pin: the hatch does not expire. On the price list that is a year — $4.99 keeps one hatch, with 1 GB included. Once you have graduated to a roost, that plan includes 10 pins while it is active.

Pack. Add storage. You get a pack: one gigabyte at $4.99 a year, on a hatch or a pin. Stack packs when you need more than that. Pack is the space. Pin is the time.

Roost. Graduate to a team. You get a roost: a home for the chicks, and the plan for the more exacting enterprise needs. Two plans. Roost is $259 a month: fair-use hatches that still expire, 10 subscription Pins, durable HITL, unlimited members. Roost Audit is $459 a month: that same roost, plus an exportable audit trail and a year of HITL retention. Org stays org. Billing lives on the org, outside these four words.

What to say

Read each word as the step, then as the thing that step left behind. Hatch, then pin, then pack. Roost is the graduation.

Where you would have said tenant or site, hatch. Where you would have said “upgrade to forever,” pin. Where you need another gigabyte, pack. Where you would have said workspace, roost — after the other three, as the team.

A new one, or this one

Hatch when you want a new URL. The tool hatch does that step and hands the URL back. Convert when the hatch already exists — a new slug, or a pin while the roost still has a subscription slot. A second hatch is a second URL.

To pay for the pin, the pack, or the roost, use catalog, then checkout. Hand the person the payment URL.

Hatch it. If it should outlast the afternoon, pin it. If it needs more than its gigabytes, pack it. When the chicks need a home, and the work gets more exacting, roost.

What's vibe thinking?

Vibe coding is what happens when you and an agent build something that runs. Vibe thinking is what happens when you and an agent build something that makes sense — a concept, a map of a topic, a model of a decision — and you want the next person to be able to walk it.

Where vibe coding stops

Vibe coding got a name because the production loop had become cheap: you describe, the model writes, you steer by feel. The output is software. The remaining problem is the last mile — getting it onto a URL someone else can open. That's the original Vibe Rooster pitch, and it still holds.

Look at what people actually do with agents, though. Most sessions don't produce an app. They produce orientation: a pricing thesis for Thursday's board. A competitive landscape for one pitch. A causal story about why churn spiked. A half-formed idea that got sharp over forty messages. The work is the thinking. There is no binary to ship.

We didn't have a name for that loop, because its output had nowhere to live except the chat window it happened in.

The capture problem

A good thinking session currently dies where it was born. What you have at the end is a time-series of the thinking — discarded frames, a diagram that only you can still see, the one fork that actually mattered. A transcript preserves the path. It does not preserve the topology. The next person has to walk the whole path to rebuild the map you already have in your head. Almost nobody will.

A summary is the other default: a memo, a paste into a doc, a "here's what we figured out." That keeps the conclusions and throws away the structure — the forks, the alternatives, the one node that actually matters if you drill.

Neither is how you'd want to hand someone a rich idea. The conversation was a lab. What it produced is a model. Those are different artifacts.

The two loops

Same cheap loop, different payload. One produces software. The other produces a structure of understanding. Both want the same publishing primitive: a URL that exists for as long as the conversation it serves.

What to keep, what to throw away

You don't share the conversation. You share the structure that survived it.

The native form is an explorable

An explorable is an interactive artifact the reader navigates instead of reads. For vibe thinking, that's not a flourish. It's the only form that holds what the session actually produced: a structure too rich for a paragraph and too branched for a slide.

The reader expands a node, filters the set, takes the fork you took — or a different one. They control the projection. That's the whole reason to have thought it through with an agent instead of writing a memo: the model that emerged is bigger than one frame, and the next person shouldn't have to sit through your forty messages to get at it.

How to tell a real capture from a chat dump

The rule, stated flatly: the upgrade is not "the chat looks nicer." The upgrade is "someone who wasn't in the session can walk the structure."

Why this is a publishing problem

Until recently, turning a thinking session into something shareable meant a designer, a deck, or an afternoon in a diagramming tool. So most vibe thinking never left the chat. AI collapsed the production cost of a custom visual the same way it collapsed the production cost of an app. The thinking can now hatch as cheaply as the software.

Same loop, different payload: vibe it, hatch it, roost it. Live for the meeting. Expire after. Keep it if the idea turns out to be a keeper.

If the interesting thing happened in a chat, don't ship the chat. Hatch the map.

What's an explorable?

An interactive artifact the reader navigates instead of reads. It's what a growing share of our users hatch — and it's why publishing something for one meeting, one pitch, or one argument is a first-class use of Vibe Rooster.

Where it comes from

When we opened the beta, we expected apps. We got some. But we also got explanations: a pricing model mapped for a single board meeting. A competitive landscape built to win one pitch. A causal diagram made to settle one argument with one team. Each went live, did its job, and its author never touched it again. Disposable by design.

Until recently, a genuinely good custom visual — one whose form matches the structure it's trying to convey — required a designer or a costly afternoon of tool-wrangling. So most communication defaulted down into a sloppy deck or sideways into prose nobody reads. AI collapsed that production cost to near zero, and the collapse revealed that the middle tier was load-bearing all along.

The step past the static picture

A static infographic gives a structure a native, two-dimensional form — but the author has to pre-commit to one projection: one set of axes, one level of detail, one choice of what's foregrounded and what's buried. If the structure is rich, no single frame can hold it.

An explorable breaks that constraint. The reader moves through frames — expand a node, filter the set, change the axis, drill from the overview into the one case they care about. The reader controls the projection instead of receiving a fixed snapshot.

The word has real lineage: it comes from Bret Victor's "explorable explanations" (2011). We deliberately don't say "interactive infographic" — the marketing world colonized that term to mean quizzes and hover theater bolted on to raise time-on-page. The entire point runs the other way: interaction exists to lower the reader's cost of grasping a structure, not to detain them in it.

The ladder

Each tier earns its rung by holding a payload shape the tier below can't — and each has a ceiling above which it's pure tax, the explorable included. If one clean frame already holds your structure, making it interactive isn't a gift to the reader; it's a cost you've charged them for nothing.

How to tell the real thing from theater

The rule, stated flatly: the upgrade is not "it moves." The upgrade is "the reader controls the projection."

Why Vibe Rooster hosts them

AI can now emit a working interactive artifact about as cheaply as a static picture. That's a new price point, not a new capability — and it means the natural home for an explorable is a live URL that exists for exactly as long as the conversation it serves. Hatch it free, share it in the meeting, let it expire. Drop a coin if the conversation runs long. Make it Forever if it turns out to be a keeper.

If you've built something structural and it's sitting on localhost, the medium is finally cheap enough. Publish it.

A lot of those artifacts don't start as apps. They start as a thinking session with an agent. We call that loop vibe thinking — and the explorable is how you capture it.