Agentbroker MCP Server

Agent Broker - SMB Transaction & Communication MCP Server

An agent-callable MCP server that lets autonomous AI agents find, verify, message, schedule with, and transact with small and mid-sized businesses (SMBs) through a single compliance-enforced tool surface.

Live endpoint: https://hatchloop.dev/mcp/agent-broker (streamable-http, always-on Cloudflare edge)

---

Why this exists

There are tens of millions of long-tail small businesses in the US - barbers, plumbers, accountants, home cleaners - and they have no API surface. AI agents that need to schedule a haircut, get a quote, or send a confirmation today must either drive a browser, cold-call by voice, or give up.

This server is the missing middle layer. Agents call us; we route to the right SMB through whichever channel reaches them fastest - Cal.com -> WhatsApp -> SMS -> voice AI -> email - with full TCPA / GDPR / CASL / 10DLC compliance enforced as a non-bypassable gate.

---

Current status (honest)

The MCP server is live and callable right now. Bookings hit demo data. 12 utility tools are free (no key, unmetered). Premium data tools (verify_company_record, screen_sanctions, map_trade_restriction) are free up to a daily limit; beyond that, $0.02/call via credits. Write tools require a free email-verified key (100 ops/day) - get one at https://hatchloop.dev/agent-broker. Credit packages from $9/1,000 credits at https://hatchloop.dev/pricing.

---

23 MCP Tools

All tools are callable via MCP, REST, OpenAI function calling, Anthropic tool_use, or A2A protocol.

Free key (100 write ops/day + 500 premium data calls/day): https://hatchloop.dev/agent-broker - Credits from $9/1,000 ops: https://hatchloop.dev/pricing - Premium data beyond quota: $0.02/call

---

Verifiable compliance receipts

screen_sanctions and check_compliance attach a compliance receipt: a hash-bound record of which list copies were screened (and how fresh they were), which ruleset decided, what inputs it was given, and what it returned. It is signed with Ed25519 and verifiable offline - months later, with no call back to us. It asserts facts about our system's actions only; it never claims "this party is clean."

Verify one in ~12 lines (pin the public key from hatchloop.dev/agents.md):

import json, hashlib
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

PINNED_KEY_HEX = "<hex public key from hatchloop.dev/agents.md>"

receipt = json.load(open("receipt.json"))          # the compliance_receipt object
payload, integrity = receipt["payload"], receipt["integrity"]

canonical = json.dumps(payload, sort_keys=True, separators=(",", ":"),
                       ensure_ascii=True, allow_nan=False).encode()
assert integrity["payload_sha256"] == "sha256:" + hashlib.sha256(canonical).hexdigest()

Ed25519PublicKey.from_public_bytes(bytes.fromhex(PINNED_KEY_HEX)).verify(
    bytes.fromhex(integrity["signature"]), canonical)   # raises if tampered

If no signing key is configured on the server, the receipt says signature_status: "unsigned" with the reason - it never claims a signature it does not have.

---

Quick start

Connect via MCP (Claude Desktop, Cursor, Cline, Continue, etc.)

{
  "mcpServers": {
    "agent-broker": {
      "url": "https://hatchloop.dev/mcp/agent-broker"
    }
  }
}

15 tools require no key. 12 are always free (find_business, verify_business, check_booking_link, check_compliance, get_conversation, get_status, get_outcome, preview_cost, self_test, check_quota, mint_key, lookup_us_contracts) and 3 more are free within a daily quota (verify_company_record, screen_sanctions, map_trade_restriction).

Write tools require an X-Agent-Identity bearer token:

• Free email-verified key (100 ops/day): https://hatchloop.dev/agent-broker
• Machine-mintable key (no email, agent self-serve): POST https://api.hatchloop.dev/keys/mint - see Machine-mintable keys below.
• Credits from $9/1,000 ops: https://hatchloop.dev/pricing

Add your key to the config once you have one:

{
  "mcpServers": {
    "agent-broker": {
      "url": "https://hatchloop.dev/mcp/agent-broker",
      "headers": {
        "X-Agent-Identity": "Bearer YOUR_KEY_HERE"
      }
    }
  }
}

Or via npx (stdio transport)

npx agentbroker-mcp

With a key:

AGENT_BROKER_KEY=your_key npx agentbroker-mcp

Discover tools (JSON-RPC)

curl -X POST https://hatchloop.dev/mcp/agent-broker \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

Call a tool (JSON-RPC)

curl -X POST https://hatchloop.dev/mcp/agent-broker \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "find_business",
      "arguments": {
        "vertical": "personal_services",
        "location": {"zip_or_city": "30309"},
        "capability": "haircut"
      }
    }
  }'

OpenAI function calling

import httpx, openai
tools = httpx.get(
    "https://hatchloop.dev/.well-known/openai-tools.json"
).json()["tools"]
client = openai.OpenAI()
resp = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Book a haircut in Atlanta Saturday under $50"}],
    tools=tools,
)

Anthropic tool use

import httpx, anthropic
tools = httpx.get(
    "https://hatchloop.dev/.well-known/anthropic-tools.json"
).json()["tools"]
client = anthropic.Anthropic()
msg = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "Book a haircut in Atlanta Saturday under $50"}],
)

Plain REST

curl -X POST https://hatchloop.dev/ops/find_business \
  -H "Content-Type: application/json" \
  -d '{"vertical":"personal_services","location":{"zip_or_city":"30309"},"capability":"haircut"}'

---

Machine-mintable keys

AI agents that cannot receive email can self-provision a free-tier API key (100 gated ops/day) by proving identity via HMAC-SHA256.

How it works

1. Obtain the MACHINE_MINT_SECRET from hatchloop.dev/docs/#machine-mint.
2. Compute the signature:

   signature = HMAC-SHA256(agent_id + str(timestamp) + nonce, MACHINE_MINT_SECRET)
   

   The HMAC input is the raw concatenation of the three fields (no separators). Digest must be lowercase hex.
3. POST to https://api.hatchloop.dev/keys/mint:

{
  "agent_id": "my-agent-abc123",
  "timestamp": 1725100000,
  "nonce": "4f8a2c1d9e2b7c6a",
  "signature": "<lowercase-hex-hmac>"
}

Response

{
  "ok": true,
  "key": "<JWT - use as X-Agent-Identity header>",
  "key_id": "free_machine_<hash>",
  "expires_at": "2026-11-28",
  "tier": "free",
  "daily_limit": 100,
  "usage": "Send as the X-Agent-Identity header on every call to https://hatchloop.dev/mcp/agent-broker"
}

Constraints

• timestamp must be within 60 seconds of server time (prevents replay attacks).
• Use a fresh nonce on every call (UUID or random hex).
• agent_id is a stable identifier for your agent; the issued key is tied to its SHA-256 hash.
• Returns 401 {error: "invalid_request"} on bad signature or stale timestamp.
• Returns 503 {error: "not_configured"} if the server secret has not been set (contact hello@hatchloop.dev).

---

Discovery surfaces

---

Architecture

AI agent
   |
   v  MCP / REST / A2A
