login
quiescence.eu
Skip to content

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.

Create a key

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.

ToolWhat it doesCost
list_human_capabilitiesEvery task a person can perform for you, with its JSON schema, duration, price band and the evidence it returns.Free
check_human_coverageWhether a capability is live in a place, how fast, and — where it is not — the nearest city that is.Free
quote_human_taskExact price, deadline and evidence list. Valid 15 minutes. An impossible job answers with alternatives, not an error.Free
create_human_taskOrders the work. Returns immediately with a reference; a person then takes 1–24 hours. Requires a max_price_cents ceiling.Per task
get_human_taskStatus and progress, with a poll_after_s telling your agent when it is worth asking again.Free
get_human_task_resultThe structured answer, its confidence in basis points, and the evidence with hashes and short-lived signed URLs.Free
cancel_human_taskCancels while the task is still queued or offered, and returns the whole hold.Free
list_human_tasksThis 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.

URIWhat it does
humanops://capabilitiesEvery 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://coverageEvery 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.
RecipeWhat it does
verify-a-businessConfirm 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-shelfSend 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-accessibilityEstablish 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-supplierDue 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.

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.

Next