Waypoint

Waypoint is a developer infrastructure company building the routing, discovery, and settlement layer for AI agents. Co-founded by Narasimhan Rengan and admitted to Canopy Spring 2026 at Founders, Inc., the platform lets developers discover, invoke, and pay any agent through a single SDK, handling routing, billing, and trust scoring across an index of over 41,000 agents organized into 66 capability categories.¹ The company describes its position as "DNS + npm + OpenRouter for agents" — resolving the coordination gap that emerged after the Model Context Protocol standardized agent invocation but left capability discovery, quality signaling, and payment entirely unsolved.²

Background

The Model Context Protocol (MCP) standardized how AI agents invoke tools. In under a year of its introduction, 41,000+ MCP servers appeared across multiple public registries.² That growth created a structural problem: when an agent needs a capability — say, lead enrichment — it receives a flat list of servers and must pick one without access to quality signals, pricing, latency benchmarks, SLA guarantees, or trust scores. The availability of many agents made the selection problem worse, not better.²

Waypoint's founders framed this as a solved-call, unsolved-contract problem: MCP handled the mechanics of invoking a tool, but everything that should happen before and after the call — discovery, negotiation, billing, and accountability — remained unaddressed.² The company launched to operate as the coordination layer between agent consumers and agent providers, drawing an analogy to the role DNS plays for web addresses, npm for software packages, and OpenRouter for LLM access.²

Platform

Waypoint's platform indexes agents from five public MCP registries, classifying them into a 66-category capability taxonomy with categories like ai.inference, search.web, and database.query.¹ As of April 2026 the directory contains 41,390 agents,¹ with over 200 verified as working without authentication and over 3,800 individual tools discovered.² The platform runs a hosted MCP Discovery Gateway at mcp.waypoint.ing that connects standard MCP clients — including Claude and Cursor — to the full agent directory without any installation or OAuth setup.¹

New accounts receive $5 in free credits on signup. Access requires signing in with Google or GitHub and generating an API key from the billing dashboard; the dashboard shows every invocation with latency and per-call cost.⁷

ATP: Agent Transfer Protocol

Waypoint defines the Agent Transfer Protocol (ATP), a thin layer above HTTP that adds identity, routing, billing, and trust to every agent interaction.⁶ The protocol specifies five commands:

• DISCOVER — search agents by capability, cost, latency, and trust score
• TASK — execute a capability on a specific agent
• NEGOTIATE — compare cost and latency offers from multiple agents before committing to an invocation
• DELEGATE — used by orchestrator agents to route to the best downstream provider for a sub-task
• METRICS — retrieve performance data, trust scores, and usage statistics⁶

Every agent is identified by a stable URI in the format agent://{owner}/{name}, where the owner is a verified namespace tied to a cryptographic identity.⁶ Capability names follow a dot-separated taxonomy — lead.enrich, search.web, code.review — with each capability declaration including JSON Schema definitions for inputs and outputs, a per-call price in USD, and SLA commitments for latency and availability.⁶

Authentication uses Ed25519 signatures: every ATP request is signed with the caller's private key against a canonical representation of the method, path, body hash, and timestamp; the gateway verifies the signature against the caller's registered public key in under 1ms.⁶ For agent-to-agent calls, delegation tokens — scoped JWTs specifying which capabilities the delegate can invoke, a cost ceiling, and an expiration time — carry authorization without sharing raw credentials.⁶

Waypoint supports agents built with any framework through protocol adapters. The MCP adapter maps MCP tools to ATP capabilities automatically; the OpenAPI adapter wraps REST APIs using their OpenAPI specs; the A2A adapter bridges Google's Agent-to-Agent protocol, mapping A2A tasks to ATP TASK commands.⁶

Routing Engine

The routing engine selects agents through multi-signal ranking across five dimensions: trust score, benchmark score, per-call cost, observed latency (p50 and p95), and historical success rate.³ The router computes a weighted composite score, applies any caller-specified constraints (a cost ceiling via max_cost_usd or a latency cap via max_latency_ms), and excludes non-qualifying agents before ranking. If no agents can satisfy the stated constraints, the router returns a CONSTRAINT_NOT_SATISFIABLE error rather than silently degrading quality.³

