MCP + REST handoffs

The human handoff layer for AI products.

Your agent calls HumanDeploy when judgment is needed. We package the context, route the expert, and return a typed result to your product.

Let's Chat Read the API docs →

Your AI product

Publish blocked by judgment.

The app sends the task, files, constraints, and memory when the agent reaches the approval gate.

POST /v1/handoffs

surfacebefore_publish

filesdraft.html, voice.md

policylaunch_check

HumanDeploy routed

Context packet matched to an expert and returned as a typed object.

Returned object

{
  "status": "ready",
  "artifact": "review.patch",
  "comments": 7,
  "memory_event": true
}

01 · Handoff primitive

One object carries the judgment wall into HumanDeploy.

The call keeps the request, files, policy, expert route, returned patch, and memory event in one inspectable object.

builder.app / launch-page / handoffs.create object inspector

Tool call handoffs.create()

Review generated launch page before a user publishes it.

surface before_publish

trigger risk_detected

policy brand_review

return review.patch

01 Surface The AI product pauses before publish.

02 Context packet Draft, voice rules, goal, and memory travel together.

03 Policy route Brand review routes to HumanDeploy network.

04 Expert work Sarah M reviews the page with context intact.

05 Returned object The product receives a patch it can render.

Returned object ready

{
  "id": "hnd_42",
  "status": "ready",
  "surface": "before_publish",
  "artifact": "review.patch",
  "expert": "sarah_m",
  "memory_event": true
}

02 · Product surface

Show the handoff at the moment the agent needs judgment.

The same launch-page run becomes four product states: generated draft, risk detected, handoff opened, returned patch.

builder.app / launch-page draft_generated

Draft generated

The agent has a launch page ready to publish.

The product shows the generated work, confidence state, and the decision point before the user commits.

AI-generated launch page

Risk signal

confidence 82%

Checkpoint Awaiting publish decision.

HumanDeploy handoff not opened

Handoff available

The app can call HumanDeploy when the generated page needs expert judgment.

surface before_publish

trigger publish gate

policy launch_check

Context packet

draft.html voice.md audience publish gate

Returned object

{
  "status": "available",
  "surface": "before_publish",
  "requires_handoff": false
}

03 · Operations behind the API

You embed the surface. HumanDeploy runs the expert operation behind it.

Matching, scoping, quality control, revisions, payments, and memory sit behind the endpoint. The product shows the outcome, not the operational mess.

Operation trace

hnd_42 · launch_check · same thread

live routing

intake Context packet received

Draft, voice rules, goal, prior decisions, and launch risk arrive as one bounded request.

+0s

scope Work becomes a launch check

The request is narrowed to claims, voice, CTA hierarchy, and publish risk.

+8s

match Sarah M routed with context

HumanDeploy selects the brand route and passes the packet without a new intake thread.

+14s

review Expert patch created

Sarah returns a patch, risk notes, and the decision trail the product can show.

+38m

return Typed object delivered

The app receives review.patch, status, revision state, and memory metadata.

+39m

04 · Build surface

Start with a widget. Go native when the product needs it.

The developer surface should be direct: widget, REST, MCP, or native workflow. Same handoff. Different depth.

developers / handoffs.create REST

POST /v1/handoffs
{
  "surface": "before_publish",
  "outcome": "launch_check",
  "route": "hd_network",
  "context": {
    "goal": "Review generated launch page before publish",
    "files": ["draft.html", "voice.md"],
    "memory_keys": ["brand.voice", "launch.rules"]
  }
}

Read API docs

Product preview POST /v1/handoffs

Native launch check

The app sends the launch page, policy, and memory. HumanDeploy returns review.patch.

surfacebefore_publish

routehd_network

returnreview.patch

Widget Drop in the handoff button first.

REST + MCP Let your backend or agent call the same object.

Native Render state, expert work, revisions, and memory.

05 · Trust and proof

The expert does not arrive cold.

The human receives the state of the work before touching it. The finished work returns with the decision trail intact.

humandeploy / hnd_42 / expert-route Sarah M assigned

Inherited context 4 sources

brief Review generated launch page before publish.

Focus on category clarity, claims, CTA hierarchy, and trust risk.

files draft.html, voice.md, homepage-notes.md

The product sends the work, not a blank request.

memory Keep one coral action. Avoid platform claims.

Sarah inherits the decisions that already happened.

Sarah M Brand Strategy

routehd_network

scopelaunch_check

slasame_day

Returned to product review.patch

object returned

Launch review ready

Hero claim tightened, risk notes attached, CTA hierarchy cleaned up, and comments returned to the app.

status: ready revision: open memory: saved

{
  "artifact": "review.patch",
  "comments": 7,
  "memory_event": true
}

Build with HumanDeploy

Add the handoff call where your agent stops.

Start with the widget or call handoffs.create. The request carries files, policy, and memory into HumanDeploy, then returns a typed object your product can render.

Let's Chat Read API docs →

Surfacebefore_publish

Routeexpert policy

Returnreview.patch