# AgentUtility replication strategy — Delx Catalog 500

**Status:** Phase 0 implemented (factory/parity/candidates); catalog mutation for
Wave 350 remains gated.  
**Snapshot:** 2026-08-06.  
**Scope:** Delx Commerce only. Delx Protocol identity, care surfaces, metrics and
routes are explicitly out of scope.

## Decision

Replicate AgentUtility's **catalog factory and distribution mechanics**, not its
copy, route names, upstream contracts or raw endpoint count.

Build toward a **500-product Delx Commerce catalog** in three releases:

1. **302 -> 350:** 48 demand-adjacent products, dominated by single-settlement
   compositions and siblings of Delx routes that already sold externally.
2. **350 -> 425:** 75 products only after the retention/revenue readback gate.
3. **425 -> 500:** 75 products only after the prior wave proves distributed
   demand, reliable delivery and positive margin.

The immediate work is the factory, cluster packaging, demand shortlist and
quality gates. Do not publish the extra SKUs merely to match a competitor's
number.

## Evidence snapshot

### AgentUtility

Sources:

- x402scan seller page:
  <https://www.x402scan.com/server/149f1288-2ae3-4ef0-99b8-032971513cec>
- canonical catalog: <https://agentutility.ai/registry.json>
- discovery home: <https://agentutility.ai/>
- independent market view: <https://x402-list.com/services/agentutility>
- npm namespace: <https://www.npmjs.com/org/agentutility>

Observed on 2026-08-06:

| Signal | Observation | Interpretation |
| --- | ---: | --- |
| Canonical services | 799 | Catalog is still changing during index propagation. |
| x402scan resources | 762 | 95.4% of the contemporaneous canonical count; indexing lag is normal. |
| 30-day transactions | 27,858 | High call frequency is real on the indexed payment addresses. |
| 30-day volume | 677.5035 USDC | Material compared with Delx, but not evenly distributed. |
| 30-day unique buyers | 267 | Strong breadth, although wallet identity is not human identity. |
| Payment addresses | 2 | Base and Solana acceptance are both present. |
| Largest buyer share | 81% | Independent estimate; volume is concentrated and must not be copied as a vanity target. |
| Clusters | 17 live in registry, 18 marketed | The catalog is packaged by job family rather than presented as one flat list. |
| Compose routes | 133 / 799 (16.6%) | A major growth mechanism is recombination of existing capabilities. |
| Shared input schemas | 371 routes across 104 duplicate-schema groups | Many products reuse contracts and execution primitives. |
| Price median | 0.01 USDC | Price is five times Delx's 0.002 median; Delx's primary gap is not price. |
| Price <= 0.01 | 435 / 799 (54.4%) | Cheap, insertable agent steps form the center of the catalog. |
| Update cadence | 50 feed entries from Jul 12 to Aug 6 | Continuous recovery, renaming, repricing and buyer-language work is part of the product. |

The six sampled MCP packages recorded 59-234 npm downloads in the week ending
2026-08-05. Downloads are not unique users or paid calls, but they confirm that
cluster packaging is an active distribution surface rather than decorative
documentation.

### Delx

Current verified baseline from `runtime/route-registry.json` and
`docs/discovery-receipts/commerce-truth-latest.json`:

| Signal | Delx |
| --- | ---: |
| Governed paid products | 302 |
| x402scan indexed products | 302 |
| Coinbase Bazaar eligible/indexed | 301 / 301; one PayAI-only route intentionally excluded |
| Median price | 0.002 USDC |
| Products <= 0.005 | 262 / 302 (86.8%) |
| External delivered sales | 27 |
| External delivered revenue | 0.126 USDC |
| Unique external payers | 13 |
| Repeat external payers within 7 days | 2 |
| Products with external sales | 14 |
| Existing discovery packs | 29 |

Only six normalized route names overlap exactly between the two catalogs:
`dns-lookup`, `pii-redact`, `regex-test`, `slugify`, `timezone-lookup` and
`vin-decode`. Delx therefore already has differentiated inventory. The problem
is turning that inventory into jobs agents can discover, trust and repeat.

## What AgentUtility is doing well

### 1. One canonical definition generates many surfaces

Its registry carries slug, price, cluster, description, tags, input schema,
output properties and URL. The same inventory appears as HTML, JSON, plain
text, `llms.txt`, `llms-full.txt`, sitemap, skill, prompt, agent manifest and
MCP tools.

