If Picks and Shovels had one more chapter: marketing to AI agents

Marketing to AI agents is the practice of structuring product information so AI systems can evaluate, compare, and recommend your product on behalf of human buyers.

I published Picks and Shovels in 2025. The book covers positioning, messaging, launches, content strategy, go-to-market planning, developer relations, and community building. All of it grounded in thirty years of doing this work at companies like Microsoft, Amazon Web Services, Facebook, Twitter, and several startups.

The book holds up. I stand by every chapter.

But if I were adding one more chapter today, I know exactly what it would be called.

Marketing to AI Agents.

Not marketing with AI. Not using AI to write blog posts or generate ad copy. I mean marketing to AI agents as a distinct audience. Because AI agents are now participants in the buying process. They evaluate vendors. They compare pricing. They read documentation. They recommend products. And they do all of this on behalf of humans who increasingly trust their judgment.

Jon Miller, the founder of Marketo, said it plainly in his 2026 predictions: marketers must learn to market to AI agents. Not someday. Now. He's right. And the shift is already measurable. McKinsey projects that agentic commerce could reach $3 to $5 trillion in global sales by 2030. Forty percent of enterprise applications will feature AI agents by the end of 2026, up from just 5% in 2025. Google launched its Universal Commerce Protocol. OpenAI launched its Agentic Commerce Protocol. Anthropic's Model Context Protocol has over 500 public servers and has been adopted by OpenAI and Google DeepMind, then donated to the Linux Foundation.

The agents are here.

