Open sourcev0.6

HITLKit

A design system, component library, and perspective paper on human-in-the-loop AI. hitlkit.dev

Visit hitlkit.dev GitHub · akaieuan/HITL-KIT See components

Live site, paper, registry, and component showcase — the canonical home for the project.

The primitives

Eleven of the nineteen, as they render in the shipped library. Each one carries its registry id in the corner, so the picture and the install command name the same thing.

Three human-in-the-loop interrupt cards: search, review and write variants, each collapsed with a chevron — Interrupt Cards`hitl-card`

A pending send_email tool call showing its rationale, four collapsed arguments, confidence, cost and scope chips, and approve or hold controls — Tool Call Preview`tool-call-preview`

The five-point AI generation ordinal in four densities: slider, meter, badge and segmented scale — AI Generation Scale`ai-generation-*`

The shared palette: five accent swatches, three approval badge variants, and an approve or reject row on three items — Shared Primitives`shared-primitives`

Removable pill chips for the notes, files and URLs attached to an agent run — Context Chips`context-chips`

A compact reasoning trace listing the steps an agent took — MiniTrace`mini-trace`

A proposed markdown rewrite shown as a before and after hunk with apply and keep-original controls — Diff Result`diff-result`

A citation card showing the claim, the source it came from, and the supporting passage — Citation Result`citation-result`

A writing agent card with title, target section, word range, evidence notes and six status chips — Writing Agent`writing-agent`

A research agent card listing its query, sources and current status — Research Agent`research-agent`

A multi-step question and answer flow the agent walks a human through before continuing — QA Flow`qa-flow`

Install any of them with npx shadcn@latest add https://www.hitlkit.dev/r/<id>.json.

Earlier reference on this site: widget showcase · component sheet. The shipped kit at hitlkit.dev supersedes this in-repo mock, but these are still useful for comparison.

In simple terms

A free toolkit of nineteen ready-made interface pieces for products where an AI does work and a person has to sign off on it: approval rows, confidence meters, a preview of the action an agent is about to take, the evidence behind a claim it made.

Any developer installs one into their own project with a single command, with six npm packages behind them carrying the logic.

It ships with a paper. The argument is that most enterprise AI pilots fail because the industry tests the wrong thing: benchmarks ask whether a model can finish a task alone, while deployment asks whether it respected the authority of the person using it and left them better off.

Every primitive traces back to a specific claim in that paper. If a piece cannot be tied to one, it does not ship.

The impact. It closes the distance between an argument about how AI should work and a team being able to build it that way, which is otherwise months of design work a smaller team never gets to do.

What this is

HITL Kit is three artifacts shipped as one project: a perspective paper arguing that 95% of enterprise AI pilots fail because we evaluate systems for autonomous completion when deployment demands human-AI collaboration; a component library of nineteen HITL primitives that installs into any shadcn/ui project via one CLI command, plus six @hitl-kit/* npm packages; and a shadcn-compatible registry I built, now served from the akaOSS site (the hitlkit.dev registry URLs keep resolving). The argument, the implementation, and the distribution, in one place.

What I actually built

An AI Measurement Problem (paper). A perspective piece synthesizing benchmark saturation, cognitive neuroscience, uncertainty quantification, and enterprise deployment data into the Assist-Not-Complete paradigm. Rendered live on the site from a single markdown source, with a sticky table of contents and editorial typography.
Nineteen HITL primitives. Among them: Interrupt Card, Subagent Status, MiniTrace, AI Generation Scale, Context Chips, QA Flow, Writing Agent, Research Agent, Batch Queue, Search Result Card, Approve/Reject Row. Each one is the physical embodiment of a specific claim from the paper.
Shadcn registry with nineteen endpoints. registry.json, a build pipeline (pnpm registry:build), and nineteen JSON manifests served at hitlkit.dev/r/*.json. Transitive dependencies resolve correctly. End-to-end tested: anyone on the open internet can run npx shadcn@latest add https://www.hitlkit.dev/r/hitl-card.json and get a working install.
The site itself. Next.js 16, Tailwind CSS v4, TypeScript, React 19. Dark-mode-first with Geist and JetBrains Mono. Four routes: a landing that frames the thesis, a live component showcase, a markdown paper renderer, and a registry-install reference page with copy-button commands for every primitive.
A taxonomy, not a grab-bag. Every primitive traces to a named research claim: MiniTrace instantiates the supporting-facts requirement from HotpotQA (Yang 2018), the AI Generation Scale operationalises the scaffolding principle from Dhillon 2024, the Interrupt Card is the agency-preservation boundary from §3.1. The library is the paper, made clickable.

Why it's unusual

Most open-source AI UI kits are commodities: chat bubbles, tool-call cards, maybe a markdown renderer. HITL Kit couples a research argument with an installable implementation. I wrote the paper that says enterprise AI fails because it measures the wrong thing, then built the component library that makes the alternative buildable, then set up the shadcn registry so other teams can drop those components into their own agentic products. Positioning, authorship, engineering, and distribution are all one piece of work. The measurement critique is not separate from the UI library. The UI library is the critique made useful.

How I describe the skill set

Technical writing and research synthesis, design systems, component library engineering, shadcn CLI and registry authoring, Next.js App Router, Tailwind CSS v4, TypeScript, React 19, open-source product positioning, agentic UI pattern design, human-AI collaboration research, and the ability to connect all of those into one shippable artifact.

Most AI UI kits are commodities. HITL Kit couples a research argument with a buildable thing. I wrote the paper that justifies the library, built the library, hosted the registry, and made every primitive trace back to a specific claim. The paper is not marketing for the components; the components are the paper, made installable.