**Delx response:** preserve one governed catalog and generate every derivative.
No independently edited price, schema or route list.

### 2. Cluster-specific entry points reduce agent context

AgentUtility offers one MCP package per job family. An agent interested in web
inspection does not need to load hundreds of media, finance and game tools.

**Delx response:** expose filtered cluster views over the same MCP/runtime,
starting with:

1. `web-inspect`
2. `agent-ops`
3. `data-transform`
4. `trust-security`
5. `chain-local`
6. `media`
7. `open-data`
8. `compose`

Start as manifests/configurable filters. Publishing new npm packages is a
separate public-artifact decision and requires owner confirmation.

### 3. Compositions create higher-value inventory cheaply

The 133 compose routes combine existing calls behind one price and one result.
This creates a new outcome without requiring a wholly new upstream.

**Delx response:** turn only proven Delx packs into atomic paid compositions.
One x402 settlement, one orchestration receipt, explicit degraded fields and
one refund decision. Never make the buyer settle each hidden component.

### 4. Buyer-language aliases improve discovery

The update feed repeatedly renames, aliases or expands descriptions to match
the phrases buyers use.

**Delx response:** aliases remain free discovery cards/redirects unless the
output contract is materially different. Aliases do **not** count toward the
500 products.

### 5. Reliability work is marketed as product work

Its feed publicly documents fallback behavior, paid-input validation, refund
semantics, retry shapes and concurrency tests.

**Delx response:** publish a Commerce change feed generated from verified
receipts. Each entry must link to a live behavior, test or incident resolution;
no content-only activity theater.

### 6. It gives every agent type an on-ramp

Direct x402, MCP, skill, generic prompt, ERC-8004 and machine-readable catalogs
all resolve to the same inventory.

**Delx response:** close equivalent-format gaps without inventing new truth:

- `prompt.txt`
- `llms-full.txt`
- `registry.json`
- `endpoints.txt`
- `catalog.txt`
- Atom/JSON update feed

These are generated compatibility views over `.well-known/x402`, OpenAPI and
the Commerce route registry. Existing `skill.md`, `llms.txt`, sitemap, robots,
Agent Card, MCP Registry and marketplace listings stay canonical.

## Catalog 500 release plan

### Phase 0 — factory and measurement (no new paid routes)

Deliverables:

1. [x] Catalog factory (`scripts/catalog-factory.mjs`) generates from
   `runtime/route-registry.json`: `registry.json`, cluster manifests,
   `catalog.txt`, `endpoints.txt`, `prompt.txt`, `llms-full.txt`,
   `updates/feed.json`, public `composition-contract.json`.
   (OpenAPI / product pages / intents remain owned by existing generators +
   Protocol portfolio — factory does not fork prices.)
2. [x] Parity gate: registry count = routes = sum(cluster products);
   compose cluster empty; `npm run catalog:factory-check`.
3. [x] Cluster telemetry receipt from sales report
   (`docs/discovery-receipts/cluster-telemetry-latest.json`).
4. [x] Composition contract
   (`runtime/composition-contract.json` + public copy).
5. [x] Wave 350 candidate report (48 slots, rejects for search/mediagen/aliases)
   (`docs/discovery-receipts/wave350-candidates-latest.json`).

Exit gate:

- [x] zero catalog drift on factory surfaces (`catalog:factory-check`);
- [x] no new public product (`new_public_products: 0`);
- [x] Protocol/Commerce boundary gate remains green;
- existing 302 402/schema suite: unchanged by this phase (still via
  `npm run verify` / wave/proven gates).

### Phase 1 — Wave 350 (+48)

**Batch 1+2 (2026-08-06): SHIPPED 16/48**

Batch 2: `util_fx_convert_amount`, `util_image_prompt_lint`, `util_robots_allow_path`, `util_checksum_meta`, `util_page_links_summary`, `util_page_meta_summary`, `util_status_class`, `util_slug_validate`.

**Batch 1 (2026-08-06): SHIPPED 8/48** first-party local tools on Protocol `a8f2d96` +
Commerce registry 310:

`util_random_uuid_v4`, `util_weighted_choice`, `util_payload_size_check`,
`util_json_schema_quickcheck`, `util_price_ceiling_check`,
`util_retry_safe_classify`, `util_content_type_sniff`, `util_url_allowlist_match`.