Your pricing page has a new audience (and it can't parse your marketing copy)

AI agents are joining B2B buying committees. Not metaphorically. Literally.

When a developer asks Claude to recommend a database for real-time analytics, Claude reads documentation, evaluates features, and checks pricing. When a procurement team uses an AI agent to do initial vendor screening, that agent visits pricing pages, compares tiers, and produces a shortlist. The agent does the work that a junior analyst used to do. Except it does it in seconds, across dozens of vendors, without getting tired or distracted.

Your pricing page was designed for humans. It has gradient backgrounds, animated counters, and a headline that says "Scale with confidence." It has a "Contact us" button where the Enterprise tier price should be. It uses words like "unlimited" without defining what that means. It buries the actual feature comparison behind a toggle and a calculator that lets you estimate your costs, both of which require JavaScript to render.

An AI agent cannot parse any of that. It doesn't care about your brand narrative. It doesn't respond to social proof badges. It wants structured data. Clear feature lists. Machine-readable pricing tiers. Explicit limits. Unambiguous comparisons.

I wrote about positioning and how it remains the foundation of everything. That hasn't changed. But the expression of positioning on a pricing page needs to work for two audiences now. The human who responds to visual hierarchy, trust signals, and a compelling value proposition. And the machine that needs JSON-LD schema, consistent naming, and every tier described in a format it can parse without guessing.

Right now, when a procurement team's AI agent screens database vendors, it visits your pricing page and tries to extract structured data. If it finds JSON-LD markup with explicit tiers, feature limits, and per-unit costs, you make the shortlist. If it finds an animated pricing calculator that requires JavaScript and a "Talk to Sales" button where the enterprise price should be, the agent moves to the next vendor.

Practically:

• Publish structured pricing data. Use JSON-LD schema markup on your pricing page. Define each tier with explicit features, limits, and costs. Make it parseable by any agent using any protocol.
• Stop hiding prices. "Contact us for pricing" is a human strategy. It works because humans are willing to have a conversation. AI agents are not. If the agent can't find a price, it moves to the next vendor. Period.
• Define your terms. "Unlimited API calls" means nothing to a machine. Does it mean 10 million calls a month with a soft cap? Does it mean truly unlimited with a fair use policy? Spell it out. Machines need specifics.
• Make feature comparisons explicit. Don't force a user (human or machine) to click a "Show full comparison" button. Put the comparison in the page. In HTML. With semantic markup.

I covered API marketing strategy in a recent post, and this principle extends directly. Your API product page, your pricing page, your feature comparison: all of it needs to work for the agent that is doing the first pass of evaluation before a human ever gets involved.

This is a mindset shift. You're designing for the agent that visits as well as the user.

How to annotate your pricing page for agents

I keep saying "structured data" and "JSON-LD markup." Let me show you exactly what that looks like.

Say you sell a developer database called AcmeDB. You have three tiers: Free, Pro, and Enterprise. Your pricing page already shows these tiers in a nice visual layout with cards, gradients, and a big "Get Started" button. That's fine. Keep all of it. But somewhere in the <head> of that page, you add a <script type="application/ld+json"> block that describes the same information in a format any machine can read.

Here is a complete example:

{
  "@context": "https://schema.org",
  "@type": "SoftwareApplication",
  "name": "AcmeDB",
  "applicationCategory": "DeveloperApplication",
  "operatingSystem": "Cloud",
  "offers": [
    {
      "@type": "Offer",
      "name": "Free",
      "price": 0,
      "priceCurrency": "USD",
      "priceSpecification": {
        "@type": "UnitPriceSpecification",
        "price": 0,
        "billingDuration": "P1M"
      },
      "eligibleQuantity": {
        "@type": "QuantitativeValue",
        "name": "API calls",
        "maxValue": 100000,
        "unitText": "per month"
      },
      "additionalProperty": [
        { "@type": "PropertyValue", "name": "Storage", "value": "1 GB" },
        { "@type": "PropertyValue", "name": "Connections", "value": "5" },
        { "@type": "PropertyValue", "name": "Support", "value": "Community forums" },
        { "@type": "PropertyValue", "name": "Regions", "value": "1" }
      ]
    },
    {
      "@type": "Offer",
      "name": "Pro",
      "price": 49,
      "priceCurrency": "USD",
      "priceSpecification": {
        "@type": "UnitPriceSpecification",
        "price": 49,
        "billingDuration": "P1M"
      },
      "eligibleQuantity": {
        "@type": "QuantitativeValue",
        "name": "API calls",
        "maxValue": 10000000,
        "unitText": "per month"
      },
      "additionalProperty": [
        { "@type": "PropertyValue", "name": "Storage", "value": "50 GB" },
        { "@type": "PropertyValue", "name": "Connections", "value": "100" },
        { "@type": "PropertyValue", "name": "Support", "value": "Email, 24-hour response" },
        { "@type": "PropertyValue", "name": "Regions", "value": "3" }
      ]
    },
    {
      "@type": "Offer",
      "name": "Enterprise",
      "price": 399,
      "priceCurrency": "USD",
      "priceSpecification": {
        "@type": "UnitPriceSpecification",
        "price": 399,
        "billingDuration": "P1M"
      },
      "eligibleQuantity": {
        "@type": "QuantitativeValue",
        "name": "API calls",
        "maxValue": 500000000,
        "unitText": "per month"
      },
      "additionalProperty": [
        { "@type": "PropertyValue", "name": "Storage", "value": "1 TB" },
        { "@type": "PropertyValue", "name": "Connections", "value": "Unlimited" },
        { "@type": "PropertyValue", "name": "Support", "value": "Dedicated Slack channel, 1-hour response" },
        { "@type": "PropertyValue", "name": "Regions", "value": "All available" },
        { "@type": "PropertyValue", "name": "SSO", "value": "SAML, OIDC" }
      ]
    }
  ]
}

Look at what an AI agent can extract from this in milliseconds. Three tiers. Explicit prices in dollars per month. Hard caps on API calls per tier: 100,000, 10 million, 500 million. Storage limits. Connection limits. Support response times. Region availability. SSO options on Enterprise.

Now compare that to what most pricing pages actually provide to a machine. A bunch of divs with class names like pricing-card-pro and text that says "Everything in Free, plus more." An agent will have to reason through that to understand the difference between Free and Pro.

A few things to notice about this markup:

• Every number is explicit. Not "generous API limits." Not "high-performance storage." Actual numbers. 100,000 calls. 50 GB. These are things you'd expect to see on a pricing page, usually with a toggle the user selects to see the full comparison. Here, you're simply codifying it in a format an agent can parse without guessing.
• Support is described in terms of channel and response time. "Email, 24-hour response" is comparable. "Priority support" is not. The agent needs to answer the question "if something breaks at 2 AM, how fast do I hear back?" Give it the data to answer that.
• The schema uses standard types. schema.org is the vocabulary that Google, Bing, and every major search engine already understands. AI agents trained on web data know this schema.
• Billing duration uses ISO 8601. P1M means one month. Not "monthly." Not "/mo." A machine-parseable duration that leaves no room for ambiguity.

You don't need to restructure your pricing page. You don't need to remove the gradients or the testimonials or the "Most Popular" badge on the Pro tier. Keep all of that for humans. The JSON-LD block is invisible to visitors. It sits in your page source, waiting for the agent that reads it.

Why is documentation the new storefront for AI agents?

Documentation is the new storefront because AI agents read docs, not landing pages. Your homepage used to be the front door. A developer would Google your product name, land on your site, read the hero section, scroll to the features, maybe click Pricing. That was the storefront.

That era is ending.

When AI agents recommend products, they cite documentation. Not marketing pages. Not landing pages. Not your beautifully designed homepage with the animated hero video. They cite your getting started guide. Your API reference. Your error codes. Your migration guide.

I wrote about this in Your docs are for AI now. Documentation page views were already dropping 30 to 40% while API adoption was rising 20 to 30%. The trend has only accelerated. AI agents are consuming your docs at a rate that dwarfs human traffic. And they're making purchase recommendations based on what they find there.

Think about what happens when a developer asks an AI agent: "What's the best way to add authentication to my Next.js app?" The agent doesn't visit the Auth0 homepage. It doesn't read the Clerk marketing page. It reads documentation. It looks for a getting started guide that shows the integration in three steps. It checks error documentation to see if the product handles edge cases. It looks for code examples in the language and framework the developer actually uses.

The companies that win in this environment are the ones whose docs are structured for machine consumption. Not instead of human consumption. In addition to it. As I wrote in making your content AI-friendly in 2026, this means semantic HTML, complete code examples, proper heading hierarchies, and machine-readable metadata.

But it goes deeper than formatting. The content itself matters. I wrote a guide on how to write a great getting started guide years ago. Every principle in that guide is now amplified by AI. Clear prerequisite sections. Explicit environment requirements. Runnable code at every step. These used to be nice-to-haves that improved the human experience. They are now requirements for getting recommended by AI agents.

Developer tool companies that figure this out will dominate AI-mediated discovery.

• Your getting started guide is your most important marketing asset. Not your homepage. Not your launch blog post. Your getting started guide is the thing AI agents read first when evaluating whether to recommend you. Make it flawless. Make it complete. Make it work on first try. Every time.
• Your API reference is sales collateral. When an agent compares your product to a competitor, it compares documentation depth. Incomplete references, missing parameters, undocumented error codes: these are disqualifiers. The agent moves on to a competitor whose docs are thorough.
• Scenario-based docs drive discovery. An agent matching a developer's problem to a product needs to see that your documentation addresses that problem explicitly. "How to build a webhook processor with [your product]" is discoverable. "POST /webhooks" is not. The first is a scenario. The second is a reference. You need both. But the scenario is what gets you recommended.
• Stop gating documentation. If a developer (or an agent) needs to create an account and log in just to read your docs, you've lost. Agents can't fill out signup forms. And they shouldn't have to. Your documentation should be open, indexable, and accessible without authentication.

Companies that hide pricing, gate content, or write docs only for humans will lose to competitors whose entire documentation surface is machine-readable. It's that direct.

The old storefront was your homepage. The new storefront is your docs site.

How do AI agents audit trust?

AI agents audit trust by cross-referencing everything. They don't just read your docs. Community sentiment. GitHub activity. Stack Overflow discussions (what's left of them). Reddit threads. Hacker News comments. Discord conversations. Third-party review sites. Blog posts from independent developers. Conference talk transcripts.

