Source confidence: medium
See also: Deeper Dive — Selling to Agents — metered data for buyers that don't have eyes →

Selling to Agents — metered data for buyers that don't have eyes

Insight class: Arbitrage Opportunity · Difficulty: Medium · Quality: 3/5 Connected entries: 9 · Tools: Agent Reach, Anthropic, Binance, ChatGPT, Claude, Claude Code, Google AI Overview, Grok, LinkedIn, OpenAI, Salesforce, USYC, oc

In short: Running this system turns one dataset you genuinely own into a machine-first product: a free llms.txt discovery layer, a structured JSON endpoint metered per call with x402 stablecoin micropayments, and the same data exposed as a listed MCP server, with request logging that separates crawlers, agents and humans.

Key fact Detail
What it covers agents, news, LLM, crypto
Tools Claude, ChatGPT, Agent Reach, Anthropic, Binance
Posts covered 9 posts (4 A-tier) · top: Agent Reach — open-source skill letting agents… · only-cli/oc — browse websites as a compact… · Princeton sponsored-ads study — 18 of 23 AI…
Creators @alexanderelorenzo, @atlasberry008, @brycenwood.ai
Sources dated Apr 2026 – Oct 2026
Difficulty Medium
Prompt system Run-it-yourself prompts
Last verified 2026-10-22

Thesis

Three saves describe one gap. Quality publishers block AI crawlers, so AI search cites whatever is left. AI assistants favor the sponsored option in 18 of 23 models, so they are steerable buyers. Software is going headless, so agents pick tools by speed, cost and accuracy instead of interface. x402 revives HTTP 402 so an agent can pay a stablecoin micropayment per request. A one-person owner of a clean niche dataset can sit exactly in that gap — machine-legible, crawler-reachable, and metered.

Why it matters

This is distribution without an audience. The buyer is an agent that never sees your landing page, so a solo builder with good data competes on structure and price, not on ads. DejaViewed's own catalog and API are the obvious first item to sell.

The evidence — connected entries

x402 protocol — pay-per-crawl tolls for AI agents scraping your site

Creator: @alexanderelorenzo · Tier: B Tools: Anthropic, Claude, OpenAI

x402 — HTTP 402 plus stablecoin micropayments, the toll gate

