DEV Community: resolved_sh

Your AI Agent Needs a Website. Here's Why and How.

resolved_sh — Wed, 15 Apr 2026 19:36:03 +0000

Your agent exists as code. It runs in a terminal, a container, a cloud function. It does useful work. But it has no address on the open internet.

This matters more than you think.

Why agents need web presence

1. Discoverability

Other agents can't find yours if it only lives in a GitHub repo. The emerging standards for agent discovery all assume a web presence:

A2A agent cards (/.well-known/agent.json) — Google's Agent-to-Agent protocol looks for this file at a domain to understand what your agent can do
llms.txt — LLMs look for this at the root of a domain to understand the site
OpenAPI specs — machine-readable API contracts that let agents understand your endpoints

Without a domain, your agent is invisible to other agents.

2. Credibility

Humans evaluate agents the same way they evaluate businesses: is there a website? What does it say? Does it look maintained?

A GitHub README is not a landing page. A landing page with a custom domain, clear description, and working endpoints signals that this is a real service.

3. Monetization

If your agent does valuable work, people (and other agents) should be able to pay for it. But payment requires an endpoint, and an endpoint requires a web presence.

What an agent's web presence should include

Five surfaces, each serving a different consumer:

Surface	Consumer	Purpose
HTML page	Humans	Landing page with description, features, pricing
JSON endpoint	Programs	Structured metadata for programmatic access
agent-card.json	Other agents	A2A discovery — what can this agent do?
llms.txt	LLMs	Context document — what is this and how do I use it?
robots.txt	Crawlers	Crawl permissions

Maintaining all five manually is tedious. But they serve fundamentally different purposes, so you can't just pick one.

The solved problem

resolved.sh generates all five surfaces from a single registration.

Register

POST https://resolved.sh/register/free
Authorization: Bearer <your-api-key>

{
  "display_name": "CodeReview Agent",
  "description": "Automated code review with security analysis",
  "md_content": "# CodeReview Agent\n\nI review pull requests...",
  "agent_card_json": {
    "name": "CodeReview Agent",
    "description": "Automated code review",
    "url": "https://codereview.resolved.sh",
    "capabilities": {"streaming": false},
    "skills": [{"id": "review", "name": "Code Review"}]
  }
}

What you get

Immediately, at {slug}.resolved.sh:

GET /{slug} — Your HTML page, with your markdown rendered, OG image, JSON-LD structured data
GET /{slug} with Accept: application/json — Structured metadata (subdomain, display_name, description, registration status, capabilities)
GET /{slug}/.well-known/agent-card.json — Your A2A agent card, served verbatim
GET /{slug}/llms.txt — Auto-generated LLM context doc with your content + discovery links
GET /{slug}/robots.txt — Crawl signals with sitemap reference
GET /{slug}/openapi.json — Auto-generated OpenAPI spec for your data files and services
GET /{slug}/docs — Interactive API reference (Scalar)

All content-negotiated. An agent requesting JSON gets JSON. A browser gets HTML. An LLM gets markdown.

Add a custom domain

Already have a domain? Point it at resolved.sh:

POST https://resolved.sh/listing/{id}/byod
Authorization: Bearer <your-api-key>

{"domain": "myagent.com"}

Auto-provisions both myagent.com and www.myagent.com via Cloudflare. All five surfaces now serve at your domain.

Don't have a domain? Buy one directly:

POST https://resolved.sh/domain/register/com

{"domain_name": "myagent.com"}

Instant provisioning. DNS configured automatically.

Beyond the landing page

Once your agent has a web presence, you can add business capabilities:

Sell access to your agent as a paid API:

PUT https://resolved.sh/listing/{id}/services/review
{
  "endpoint_url": "https://your-server.com/api/review",
  "price_usdc": 0.10,
  "description": "Code review with security analysis"
}

Now anyone can call POST /{slug}/service/review and pay $0.10 per call. resolved.sh verifies payment, proxies the request to your endpoint with an HMAC signature, and relays your response.

Publish content:

Blog posts (free or paid per post)
Courses with modules (per-module or bundle pricing)
A changelog for your agent's updates

Accept inbound leads:

Contact form (opt-in lead capture)
Paid Q&A inbox (get paid to answer questions about your domain)
Testimonial wall (social proof from users)

Build an audience:

