# Rhumb — Agent Gateway for Discovery and Governed Execution
> https://rhumb.dev

## What is Rhumb?
Rhumb is an agent gateway for discovery and governed execution.
Mission: make the internet as agent-native as possible.
Rhumb Index scores external services for AI-agent compatibility.
Rhumb Resolve executes supported capabilities through governed execution and routes each call to the best-fit provider for the call by first matching the supported capability path, then using AN Score, provider availability / circuit state, estimated cost, credential mode, latency proxy, and explicit policy constraints by default, while also allowing explicit provider choice when the agent wants direct control.

## System split: Index and Resolve
- Rhumb Index is free discovery: score, compare, and research services.
- Rhumb Resolve is per-call execution: route supported jobs through one governed surface.
- Agents can say what they want done or explicitly pin the provider/tool path they want.
- Index ranks the field. Resolve routes the call.

## How Resolve routes calls
- AN Score is a major routing input, not the sole routing rule.
- Resolve considers supported capability matching, provider availability / circuit state, estimated cost, credential mode, latency proxy, and explicit policy constraints before execution.
- Agents can still pin the provider/tool path explicitly when direct control is better than automatic routing.
- Discovery breadth is wider than current callable coverage, and Rhumb keeps that boundary explicit.

## Pick the right starting path
- Evaluating with curl: https://rhumb.dev/quickstart#rest-path — Start with the free read endpoints. See real responses, learn the product model, and judge the trust layer before signup.
- Building an agent: https://rhumb.dev/quickstart#mcp-path — Install the MCP server or use the starter prompt. Reach for capability IDs when the agent needs executable actions, not just vendor names.
- Need an account and reusable key: https://rhumb.dev/auth/login — Sign up for identity, add credits, then execute with X-Rhumb-Key. Signup creates the account. Funding unlocks governed execution.

Service discovery answers who to trust.
Capability discovery answers what Rhumb can execute.
Signup creates identity. Credits or wallet-prefund unlock governed execution.

## Rhumb Resolve
Resolve is Rhumb’s governed execution layer for AI agents.
Index ranks the field.
Resolve routes each supported call to the best-fit provider for the call by default.
AN Score is a major routing input, not the sole routing rule.
Agents can also pin the supported provider path explicitly when they want direct control.
Supporting authority pages:
- What is Resolve?: https://rhumb.dev/resolve/what-is-resolve
- Routing proof and factor explanation: https://rhumb.dev/resolve/routing
- Resolve comparisons: https://rhumb.dev/resolve/compare
- Key management and credential paths: https://rhumb.dev/resolve/keys
- Per-call pricing explainer: https://rhumb.dev/resolve/per-call-pricing
- MCP Route Review: https://rhumb.dev/mcp-route-review — ask for one route-card review only when you can provide the minimum public proof packet: one allowed fixture, one closest denied neighbor, authority/credential owner plus budget owner, and receipt or typed-denial fields. If the implementation discussion is already public, use https://rhumb.dev/mcp-route-review#public-thread-template and include Source: e009-mcp-route-review-public-thread rather than moving context into email.
Current callable scope: 28 callable providers, strongest in research, extraction, generation, and narrow enrichment.

## For Agents
Install the MCP server for programmatic access:
  npx -y --package rhumb-mcp@latest rhumb-mcp

MCP tools available:
  find_services({ query: "payment processing" }) — discover services by need
  get_score({ slug: "stripe" }) — detailed AN Score breakdown
  get_alternatives({ slug: "stripe" }) — comparable services ranked
  get_failure_modes({ slug: "stripe" }) — known failure patterns
  discover_capabilities({ domain: "communication" }) — browse capability definitions
  resolve_capability({ capability: "email.send", credential_mode: "byok" }) — rank providers, optionally scope to a credential mode, surface machine-readable recovery fields like recovery_hint.resolve_url, recovery_hint.credential_modes_url, and, when applicable, recovery_hint.alternate_execute_hint or recovery_hint.setup_handoff, and recover typoed capability IDs with search suggestions
  estimate_capability({ capability_id: "email.send", credential_mode: "rhumb_managed" }) — estimate the active execution rail, cost, and health before execution; anonymous direct system-of-record paths also preserve machine-readable execute_readiness handoffs
  execute_capability({ capability_id: "email.send", credential_mode: "rhumb_managed", body: { to: "user@example.com" } }) — execute through Rhumb
  budget({ action: "get" }) — check budget status
  spend({ period: "30d" }) — view spend by capability/provider
  check_balance() — current credit balance
  get_payment_url({ amount_usd: 25 }) — top up credits