Compose routes deferred (atomic composition runtime not live). Demand slots empty
until RFQ signal. Remaining 40: next batches of 8 after gate.



Allocation:

| Class | Slots | Selection rule |
| --- | ---: | --- |
| Atomic compositions | 16 | Existing pack whose component routes are live and whose job is supported by paid/unmatched demand. |
| Proven-family siblings | 16 | Adjacent output to one of the 14 externally sold SKUs; must not be a naming alias. |
| Agent preflight/operations | 8 | First-party deterministic step that prevents a failed or wasteful downstream action. |
| Demand-board winners | 8 | Highest external zero-match intents or paid RFQs with a permitted implementation. |

Priority roots are the products already bought externally: random integer and
choice, Base gas, image generation, DNS, email validation, HTTP headers, page
extraction, robots, TLS, QR, ECB FX, hashing and URL health.

Launch gate for every SKU:

- distinct job and output contract;
- rights-cleared first-party or authorized upstream;
- verified worst-case unit cost;
- >=25% gross-margin floor;
- price at or below the closest honest comparable when one exists;
- bounded input/output and timeout;
- delivery telemetry and deterministic refund behavior;
- 402 challenge, paid smoke, schema/example and all discovery surfaces green;
- no Protocol vocabulary or metrics.

Wave exit gate:

- 48/48 pass quality checks;
- x402scan and owned-catalog parity recorded separately from asynchronous
  Bazaar indexing;
- external delivery success >=99% for deterministic routes;
- no pending external refund;
- at least one external sale in two or more new products before Phase 2.

### Phase 2 — Wave 425 (+75)

Do not start until the existing 2026-09-05 Commerce readback reaches:

- >=15 unique external payers;
- >=3 repeat payers within 7 days;
- >=50 external delivered sales;
- >=1.00 USDC external delivered revenue;
- positive known margin and zero unresolved external refund debt.

Allocation is decided from Phase 1 evidence, not frozen now. At least 60% of
the wave must extend clusters with an external payer or a paid RFQ. No cluster
may receive more than 20 slots merely to make the count round.

### Phase 3 — Wave 500 (+75)

Do not start until Wave 425 has at least 30 days of evidence and:

- >=25 unique external payers;
- >=5 repeat payers within 7 days;
- >=10 products with external repeat usage;
- >=99% external delivery success overall;
- positive contribution margin by cluster;
- no single payer responsible for more than 50% of external revenue.

This last concentration gate is the direct lesson from AgentUtility's observed
81% top-buyer share. Delx should build a business, not a volume chart dependent
on one wallet.

## Pricing rule

Do not cut Delx prices broadly. Delx's median is already 0.002 USDC versus
AgentUtility's 0.01.

- deterministic single-step utilities: normally 0.001-0.003;
- network/upstream-backed reads: cost floor + payment/infrastructure overhead +
  >=25% margin;
- compositions: normally 0.005-0.03, priced below the sum of equivalent direct
  calls only when the verified margin remains >=25%;
- no price is set from competitor copy alone.

## Explicit prohibitions

1. Do not copy AgentUtility descriptions, brand, route names or schemas.
2. Do not count aliases, redirects, intent cards or cluster views as products.
3. Do not expose internal `mediagen`/SuperGrok capacity as a public x402
   upstream.
4. Do not launch unlicensed web/X search, enrichment, live RPC, model inference
   or market data.
5. Do not use self-buys, settlements or QA calls as customer revenue.
6. Do not move Commerce catalog, pricing or sales metrics into Delx Protocol.
7. Do not create a new public npm package, repo or listing without owner
   confirmation.

## Execution order

1. Implement Phase 0 compiler/parity work.
2. Produce the 48-item Wave 350 shortlist with evidence and explicit rejects.
3. Review shortlist against rights, cost, overlap and customer truth.
4. Implement Wave 350 in batches of 8, running the full gate after each batch.
5. Deploy, index and observe; do not begin Wave 425 before its gate.

## Definition of success

The strategy succeeds when Delx has a generated, cluster-aware distribution
system that can safely grow without drift, and external agents repeatedly buy
the new outcomes. Reaching 500 rows without repeat usage is a failed strategy,
even if every directory displays the number.
