Your Next Customer Might Be an AI Agent

Product-led growth (PLG) made software self-serve for humans.

The next growth battle is making software self-serve for their agents.

I call that Agent-Led Growth, or ALG.

I’m using ALG to describe the growth model emerging for products that agents can discover, evaluate, use, and recommend within clear human-approved boundaries.

An agent acting for a buyer should be able to find a product, inspect the evidence, compare options, run a bounded action, pay within a preset limit, verify the result, and bring a recommendation back to the human.

If your product only works after someone visits a landing page, watches a demo, talks to sales, and clicks through a dashboard, the agent hits a wall.

ALG is the next evolution of PLG because the interface is changing.

Humans still matter sure, but the software acting on their behalf now needs an interface too.

The practical framework underneath ALG is what I call the Agent-Addressable Funnel.

Human intent
|
v
Agent discovers product
|
v
Reads proof + permissions
|
v
Calls a bounded action
|
v
Verifies the result
|
v
Human approves expansion

The product still needs to work for humans.

ALG adds a second customer interface for the software acting on their behalf.

The infrastructure for this arrived faster than most teams noticed. Cloudflare recently described an open Agentic Internet as "readable, discoverable, callable, and payable."

Shopify now gives every store a canonical agents.md file pointing agents to UCP and MCP endpoints.

Stripe supports the separate ACP standard plus UCP payment handling. Anthropic put skills, connectors, and plugins into one directory.

None of those companies has published adoption, transaction volume, or revenue from these surfaces. I'm not going to pretend they have.

They've published enough product infrastructure to show where the interface is going.

The eight jobs of an agent-addressable product

1. Discoverable

An agent has to know your product exists and when to use it. That means publishing more than a human-readable homepage.

The agent needs a canonical description, clear capability names, machine-readable metadata, and a stable place to find your offer.

Shopify is the cleanest example.

Its docs call agents.md the canonical agent-facing description of a store, and Shopify manages one by default for every store, including UCP discovery and MCP endpoint information.

The official MCP Registry adds a machine-readable supply catalog.

It launched in preview as a centralized metadata repository for public MCP servers, with a REST API that clients and aggregators can use for discovery.

It's still preview infrastructure with self-reported metadata, not a mature app store.

Directory placement and capability metadata may become the agent version of SEO and app-store ranking.

Treat it as a product surface to test, not a promised acquisition channel.

2. Understandable

Finding your product is useless if the agent can't tell what it does, what it costs, who it's for, and what evidence supports the claim.

Your machine-facing offer should answer:

• What job can this product complete?
• What inputs does it require?
• What permissions does it request?
• What will it return?
• What does a call cost?
• What proof can the agent inspect?
• What conditions should make the agent stop?

Cloudflare's AI Search preview shows the shape.

It can expose /search and /mcp endpoints across one or more sites, priced on ingestion, storage, and queries. The point is the packaging.

Machine consumers need predictable inputs, outputs, access rules, and unit costs.

3. Callable

A product built only around buttons forces the agent to imitate a person. That's brittle.

Cloudflare's WebMCP developer preview adds a bridge that registers tools on a webpage for a visiting agent.

Shopify says every Liquid storefront already has WebMCP tools for catalog search, product navigation, variant selection, and cart management, though agent support is still limited to Chromium-based browsers.

MCP also went stateless in its 2026-07-28 revision, which removes required protocol sessions from the core request path and makes MCP easier to host on ordinary web infrastructure.

APIs were core PLG plumbing. APIs, MCP, and WebMCP are becoming ALG plumbing.

4. Purchasable

Agents need a clean way to buy without receiving an unlimited company card.

Shopify's store-facing protocol is UCP, the Universal Commerce Protocol. ACP is a separate agentic commerce standard created by Stripe, OpenAI, and Meta.

Stripe supports ACP and documents a payment handler for UCP-compatible platforms.

OpenAI launched Instant Checkout in ChatGPT using ACP, but implementing ACP only makes your checkout callable.

It doesn't list you inside an AI platform.

The guardrails are where this gets real. Stripe's Shared Payment Tokens can be limited to a seller, time window, and amount.

Cloudflare says its planned Virtual Wallets will support allowances, allow lists, and maximum transaction sizes, with agents requesting a manual override when they exceed the limit.

Stripe's machine-payments product takes the paid API route: an agent receives a payment challenge, presents a credential, and completes the request.

Stripe supports MPP for cards and stable coins, plus x402 for stable coins, with current minimums of 0.01 USDC for stable coin microtransactions and $0.50 for card-based Shared Payment Tokens.

The governance rule is simple:

Inside budget + policy -> agent acts
Consequential action -> human approves
Outside policy -> human reviews
Missing proof -> agent stops

Agents spend autonomously inside preset budgets. Consequential actions come back as recommendations. Exceptions always return to a person.

5. Usable

The agent needs to complete a real job, not admire your tool schema.