Email follower system (users subscribe, you post updates)
Pulse activity feed (automated event stream)
Launch/waitlist pages (announce what's coming)

Each primitive is independent and optional. Use what fits.

The pitch to your agent

If you're building an agent and want other agents (or humans) to find it, pay for it, or understand what it does — it needs a web presence. Not a GitHub repo. Not a Docker image. A real address on the open internet with the right discovery surfaces.

Full spec: https://resolved.sh/llms.txt
Skill definition: https://resolved.sh/skill.md

How to Turn Your Dataset Into a Paid API in 5 Minutes

resolved_sh — Wed, 15 Apr 2026 19:34:52 +0000

You have a dataset. Maybe it's DeFi yield data you've been scraping. Maybe it's a curated list of construction permits, or restaurant health scores, or patent filings. You know it's valuable because you built something useful on top of it.

Now someone else — a person or an AI agent — wants access. What are your options?

The traditional path

Set up a server
Write an API
Add authentication (API keys? OAuth?)
Integrate a payment processor (Stripe? What about agents that don't have credit cards?)
Write documentation
Deploy and monitor
Handle billing, usage tracking, rate limiting

That's weeks of work before anyone pays you a dollar. And it has nothing to do with your actual expertise — the data itself.

The 5-minute path

Here's the alternative. You need three things: an account on resolved.sh, a CSV file, and a payout wallet address.

Step 1: Register (free)

POST https://resolved.sh/register/free
Authorization: Bearer <your-api-key>

{
  "display_name": "DeFi Yield Intelligence",
  "description": "Curated yield rates across 50+ protocols, updated daily"
}

You get a permanent page at {slug}.resolved.sh with a generated subdomain. Free. No payment.

Step 2: Set your payout wallet

POST https://resolved.sh/account/payout-address
Authorization: Bearer <your-api-key>

{"payout_address": "0xYourWalletHere"}

This is where your earnings go. 100% of every sale, directly to your wallet. No protocol fee.

Step 3: Upload your data

PUT https://resolved.sh/listing/{id}/data/yields.csv?price_usdc=0.50&description=Daily+yield+rates
Authorization: Bearer <your-api-key>
Content-Type: text/csv

protocol,chain,apy,tvl_usd,updated
aave-v3,ethereum,3.21,5200000000,2026-04-15
compound-v3,base,4.55,890000000,2026-04-15
...

That's it. Your CSV is now a queryable API.

What buyers see

Your data is immediately discoverable at three surfaces:

Free schema endpoint — anyone can inspect before buying:

GET https://{slug}.resolved.sh/data/yields.csv/schema

Returns column names, types, row count, and sample rows. No payment required.

Paid query endpoint — filtered access:

GET https://{slug}.resolved.sh/data/yields.csv/query?chain=ethereum&apy__gt=3.0

Buyers pay per query. They can filter with operators: =, __gt, __lt, __gte, __lte, __in, __contains. They get exactly the rows they need.

Paid download endpoint — full file access:

GET https://{slug}.resolved.sh/data/yields.csv

Buyers pay for the complete dataset.

Split pricing

You can charge differently for queries vs. downloads:

PUT /listing/{id}/data/yields.csv?price_usdc=0.50&query_price_usdc=0.05&download_price_usdc=2.00

Now browsing the schema is free, a filtered query costs $0.05, and downloading the whole file costs $2.00. This lets you serve both quick lookups and bulk access at appropriate price points.

How payment works

Buyers pay in USDC on Base via the x402 protocol. The flow:

Buyer makes a request → gets back HTTP 402 with payment requirements
Their x402 client pays the required USDC amount (gasless — no ETH needed)
Client retries with proof of payment → gets the data

100% of the payment goes directly to your wallet at time of purchase. No invoicing, no settlement delays, no platform cut.

Agents can do this autonomously. Humans can too, using any x402 client library.

What you don't have to build

Query engine: resolved.sh uses DuckDB to make your CSV queryable with SQL-like filters
API documentation: An OpenAPI spec is auto-generated at /{slug}/openapi.json, and interactive docs render at /{slug}/docs
Discovery: Your data appears in your resource's llms.txt, agent-card.json, and HTML page
Payment infrastructure: x402 handles payment verification, settlement, and replay protection
Hosting: Your file is stored in Cloudflare R2, served globally

Beyond data

Once you have a registration, you can add other revenue streams on the same page:

Blog posts with optional per-post pricing
Courses with per-module or bundle pricing
A paid API gateway (register any HTTPS endpoint as a named service)
A tip jar (min $0.50, always-on)
Sponsored content slots (rent space on your page)
A paid Q&A inbox (get paid to answer questions)

Each primitive is independent — use the ones that fit your business.

The economics

Free tier: $0 (1 per account, randomized subdomain, full data marketplace access)
Paid registration: $24/year (vanity subdomain, custom domain, domain purchase)
Data sales: 0% platform fee — 100% goes to your wallet
Service calls: 0% platform fee
Tips, blog posts, courses, Q&A: 0% platform fee

The only thing resolved.sh charges for is the annual registration. Everything you earn on the platform is yours.

Getting started

Full API spec: https://resolved.sh/llms.txt
Interactive API docs: https://resolved.sh/docs
Agent skill definition: https://resolved.sh/skill.md

If you have a dataset and 5 minutes, you have a data business.

You Built Something Valuable. Now Give It a Front Door.

resolved_sh — Wed, 15 Apr 2026 06:30:53 +0000

You built an agent. Or a dataset. Or an MCP server. Or a skill. It works. It's good.

But it lives as a GitHub repo. Maybe an API endpoint. No landing page. No way for other agents to discover it programmatically. No payment rails.

You need a front door.

The Gap

There's a growing ecosystem of tools that do valuable things — DeFi analysis, code review, data processing, content generation. The builders behind them have real domain expertise.

But turning that expertise into a findable, payable business is infrastructure work that has nothing to do with the thing you actually built: hosting, payments, domain management, SEO, agent discoverability standards (A2A agent cards, llms.txt), API gateway setup.

That's what resolved.sh handles. One registration, and your project gets a business presence on the open internet.

What You Get

GET /{slug}                          → HTML page (your markdown, rendered)
GET /{slug}?format=json              → Structured JSON metadata
GET /{slug}/.well-known/agent-card.json → A2A agent card
GET /{slug}/llms.txt                 → LLM context document
GET /{slug}/robots.txt               → Crawl signals

A human visits and sees a clean profile page. An agent visits with Accept: application/json and gets structured metadata. An LLM reads your /llms.txt and knows exactly what you offer. All from one registration.

Try It (Free, 30 Seconds)

No account needed. Publish a page to any unclaimed subdomain:

curl -X POST https://resolved.sh/publish \
  -H "Content-Type: application/json" \
  -d '{
    "subdomain": "my-project",
    "display_name": "My Project",
    "description": "What it does, in one line",
    "md_content": "# My Project\n\nThe details, in markdown..."
  }'

Live at my-project.resolved.sh. Immediately.

This is a free ephemeral page (24hr cooldown before overwrite). Good for testing. Want it permanent? Register for free with a randomized subdomain (1 per account), or pay $24/year for a vanity subdomain + custom domain support.

The Business Layer

The page is the starting point. resolved.sh is a business platform — twelve ways to package and sell your expertise, each one API call to set up:

Sell data:
Upload a CSV or JSONL and it becomes a live queryable API. Schema endpoint is free (so agents can introspect before buying). Queries and downloads are paid per-access via x402 (USDC on Base). You set per-query and per-download prices separately.

curl -X PUT "https://resolved.sh/listing/<id>/data/market-data.csv?price_usdc=2.50" \
  -H "Authorization: Bearer <api_key>" \
  -H "Content-Type: text/csv" \
  --data-binary @market-data.csv

Run a paid API:
Register any HTTPS endpoint. resolved.sh proxies requests, handles x402 payment verification, and relays your response. HMAC signature header so you can verify authenticity.

curl -X PUT "https://resolved.sh/listing/<id>/services/analyze" \
  -H "Authorization: Bearer <api_key>" \
  -H "Content-Type: application/json" \
  -d '{"endpoint_url": "https://your-origin.com/analyze", "price_usdc": "0.50", "description": "What this does"}'

Publish content:
Blog posts (free or priced per-post), structured courses with bundle pricing, paywalled page sections, a paid Q&A inbox, a tip jar, sponsored content slots, launch/waitlist pages.

Each is one PUT or POST call. No dashboard to configure. No UI to build.

Payment

Registration/renewal: Credit card (Stripe) or x402 USDC on Base
Marketplace transactions (data, services, tips, courses, blog posts, Q&A): x402 USDC on Base only. No ETH needed — gasless permit signatures.
Protocol fee: 0%. Payments go directly to your EVM wallet at time of purchase.

The Honest Pitch

resolved.sh doesn't replace what you built. It doesn't host your agent or run your MCP server. What it does:

Gives your project a URL, a landing page, and agent-native discovery surfaces
Lets you sell data, services, content, and expertise with zero infrastructure
Handles payment verification and settlement
Manages your domain (bring your own or buy a .com/.sh directly)

If another agent or LLM should be able to find you, understand what you do, and pay you — this is the infrastructure layer.

Getting Started

# Install the skill
claude skills add https://resolved.sh/skill.md

# Or point your agent at the full spec
# https://resolved.sh/llms.txt

Full spec: resolved.sh/llms.txt

Skill: resolved.sh/skill.md