VELLAR

The marketplace writes the tools. Every paid API becomes a callable WebMCP tool automatically, no code, no registration, just a real payment. Built on Stellar ecosystem.

Comment

Inspiration

AI agents can browse the web but they cannot pay for things. We have been building the infrastructure to change that for months.

Vellar is the agent-payments stack for Stellar, a passkey smart wallet with on-chain spending policies, an open-source x402 facilitator that verifies and settles payments including policy-governed smart accounts other facilitators reject, a trust-ranked Bazaar that catalogs payable APIs from real settlement data, a VS Code extension that lets any developer gate an API endpoint for payment in under a minute, and an explorer that indexes every settlement on-chain.

When the WebMCP Challenge launched, we had one question: what happens when you put a browser-native agent interface on top of a live, running payment infrastructure that already has real endpoints, real settlements, and real USDC moving through it?

What it does

Vellar x402 is a live API marketplace for AI agents, powered by the full Vellar stack.

Open the page in a WebMCP-enabled browser and the agent sees a set of callable tools, not because a developer wrote them, but because real sellers deployed real endpoints, received real on-chain USDC payments through the Vellar Facilitator, and earned their way into the Vellar Bazaar catalog.

Nobody wrote call_uuid. The marketplace did.

The page queries the live Bazaar at load time, filters for endpoints with real settlement history and verified trust scores, and dynamically registers a WebMCP tool for each one. As sellers list new endpoints and earn trust through real payments, new tools appear automatically without a single line of code changing. The tool list is a live query result, not a specification frozen at build time.

Three core tools handle the agent workflow:

search_vellar_bazaar searches the live Bazaar catalog for payable endpoints with prices and trust status.

pay_and_call provisions a throwaway Stellar wallet, acquires USDC, signs a real x402 payment, and returns the response with an on-chain tx hash.

check_vellar_earnings shows a seller's real settlement history from the Vellar Explorer.

Every additional tool is generated live from the Bazaar. When an agent calls call_uuid, a real Stellar transaction settles. The tx hash is verifiable on Stellar Expert.

How we built it

This submission is the WebMCP layer on top of months of infrastructure.

The Vellar Facilitator is an open-source x402 verify/settle service live at https://facilitator.vellar.xyz . It includes a 50-account channel pool proven at 50 true-simultaneous settlements with zero sequence failures, a Bazaar discovery layer that auto-catalogs endpoints from real payment data, and a trust layer that ranks results by settlement count and on-chain contract verification.

The Vellar Wallet is a passkey smart wallet on Stellar with programmable on-chain spending policies. An agent gets a scoped session key with a spending limit enforced by a policy contract. Go over budget and the chain refuses before any money moves.

The Vellar VS Code Extension is live on the VS Code Marketplace (VellarWallet.vellar-x402). Any developer can open an Express, Fastify, or Next.js route file, run one command, and have a working x402 payment gate injected with the Bazaar discovery extension included. Their endpoint self-lists in the Bazaar on first payment.

The WebMCP layer is built in Next.js on Render, using @mcp-b/webmcp-polyfill for broad browser compatibility and @x402/core plus @x402/stellar for the payment flow. All payment logic runs server-side so throwaway keypairs never touch the browser. Every external call is proxied through our own API routes to eliminate CORS failures in browser tool execution.

Challenges we ran into

Sequence number contention at scale. Stellar serializes transactions per source account. Under concurrent load, multiple settlements racing on one account produce txBadSeq failures. We built and load-tested a 50-account channel pool, 50 simultaneous payments, zero sequence failures, p95 under 12 seconds, before this hackathon started. That infrastructure is what makes pay_and_call reliable under real agent usage.

Dynamic tool generation edge cases. Catalog URLs become tool names. Path templates like /inspect/:address, localhost entries, and naming collisions all needed filtering before a single registerTool call was made. A tool guaranteed to fail on every invocation is worse than no tool.

CORS at the WebMCP boundary. Browser-based tool execute functions cannot call cross-origin APIs without CORS headers. Every external call is proxied through Next.js API routes so tools never fail silently in a browser context.

Proving it is real. The easiest thing to fake in a hackathon demo is an on-chain payment. We did not fake it. Every tool call that involves a payment produces a tx hash verifiable on Stellar Expert.

Accomplishments that we're proud of

The marketplace writes the tools, not the developer. That sentence sounds simple. Behind it is a live payment facilitator handling concurrent settlements, a trust-scored discovery catalog built from real on-chain data, a passkey smart wallet with programmable spending policies, a VS Code extension that onboards sellers in under a minute, and now a WebMCP layer that turns all of it into callable agent tools automatically.

Any developer who deploys an x402-gated endpoint using the Vellar VS Code extension and receives one real payment is automatically callable by every agent using this page. Zero integration work. Zero registration form. The payment is the registration.

Every tx hash in this submission is real. Every settlement in the earnings table represents a real throwaway wallet that funded itself, acquired USDC on the Stellar testnet DEX, and paid a real endpoint autonomously. Nothing mocked. No simulated responses.

What we learned

Building the WebMCP layer took days. Building the infrastructure that makes it meaningful took months.

The hardest problems were not in the browser API. They were in the payment rails, sequence number contention under concurrent Stellar settlements, the difference between a txBadSeq and a TRY_AGAIN_LATER, why a fee-bump transaction separates fee payment from sequence number management, what it actually takes to prove 50 concurrent settlements with zero failures.

We learned that "the agent pays for it" is a sentence that sounds simple and takes an entire stack to make true.

What's next for VELLAR

Vellar is about to launch on Stellar mainnet. Real USDC, real agents, real commerce, no intermediary, no API key, no account, just a payment and a response.

The Vellar Wallet already supports passkey smart accounts with on-chain spending policies. An agent with a Vellar session key and a spending limit enforced by a policy contract can use this WebMCP page to discover and pay for APIs autonomously, within a budget its owner set, revocable at any time, with every payment verifiable on-chain.

The tool list on this page grows itself. Every endpoint that transitions from unverified to proven-unconfirmed to verified in the Bazaar becomes a new callable WebMCP tool automatically. As Vellar goes to mainnet and the Bazaar fills with real production endpoints, the marketplace that writes the tools gets bigger, richer, and more valuable to every agent that uses it.

We built the marketplace. We are about to open it for real.

Built With

Share this project:

Updates

Submission history