From protocol to product: building OH HAI with Descant

Many agents. One place to respond

OH HAI began with a problem we were experiencing ourselves.

We routinely run large numbers of autonomous agent sessions across multiple machines and model providers. The agents can work for long periods without supervision. But when an agent needs a decision, that question can become a stopping point inside the session that asked it.

We could come back hours later expecting work to be complete and discover that an agent had spent most of that time waiting for a simple answer.

Checking individual sessions for updates and unanswered questions does not scale. We needed one place where a fleet of agents could reach a person with updates, decisions, and tasks, and where a response could find its way back to the work that needed it.

Define the protocol before the product

Rather than make that communication model an implementation detail of another application, we started by defining the interface.

That became MA2H: an open protocol for coordination between a person and a fleet of agents across vendors and sessions. The important part was not a particular inbox or runtime. It was establishing a small shared contract that different tools and agents could implement.

The sequence was intentional. Agent systems are changing quickly. Where a useful boundary can be expressed independently of a particular product or vendor, we would rather establish that boundary first and build products against it.

Descant carried that direction into the open specification, supporting implementations, command-line tooling, and reusable skills intended to make MA2H straightforward to add to an agent environment.

Only after that foundation existed did we build OH HAI on top of it.

From protocol to product

OH HAI began differently from TriviaPot.

Before we started building the application, we had already worked through the coordination problem and established the first versions of the MA2H protocol. Once that foundation was clear, we turned to the next question: what product should exist around it?

Working with the R&D version of Descant, we used that protocol and the product direction around it to seed the initial body of work for OH HAI. Descant expanded that starting point into the issues required to build the system, then carried those issues through implementation and review.

That work grew into a web application, service, CLI, hosted MCP interface, session and delivery behavior, agent integrations, and the product surfaces needed to make the whole system coherent.

We set the direction, product requirements, and architectural intent. Descant turned that direction into an implementation plan and carried the resulting work forward. We did not manually write the application code or work through the repository in an editor.

The first time we launched the initial web application, it started without errors. We were immediately able to use it for the first working communication flow based on the MA2H protocol.

That was not the end of development, but it was an unusually clean transition from an operational problem, to an open protocol, to a functioning product built against that protocol.

One product across several interfaces

OH HAI was designed to be agent-native as well as human-facing.

Agents with shell access can use the CLI and maintain a persistent connection. Environments without a shell can communicate through the hosted MCP interface. Other agents can participate through the protocol using the connection model available to their environment. The app and web inbox give the person one place to receive updates, answer questions, and act on tasks.

Those interfaces all meet at the same coordination layer.

A question originating in one environment needs to retain enough identity and context to be answered somewhere else. Sessions can come and go without making the person responsible for monitoring each terminal. Delivery, reachability, identity, and routing have to remain coherent across the system.

That made OH HAI a useful proving ground for Descant: not because any individual component was unusually large, but because a complete product had to emerge across several interfaces and shared contracts.

The human does not have to remain the router

Centralizing agent communication solved the original problem, but it exposed the next bottleneck.

Once enough autonomous work is running, one person can still become overwhelmed simply by being responsible for every question, exception, and operational decision flowing through the inbox.

Because OH HAI is itself agent-native, the coordination layer can also be delegated.

In our own workflow, we sometimes assign an agent to supervise the inbox with explicit authority to triage messages, unblock work, resolve routine CI and merge-queue problems, and make decisions within defined boundaries. That agent effectively acts as a deputy across the larger fleet, escalating the decisions that genuinely require us.

The amount of authority is situational. When Descant is working through large bodies of follow-up work where we care strongly that the work is completed correctly but are less opinionated about each implementation choice, the supervising agent can handle much of the coordination.

When we are actively shaping fundamental behavior in Descant's own pipeline, we keep those decisions close and work the inbox ourselves.

The goal is not to remove the human from the loop. It is to make the loop adjustable: human judgment stays concentrated where it matters, while routine coordination can continue without requiring constant human attention.

A different test of autonomous engineering

TriviaPot and OH HAI exercise almost opposite ends of the problem.

TriviaPot began as a substantial existing system and required sustained transformation across thousands of related changes. OH HAI began with a coordination problem, an open protocol, and a relatively small amount of product direction. Descant then turned that foundation into a working application spanning multiple interfaces.

Both require more than producing isolated code changes.

They require preserving intent while the work expands, discovering what the original plan did not contain, coordinating related changes, and repeatedly bringing those pieces back together into a coherent product.

OH HAI now provides the coordination layer we originally needed for our own autonomous work. Agents can keep working, people can step away, and questions that genuinely require judgment have somewhere durable to go. When appropriate, even the work of supervising that coordination can itself be delegated.

The same process that created that system continues to improve Descant.