From your agent to the real world, in three calls. Hire verified people over MCP or REST.

Get your test key Read the docs

// your agent calls one governed tool, over MCP or REST
hannu.create_task({
  type: "field_verification",
  location: { lat: 6.45, lng: 3.39 },
  proof: ["photo", "geofence"],
  idempotency_key: "7f3c-…"
})

Your first task, in three calls. From a fresh test key to a signed outcome — test mode is free and behaves exactly like live.

Step 1

Connect your agent

Add the MCP server to your agent, or point any HTTP client at REST v1 with your bearer key.

mcp.json

# ~/.your-agent/mcp.json — add the hannu server
{ "mcpServers": {
  "hannu": {
    "url": "https://mcp.hannu.africa",
    "auth": "Bearer ${HANNU_KEY}"
  } }
}

Step 2

Create a task — escrow locks atomically

One governed call funds escrow, runs the safety filter, and matches a verified Operator. Nothing is at risk until you create.

POST /v1/tasks

# estimate first (no charge), then create — escrow locks on create
curl https://api.hannu.africa/v1/tasks \
  -H "Authorization: Bearer $HANNU_KEY" \
  -H "Idempotency-Key: 7f3c-…" \
  -d '{ "type": "field_verification",
       "location": { "lat": 6.45, "lng": 3.39 },
       "proof": ["photo", "geofence"] }'

Step 3

Collect the Verified report

A webhook fires the moment proof passes; the task returns a signed report your systems can verify and file.

200 OK

// a signed Verified report — not a screenshot
{
  "id": "task_8f21",
  "state": "verified",
  "report": {
    "confidence": 0.97,
    "checks": ["gps", "exif", "registry", "human"],
    "signature": "hmac-sha256:a17f…c4"
  }
}

Native to your agent, or any stack. Same governance, same audit, same signed proof — whichever way you wire it in.

For agents, the way they already think. Streamable HTTP, OAuth 2.1, registry-published — your agent discovers the tools, calls them, and stays inside its spend policy, with no glue code to write.

Connect over MCP

For anything that speaks HTTPS. A predictable JSON API with cursor pagination, idempotency and generated SDKs from the OpenAPI 3.1 schema — drop it into the stack you already run.

Read the API reference

Built for agents that move fast — safely. Every call governed, every outcome signed — the contract your agent can rely on, on every request.

See our approach to trust

Your agentone governed call

Your limitscaps · allowlists · off switch

Safetyrefuses credential work

Retry-safenever double-charges

Signed reportyours to re-check

It can only do what you allow.

Per-agent spending caps, the task types and areas it may touch, and an instant off switch — all enforced before any task can start.

It refuses work it shouldn’t do.

Credential work — account sign-ups, CAPTCHAs, one-time codes — is blocked before it ever reaches a person. By design, not by policy.

A retry never double-charges.

If a request drops or repeats, it never creates the same task twice or moves the same money twice — safe to call again, always.

Your systems hear every state change. Signed the moment it happens — delivered, retried, and safe to process once.

The task moves through live, matched, proof submitted, verified and paid — and every transition fires a webhook to your systems the moment it happens, carrying the full resource so there is nothing to fetch. No polling, ever.

Every webhook is HMAC-signed over its timestamp and body, so your systems can confirm it truly came from hannu and was not replayed — before they act on it. Trust the event, not the sender’s word.

Delivery is retried with backoff until it lands, with an event_id so processing the same event twice is safe — and a dead-letter alert if it ever can’t be delivered. No missed events to reconcile by hand.

Set up webhooks

Everything you need to ship.

Guides

Get a test key and build today.

Test mode is free and behaves exactly like live. Ship the integration, then fund a wallet when you’re ready to dispatch real Operators. hannu never custodies funds.

Get your test key Talk to us