Cloudflare Worker edge  (hatchloop.dev)
   |  300+ PoPs globally -- discovery served from edge bundle in 40-70 ms
   |
   +-- GET /.well-known/* /manifest /llms.txt  --> embedded snapshot (40-70 ms)
   +-- POST /mcp  initialize / tools/list      --> embedded snapshot (40-65 ms)
   +-- POST /mcp  tools/call  /ops/*           --> proxy to origin  (170-190 ms)
                |
                v
        Python FastAPI  (api.hatchloop.dev)
                |  Cron keep-alive every 2 min (eliminates Render cold starts)
                |
                +-- 23 operation handlers  (core/)
                +-- Compliance gate        (compliance/pre_check)
                +-- Channel adapters       (channels/ -- Twilio, Cal.com, Vapi, SendGrid)
                +-- Billing + outcome store
                +-- All .well-known / MCP endpoints (also served from edge bundle)

The edge worker can outlive the origin: discovery still works even if the origin is down. Idempotency is keyed by (agent_id, operation, idempotency_key) with 24h TTL. Async operations return pending_async; poll with get_status / get_outcome.

---

Compliance

Every outbound communication passes through compliance/pre_check():

1. Content classification - blocks restricted categories (gambling, adult, cannabis, spam)
2. Opt-out check - TCPA STOP keyword, GDPR right-to-be-forgotten, CASL
3. Consent check - TCPA written consent, GDPR opt-in, CASL implied/express
4. 10DLC registry check - US SMS campaign compliance
5. Two-party recording consent - CA, FL, IL, MD, MA, MT, NV, NH, PA, WA
6. Audit log - PII stored as SHA-256 hash, never plaintext

Violations surface as ComplianceViolationError and are never silently bypassed.

---

Repo layout

agentbroker/
+-- core/                  # 23 operation handlers + shared Pydantic models
+-- channels/              # Twilio, SendGrid, Vapi, Bland, Cal.com, Playwright
+-- compliance/            # pre_check, jurisdiction_rules, consent_store, audit_log
+-- reliability/           # retry, circuit_breaker, channel_fallback, async_runner
+-- billing/               # meter, budget_guard, receipt_signer, pricing_tiers
+-- telemetry/             # tracer, log_redactor, metrics_emitter
+-- storage/               # outcome_store, idempotency_store
+-- supply/                # smb_directory (20+ seed/demo SMBs)
+-- onboarding/            # self_serve, verification_flow, channel_capture
+-- feedback/              # failure_classifier, attribution_engine, outcome_evaluator
+-- optimizer/             # ab_router, selection_analytics, weekly_report
+-- agent_interface/       # manifest_server, mcp_server, well_known, identity, webhooks
+-- manifest/              # manifest.json, mcp_tools.json, openapi.yaml
+-- api/                   # errors.md, identity.md, async.md
+-- docs/                  # mission, architecture, compliance, ADRs
+-- edge/                  # Cloudflare Worker (TypeScript/Hono)
+-- deploy/                # Dockerfile, docker-compose.yml
+-- tests/                 # unit, contract, compliance, fault_injection, agent_sim
+-- main.py                # FastAPI entry point
+-- config.py              # Centralized config from env
+-- requirements.txt

---

Local development

# Install dependencies
pip install -r requirements.txt

# Run tests (1173 passing at the time of writing)
python -m pytest tests/ -q

# Start the API
python main.py
# --> http://localhost:8000/docs      (Swagger UI)
# --> http://localhost:8000/mcp       (MCP endpoint)
# --> http://localhost:8000/manifest  (capability manifest)

# Run the agent simulation harness
python -m tests.agent_sim.harness

# Self-test
python -c "import asyncio; from agent_interface.self_test import run_self_test; print(asyncio.run(run_self_test()).all_passed)"

Or with Docker:

docker compose -f deploy/docker-compose.yml up

---

Documentation

• Architecture - module map, data flow, fallback chains
• Compliance - full jurisdiction matrix, pre-check sequence
• Agent integration guide - copy-paste examples for every protocol
• API errors - 16 error codes with retry semantics
• API identity - Agent-Identity JWT spec
• API async - execution profiles, polling rules, webhook contract
• Benchmarks - measured WinRate, latency, cost vs alternatives
• Mission - north-star metric and scope

---

Contributing

Licensed under MIT. Issues and discussion are welcome - open a GitHub issue to report bugs or suggest features. For substantial changes, please open an issue first to discuss direction. Note: this repo is the open-source server; the hosted service at hatchloop.dev (supply index, billing rails) is operated by Hatchloop.

---

License

MIT - see LICENSE. The hosted service and its supply/billing data are operated separately by Hatchloop.

---

Built by Basil Al-Shukaili. Listed on the MCP Registry and Glama.