Summary
PATH is the open-source demand-side client for Pocket Network’s Morse and Shannon upgrade—a suite of APIs and orchestration tools that simplifies integration for applications, including enterprise deployments. It provides a lightweight off-chain Gateway for dispatching JSON-RPC relays into the network, leveraging Shannon’s on-chain proofs, compute-unit metering, token burns, and on-chain reward distribution, with built-in QoS for data validation, abstracting the complexity of proof generation and stake-based routing behind developer-friendly APIs. This gives you a permissionless, transparent API that’s predictable in cost and free from centralized bottlenecks.
Intro
Decentralization promised to eliminate single points of failure. Yet, dApps today rely on a patchwork of proprietary RPC gateways that behave like private toll roads—each with its own closures, bandwidth gaps, and surprise fees. When demand spikes or markets swing, these single-point services buckle, quietly slow down traffic, which leads to inefficiencies and eventually erodes user trust. Worse still, no gateway covers every use case, so every new integration becomes its own engineering project—juggling API keys, endpoints, and SLAs.
PATH reframes this reality as a unified, permissionless infrastructure layer. Built on Pocket Network’s Shannon upgrade, it transforms any HTTP API, blockchain node, or AI model into a composable ‘data lane’ on a single decentralized freeway—with transparent economics and quality-of-service guarantees.
This blog examines PATH’s core architecture and operational model, its role in the Shannon upgrade, its economic and data-validation frameworks, and its real-world use cases.
Fundamentals: What is PATH?
At its simplest, PATH (short for PATH API and Toolkit Harness) is an open-source framework that makes it incredibly easy to spin up a permissionless gateway on top of Pocket Network’s decentralized relay mesh. Instead of managing a fleet of unreliable RPC nodes or paying steep fees to centralized providers, you deploy PATH, point it at your configuration, stake some POKT, and you’re in business.
PATH, which was significantly enhanced by the Shannon upgrade, now serves as Pocket Network’s “Gateway” layer and even more. It lets anyone deploy a lightweight service between their application and the decentralized web of data suppliers. Think of it as a round-the-clock concierge for data—whether you need a blockchain node, a web API, or an AI model, it routes your requests to the right source every time.
In practical terms, PATH is:
- Permissionless: Anyone can deploy a Gateway or consume data without special access approvals.
- Composable: Mix and match any open data source—public blockchains, Web2 APIs, AI endpoints, storage networks, oracles—under a single PATH endpoint.
- Scalable: Gateways act as application-facing load balancers, automatically distributing traffic across all available supplier nodes.
But how did PATH emerge, and what milestones defined its evolution? Let’s find out in the next section.
Technical Architecture of PATH
Under the hood, PATH is built around a few core components that work together to deliver reliable, permissionless API access. In the following subsections, we’ll break down each component, showing how PATH’s architecture ensures high performance, on-chain settlement, and built-in quality of service. First, let’s see exactly where PATH fits in the Web3 infrastructure stack—this will give us a clear picture of its role and purpose.
PATH in the Infrastructure Stack
To understand PATH, you have to place it in context.
In the Web3 infrastructure stack, think of PATH as the connective tissue between apps and the decentralized networks they rely on. It’s not a node or a blockchain—it’s the access layer.
Web3 Stack Overview:
- Data Layer: Blockchain networks (Ethereum, Solana, etc.)
- Compute Layer: Rollups, execution layers, and indexing tools
- Access Layer: Gateways, APIs, SDKs (PATH lives here)
- Incentive Layer: Tokenomics, staking, governance (Pocket protocol)
PATH competes with services like Infura and Alchemy. But while those are closed, centralized SaaS offerings, PATH is permissionless and modular. You can run one yourself, tailor it to your users, and earn rewards.
| Feature | PATH Gateway | Centralized RPC providers |
| Permissionless | ✅ Yes | ❌ No |
| Self-hosted Option | ✅ Yes | ❌ No |
| Revenue Opportunity | ✅ Gateway earns | ❌ Vendor keeps profits |
| Customizable Logic | ✅ Fully | ✅ Partial (Enterprise) |
Core Components of PATH
Technical Architecture of PATH
1. Gateways: The Front Door
Gateways are the off-chain HTTP/JSON-RPC servers you deploy with PATH, which your applications call when they need data. They are public endpoints that provide lightweight and stateless services that:
- Accepts requests in standard JSON-RPC or REST formats.
- Handles authentication (API-key or, soon, JWT/OIDC) via the GUARD component.
- Batches and forwards incoming calls to RelayMiners, tracking each request in memory to facilitate response reconciliation.
- Applies basic validation (e.g., rate limiting, input sanitization) before passing work downstream.
Because Gateways run off-chain, you can spin up as many as you need to handle any traffic surge, all while keeping the interface simple and developer-friendly. Under the hood, PATH is the open-source toolkit that powers these Gateways—so every public RPC URL you hit is just one live instance of PATH’s Gateway module, seamlessly bridging your app to the network’s on-chain mechanics.
Examples of Gateways on Pocket Network. Source: POKTScan
2. RelayMiners
RelayMiners are the heart of PATH’s on-chain guarantees. They sit between Gateways and Suppliers, performing three critical functions:
- Routing: RelayMiners select an optimal Supplier based on real-time metrics like latency, error rates, and historical reliability.
- Proof Generation: After a Supplier returns the data, the RelayMiner packages the request, response, and metadata into an on-chain “relay proof,” minting one compute unit (CU) worth of settlement.
- Settlement: Relay proofs get recorded on the Pocket blockchain, triggering automatic POKT token transfers (and burns) according to Shannon’s compute-unit pricing.
This design ensures every data request is logged on-chain, creating an auditable trail and aligning economic incentives between operators and users.
3. Suppliers
Suppliers are “staked node” operators running the infrastructure, including full blockchain nodes, LLM endpoints, or other API services. Because Suppliers must lock up POKT tokens to participate, they have skin in the game: delivering accurate, timely data directly impacts their earnings.
Their responsibilities include:
- Running reliable, up-to-date nodes for each supported chain or service.
- Responding to RelayMiner queries with the requested data.
- Maintaining high uptime and consistency, since poor performance can lead to reputational penalties (e.g., lower selection priority).
Suppliers’ information on Pocket Network. Source: POKTScan
Built-in QoS Mechanisms
PATH comes with quality-of-service (QoS) checks enabled by default, ensuring the data you receive is accurate and reliable. These mechanisms run transparently, with no extra setup, across any staked service you deploy. Please check our previous PATH blog here for more info on activating it.
- Archival State Validation
In PATH, archival state validation ensures reliable access to historical blockchain data. When an application issues a deep-history request, PATH tags the call with the RPC method and target block height, then checks its on-chain registry to find only those Suppliers who’ve confirmed they run full archive nodes. Next, it selects a random block at least 128 confirmations behind the tip and sends the request—whether eth_getBalance, eth_call, or a similar request—to every qualified archive node. As soon as five of them report the same result, that value becomes the official “ground truth,” and any outliers are quietly dropped.
Behind the scenes, PATH handles block selection, node filtering, quorum checks, and error handling for you, so you get accurate, up-to-the-minute historical data without ever touching a node yourself. This results in reduced error rates, more reliable data for developers, and better resource allocation across the network, all without requiring the application to understand the underlying complexity.
- Error Mapping
PATH implements a standardized mapping of JSON-RPC error codes to HTTP statuses, providing clear and consistent responses to client applications. Below are some examples of responses:
For example:
- Parse error (-32700) and Invalid request (-32600) both return 400 Bad Request
- Method not found (-32601) returns 404 Not Found
- Invalid params (-32602) returns 400 Bad Request
Please refer to the source and mappings in the PATH QoS documentation for more information.
- Automatic QoS & Supported Services
PATH runs quality-service checks on every configured service by default and lets you disable or tweak them via the qos_disabled_service_ids setting in your .config.yaml. As of May 2025, archival validations are applied across all major EVM chains (Ethereum MainNet, Polygon, Oasys, etc.) and select CometBFT networks (e.g., Celestia), while other chains will operate normally without archival consensus.
At-a-Glance Component Table
| Component | Role | Pocket Layer Fit | Other RPC Alternative |
| Gateway | Entry point for app requests | On-chain Gateway | Load balancer |
| RelayMiner | Proxies & proof generator | Relay mining node | API proxy |
| Supplier | Decentralized data provider | Staked node operator | Managed node |
| Source | Actual backend server | Blockchain/LLM nodes | Central server |
PATH & Shannon: How They Power Each Other
At its core, Shannon is Pocket Network’s major protocol upgrade, rebuilt on the Cosmos SDK to unlock permissionless gateways, enhance scalability, and implement a sharing-economy model for any open data source. PATH, meanwhile, is the open-source toolkit designed from the ground up to leverage Shannon’s new features, turning raw protocol capabilities into developer-friendly, production-ready gateway instances.
Shannon’s Key Innovations
- Permissionless Gateways: Any operator can spin up a gateway without an invitation, broadening supply-side participation and use-case diversity.
- Compute-Unit Economics: Shannon charges and rewards per compute unit (CU), with transparent on-chain minting, burning, and distribution of POKT for every fulfilled request. Some of the new Shannon economic parameters include:
- Price peg: $1 per 1 billion CUs (1 × 10⁻⁹ USD)
- Initial CUTTM: 66,667 pico-POKT (1 pico-POKT = 10⁻¹² POKT)
- Adjusted CUTTM: 495 pico-POKT to target $2.50 per million relays (≈ 5× cost reduction vs. Morse’s RTTM). More details in our recent tokenomics upgrade blog.
- Modularity & Interop (“MICE”): Built on the mainline Cosmos SDK (CometBFT), Shannon brings Modularity, Interoperability (IBC), Compatibility (with Cosmos tools), and Extensibility for future features.
PATH’s Role in Shannon’s Ecosystem
- Enabling Permissionless Gateways: PATH’s Gateway module is the recommended implementation for Shannon’s permissionless gateway concept—configuring, authenticating, and scaling public endpoints without extra code.
- Driving Economic Participation: By packaging Shannon’s CU pricing into its RelayMiner module, PATH automatically generates and submits relay proofs, ensuring every request earns or burns POKT according to Shannon’s rules.
- Extending Use Cases: Shannon opens the network to any data service—blockchain, AI models, oracles, social protocols—and PATH’s modular design makes adding new Sources as simple as updating a config file, bringing Shannon’s sharing economy to life.
- Abstracting Complexity: While Shannon handles on-chain coordination and tokenomics, PATH abstracts those details behind developer-friendly APIs,
PATH Economic Incentive Mechanics
Let’s talk dollars (or rather, POKT) for a minute—because PATH isn’t just about clever code and slick APIs, it’s also a finely tuned economic engine. Whenever your PATH gateway proxies a request, its RelayMiner module applies Shannon’s compute-unit pricing to burn fees and mint rewards on-chain. Here’s how it breaks down:
- Staking & Fee-Burn
Operators stake POKT to register Gateways or Suppliers. Each relay consumes CUs and burns a small POKT fee. Following the Shannon parameters above at 495 pico-POKT/CU, 1 M relays burn 0.495 POKT.
- Reward Distribution via RelayMiner
PATH’s RelayMiner then submits the relay proof on-chain, triggering Shannon’s reward split:
- Suppliers: 78 %
- Validators: 14 %
- DAO treasury: 5 %
- You (Gateway operator): 3 %
- Network Impact
As more PATH gateways come online and handle greater relay volume, total POKT burned—and thus the overall reward pool—grows. Because PATH automates proof submission, every new gateway scales both the deflationary burn and operator rewards in lockstep with Shannon’s fixed percentage splits.
Example Breakdown
If your PATH gateway manages 100 million relays at 495 pico-POKT/CU:
- Total POKT burned & minted: 0.495 POKT
- Your share (3 %): 1.485 POKT
Staking 100 POKT to run a PATH gateway yields a 1.485 % monthly return under these parameters—modest on a single node, but entirely automated and compounding as you scale your gateway fleet.
PATH’s Interoperability with the Broader Web3 Ecosystem
PATH is fundamentally protocol-agnostic: if a service exposes an HTTP/JSON-RPC interface, PATH can treat it as a “Source” and relay through its Gateway → RelayMiner → Supplier pipeline.
By treating every external service as a first-class Source, PATH turns any Web3 (or Web2) infrastructure into a permissionless, token-aligned API—truly blurring the lines between networks and making interoperability the default. This design unlocks easy interoperability with:
- CometBFT Chains (e.g., Celestia):
PATH’s QoS modules already support archival checks for CometBFT chains like Celestia. By adding a Celestia node RPC URL under your chains.json, your gateways can relay DA queries with the same reliability as EVM calls.
- AI/ML Inference Endpoints:
Decentralized LLM services (like DeepSeek on Shannon Beta) plug into PATH by registering the model’s HTTP endpoint as a Source. This enables on-chain metering and token-backed reliability for inference calls via PATH’s RelayMiner proofs.
- XRPL EVM Sidechain
Grove announced support for the XRPL EVM sidechain, enabling developers to call XRP-Ledger smart contracts through a PATH Gateway URL. This makes PATH a bridge between ISO-style Web3 apps and XRPL’s high-throughput environment.
Ideal PATH Users Outside Pocket Network
Every piece of technology finds its sweet spot—PATH is no exception. While it can serve any project needing reliable, decentralized data access, a few profiles stand to gain the most:
- Middleware & Infrastructure Providers: White-label decentralized APIs without running node fleets.
- dApp Teams: One gateway, multi-chain support, built-in QoS—no vendor lock-in.
- Enterprises: Permissionless gateways with transparent cost models and on-chain SLAs.
- AI & Data Science Groups: Metered, token-backed access to decentralized ML endpoints.
- DePIN/IoT Builders: Secure, scalable endpoints with on-chain proofs for sensor feeds and edge data.
Get Involved
Ready to join the PATH community and start building?
- Explore the Code: Browse the open-source PATH GitHub repo for CLI tools, Helm charts, and docs.
- Try a Gateway: Spin up a test gateway in minutes—no invites needed—using resources from our blog.
- Join the Community: Hop into our Discord or Forum to ask questions, share feedback, and watch new features roll out.
- Govern the Future: Stake POKT, vote on proposals, and help steer Shannon’s and PATH’s roadmap via our DAO.
Conclusion
PATH has transformed from an invite-only experiment into a permissionless, open-source gateway framework built on Shannon’s token-backed economics and on-chain proofs. Combining lightweight Gateways with RelayMiners, staked Suppliers, and modular Sources delivers reliable, metered, and auditable data lanes for any HTTP or JSON-RPC service, whether blockchain nodes, AI models, or custom APIs.
With every request burning POKT, rewarding performance, and funding the DAO, PATH aligns incentives across the ecosystem and keeps costs predictable.
Now that permissionless gateways are live on Shannon mainnet, it’s your move: deploy a PATH gateway, stake some POKT, and start providing resilient, decentralized API services at scale. The freeway is open—let’s build the next generation of Web3 together.