When the top-ranked agent fails — due to a timeout, error response, or open circuit breaker — the router automatically retries with the next-best candidate from the ranked list, continuing until either a successful response is returned or all fallbacks are exhausted, at which point it returns an AGENT_UNAVAILABLE error with per-attempt failure reasons.³

Circuit breakers operate per agent across three states: Closed (normal operation), Open (triggered after consecutive failures, causing all requests to be immediately rejected and rerouted), and Half-open (a single probe request is sent after a 1-second cooldown; success closes the breaker, failure reopens it).³ A single degraded agent does not affect routing to other agents serving the same capability.³

The NEGOTIATE command lets callers compare cost, latency, and quality estimates from multiple agents before committing to an invocation, enabling cost-sensitive or latency-sensitive applications to make informed routing decisions.³ The DELEGATE command supports router agents — agents that orchestrate other agents — by issuing scoped delegation tokens that permit specific downstream capabilities up to a cost ceiling and expiration.³

Trust and Scoring

Every indexed agent receives a composite trust score derived from three components.⁴

The metadata trust score draws on signals gathered during cross-registry crawling: GitHub stars, commit recency (commits within 90 days score higher than older repositories), usage volume (Docker pull counts, Smithery useCount, download metrics), schema completeness (whether tool definitions include descriptions, typed parameters, and output schemas), and registry presence across multiple listing sources.⁴ Three adaptive weight profiles — Full, Partial, and Enriched — adjust signal contributions based on data availability.⁴

The probe score reflects automated health checks covering liveness (servers that fail liveness score 0 across all checks regardless of other signals), handshake latency, tool count, and schema quality.⁴

The benchmark score is computed in a second probe phase that invokes each tool with valid test inputs and verifies the response against expected patterns.⁴ This identifies agents that work without authentication — a non-trivial filter, since many indexed servers are misconfigured, abandoned, or require inaccessible API keys.⁴

Based on the composite score, agents fall into four trust tiers: Limited (minimal signals), Standard (basic metadata and passing health checks), Trusted (strong signals, consistent probes, verified tool-call success), and Exemplary (top-tier across all dimensions).⁴ Portal display tiers — Featured, Verified, and Indexed — determine search ranking and badge visibility. Trust scores are recomputed every five minutes; probe data is refreshed daily via a scheduled Kubernetes CronJob.⁴

Billing and Settlement

Agents declare per-call prices in USD in their ATP manifests; free agents set price_usd: 0 and are still metered for usage analytics.⁵ Consumers prepay credits; each invocation deducts the agent's declared price from the consumer's balance, with the balance checked before dispatch and insufficient balances returning a SPENDING_LIMIT_EXCEEDED error rather than proceeding.⁵

Exactly-once billing is enforced through metering deduplication: every invocation carries an idempotency key, and duplicate metering events from retries or network failures are detected and discarded, ensuring consumers are never double-charged.⁵ Provider payouts settle within 24 hours of the invocation; the platform retains a percentage of each transaction.⁵

Consumers can configure per-agent and per-day spending limits. Disputes may be filed within 7 days of an invocation; automated refunds are issued for provable failures — error responses, timeouts, and unreachable agents — without manual review.⁵

SDK

The TypeScript SDK (@waypointing/sdk) and a Python SDK provide the primary developer interfaces.⁷ The TypeScript client is initialized from three environment variables issued when an API key is generated:

WAYPOINT_AGENT_ID=users/u-<id>
WAYPOINT_KEY_ID=wk_<timestamp>_<random>
WAYPOINT_PRIVATE_KEY=<64-char hex>

A WaypointClient.fromEnv() call reads these variables and returns a configured client. Invocations use waypoint.task(agentId, input), with SSE streaming, automatic fallback chains, and circuit breaker logic built into the client.⁷³

References

1. Waypoint — The Agent Routing Layer(accessed Apr 24, 2026)
2. Waypoint Documentation(accessed Apr 24, 2026)
3. Routing — Waypoint Docs(accessed Apr 24, 2026)
4. Trust & Scoring — Waypoint Docs(accessed Apr 24, 2026)
5. Billing — Waypoint Docs(accessed Apr 24, 2026)