A protocol became our everyday agent inbox

Autonomous agents stop when they need a decision or a person to do something. We wrote MA2H, an open protocol for reaching that person, then gave Descant’s research prototype the specification and our product direction. It built OH HAI: a hub, web inbox, native app, command line and hosted tools—the product we now use to coordinate our own agents.

  • 573 pull requests merged

    The repository records implementation, documentation, releases and maintenance behind the inbox we now use every day.

  • 5 product surfaces work together

    The Hub, web inbox, native app, command line and hosted tools carry requests and answers across the same protocol.

  • 410 of 573 merged PRs changed tests

    Verification changed alongside the product, including regression checks for failure recovery and message handling.

  • Sept 21 iPhone release in 2026

    The native inbox reached a public release, alongside the live web product and published command line.

Start with a contract

MA2H defined how an agent sends a notification, asks for a decision or hands a task to a person—and how the answer reaches the right recipient. OH HAI turned that contract into a durable Hub and clients that agree on the same message behavior.

Plan the order of work

The native-app plan named ten child issues. A shared contract came first, followed by the app foundation, onboarding, live transport, inbox and resolution screens. Server-side push could proceed in parallel, while a browser-driven end-to-end path made the client verifiable before store distribution.

Issuegraph represents the dependencies and priorities in issue frontmatter, giving Descant an explicit order for the work and identifying what can proceed in parallel. The specification and its tools are another product of this development process.

Ship usable surfaces

The product now has a live web inbox and hosted tools, a published command line, and an iPhone app released on September 21. Public release records were checked separately from the source history: the current app is version 1.1.0, the command line 0.14.0 and the tool-server package 0.3.1.

The recorded work

OH HAI’s full repository history contains 573 merged pull requests and 615 tracked issues. Of those issues, 490 closed as completed, 20 closed as not planned and 105 remain open. The record includes implementation, documentation, releases and ongoing maintenance.

  • 2,344 review comments on merged work

    The examples connect review to fixes for hung requests, malformed responses and tests that could pass without exercising a failure.

  • 282 merged PRs drew inline review

    Nearly half the merged changes have recorded findings, preserving the concerns raised about the implementation.

  • 525 test source files

    Tests span the native app, web inbox, Hub, command line, shared packages and release tooling.

  • 182 prototype PRs merged

    Retained workflow sessions connect these changes directly to the prototype. The full repository covers a broader set of work.

Repository, retained-session and public-release snapshot · November 1, 2026

A product built across hundreds of changes

Cumulative repository activity from June through November 1, 2026: 614 PRs opened and 573 merged.
The full repository history, including releases and maintenance. At the snapshot, 29 PRs had closed without merging and 12 remained open. These counts describe changes in the repository, not the number of agents running at once.

The backlog changed as the product grew

Daily open issues, reconstructed from creation, closure and reopen events through 2026-10-29; 105 remain open.
Every recorded close and reopen is included. This daily view ends with 105 open issues. A closed issue is counted separately from a completed deliverable: 20 were closed as no longer planned.

Verification across the product

525 test source files: native app 155, Hub service 125, web inbox 103, command line 89, shared packages 28, agent scripts 11, end-to-end 9, distribution and infrastructure 5.
410 of the 573 merged PRs changed a named test source file. The current inventory spans the product’s surfaces; it counts source files, not individual test cases or successful test runs.

What changed in the software

An inbox that recovers from a hung request

A server could accept a connection and never answer. The native polling loop would stop scheduling work, leaving an inbox that looked connected but no longer updated.

Review led to a follow-up that added bounded waits and recovery across both clients: requests, polling, sign-in checks and stream connection. The open stream itself remained long-lived.

The original review, follow-up issue, merged change and tests for timeout, retry and cancellation are retained.

A green test had to prove the failure happened

Local tests and automated checks used different browser-storage implementations. A spy could silently attach to the wrong object, so an error-handling test passed even when no error occurred.

The fix gave every environment the same storage implementation, corrected the spies and added a test for that invariant. The failure and its wider lesson became a durable learning.

The merged change records the reproduction and verification. Historical suite results are reported results, not a fresh run for this study.

Four symptoms led to one boundary fix

Repeated review findings showed that clients trusted the shape of successful responses. Missing fields could crash a list or lose the one-time secret returned by a credential request.