This is where our own build changed my thinking.

With ClickFlow, we're putting API and MCP access around one agent workflow: detect decaying pages, prepare a rewrite, wait for approval, land a draft in the CMS, then re-measure after publishing.

That's an end-to-end job with the consequential step kept under human control. The product pitch should be the completed job. The protocol belongs under the hood.

6. Verifiable

An agent needs evidence the action happened and the result met the stated condition. A successful response should return more than 200 OK.

It should identify what changed, when it changed, which inputs were used, what policy allowed it, and where the human can inspect the result.

For a content product, that's a CMS draft URL and a before-and-after diff. For an API, a signed receipt or result objectFor a marketplace, order status and a clear exception path.

Verification turns an agent action into an auditable recommendation.

7. Recommendable

The agent needs enough structured evidence to explain why it chose you. A black-box claim like "best AI SEO platform" gives it very little to defend.

A better recommendation object looks like this:

Job: refresh a decaying page
Tool: ClickFlow
Permission: draft only
Cost: stated before call
Result: draft + change log
Proof: source links + readback
Next step: human publish approva

The agent can now bring a decision to the buyer instead of dropping another tab into the browser.

Claude's current purchase boundary is a useful model.

It can suggest an already connected app and help prepare a cart, but Anthropic says Claude checks with the user before it books, buys, or reserves anything. It doesn't transact on its own.

8. Composable

One product rarely completes the whole job.

An SEO agent may need analytics, a content system, WordPress, billing, and a reporting destination.

Your product gets more useful when it fits that chain cleanly.

Skills Dojo is our build in this direction, a directory for AI-agent skills where an agent can discover a workflow, install it, and run it when a job calls for that capability.

At Single Grain we're also designing a customer architecture with a connector gateway sitting between the high-context agent and company systems.

The gateway handles connector access and permissions while scoped execution agents do the work.

Humans approve external writes and sensitive actions.

That's how products become composable without giving one agent unrestricted access to everything.

Why this matters now

Cloudflare reported that 52% of crawler requests on its network were for AI training in June 2026, up from 22% in spring 2025.

Mixed-use crawlers accounted for more than 36% of crawler activity.

Its separate crawl-to-referral metric is starker. Between June 19 and June 26, 2025, the Anthropic ratio was 70,900 crawls to one referral. OpenAI was 1,600 to one. Perplexity was 202.4 to one.

The old bargain, let bots consume your pages and hope a person clicks back, looks weak at those ratios.

ALG gives the agent something useful to do after discovery: inspect, call, pay, verify, and recommend.

The uncomfortable part

Nobody can show you ALG revenue yet.

Every protocol above is a preview, a spec, or a vendor announcement.

If you need proof of conversion before you build, you'll get it around the same time your competitors finish shipping. That's the actual trade.

You're building a second customer interface on the strength of where the infrastructure is pointing, not on a case study.

The cost is real but it's smaller than a replatform. You're not rebuilding the product. You're exposing what it already does in a form a machine can find, call, pay for, and verify.

Steal this Agent-Led Growth audit

Run this against one product, feature, or marketplace listing. Mark each item pass or fail.

Discovery

• Can an agent find a canonical description of the product?
• Does the description say when the agent should and shouldn't use it?
• Are capability names and endpoints stable enough to reference?

Evaluation

• Can the agent read current pricing, permissions, limits, and exception rules?
• Can it inspect primary proof rather than marketing claims alone?
• Can it compare a structured input and expected output?

Action

• Can the agent complete one bounded job through an API, MCP, or WebMCP tool?
• Can it authenticate without borrowing a human's unrestricted credentials?
• Can it pay through a preset allowance, scoped token, or per-call budget?

Governance

• Do consequential actions return to a human for approval?
• Do out-of-policy requests stop and escalate?
• Can an operator revoke access, change limits, and inspect who authorized the action?

Verification

• Does every action return a result, receipt, trace, or readback?
• Can the agent explain what changed and cite the evidence?
• Can the buyer inspect the output before expanding access or spend?

Composition

• Can another approved agent or tool consume the output?
• Are schemas, errors, and retry behavior documented?
• Can the product fit inside a larger workflow without exposing every system behind it?

Any failed item is machine friction. Don't rebuild the whole product. Pick one failure, fix it, and rerun the same agent path.

The move this week: give one external agent a real buyer job, then remove the first point where it has to guess, click blindly, request unlimited access, or trust a claim it can't verify.

---

What can an agent complete on your product today without a human in the loop?

---

If you're a business that wants AI systems built for you, check out https://www.singlebrain.com

For marketing help, go to https://www.singlegrain.com

For more like this, level up your marketing with 14,000+ marketers and founders in my Leveling Up newsletter, free: https://levelingup.beehiiv.com/subscribe

If you want to join our team, beat AI first ;) https://github.com/ericosiu/beat-claude