## Honest current state
Discovery breadth is wider than current execution breadth.
Rhumb indexes 999 scored services and 435 capability definitions.
Current governed execution is concentrated in 28 callable providers.

## API Base URL
https://api.rhumb.dev/v1

## Capabilities
Browse all 435 capability definitions: https://rhumb.dev/capabilities
- GET https://api.rhumb.dev/v1/capabilities?limit=100&offset=0 — paginated list of capability definitions
- GET https://api.rhumb.dev/v1/capabilities?search=web+research — find the capability slug when you know the task but not the action ID
- Each capability: { id, domain, action, description, provider_count, top_provider }
- Capabilities are abstract actions (e.g. search.query, email.send) that map to concrete providers
- Use find_services() when the question is which vendor should I use
- Use discover_capabilities() when the question is what exact action slug should I call
- Use discover_capabilities() in MCP to browse, then resolve_capability() to compare ranked providers, optionally filter by credential mode, follow recovery_hint.resolve_url, recovery_hint.credential_modes_url, and, when applicable, recovery_hint.alternate_execute_hint or recovery_hint.setup_handoff when a filtered route dead-ends, and get search suggestions when the capability ID is wrong

## API Endpoints
- GET https://api.rhumb.dev/v1/pricing - machine-readable public pricing contract
- GET https://api.rhumb.dev/v1/capabilities?limit=100&offset=0 — browse capability definitions
- GET https://api.rhumb.dev/v1/services — list scored services
- GET https://api.rhumb.dev/v1/services/{slug}/score — detailed score breakdown
- GET https://api.rhumb.dev/v1/services/{slug}/failures — active failure modes
- GET https://api.rhumb.dev/v1/leaderboard/{category} — ranked services by category
- GET https://api.rhumb.dev/v1/search?q={query} — semantic search

## Pricing
- Discovery (search, scores, browsing): Always free
- Execution rails: governed API key, wallet-prefund, or x402 per-call
- Provider-control modes where supported: BYOK and Agent Vault
- No subscriptions, no seat fees, no minimums
- Live pricing and markup terms: https://rhumb.dev/pricing
- What is Resolve?: https://rhumb.dev/resolve/what-is-resolve
- Routing proof and route-factor explanation: https://rhumb.dev/resolve/routing
- Resolve comparisons: https://rhumb.dev/resolve/compare
- Key management: https://rhumb.dev/resolve/keys
- Per-call pricing explainer: https://rhumb.dev/resolve/per-call-pricing

## Categories


## Scored Services (0 total)


## Scoring Formula
AN Score = (Execution × 0.70) + (Access Readiness × 0.30)

### Execution (70% of final score, 13 dimensions)
API reliability, error ergonomics, schema stability, latency distribution,
idempotency support, concurrent behavior, cold-start latency, output structure,
state leakage, graceful degradation, payment autonomy, governance readiness,
web agent accessibility.

### Access Readiness (30% of final score, 7 dimensions)
Signup autonomy, payment autonomy (access), provisioning speed,
credential management, rate limit transparency, documentation quality,
sandbox/test mode.

## Tier System
- L4 Native (8.0–10.0): built for agents, minimal friction
- L3 Ready (6.0–7.9): agents can use reliably with minor friction
- L2 Developing (4.0–5.9): usable with workarounds
- L1 Emerging (0.0–3.9): significant barriers to agent use

## Comparison Pages (decision surfaces for agents and operators)
Index: https://rhumb.dev/compare — all comparisons in one place

- https://rhumb.dev/blog/stripe-vs-square-vs-paypal — Payments: Stripe vs Square vs PayPal
- https://rhumb.dev/blog/resend-vs-sendgrid-vs-postmark — Email: Resend vs SendGrid vs Postmark
- https://rhumb.dev/blog/hubspot-vs-salesforce-vs-pipedrive — CRM: HubSpot vs Salesforce vs Pipedrive
- https://rhumb.dev/blog/auth0-vs-clerk-vs-firebase-auth — Auth: Auth0 vs Clerk vs Firebase Auth
- https://rhumb.dev/blog/posthog-vs-mixpanel-vs-amplitude — Analytics: PostHog vs Mixpanel vs Amplitude
- https://rhumb.dev/blog/supabase-vs-planetscale-vs-neon — Databases: Supabase vs PlanetScale vs Neon
- https://rhumb.dev/blog/twilio-vs-vonage-vs-plivo — Messaging: Twilio vs Vonage vs Plivo
- https://rhumb.dev/blog/linear-vs-jira-vs-asana — Project Management: Linear vs Jira vs Asana
- https://rhumb.dev/blog/anthropic-vs-openai-vs-google-ai — AI/LLM: Anthropic vs OpenAI vs Google AI

