Introducing the Sahara Open Source Agentic Protocols

Creating a fair, secure, and programmable agentic economy

Today, we’re excited to open-source three agentic protocols that fill a long-standing gap in AI and Web3 by giving agents a trustless, programmable way to access the tools and logic they need while automatically paying providers each time their assets are accessed or interacted with.

Through our work with developers and enterprise partners, it became clear that as the agentic ecosystem grows—and agents begin interacting with more tools, datasets, models, and even other agents—they need more than just a way to pay for access. The entire ecosystem needs a way to trust the compute being performed, verify that outputs were produced correctly, enforce usage policies, and ensure transparent compensation for providers. Existing standards, including the original x402 payment primitive, didn’t cover this full set of requirements.

To solve this, we built a suite of protocols that extend the original x402 design into a complete execution and coordination layer for autonomous systems. This release marks the foundation for the next phase of our vision. As agents become more capable and interconnected, they require infrastructure that enables fair value distribution, verifiable execution, and programmable collaboration at scale. These protocols form the foundational trust layer that future autonomous systems will depend on.

These extensions are now open source at:
👉 GitHub: https://github.com/SaharaLabsAI/x-function 

The Sahara x402 Extensions

1. x/function - serverless — Serverless, Modular Deployment for Fair Value Distribution

x/function - serverless upgrades x402 from a payment-for-access model to payment-for-deployment. Agents can now spawn micro-agents, single-use functions, or personalized logic on demand without developers having to host servers, manage infrastructure, or maintain full APIs.

In real agentic systems, needed computation often doesn’t exist ahead of time. But hosting entire services for tiny pieces of logic isn’t practical, and it prevents smaller contributors from participating.

By enabling dynamic, serverless deployment, x/function makes it possible for developers to contribute small, modular pieces of functionality that come together to form a larger agent workflow. And that modularity unlocks fair revenue sharing:

• each function or micro-agent can be owned by a different contributor (e.g., one person builds a data-cleaning step, another builds a risk estimator, another builds a formatting layer, etc)

• each invocation automatically routes payment to that contributor

• agent workflows can chain multiple components, distributing value across all contributors involved

This creates a more flexible and equitable agent economy where value flows directly to the people who build the tools agents actually use, not just to large API providers.

For a technical breakdown of x/function, check out our docs.

2. x/function - verifiable — Trustless Compute for Secure Agent Workflows

x/function - verifiable adds a secure and verifiable execution layer to agent workflows. Every computation returns a cryptographic work proof generated inside a Trusted Execution Environment (TEE) or another secure runtime. This lets agents confirm that a function was executed correctly without revealing private data or internal code.

As agents increasingly interact with external tools, financial systems, and other agents, trust can’t be assumed. The base x/function model relies on the provider executing the function honestly, but autonomous systems require something stronger.

x/function/verifiable replaces trust with cryptographic verification:

• every computation includes a proof of correct execution

• enclaves ensure data and logic stay private

• agents can independently validate results before acting on them

• workflows can chain together untrusted components with confidence

This provides the security and integrity layer needed for agents to make reliable decisions, coordinate with unfamiliar services, and operate in complex environments without relying on blind trust.

For a technical breakdown of x/function/verifiable, check out our docs.

3. x/function - customized policy — Programmable Governance for Programmable Agent Workflows

x/function - customized policy adds a programmable rules layer that lets providers define and enforce “terms of use” for their data, models, and tools (e.g., “this data can be used for analysis but not for training”). Requesters submit intent claims, secure enclaves verify those claims against the provider’s policy, and only compliant interactions proceed.

As autonomous systems become more modular and interconnected, agents increasingly rely on one another for specialized capabilities. For that to work, agents need clear, machine-readable usage rules they can trust, and providers need assurance their assets are used in ways that respect their terms.

This creates fine-grained, enforceable governance across the AI ecosystem. As AI becomes increasingly modular—with functions, datasets, and models composed from many independent contributors—providers need assurance that their assets are used as intended, and consumers need clear, machine-readable rules they can rely on.

x/function/customized-policy introduces that missing layer:

• providers can define precise, enforceable usage rules

• requesters formally declare intended use

• secure enclaves validate compliance before execution

• AI assets from multiple contributors can be safely combined

This also lays the groundwork for safer agent-to-agent interaction, where agents can call other agents or services with guaranteed, verifiable constraints on how underlying assets may be used. It’s a foundational step toward a broader crypto agent network where collaboration is governed by transparent, programmable policies.

For a technical breakdown of x/function/customized-policy, check out our docs.

What’s Coming Next: The Path to an Autonomous AI Economy

The x402 extensions mark the trustless foundation for the next phase of our vision. Since the beginning, our mission has been to build a more open, transparent, and equitable AI economy where anyone can create, contribute to, and benefit from AI. Expanding this vision into the agentic space is a natural evolution of that work, as autonomous agents become an increasingly important part of how AI will be built and used.

To support this future, we’re enhancing both our on-chain infrastructure (the Sahara Blockchain) and our off-chain infrastructure to better serve as the economic and coordination layer for autonomous agents. This includes optimizing the chain for high-frequency micro-transactions, low-latency agent discovery, secure on-chain state management, and transparent attribution and agentic revenue distribution. Paired with our open-source agentic protocols, this creates an end-to-end foundation for developers to build a new wave of autonomous AI applications.

For updates as we continue shaping the agentic economy, be sure to join our newsletter. 

Be sure to check out the docs for a technical dive into all three x402 Extensions.