Galleon

Inspiration

Publishers earn through subscriptions and advertising. Agents do not look at ads, and they often need one authoritative source rather than a full subscription. A publisher's work can become more useful to agents while generating less revenue for the people who created it.

Galleon asks a simple question: what if a webpage could quote an exact price to an agent, let the person approve it, and return the licensed source with its canonical citation?

What it does

Galleon gives an AI agent an authenticated wallet with human-controlled spending limits.

A participating publisher exposes two WebMCP tools. inspect_source returns free metadata, provenance, the exact price, access rights, and a signed offer. unlock_source redeems a short-lived entitlement and returns the full article as formatted Markdown with its canonical citation.

Payment authority never enters the publisher page. After the person approves the exact source, price, and rights, the agent calls purchase_offer through the user's local Galleon wallet MCP. The wallet validates the offer, enforces spending policy, records the purchase, and returns an entitlement scoped to that source and publisher.

The complete flow is intentionally small:

const offer = await inspect_source({});

await human.approve({
  source: offer.source.title,
  price: offer.offer.display_price,
  rights: offer.offer.rights,
});

const purchase = await purchase_offer({
  offer_token: offer.offer.offer_token,
  expected_amount_minor: offer.offer.amount_minor,
  expected_currency: offer.offer.currency,
  idempotency_key: crypto.randomUUID(),
});

const article = await unlock_source({
  entitlement_token: purchase.entitlement.token,
});

return {
  markdown: article.source.markdown,
  citation: article.source.citation,
};

The current prototype uses test credits.

Why WebMCP

WebMCP lets the commercial terms travel with the source. The agent discovers the offer on the page instead of scraping a paywall or sending the user through a separate checkout.

We pair WebMCP with a traditional MCP because they represent different trust boundaries. WebMCP belongs to the publisher page and exposes page-scoped source tools. The wallet MCP belongs to the user and holds identity, balance, policy, and purchase authority. Together, they let a person and an agent buy one authoritative source without exposing payment credentials or moving the article into an intermediary catalog.

We believe the end-state of Galleon is one where the human browsing experience remains the same as it has historically been and ad-supported, while agents are metered for their consumption.

How we built it

We built and deployed Galleon on floo, which helped us ship a multi-service application with Codex and allocate necessary resources such as our postgres database.

Codex was our primary agentic development tool. We used Codex to implement the TypeScript application, inspect the repository, test the real browser journey, exercise the WebMCP tools, review trust boundaries, diagnose deployment failures, and iterate on the product experience.

The system has three parts:

1. A consumer application for accounts, test-credit wallets, spending policies, and purchases.
2. An authenticated wallet MCP that validates offers, records retry-safe ledger transactions in PostgreSQL, and issues short-lived entitlements.
3. An independently hosted publisher that registers inspect_source and unlock_source through document.modelContext.registerTool().

Offers and entitlements are signed and bound to the content, publisher origin, and browser session. The publisher receives only the entitlement. It never receives the user's wallet credential.

Challenges we ran into

The first challenge was the economics of very small purchases. Traditional credit-card checkout is poorly suited to charging a few cents whenever an agent needs one source. We built a test-credit wallet and balanced ledger to prove the interaction before connecting production financial infrastructure.

The second challenge was separating trust correctly. The publisher needs proof of purchase but must never receive the wallet credential. The wallet must pay the correct publisher but must never trust unsigned claims from page JavaScript. This led us to connect page-scoped WebMCP tools and the authenticated wallet MCP with signed, short-lived capabilities.

Live testing also exposed a cross-service signing-key mismatch. Separate service containers generated separate keys, so the wallet correctly rejected the publisher's offer. We moved the key into shared secret-backed configuration and added tests for the multi-service boundary.

Accomplishments that we're proud of

We built a coherent product experience, not only a tool demo. A user can create an account, fund a test wallet, connect Codex, inspect a paid source, approve the exact terms, purchase it, and unlock it on the publisher's own website.

The publisher retains its content and canonical URL. The user retains payment authority. The agent receives the evidence and citation it needs.

We think that this idea of building a consumer-grade wallet and payments infrastructure could really benefit publishers who need a way to transform their businesses for the AI era.

What we learned

WebMCP and MCP are complementary. WebMCP provides contextual tools controlled by the publisher. MCP provides durable authority controlled by the user.

We also learned that agent payments are a capability and trust problem before they are a checkout problem. Origin binding, session binding, explicit approval, retry safety, and narrow entitlements make the experience understandable and safe.

What's next for Galleon

Our next step is focused: connect Galleon to real financial infrastructure and work directly with publishers to help them earn from agent demand.

The prototype uses test credits today. The goal is real settlement that supports the people producing the knowledge agents depend on.

Built With

• codex
• getfloo.com
• mcp
• postgresql
• typescript
• webmcp