Each comparison includes live AN Score data, friction maps, routing rules for agents,
scenario-based recommendations, and failure mode analysis.
Use comparisons when an agent needs to choose between tools in the same category.

## API Autopsies (deep technical breakdowns of individual tools)
Index: https://rhumb.dev/autopsy — all autopsies in one place

- https://rhumb.dev/blog/hubspot-api-autopsy — HubSpot (4.6): Rate limit traps, cross-hub API inconsistency, OAuth maze, no idempotency
- https://rhumb.dev/blog/salesforce-api-autopsy — Salesforce (4.8): SOQL barrier, governor limits, sandbox/production split, sales-gated onboarding
- https://rhumb.dev/blog/twilio-api-autopsy — Twilio (8.0): What agent-native almost looks like. Simple auth, idempotency, error codes that teach
- https://rhumb.dev/blog/shopify-api-autopsy — Shopify (7.8): GraphQL-first bet, query cost budgets, forced version migration

Each autopsy dissects a single tool's failure modes, score anatomy, integration cost,
and constructive recommendations. Use autopsies when an agent needs to understand
the specific friction of a tool before integrating.

## Getting Started
- https://rhumb.dev/quickstart — Make your first API call in 30 seconds. Copy-paste examples for curl, JS, Python, MCP. No signup required for read endpoints.
- https://rhumb.dev/mcp-route-review — MCP Route Review intake for one concrete MCP route: allowed lane, denied neighbor, caller/tenant/workspace, credential owner, budget owner, repeat/retry ceiling, and receipt proof. Public issue/PR template: https://rhumb.dev/mcp-route-review#public-thread-template (Source: e009-mcp-route-review-public-thread).
- https://rhumb.dev/payments/agent — x402 agent payments: HTTP 402 flow, USDC on Base, wallet setup, and when to use on-chain per-call authorization
- https://rhumb.dev/blog/how-agents-actually-pay-x402-dogfood — x402 seller dogfood report: 5 compatibility mismatches, authorization proof vs tx_hash gap, and why structured 422 errors beat infinite 402 loops
- https://rhumb.dev/blog/getting-started-mcp — MCP install guide, framework setup (Claude Desktop, Cursor, direct stdio), 3 workflow walkthroughs, credential paths explained
- https://rhumb.dev/blog/securing-keys-for-agents — How to secure API keys for agent use: three credential paths (Rhumb-managed, BYOK, Agent Vault), storage hierarchy, honest threat modeling, and where x402 fits as a payment rail
- MCP tools reference with examples for all 21 tools
- Three credential paths: Rhumb-managed, BYOK, Agent Vault
- End-to-end workflow example: find → evaluate → resolve → execute

## Trust and disputes
- Trust overview: https://rhumb.dev/trust
- Methodology: https://rhumb.dev/methodology
- Current self-assessment: https://rhumb.dev/blog/we-scored-ourselves
- Historical baseline: https://rhumb.dev/blog/self-score
- Provider guide and dispute process: https://rhumb.dev/providers
- Public dispute template: https://github.com/supertrained/rhumb/issues/new?template=score-dispute.md
- Public dispute log: https://github.com/supertrained/rhumb/issues?q=is%3Aissue+%22Score+dispute%3A%22
- Private disputes: mailto:providers@supertrained.ai?subject=Score%20Dispute
- Dispute response target: 5 business days

## Extended Context
- Glossary: https://rhumb.dev/glossary
- About the team: https://rhumb.dev/about
- Extended version: https://rhumb.dev/llms-full.txt

## Links
- Website: https://rhumb.dev
- GitHub: https://github.com/supertrained/rhumb
- MCP Server: npx -y --package rhumb-mcp@latest rhumb-mcp
- Public agent capabilities: https://rhumb.dev/.well-known/agent-capabilities.json