Both client APIs began requiring a response shape at the boundary. Existing local checks were folded into that boundary, while an unreadable response still preserved the possibility that a write had committed.

The issue explicitly traces four earlier findings to the shared cause; the merged change includes regression and mutation checks.

A token handoff became a simpler flow

A new agent’s token was handed from one screen to another. Seven review rounds found ten problems around mounting, retrying, focus and concurrent creation.

The design changed to mint and reveal the token on the same screen. One recipient for the held secret removed the coordination code that the handoff had needed.

The review ledger preserves the rejected design and final change. Two broader follow-up issues remain open in this snapshot.

The performance check was tested too

The first check could report success while hiding recurring stalls, missing its calibration or losing the graphics context entirely. Broken rendering could appear faster.

Review drove new checks for those failure modes and a revised measurement. The author reproduced the failures and re-established the regression evidence after changing the statistic.

The merged record includes constructed counterexamples, self-checks and the measurement’s stated limits.

A fix generated its own follow-up work

Handling malformed messages safely in one view exposed the same crash pattern in two other interfaces. Keeping the current change small still left work to do.

The implementation session filed separate native and web follow-ups. Both later merged. Its tests also applied a prior review lesson: pair broken input with a valid example so an absence assertion cannot pass by doing nothing.

Retained review output, the merged tests, successful issue-creation results and both follow-up merges establish the chain.

Lessons were recorded, corrected and applied

The repository contains 13 durable learning documents, covering live-list pagination, packaging, background notifications, ownership invariants and tests that can pass without exercising their intended failure. Four later modifications updated three of those documents.

The retained archive records 103 successful reads of these 13 documents across 16 sessions, each matched to a non-error result. Those are recorded retrievals. The application example below is established separately by a review report and the merged tests.

When a packaging workaround was replaced, the earlier learning was marked as superseded and linked to the new approach. Its still-relevant explanation of the underlying trap was preserved, so the next change would inherit the reason without following obsolete instructions.

One retained review explicitly names an earlier lesson about vacuous assertions. The later merged tests pair malformed input with a valid control, and the session’s two follow-up fixes also merged. That is a concrete example of a prior lesson shaping subsequent work; a document count alone would not establish it.

  • 13 lessons recorded for later work

    The documents preserve causes and corrections, including packaging traps and tests that can pass for the wrong reason.

  • 4 later updates to those lessons

    Three documents changed as the implementation evolved; a superseded workaround now points to its replacement.

  • 103 successful reads of prior lessons

    Sixteen retained sessions retrieved the documents. A review report and merged tests separately show a lesson being applied.

Sources and method

OH HAI was developed with Descant’s research prototype. Across 379 retained sessions from two machines, exact repository and PR records connect 182 merged PRs to sessions that invoked that workflow. This is a verified subset of the product’s history; the full repository totals cover a broader set of work.

OH HAI’s implementation repository and session records are private. The owner retains the complete source census, review discussions and extraction hashes for audit. The downloads below contain aggregate history, counting rules and sanitized examples; the running product and public releases can be inspected directly.

Counting rules and coverage
  • Repository figures are a complete census. Prototype attribution uses the narrower retained-session cohort described above.
  • Test sources match .test or .spec filenames with JavaScript or TypeScript extensions. The 410 PRs were measured by comparing each merge commit with its first parent. File counts are not test-case counts or a pass rate.
  • Review totals count automated inline comment records on merged PRs. Repeated reports are retained; replies, resolved-thread flags and outdated lines do not establish a fix. Formal review state is not treated as approval.
  • The daily backlog is reconstructed from every creation, close and reopen event and reconciles to 105 open issues and 12 open PRs. Open PRs are not simultaneously executing agents.
  • Each plotted series stops at its own last recorded lifecycle event. Daily points and complete counting rules are supplied for reproduction.
  • Private implementation records, review discussions, retained sessions and extraction hashes remain available to the owner for audit. Only aggregate data and sanitized examples are distributed here.
  • Versions in a merged source tree and publicly released versions are different observations. Store and registry releases were checked independently.
  • No complete prototype cost ledger or manual-code authorship audit was available; no cost, savings or zero-manual-code claim is made.

Start with an issue worth solving

Give Descant a real piece of work. Inspect the code, review the result and see what delivering it cost.