When a developer asks Claude "what's the best database for real-time analytics?", Claude doesn't just check vendor documentation. It checks what the internet says about each vendor. It synthesizes sentiment from hundreds of sources. It weighs recent activity more heavily than old testimonials. It notices if your GitHub issues pile up without responses. It notices if your Discord is a ghost town. It notices if the Reddit threads about your product are full of frustrated developers asking why support takes two weeks.

You can't control this narrative. You can only earn it.

I wrote about how to build an amazing developer community with a focus on authenticity and long-term investment. That advice has never been more relevant. Because AI agents are auditing your community health as a trust signal. A vibrant, active, honest community is now a competitive advantage in AI-mediated discovery. Not because the AI "likes" community activity. But because community activity generates the kind of authentic, distributed content that AI models weigh heavily when forming recommendations.

This is the part Jon Miller's prediction gets exactly right. Marketers built their careers on controlling the narrative. We wrote the messaging. We placed the press coverage. We paid for the analyst report. We shaped the story and pushed it through channels we controlled.

AI agents break that model. They synthesize information from channels you don't control. They weight authentic community sentiment over polished marketing copy. They can tell when a testimonial is real and when it's manufactured. Not perfectly. Not every time. But better than most humans, because they process thousands of signals instead of a few.

What this means for your marketing:

• Invest in genuine product quality above all else. This sounds obvious. It isn't. Many companies invest more in marketing their product than in making it good. When AI agents audit your reputation across the entire internet, the quality of your product becomes your most important marketing asset. No amount of positioning can overcome a product that developers complain about in every forum.
• Respond to issues publicly and quickly. AI agents notice response times on GitHub issues. They notice whether bug reports get acknowledged or ignored. They notice whether your team engages with community feedback or hides from it. Fast, honest, public responses to problems build the kind of trust that AI agents detect and relay.
• Be honest about limitations. When your documentation clearly states what your product can't do, AI agents trust the things you say it can do. When you oversell and a developer discovers the gap, that complaint shows up on Reddit. The AI reads that too. Honesty in documentation creates trust. Overselling creates the complaints that erode it.
• Your community is a trust engine. Developers talking about your product in their own words, in forums you don't control, generates the most valuable content for AI-mediated discovery. Every helpful answer in your Discord. Every positive mention on Hacker News. Every "I switched to X and it just works" post on Reddit. These are the signals AI agents weigh most heavily. And you can't fake them.
• Third-party content matters more than first-party content. A blog post on your company blog is marketing. A blog post by an independent developer who chose your product after evaluating three alternatives is evidence. AI agents know the difference. Invest in the conditions that produce third-party content: make a great product, support the people who use it, and let them tell their own stories.

The Anthropic Model Context Protocol is relevant here too. With over 500 public MCP servers and adoption across OpenAI, Google DeepMind, and the Linux Foundation, the infrastructure for AI agents to access and evaluate information is growing fast. These agents won't just read static web pages. They'll pull data from live sources. They'll check real-time community health. The audit is going to get more thorough, not less.

What this means for the next edition

If I wrote this chapter for Picks and Shovels, it would sit right after the chapter on AI and marketing. Chapter 25 teaches you to use AI as a marketing tool. This chapter extends that to treating AI agents as an audience. And because the chapter references documentation, community, pricing, positioning, and measurement, it works best after you've learned all of those disciplines, pulling the threads together before you reflect on your own career path. Marketing to AI agents is fundamentally about two things: making your product information machine-accessible, and earning the kind of authentic reputation that machines can verify.

Every chapter in the book connects to this. Positioning still matters, as I argued recently, but your position needs to be expressed in formats machines can parse. Content strategy still matters, but your content needs to serve the agent that reads it at 3 AM alongside the human who reads it at 9 AM. Community still matters, but its value has expanded from human loyalty to machine-auditable trust.

The developers reading this are already ahead of most marketers. You understand APIs. You understand structured data. You understand documentation as a product. Those instincts serve you well in an agentic world. The gap is in recognizing that these technical skills are now marketing skills. Your ability to structure data, write clear docs, and build genuine community are the marketing capabilities that matter most when the buyer is a machine.

Developer marketing leaders who understand agent skills and AI workflows already have an advantage. The next step is to stop thinking of AI agents as tools you use and start thinking of them as audiences you serve.

The agents are already shopping. The question is whether they can find you.