This server is the Rhumb MCP gateway for discovering, evaluating, resolving, and executing external tool capabilities with governed credentials, budgets, routing, and telemetry.
Discovery & evaluation: find_tools, get_score, get_alternatives, get_failure_modes, discover_capabilities, and resolve_capability for researching services and capability providers
Execution: execute_capability to call capabilities via byo, rhumb_managed, or agent_vault credential modes; estimate_capability for pre-call cost/health checks; credential_ceremony and check_credentials for credential setup and readiness
Billing & budgets: budget to check/set limits, spend for cost breakdowns, check_balance for credit balance, get_payment_url for top-ups, get_ledger for billing history
Operations: routing to configure provider selection strategy, plus execution telemetry and provider health visibility via the broader API
Enables agents to discover, score, and execute Stripe capabilities with visibility into failure modes, execution quality, and cost-aware routing.
Index ranks. Resolve routes. Rhumb is an agent gateway for external tools: Index scores and compares services; Resolve routes supported capability calls through governed execution rails with receipts.
🌐 rhumb.dev · ⚡ Quickstart · 🧭 Resolve · 💵 Pricing · 📊 Leaderboard · 📖 Methodology · 🔑 Trust
For agents: See
llms.txtfor machine-readable documentation andagent-capabilities.jsonfor structured capability metadata.
npx -y --package rhumb-mcp@latest rhumb-mcpZero config. Discovery tools work immediately — no signup, no governed API key.
For execution, pass your governed API key:
RHUMB_API_KEY=your_key npx -y --package rhumb-mcp@latest rhumb-mcpcurl "https://api.rhumb.dev/v1/services/stripe/score"
# See supported execution routes before you execute
curl "https://api.rhumb.dev/v1/capabilities/email.send/resolve"All read endpoints are public, including Resolve readiness checks. Estimate and execute require an authenticated payment path.
Related MCP server: agent-validator-mcp-server
Use Rhumb Index when an agent needs to discover and evaluate services. Use Rhumb Resolve when the task is on a supported capability path and you want governed execution with an explicit receipt.
Agents need external tools. Choosing the right one is hard — not because of feature lists, but because of:
auth and signup friction
provisioning reality vs. marketing claims
schema instability
failure recovery when no human is watching
hidden costs and rate limits
Rhumb makes those constraints visible before you commit.
Rhumb is strongest today for research, extraction, generation, and narrow enrichment.
Treat broader multi-system business automation as future scope, not the current callable promise. Use Layer 2 capabilities for real work now, and treat Layer 3 as beta with an intentionally sparse public catalog.
999 scored services across 149 capability domains. Each gets an AN Score (0–10) measuring execution quality, access readiness, and agent autonomy support.
find_services — Search indexed Services by what you need them to do
get_score — Get the full AN Score breakdown for a Service: execution quality, access readiness, autonomy level, tier label, and freshness
get_alternatives — Find alternative Services, ranked by AN Score
get_failure_modes — Get known failure patterns, impact severity, and workarounds for a service
discover_capabilities — Browse Capabilities by domain or search text
resolve_capability — Given a Capability ID, and optionally a credential mode, returns ranked providers with health status, cost per call, auth methods, endpoint patterns, execute guidance, and 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, plus typo recovery when the capability ID is wrong
Discovery breadth is wider than current execution coverage. The index is broader than what Rhumb can execute today.
435 capability definitions across 28 callable providers today. Resolve chooses the best-fit supported provider for the call using AN Score, availability / circuit state, estimated cost, latency proxy, credential mode, and explicit policy constraints.
execute_capability — Call a Capability through Rhumb Resolve
resolve_capability — Given a Capability ID, and optionally a credential mode, returns ranked providers with health status, cost per call, auth methods, endpoint patterns, execute guidance, and 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, plus typo recovery when the capability ID is wrong
estimate_capability — Estimate the active execution rail, cost, and health before a Capability call; anonymous direct system-of-record paths also preserve machine-readable execute_readiness handoffs
get_receipt — Retrieve an execution receipt by ID
Budget enforcement, credential management, and execution telemetry included
Best current fit: research, extraction, generation, and narrow enrichment. Treat general business-agent automation and broad multi-system orchestration as future scope, not the current callable promise.
Surface | What it is for | Current honest boundary |
Rhumb Index | Free service discovery, AN Score lookup, alternatives, and failure-mode research | Broad discovery is not the same as execution readiness |
Rhumb Resolve | Governed execution for supported capabilities with estimates, receipts, budgets, and telemetry | 28 runtime-callable providers today; best fit is research, extraction, generation, and narrow enrichment |
MCP package | Agent-native entry point for Claude, Cursor, and other MCP clients | Discovery works without auth; execution needs a governed key, wallet-prefund, or x402 where supported |
API | Public read endpoints plus authenticated execution endpoints | Use current API responses as source of truth for readiness and callable coverage |
Path | How it works |
Rhumb-managed | Rhumb holds the credential — zero setup for the agent |
BYOK | Bring your own provider API key. Rhumb routes, you authenticate |
Agent Vault | Your key, encrypted and stored — Rhumb injects at call time |
Governed API key — sign up, get a key, prepaid credits
x402 / USDC — no signup, pay per call on-chain
Service = vendor Rhumb evaluates and compares
Capability = executable action like email.send
Recipe = deterministic multi-step workflow on top of capabilities (beta, sparse public catalog)
Layer 2 is the default path — start with governed API key or wallet-prefund on X-Rhumb-Key, discover a Service, choose a Capability, estimate, then execute
Start with managed superpowers first — bring BYOK or Agent Vault only when the workflow touches your own systems
Default auth for repeat traffic = governed API key or wallet-prefund on X-Rhumb-Key
Bring BYOK or Agent Vault only when provider control is the point
Use x402 when zero-signup per-call payment matters more than repeat throughput
Canonical onboarding map: https://rhumb.dev/docs#resolve-mental-model
rhumb-mcp exposes 21 tools:
Discovery
find_services — Search indexed Services by what you need them to do
get_score — Get the full AN Score breakdown for a Service: execution quality, access readiness, autonomy level, tier label, and freshness
get_alternatives — Find alternative Services, ranked by AN Score
get_failure_modes — Get known failure patterns, impact severity, and workarounds for a service
discover_capabilities — Browse Capabilities by domain or search text
resolve_capability — Given a Capability ID, and optionally a credential mode, returns ranked providers with health status, cost per call, auth methods, endpoint patterns, execute guidance, and 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, plus typo recovery when the capability ID is wrong
Execution
execute_capability — Call a Capability through Rhumb Resolve
estimate_capability — Estimate the active execution rail, cost, and health before a Capability call; anonymous direct system-of-record paths also preserve machine-readable execute_readiness handoffs
credential_ceremony — Get step-by-step instructions to obtain API credentials for a Service
check_credentials — Inspect live credential-mode readiness, globally or for a specific Capability
rhumb_list_recipes — List the current published Rhumb Layer 3 recipe catalog
rhumb_get_recipe — Get the full published definition for a Rhumb recipe, including input/output schemas and step topology
rhumb_recipe_execute — Execute a published Rhumb Layer 3 recipe once one is live in the public catalog
get_receipt — Retrieve an execution receipt by ID
Billing
budget — Check or set your call spending limit
spend — Get your spending breakdown for a billing period: total USD spent, call count, average cost per call, broken down by Capability and by provider
check_balance — Check your current Rhumb credit balance in USD
get_payment_url — Get a checkout URL to add credits to your Rhumb balance
get_ledger — Get your billing history: charges (debits), top-ups (credits), and auto-reload events
Operations
routing — Get or set how Rhumb auto-selects providers when you don't specify one in execute_capability
usage_telemetry — Get your execution analytics — calls, latency, errors, costs, and provider health for your Rhumb usage
Discovery spans 999 scored services, but current governed execution spans 28 callable providers.
Note: Layer 3 recipe tooling is live, but the public catalog can still be empty. Use
rhumb_list_recipesor visit/recipesbefore assuming a workflow exists.
Best current fit: research, extraction, generation, and narrow enrichment. Treat general business-agent automation as future scope, not the current callable promise.
Base URL: https://api.rhumb.dev/v1
Endpoint | Auth | Purpose |
| No | Score breakdown |
| No | Service profile + metadata |
| No | Known failure modes |
| No | Search services |
| No | Category rankings |
| No | Capability registry |
| No | Ranked providers + explicit |
| Yes | Execute a capability |
| Yes | Cost estimate |
| No | Provider health status |
| Yes | Your usage analytics |
| No | Machine-readable pricing |
See examples/ for runnable scripts:
Example | What it shows | Auth needed? |
Search → Score → Failure modes | No | |
Resolve → machine-readable recovery handoff → Estimate → Execute | No for resolve, yes for estimate/execute | |
Budget + cost-optimal routing | Yes | |
Repeatable Resolve → telemetry verification loop | Yes | |
MCP setup for Claude, Cursor, etc. | Optional |
# Try discovery right now (no auth needed)
pip install httpx && python examples/discover-and-evaluate.py
# Try the resolve walkthrough right now (no auth needed for resolve)
python examples/resolve-and-execute.pyresolve-and-execute.py will still show the ranked providers plus any machine-readable recovery handoff Rhumb already identified. Set RHUMB_API_KEY only when you want to continue into estimate and execute.
Agent Accessibility Guidelines — making web interfaces usable by AI agents
AN Score Methodology — scoring dimensions, weights, and rubrics
Architecture — scoring engine design
API Reference — endpoint details
Repo Boundary — what stays public here vs. what lives in the private ops workspace
Security Policy — vulnerability reporting and security architecture
rhumb/
├── packages/
│ ├── api/ # Python API (Railway)
│ ├── astro-web/ # Public website (Vercel)
│ ├── mcp/ # MCP server (npm)
│ ├── cli/ # CLI tooling
│ └── shared/ # Shared types/constants
├── examples/ # Runnable examples
├── docs/ # Public documentation only
├── scripts/ # Product tooling + verification scripts
├── artifacts/ # Curated public datasets only (raw proof outputs stay local/private)
├── llms.txt # Machine-readable docs for agents
└── agent-capabilities.json # Structured capability manifest# API
cd packages/api && pip install -r requirements.txt && uvicorn app:app --reload
# MCP
cd packages/mcp && npm ci && npm run dev
# Web
cd packages/astro-web && npm ci && npm run devNode 24+ recommended (.nvmrc included).
Every score is disputable. If you believe a score is inaccurate:
Read the public provider guide at rhumb.dev/providers
Open the score-dispute GitHub template with evidence
Or email providers@supertrained.ai for a private path
We target an initial response within 5 business days. Negative findings remain visible. Rhumb does not accept payment to change scores.
Website: rhumb.dev
npm: rhumb-mcp
MCP Registry: Rhumb on MCP Registry
X: @pedrorhumb
Check or set your execution budget. Without action param, returns current status. Use action='set' with budget_usd to create/update. Budget is enforced pre-execution — you get 402 (not a surprise bill) when over limit.
Inputs: action, budget_usd, period, hard_limit.
Check the current credit balance for your organization on Rhumb
Inputs: no named parameters.
Check your credential status across all three modes. Shows which capabilities are available via Rhumb-managed (zero-config), which services have ceremony guides for self-provisioning, and BYO status. Start here to understand what you can execute.
Inputs: capability.
Get step-by-step instructions for obtaining API credentials for a service. Without a service param, lists all available ceremonies. With a service param, returns detailed steps, token format info, and documentation links. Use this before agent_vault execute mode.
Inputs: service.
Discover what capabilities are available — search by domain or text. Returns capabilities with provider counts and top provider info.
Inputs: domain, search, limit.
Get cost estimate for executing a capability without actually executing it. Use before expensive operations or when building cost-aware workflows.
Inputs: capability_id (required), provider, credential_mode.
Execute a capability through Rhumb. Three credential modes: (1) byo — bring your own token, requires method+path; (2) rhumb_managed — zero-config, Rhumb provides credentials, method/path optional; (3) agent_vault — pass your own token via agent_token param (get it from credential_ceremony first). Use resolve_capability to see providers and check_credentials to see what modes are available.
Inputs: capability_id (required), provider, method, path, +5 more.
Semantic search for agent tools, ranked by AN Score
Inputs: query (required), limit.
Find alternative services ranked by AN Score
Inputs: slug (required).
Get known failure patterns for a service
Inputs: slug (required).
Get recent billing ledger entries for your organization
Inputs: limit, event_type.
Get a Stripe checkout URL to top up Rhumb credits
Inputs: amount_usd (required).
Get detailed AN Score breakdown for a service
Inputs: slug (required).
Resolve a capability to ranked providers with health-aware recommendations, costs, and fallback chains. The core agent decision: 'I need email.send — what should I use?'
Inputs: capability (required).
Get or set your provider routing strategy. Strategies: cheapest (lowest cost above quality floor), fastest (healthiest circuits), highest_quality (highest AN score), balanced (weighted mix). Quality floor filters out low-quality providers.
Inputs: action, strategy, quality_floor, max_cost_per_call_usd.
Get your spend breakdown by capability and provider. Shows total spend, execution count, and cost averages. Defaults to current month.
Inputs: period.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 16 tools
Most tools have distinct purposes, but some overlap exists: 'discover_capabilities' and 'find_tools' both involve searching for capabilities/tools, which could cause confusion. However, their descriptions clarify that 'discover_capabilities' is domain-focused while 'find_tools' is semantic search for agent tools, helping to mitigate ambiguity.
Tool names follow a consistent verb_noun pattern throughout, such as 'check_balance', 'discover_capabilities', and 'execute_capability'. All names use snake_case and clear, descriptive verbs, making the set predictable and easy to understand.
With 16 tools, the count is slightly high but reasonable for a comprehensive platform like Rhumb that manages capabilities, credentials, billing, and routing. It covers multiple aspects without feeling overly bloated, though it borders on the upper limit of a well-scoped set.
The tool set provides complete coverage for Rhumb's domain, including capability discovery, execution, credential management, cost estimation, billing, and routing strategies. There are no obvious gaps; agents can perform end-to-end workflows from setup to execution and monitoring without dead ends.
Discover and call 10,000+ production APIs from one MCP server. Pay-per-call billing for AI agents.
Discover, compare, and monitor 1,400+ APIs directly from your AI coding agent.
Find and call verified APIs from any AI assistant, with free trial calls and previewed writes.
Pay-per-use tool marketplace for AI agents. Search, price-check, and call APIs via MCP.