Frames the AI scraping lawsuits (Anthropic's ~$1.5B author settlement, NYT v. OpenAI) as a payment problem and points to x402, a 2025 protocol that revives the long-dormant HTTP 402 Payment Required status so agents pay a crypto micropayment to access content. Explanation is hype-heavy and ends in a paid Skool pitch.

View original post

GENIUS Act stablecoins — how banks keep the T-bill yield on your cash

Creator: @alexanderelorenzo · Tier: B Tools: Binance, USYC

Stablecoin plumbing under the GENIUS Act — the rail is becoming bank-grade

Under the GENIUS Act banks can issue stablecoins, park the backing cash in short-term Treasury bills, keep the roughly 4% yield (the law bars passing it to holders), and repo the T-bills for liquidity. Holders can swap into tokenized Treasuries like USYC, which Binance accepts as collateral. Ends with a paid-group pitch.

View original post

AI search citations — why your chatbot cites the 'unlocked web'

Creator: @wetclaude · Tier: B Tools: ChatGPT, Claude

Quality publishers block AI crawlers, so AI search reads the leftovers — the supply gap

High-credibility sites (Consumer Reports, ~60% of top news) block GPTBot, Google's AI crawler and Common Crawl, so AI search reads only what's left: AI-written pages and self-ranking listicles. One in six cited sources is AI-written and models often do post-hoc citation, writing the answer first and finding sources after.

View original post

Princeton sponsored-ads study — 18 of 23 AI assistants push the paid option

Creator: @forgoodcode · Tier: A

Agents favor the sponsored option — machine buyers are steerable, so being the honest, legible cheap option wins

Carousel on a Princeton study that gave 23 models a sponsored option and a cheaper better one across flights, loans and shopping. 18 of 23 favored the sponsored pick, GPT-5.1 surfaced it 94% of the time, and a 'serve the customer only' system prompt barely moved it. Note the creator's caveat: it measures susceptibility in a hypothetical deployment, not real paid placement.

View original post

Headless software + MCP — Chamath on why software IP stops being a moat

Creator: @atlasberry008 · Tier: B Tools: Grok, Salesforce

Headless software and MCP — agents choose tools on speed, cost and accuracy, not UI

Breaks down Chamath's All-In claim that software IP is worthless once services go headless and agents call them via MCP. With Salesforce and xAI's Grok exposing headless engines, agents pick tools on speed, cost or accuracy, so the interface stops being the moat.

View original post

llms.txt — get ChatGPT to recommend your local business

Creator: @brycenwood.ai · Tier: A Tools: ChatGPT, Claude, Claude Code

llms.txt got a local shop recommended by ChatGPT — the free discovery layer that points to the paid one

@brycenwood.ai got ChatGPT to recommend his vehicle-wrap shop via an llms.txt file (built in 5min with Claude Code) describing business, location, value prop. Early GEO (generative engine optimization) tactic.

View original post

AI Overview SEO — seeding social posts that Google and ChatGPT cite

Creator: @edward.builds · Tier: C Tools: ChatGPT, Google AI Overview, LinkedIn

AI Overviews can be gamed by self-assertion — the low-quality competition you are priced against

A LinkedIn post declaring someone 'the world's most renowned AI visibility expert' was cited by Google's AI Overview the same day. Lesson: user-generated platforms (YouTube, Reddit, LinkedIn, X) dominate citations, so lead posts with your keyword and backlink them to keep them cited. Ends in a promo for compactkeywords.com.

View original post

only-cli/oc — browse websites as a compact numbered CLI for agents

Creator: @githubsignals · Tier: A Tools: oc

Compact numbered page views for agents — what a machine-first response format looks like

Open-source tool that fetches a page and returns a tidy numbered text view so agents can read, follow links and search for hundreds of tokens instead of tens of thousands of raw HTML; mimics a real browser to slip basic blocks. Spotted on Hacker News.

View original post

Agent Reach — open-source skill letting agents read Reddit and X

Creator: @itstundeanthony · Tier: A Tools: Agent Reach, Claude

Agents are blocked on Reddit and X without workarounds — demand for clean, permitted access is real

An open-source repo installed as a Claude skill that gives agents access to 13 platforms without API costs. The demo shows Claude failing to fetch a Reddit post and an X thread, then succeeding with comments once Agent Reach is installed.

View original post

Action sketch — how to implement this

Expose one niche dataset you own (start with the DejaViewed catalog's api/ JSON) as a free llms.txt summary plus a richer x402-metered endpoint with structured, citation-ready records. Wrap the same endpoint as an MCP server and list it publicly so Claude and other agents can find it; log every request, free and paid, with user agent. Run a 60-day A/B on price per call (free, 0.1c, 1c) and track how often your records show up in Perplexity and ChatGPT answers. falsifier: if after 60 days you see plenty of free crawls but close to zero paid calls, agents are not buying yet. The demand side doesn't exist and this is a 2027 idea, not a 2026 one.

Prerequisites

Key tools and resources

Creators to follow

Prompt system — run this yourself

Everything below is pasteable into Claude Code, Claude, or any agent. Use the one-shot when you want the whole result in one run; use the step prompts when you want to steer. Every step carries its own audit, and the gap audit at the end makes the agent find and fill what it missed.

Mission. Running this system turns one dataset you genuinely own into a machine-first product: a free llms.txt discovery layer, a structured JSON endpoint metered per call with x402 stablecoin micropayments, and the same data exposed as a listed MCP server, with request logging that separates crawlers, agents and humans. It is for a solo builder, starting with the DejaViewed catalog's own derived fields. Done means a 60-day price experiment with a free control arm, a log that shows whether any agent paid, and an honest verdict against the falsifier: free crawls but near-zero paid calls means the demand side does not exist yet.

1 · Deeper, not bigger

Before running anything, make the task deeper rather than larger. Ask: what would a top professional do here that I am not asking for; what is the rawest material; which methods and tools; what, other than the model or me, proves it right. Then ask for exactly that.

Rewritten prompt — ask for exactly that:

I want to sell a niche dataset to AI agents rather than humans. Act as a data-licensing product lead. Start from raw sources: the x402 spec and reference code in coinbase/x402, RFC 9110 on HTTP 402, llmstxt.org, the MCP specification and registry, and the crawler documentation for GPTBot, OAI-SearchBot, ClaudeBot and PerplexityBot. Then: (1) audit my DejaViewed catalog JSON field by field and split what I authored (tiers, classifications, syntheses, connection maps) from what I do not own (creators' captions and transcripts); only the first may be sold; (2) design a citation-ready record schema with stable IDs, provenance and a citation string; (3) ship a free llms.txt plus a summary endpoint, and a richer x402-metered endpoint tested end to end on Base Sepolia; (4) wrap the same data as an MCP server and list it; (5) log every request with verified bot identity; (6) run a 60-day A/B with arms free, 0.1 cent and 1 cent per call, with success thresholds written before launch. Prove it with on-chain settlements from wallets I do not control and a weekly citation probe. Do not use self-assertion SEO tricks, and do not promise revenue.

2 · One-shot prompt

ROLE AND STANCE
You are a data-licensing product lead and backend engineer. Your buyer is an agent that never sees a landing page. You compete on structure, provenance and price, never on manipulation. You treat demand as unproven until a wallet you do not control pays you.

CONTEXT
- x402 revives HTTP 402 Payment Required so an agent pays a stablecoin micropayment per request (alexanderelorenzo's post frames it as a toll booth for scrapers; the framing is hype-heavy, the protocol is real).
- Quality publishers block AI crawlers: wetclaude reports Consumer Reports disallows GPTBot, Google's AI crawler and Common Crawl, about 60% of high-credibility news sites block AI crawlers, and one in six cited sources is AI-written. Clean, permitted data is scarce.
- The Princeton study: 18 of 23 assistants favored a sponsored option, GPT-5.1 surfaced it 94% of the time, and a 'serve the customer only' system prompt barely moved it. Its own caveat: it measured a hypothetical deployment, not live paid placement.
- Headless software and MCP (Chamath on All-In): agents pick tools on speed, cost and accuracy.
- llms.txt got brycenwood.ai's wrap shop recommended by ChatGPT, built in 5 minutes with Claude Code.
- edward.builds shows Google AI Overviews citing a self-asserted LinkedIn claim the same day. That is the low-quality competition, not a tactic to copy.
- only-cli/oc and Agent Reach show agents want compact, permitted access; do not build on block-evasion.
- The first product is the DejaViewed catalog's api/ JSON.

HARD CONSTRAINTS
- Sell only fields you authored. Creators' captions and transcripts are excluded from paid records; link to the source post instead.
- Testnet (Base Sepolia USDC) until the end-to-end payment test passes 20 times in a row. Production hot wallet holds no more than 50 USD; sweep to cold storage weekly.
- Never log or print private keys; load them from environment at runtime only.
- Respect robots.txt and platform terms for any data you gather.
- No promised revenue anywhere in docs or listings.

DELIVERABLES, IN ORDER
1. rights_audit.md: every field in the catalog JSON, its origin, sellable yes/no.
2. schema/record.schema.json: id, title, tier, class, summary_authored, connections, source_url, updated_at, citation string, licence.
3. llms.txt and llms-full.txt at the site root describing the dataset and pointing to the free and paid endpoints.
4. api/: GET /v1/free/{id} (title, tier, one-line summary, source link) and GET /v1/records?query= behind x402 middleware, with JSON Schema validation in tests.
5. pay_test.md: 20 end-to-end payments on Base Sepolia using the x402 client from the same repo.
6. mcp/: an MCP server exposing search_records and get_record, with paid calls passing through the same x402 gate, and a registry listing.
7. logging: per request timestamp, path, arm, user agent, verified_bot (reverse DNS forward-confirmed), paid, amount, tx hash.
8. experiment.md: arms free / 0.1 cent / 1 cent assigned by hash bucket, 60-day duration, success thresholds written before launch.
9. probe/: a weekly script that asks Perplexity and ChatGPT 30 fixed questions your data answers, records citations, and checks the cited page contains the claim.

GAP ANALYSIS (BUILT IN)
Write gaps.md as you go: which x402 middleware version you used and whether it supports your host; whether any major agent framework ships an x402 client by default; whether crawlers you see can pay at all; which records lack provenance; which bot identities could not be verified. Close what you can by testing; list the rest with the missing input.

SELF-QUESTIONS
- If I remove every field I do not own, is the remaining data still worth paying for?
- Would an agent pick my record over a free AI-written listicle, and on what visible signal?
- Can a crawler that hits 402 do anything except leave?
- Am I counting spoofed user agents as agent demand?
- Is the free arm cannibalizing the paid one, and does that matter for the falsifier?

STOP CONDITIONS
Stop and ask if the rights audit leaves fewer than 30% of fields sellable, or if testnet payments fail after two fixes. Otherwise stop when all nine deliverables exist and the experiment is live.

RETURN FORMAT
Table of deliverable, path, status; the rights audit summary; pay_test result; the pre-registered thresholds; top five gaps.

3 · Step-by-step prompts

Step 1 — Ground truth: rights and raw specs

Goal: Know exactly what you may sell and how the protocols really work.

Do not write server code yet.
1. Load the DejaViewed catalog JSON from the site's api/ output. For every field, record example value, origin (authored by me, derived by my pipeline from my own judgment, or copied from a creator's post), and sellable yes/no. Captions, transcripts, creator handles' bios and thumbnails are not yours; tiers, classes, deep-dive theses, connection maps and your summaries usually are. Write rights_audit.md and the percentage of sellable fields.
2. Clone coinbase/x402. Read the spec document and list: the 402 response body fields, the payment header the client sends, the facilitator's verify and settle steps, supported networks and tokens, and the server middleware packages available for your stack. Quote file paths.
3. Read RFC 9110 section on 402, the llms.txt proposal at llmstxt.org, and the MCP specification's tool and transport sections.
4. Collect official docs and IP verification methods for GPTBot, OAI-SearchBot, ChatGPT-User, ClaudeBot, PerplexityBot and Google-Extended.
5. Write claims.md testing the dive's inputs: '18 of 23 models favored the sponsored option', '60% of high-credibility news sites block AI crawlers', 'one in six cited sources is AI-written', 'x402 was coded into the internet in 1991 and remained dormant until 2025'. Mark which you can check from primary sources.

Expect: rights_audit.md, x402_notes.md with file paths from the repo, bots.md with verification methods, claims.md.

Audit before moving on: Spot-check 10 catalog records against rights_audit.md: any sellable field containing creator text verbatim fails the audit. If sellable fields are under 30%, stop and report to the user before building.

Step 2 — Record schema and free discovery layer

Goal: Make the data machine-legible and discoverable for free.

Write schema/record.schema.json (JSON Schema 2020-12) for one record: id (stable, never reused), title, tier, class, summary_authored, connections (array of ids with a one-line reason), source_url, updated_at (ISO 8601), licence, and citation (a ready string like 'DejaViewed catalog, record <id>, updated <date>, <url>'). Add a records/ export script that emits only sellable fields from rights_audit.md and validates every record with jsonschema.
Write llms.txt following llmstxt.org: H1 name, a blockquote summary, then sections listing the free endpoint, the paid endpoint with its price, the MCP server, and the licence. Write llms-full.txt with the schema and 5 example records.
Design the response format for agents, borrowing from the only-cli/oc idea: compact, numbered, no HTML, with a total token estimate per response. Measure tokens for a typical response with a tokenizer and keep the free summary under 300 tokens.

Expect: schema/, records/ export with 100% validation pass, llms.txt, llms-full.txt, a token budget table.

Audit before moving on: Run the validator on the full export and paste the pass count. Fetch llms.txt from the deployed preview URL and confirm it is served as text/plain with no redirects. If any record lacks a citation string or updated_at, fail and regenerate.

Step 3 — x402-metered endpoint on testnet

Goal: Charge per call and prove the payment loop end to end.

Implement api/ with the x402 server middleware from coinbase/x402 for your stack (Hono or Express on Cloudflare Workers or Node).
- GET /v1/free/{id}: title, tier, one-line summary, source link. No payment.
- GET /v1/records?query=&limit=: full sellable records, ranked by a simple BM25 over titles and summaries. Protected by x402 with a price set from an env variable.
- The receiving address comes from env. Never print or log keys; check existence only.
Configure Base Sepolia USDC. Write a client script using the x402 client from the same repo that requests /v1/records, receives 402, pays, retries and gets 200. Run it 20 times. Record each tx hash and latency in pay_test.md.
Then write tests: unpaid request returns 402 with a valid body; paid request returns 200 with schema-valid records; a replayed payment header is rejected.

Expect: api/ deployed to a preview URL, pay_test.md with 20 successful testnet payments, passing tests.

Audit before moving on: Look up 3 tx hashes on a Base Sepolia explorer and confirm amount and recipient. Try a replay and an underpayment; either succeeding fails the step. Grep the repo and logs for any private key pattern; any hit is a stop-everything fix.

Step 4 — MCP server and listing

Goal: Let agents find and call the data as a tool.

Build mcp/ with the official MCP TypeScript SDK or the Python mcp package (FastMCP). Expose two tools: search_records(query, limit) and get_record(id). Write tool descriptions an agent will choose on: state the dataset scope, freshness, price per call and that records carry provenance. The server calls your own HTTP API; paid calls go through the x402 client with a per-session spend cap set by the user, defaulting to 10 cents.
Test locally with the MCP Inspector and with Claude Code as a client: install it, ask a question the data answers, confirm the tool is chosen and the answer cites a record id.
Publish to the official MCP registry following its current submission process, and add the server to llms.txt. Log every MCP call through the same request log as the HTTP API, tagged source=mcp.

Expect: mcp/ package, an Inspector screenshot or log, a Claude Code transcript showing a cited answer, the registry entry URL.

Audit before moving on: Ask Claude Code three questions the data does not answer; the tool must return an empty result, not invented records. Confirm the spend cap stops a fourth paid call in a capped session.

Step 5 — Logging and bot verification

Goal: Tell real agent demand from noise.

Add structured logging to every endpoint: timestamp, path, arm, user_agent, client_ip_hash, verified_bot, paid, amount, tx_hash, latency_ms. Store in D1 or R2 on Cloudflare, or SQLite on a VPS.
verified_bot: for user agents claiming GPTBot, OAI-SearchBot, ChatGPT-User, ClaudeBot, PerplexityBot or Google-Extended, check the IP against published ranges or do reverse DNS plus forward-confirm. Unverified claims are labelled spoofed.
Assign arms by a stable hash of client fingerprint into free, 0.1 cent and 1 cent, so a repeat client stays in one arm. The free arm still serves full records; it is the control.
Write a daily report script: requests by arm and verified bot, paid calls, revenue, unique payer wallets, 402 bounce rate (402 served with no retry). Hash client IPs with a salted SHA-256; never store raw IPs beyond verification.

Expect: Log schema, a working daily report on preview traffic, arm assignment tests.

Audit before moving on: Send requests with a forged GPTBot user agent from your own machine; they must be labelled spoofed. Check arm assignment is stable over 100 repeated requests from one client.

Step 6 — Experiment and citation probe

Goal: Run the 60-day test with thresholds fixed in advance.

Write experiment.md before launch: hypothesis, arms, duration 60 days, primary metric (paid calls from distinct wallets you do not control), secondary metrics (402 bounce rate, verified agent requests, citation rate). Pre-register thresholds: for example 'success if at least 25 paid calls from at least 5 distinct external wallets in either paid arm; failure if verified agent requests exceed 1,000 and paid calls are under 5'. Do not change thresholds after launch.
Build probe/: 30 fixed questions the catalog answers well (for example 'best open-source tool for X per DejaViewed'). Weekly, query Perplexity and ChatGPT with browsing, record the answer and every cited URL, and check whether the cited page actually contains the claimed answer, following wetclaude's advice to click every citation. Store results by week.
Do not seed self-assertion posts to game AI Overviews; the probe measures organic pickup only.

Expect: experiment.md committed with a launch date, probe/ with a baseline week of results.

Audit before moving on: Confirm experiment.md was committed before the first paid-arm request in the log. Re-run the probe twice in one day; if results differ wildly, record the variance and increase repetitions per question to 3.

Step 7 — Validate against oracles and write the gap report

Goal: Decide whether agents are buyers yet.

At day 60, compute: paid calls and revenue per arm, distinct external payer wallets (exclude every wallet you funded), verified agent requests per arm, 402 bounce rate, and citation rate trend from probe/. Verify a sample of 10 settlements on-chain.
Apply the falsifier: plenty of free crawls but close to zero paid calls means the demand side does not exist yet; write the verdict as 'agents buying', 'agents crawling, not paying', or 'no agent traffic'.
Write gaps.md: every claim from claims.md marked verified / unverified / false with evidence; which agent frameworks could pay x402 during the window; how many 402 responses went to clients that cannot pay; fields you could not sell; anything in logs you cannot explain. Fix what you can now and list the rest with owners.

Expect: results.md with a table per arm, the verdict line, on-chain verification list, gaps.md.

Audit before moving on: Re-derive paid call counts from raw logs, not from the daily report, and confirm they match. If any counted payer wallet is one you funded, remove it and recompute the verdict.

4 · Gap analysis and audit

Run this after the build. It makes the agent enumerate its own claims, mark what is verified, rank the gaps and fix the top ones.

You are auditing an agent-facing data product after a 60-day price experiment. Read rights_audit.md, schema/, llms.txt, api/, pay_test.md, mcp/, the request logs, experiment.md, probe/ results and results.md.
1. Enumerate every claim: fields sellable, payments working, bot traffic volumes, paid calls, revenue, citation pickup, registry listing.
2. Mark each verified, unverified or false with evidence: a log query, a Base explorer tx, a test run.
3. Re-check specifically: no creator caption or transcript text in paid records; thresholds in experiment.md predate launch; payer wallets exclude ones the builder funded; verified_bot uses reverse DNS or published IP ranges; no private key appears in code, logs or history; the free arm served the same records as paid.
4. List missing pieces: terms of service for buyers, a refund path, rate limiting, uptime monitoring, a data freshness policy.
5. Rank gaps by whether they could flip the verdict.
6. Fix the top three now.
7. Report what you could not fix and why.

Questions the agent must ask itself before it says done:

5 · What proves it right

6 · Failure modes

7 · Agent direction (unattended runs)

Start with the rights audit and the coinbase/x402 repository; nothing else is worth building if sellable fields are thin. Cache the cloned x402 repo, the crawler IP range files and the schema-validated export. Spawn a sub-agent for the MCP server once the HTTP API passes its tests, and another for the citation probe, since they touch separate directories. Run all payment tests on Base Sepolia; ask the user before any mainnet configuration and before setting the production hot wallet, and never read or print key values. Stop and ask when sellable fields are under 30%, when testnet payments fail twice, or when a platform's terms forbid the data use. Return README.md linking rights_audit.md, schema/, llms.txt, api/, pay_test.md, mcp/, experiment.md, probe/, results.md and gaps.md, each with a one-line status, plus the falsifier verdict once day 60 is reached.

Prompt system updated 2026-10-22 · all prompt systems · JSON

Browse more deep dives at DejaViewed — 846 entries across the full catalog.

Generated 2026-10-22 · curated by @6ab3 for DejaViewed