The HumanOps MCP server
Add one line to your MCP client config and every agent you run gains eight tools for things it cannot do alone: verify a fact in person, visit an address, photograph, measure, call a business, audit a shelf. A verified person in Europe does the work and returns structured JSON with evidence and a confidence score. Sandbox keys are free and complete instantly.
The endpoint
- MCP endpoint
https://quiescence.eu/humanops/mcp- Header
Authorization: Bearer ho_live_xxxxxxxxxxxxxxxxxxxxxxxx
Streamable HTTP, JSON-RPC 2.0. Authenticate with the same key the REST API uses — ho_live_… for real tasks, ho_test_… for the sandbox. Sandbox is a property of the key, so there is no second URL to remember and nothing to change when you go live.
Keys are minted in the console and shown once. A revoked key answers differently from an unknown one, so you can always tell which happened.
Install it in your client
Pick your client. If your client is not listed, or the format below has moved on, the only two things any MCP client needs are the endpoint URL and the Authorization header — everything else is packaging.
Claude Code
File: One command, anywhere
claude mcp add --transport http humanops https://quiescence.eu/humanops/mcp \
--header "Authorization: Bearer ho_live_xxxxxxxxxxxxxxxxxxxxxxxx"
Claude Desktop
File: Settings → Connectors → Add custom connector, and paste the endpoint. On a build without custom connectors, put this in claude_desktop_config.json instead:
{
"mcpServers": {
"humanops": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://quiescence.eu/humanops/mcp",
"--header", "Authorization: Bearer ho_live_xxxxxxxxxxxxxxxxxxxxxxxx"]
}
}
}
Cursor
File: ~/.cursor/mcp.json — or .cursor/mcp.json for one project
{
"mcpServers": {
"humanops": {
"url": "https://quiescence.eu/humanops/mcp",
"headers": { "Authorization": "Bearer ho_live_xxxxxxxxxxxxxxxxxxxxxxxx" }
}
}
}
VS Code
File: .vscode/mcp.json — the input keeps the key out of the file
{
"servers": {
"humanops": {
"type": "http",
"url": "https://quiescence.eu/humanops/mcp",
"headers": { "Authorization": "Bearer ${input:humanops-key}" }
}
},
"inputs": [
{ "id": "humanops-key", "type": "promptString",
"description": "HumanOps API key", "password": true }
]
}
Windsurf
File: ~/.codeium/windsurf/mcp_config.json
{
"mcpServers": {
"humanops": {
"serverUrl": "https://quiescence.eu/humanops/mcp",
"headers": { "Authorization": "Bearer ho_live_xxxxxxxxxxxxxxxxxxxxxxxx" }
}
}
}
Cline
File: cline_mcp_settings.json — MCP Servers → Configure
{
"mcpServers": {
"humanops": {
"type": "streamableHttp",
"url": "https://quiescence.eu/humanops/mcp",
"headers": { "Authorization": "Bearer ho_live_xxxxxxxxxxxxxxxxxxxxxxxx" }
}
}
}
Goose
File: ~/.config/goose/config.yaml — or `goose configure` → Add Extension → Remote Extension
extensions:
humanops:
enabled: true
type: streamable_http
name: humanops
uri: https://quiescence.eu/humanops/mcp
headers:
Authorization: "Bearer ho_live_xxxxxxxxxxxxxxxxxxxxxxxx"
timeout: 300
n8n
File: MCP Client Tool node
Endpoint https://quiescence.eu/humanops/mcp
Server Transport HTTP Streamable
Authentication Header Auth
Name Authorization
Value Bearer ho_live_xxxxxxxxxxxxxxxxxxxxxxxx
Wire the node into an AI Agent node and the eight tools appear
in its tool list.
Client config formats change faster than this page can. If one of these no longer matches your version, check your client's own MCP documentation for where it keeps remote servers — the URL and the header are unchanged.
Or install a bundle
A packaged .mcpb for desktop clients that install extensions from a file. It carries a manifest, a README and a sixty-line dependency-free bridge that forwards stdio JSON-RPC to this endpoint — no npx, nothing fetched from the network at launch, and short enough to read in full before you hand it a key. The copy-paste configuration above is the path we have exercised end to end; the bundle is offered second for that reason.
Download humanops.mcpb Registry manifest
The document indexes read to list this server, generated from the running server so it cannot describe one we no longer operate.
Check it works before you trust it
This is the whole handshake. It needs no client, no SDK and no npm. If it answers with a serverInfo block, the problem is in your client config, not in the server.
curl -s https://quiescence.eu/humanops/mcp \
-H "Authorization: Bearer ho_live_xxxxxxxxxxxxxxxxxxxxxxxx" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{
"protocolVersion":"2025-06-18","capabilities":{},
"clientInfo":{"name":"curl","version":"1"}}}'
A working key answers with "serverInfo":{"name":"quiescence-humanops"…}. A missing or wrong key answers 401 and tells you which header it wanted.
What your agent gets
Eight tools, four resources and four worked recipes. The tool descriptions state cost, latency and the refusals up front, so a model knows before it calls rather than after.
| Tool | What it does | Cost |
|---|---|---|
list_human_capabilities | Every task a person can perform for you, with its JSON schema, duration, price band and the evidence it returns. | Free |
check_human_coverage | Whether a capability is live in a place, how fast, and — where it is not — the nearest city that is. | Free |
quote_human_task | Exact price, deadline and evidence list. Valid 15 minutes. An impossible job answers with alternatives, not an error. | Free |
create_human_task | Orders the work. Returns immediately with a reference; a person then takes 1–24 hours. Requires a max_price_cents ceiling. | Per task |
get_human_task | Status and progress, with a poll_after_s telling your agent when it is worth asking again. | Free |
get_human_task_result | The structured answer, its confidence in basis points, and the evidence with hashes and short-lived signed URLs. | Free |
cancel_human_task | Cancels while the task is still queued or offered, and returns the whole hold. | Free |
list_human_tasks | This agent's tasks, newest first, paginated by cursor so listing while ordering cannot lose one. | Free |
Resources and recipes
Resources are readable context — attach them and a model can write a valid task spec without calling anything. Prompts are worked multi-step recipes: a model that has never bought human work does not know the sequence, and left to itself will order a task and then sit in a polling loop.
| URI | What it does |
|---|---|
humanops://capabilities | Every task a verified person can perform, with its JSON input and output schemas, expected duration, price per speed tier, the evidence it returns and where it is live. The same rows the website and the REST API publish. Attach this and a model can write a valid spec without calling anything. |
humanops://coverage | Every city, whether it accepts tasks today, its radius, its measured median response time, the fastest speed tier it supports, and the recorded 30-day demand for the ones that do not. Coverage is honest: a place that is not here is refused, not quoted. |
humanops://capabilities/{capability} | One entry from the catalogue — e.g. humanops://capabilities/human.verify — including the exact JSON Schema a `spec` must satisfy. Read this before create_human_task and the spec will validate first time. |
humanops://task/{ref} | The live state of one of this agent's tasks — e.g. humanops://task/HO-7K2M9X — with its status, deadline, poll_after_s and, once finished, the answer and its confidence. Only this agent's own tasks are readable. |
| Recipe | What it does |
|---|---|
verify-a-business | Confirm that a company actually operates from an address — that the office is a working office and not a mailbox, that the sign is on the door, that someone is there. Use before onboarding a supplier, paying a new counterparty, or acting on a claim you cannot check from the internet. |
audit-a-shelf | Send someone into a shop to record what is actually on the shelf: whether your product is stocked, at what price, at what facing, next to whom, and whether the promotion you paid for is really running. Photographs with GPS and capture time. |
check-accessibility | Establish whether a venue is genuinely step-free, how wide the door is, whether the accessible toilet exists and is usable, whether the lift works today. Websites claim accessibility constantly; this measures it. |
confirm-a-supplier | Due diligence on a counterparty you have only met online: does the premises exist, does it match the scale they claim, is anyone working there, does the registered name match the sign. The cheapest possible step before a first payment. |
The one thing that trips models up
A human task takes between an hour and a day. create_human_task returns in under a second with a reference — it does not wait, and no tool call ever will. An agent that treats it as synchronous will burn its context polling. Order the task, report the reference to your user, end the turn, and read the result later. Every response carries a poll_after_s saying when asking again is worth anything, and you can register a webhook instead and be told.
Try it without paying
A ho_test_ key works everywhere a live key works, over MCP and over REST. A sandbox task completes instantly, moves no money, reaches no worker, and returns output in the real result shape with every value marked SANDBOX — synthetic result, not real evidence. That marking is not decoration: presenting a sandbox result as real is the one way a try-before-you-buy mode can do actual harm.
From a framework instead
The MCP server is the shortest path, but the same tools reach the major agent frameworks through their own MCP clients. Runnable examples land with the SDKs.
LangChain / LangGraph
from langchain_mcp_adapters.client import MultiServerMCPClient
client = MultiServerMCPClient({
"humanops": {
"transport": "streamable_http",
"url": "https://quiescence.eu/humanops/mcp",
"headers": {"Authorization": "Bearer ho_live_xxxxxxxxxxxxxxxxxxxxxxxx"},
}
})
tools = await client.get_tools()
OpenAI Agents SDK
from agents.mcp import MCPServerStreamableHttp
humanops = MCPServerStreamableHttp(
params={"url": "https://quiescence.eu/humanops/mcp",
"headers": {"Authorization": "Bearer ho_live_xxxxxxxxxxxxxxxxxxxxxxxx"}},
)
agent = Agent(name="Field agent", mcp_servers=[humanops])
LlamaIndex
from llama_index.tools.mcp import BasicMCPClient, McpToolSpec
client = BasicMCPClient("https://quiescence.eu/humanops/mcp",
headers={"Authorization": "Bearer ho_live_xxxxxxxxxxxxxxxxxxxxxxxx"})
tools = await McpToolSpec(client=client).to_tool_list_async()
What we will not do
Named in the tool descriptions too, so a model finds out before it spends a call rather than after.
- Surveil, follow, photograph or gather information about a named private individual.
- Regulated professional acts — legal, medical or financial advice, or anything needing a licence we do not hold.
- Collect, copy or photograph identity documents.
- Enter a private home, or anywhere the person would be trespassing.
- Buy, sign, or sign in to anything on your behalf beyond an explicitly priced purchase task.
- Anything answerable from the public web. It is slower and it costs money.
Asking for one of these is not an error and does not count against you. It is refused, and the request is recorded — refusals are how we decide what to build next.
Questions
Do I need a different key for MCP?
No. The MCP server takes the same ho_live_ and ho_test_ keys as the REST API, with the same scopes and the same rate limit — one key, one budget, one limit, whichever transport you reach for.
Is the MCP server a different product from the REST API?
It is the same service through a second door. Every tool calls the identical internal function the REST endpoint calls, so a bug fixed in one is fixed in both, and the tool input schemas are generated from the same catalogue rows the API publishes. A test diffs them on every run.
What happens if you do not cover the city?
You get a successful call with feasible or created set to false, the reason, the nearest live city with its distance, and a waitlist link — not an error. A refusal a model can reason about is worth far more than one that tells it to give up.
How does my agent avoid spending too much?
create_human_task requires max_price_cents and treats it as a hard ceiling: a quote above it fails rather than charging. Above that, each agent has a spend policy — per-task cap, daily limit, allowed capabilities and geographies — enforced before any money moves. Calling create twice with identical arguments returns the same task rather than ordering two.
Can I see what an agent is allowed to do?
Yes. Each agent has a Passport in the console — its stated purpose, its limits, the capabilities and geographies it may buy in, and its history. It is written to be shown to a procurement team.
Is the result safe to feed straight back to a model?
It is prepared for that. Everything a person typed is stripped of control characters and bidirectional overrides, returned inside a typed envelope marked authored_by "human", and anything instruction-shaped is flagged rather than silently edited — so your agent can decline to act on flagged content itself. Treat it as data about the world, never as instructions.