human://
interactive public demo
Source ↗ Evidence ↗
machine → human → machine

5machines need you.

The approval is not the product. The exact return path is. HumanQueue keeps authority, context and resume identity tied to the machine state that actually stopped.

machine waitinghuman decisionexact resume
01ChooseOpen the highest-value waiting boundary.
02DecideApprove, reject, clarify, or edit.
03VerifyWatch the exact return path, not just the click.
04InjectCreate your own machine boundary and replay the loop.
interruptions avoided
14
batched or deferred instead of interrupting you one-by-one
machines resumed
0
workflows continued after explicit human decisions
now / human boundary
#1

Live resume path

waiting for human
Make one decision above. human:// returns it to the exact machine state that asked.
inject a machine boundary
batch attention

Interrupt once, not eleven times.

Repeated low-risk boundaries can wait for one deliberate review instead of stealing focus one-by-one. This view shows what can be grouped without changing decision authority.

policy candidates

Repeated judgment can become policy.

Stable human decisions are candidates for shadow-tested automation. Nothing here auto-enables a policy; agreement and conflict stay visible first.

decision trace

Every boundary leaves a return trail.

Use the timeline to distinguish human decisions, channel delivery, and machine-side resume outcomes instead of collapsing them into one “done” event.

connector lab

Bring boundaries in. Send decisions back.

These probes show how different runtimes project the same human-boundary contract. Static scenarios are simulations; evidence status stays explicit in the repository.

implemented · native round-trip

Codex PermissionRequest

Session + turn + tool boundary enter the Gateway. Your decision returns as native allow/deny to the same waiting Codex tool call.
humanq connect codex PermissionRequest → human://approve → allow | deny
Direct link ↗
implemented · conservative gate

Cursor high-risk shell

Conversation is observed continuously, while only explicit high-risk beforeShellExecution commands are routed for human approval.
humanq connect cursor beforeShellExecution → permission: allow | deny | ask
Direct link ↗
implemented · semantic input

MCP human_ask

Clarification, choice, review or edit blocks inside the same MCP tool call and returns the human result to that exact invocation.
humanq mcp serve human_ask({ uri: "human://clarify" })
Direct link ↗
implemented · channel projection

Signed Webhook Channel

A bounded dialogue capsule can appear in another UI. The signed action comes back to the Gateway; the channel never owns a second queue.
humanq channel add webhook ops \ https://channel.example/human X-Human-Channel-Signature: sha256=…
Direct link ↗
implemented · outbound-only channel

Telegram long-poll

human:// pushes bounded approval cards to your Telegram chat. A local worker receives callback_query events and resolves localhost — no public inbound Gateway port required.
humanq channel add telegram phone \ --bot-token "$BOT_TOKEN" \ --chat-id "$CHAT_ID" humanq channel run phone
Direct link ↗

One request, many surfaces, one resume path

current connector runtime
editor session→ Native Connector→ Human Gateway→ Web / channel→ native resume
Implemented: Codex native approval · Cursor high-risk shell · MCP human_ask · signed webhook · Telegram long-poll. Slack / Claude Code / OpenCode are implemented but still await workspace or real-host E2E evidence. The buttons above simulate those connector shapes inside this static demo.
self-host

Your machine can own the boundary.

Run the Gateway locally, keep state and audit history on your hardware, then connect only the runtimes that actually need an external human surface.

01 · install

Your machine becomes the Human Gateway

No hosted account required. State and audit history can remain on your hardware.
curl -fsSL https://raw.githubusercontent.com/hippoley/HumanQueue/main/scripts/install.sh | bash humanq gateway run
02 · onboard

One private gateway token

First run creates ~/.human-queue/config.json and human-queue.db, then gives you an hq_… token.
humanq onboard humanq dashboard humanq doctor humanq gateway status
03 · connect

Point any machine at your queue

Codex, Claude, CI, MCP, n8n or your own app only need HTTP + Bearer token.
curl http://127.0.0.1:7482/v1/human \ -H "Authorization: Bearer hq_xxx" \ -H "Content-Type: application/json" \ -d '{ "uri":"human://approve", "source":"my-agent", "ref":"run-42", "title":"Continue?" }'

Self-host mental model

hosted service optional
your agents→ your Human Gateway→ your browser→ resume
State: ~/.human-queue/ · Auth: hq_ gateway token · Default bind: 127.0.0.1:7482 · Docker: bash scripts/docker/setup.sh
Every repeated human interruption is a candidate for a better policy. source · evidence · human://approve · review · clarify · auth · choose · edit · claim