Selling to a machine

>_GET /blog/selling-to-a-machine

Throughout this series, Blake has been the protagonist, the cold and precise buyer who assumes you are lying and checks everything. Let's flip the table. Meet Sam, the vendor whose door that agent just knocked on. It will not be charmed or rushed, and it has already decided to trust nothing until it verifies it. Most sellers react by asking how to win the agent over, which is the wrong question to start with. The right one is a bit stranger.

In this setup, the seller's goal is different from how it seems. The immediate instinct is to close the deal. But when every claim is measured and reputation compounds over time, the transaction in front of you is almost beside the point.

This is the seller's playbook: how the funnel works when the buyer is a machine, why the old goals invert, and why a strategy of "don't trust, verify" becomes the strongest go-to-market plan a vendor can have.

Stop persuading; lower the cost to verify

Old-school sales fights for attention and tries to convince. Sam focuses on becoming the vendor that is fastest and cheapest to verify>_Cheap to verifyThe winning vendor is whoever makes its promises cheapest to check — not whoever tells the best story.defined in When machines become the customer →. Instead of focusing on conversion rates, the real metric is time-to-verified-trust>_Time-to-verified-trustElapsed time to a justified yes or no — with signatures, benchmarks, and receipts proportional to stakes.defined in Time-to-verified-trust · coming soon →, which measures how quickly Blake can reach a justified yes or no. A fast no counts as a win since a doomed trial that ends in churn is far more expensive than never starting. Sam wants to be the easiest to verify, not the loudest.

Stage by stage

Every tactic falls out of that one shift. Walking the funnel from Sam's side:

• Discovery. Keep the manifest>_Capability manifestGET /.well-known/agent.jsonThe missing middle layer between OpenAPI and schema.org — a signed business datasheet agents can parse.defined in The end of landing pages → rich, measurable, and present in registries>_Three registry layersIdentity (who), discovery (what), reputation (trust) — three owners, three politics.defined in Where agents find each other →, but hold the claims conservative on purpose. An inflated claim is a mine Blake defuses in the sandbox, and it carries a reputation penalty. Promise 0.88 and deliver 0.90, never the reverse.
• Identity. Lay out the full chain up front (legal entity, did:web, and delegation) because verification friction at the door is a disqualification. Blake will query whoever made themselves trivial to check first. Make verification seamless.
• Fit. Disqualify the product early. If Blake needs something the vendor does not support, say so and point to a partner. A bad-fit sale has negative expected value once the seller prices in churn, weak SLAs, and the reputation damage. Qualifying out is a feature.
• Sandbox. This is the new demo. A clean room lets Blake measure the production model on its own data; the more cheaply it can prove that quality, the less the seller has to say.
• Pricing. Publish a deterministic price with a most-favored-nation guarantee. Personalized gouging is a trap because Blake compares the rate to a reference price anyway, and getting caught costs more in reputation than it earns in margin.
• Post-sale. This is where the seller actually wins. Over-deliver, because every signed receipt>_Signed transaction receiptsCryptographically anchored deal outcomes — the atoms reputation compounds from.defined in Reputation as capital → and every green canary is an advertisement to the next thousand agents.

Over-delivery is your marketing channel

Rather than treating the post-sale phase as a cost center, Sam uses it to build the asset that sells the next deal. Concretely: beat the SLA visibly, pay credits before Blake asks, alert the buyer to problems before they notice, and make every receipt rich enough to be a signal:

{
  "receipt_id": "rcpt_7b1c…",
  "buyer": "did:web:blake-co.example",
  "seller": "did:web:sam.example",
  "term": "12 months",
  "sla_target": "99.9%",
  "sla_delivered": "99.97%",
  "extraction_f1": { "claimed": "0.88", "delivered": "0.90" },
  "credits_issued": 1,
  "disputes": 0,
  "signature": "ed25519:…"
}

A signed, portable receipt like that is worth more than any case study because it is generated by math rather than written by Blake. Advertise low lock-in for the same reason: data export is itself a trust signal, and Blake rewards it.

You are rating the buyer too

Vetting goes both ways. Before Sam spends money on an expensive clean room run, it risk-tiers Blake to check if the company is a good payer or litigious. Is it a tire-kicker that burns trials and never buys? Is it a competitor's agent in disguise, fishing for the model and the pricing logic? Is it an adversary probing for prompt injection or data exfiltration? Sam authenticates Blake just as Blake authenticates Sam, and scales disclosure to the buyer's assurance tier: a list price for an anonymous query, but a real production clean room only for a verified identity. A high-reputation buyer earns better terms; trust flows both ways.

The economics flip

In this environment, the cost of acquiring a customer is essentially the cost of establishing trust, and reputation amortizes that cost over time. The thousandth buyer is cheap to win because the historical record does the convincing. So instead of a sales team or an ad budget, Sam's biggest asset is accumulated, verifiable reputation paired with low verification friction. The money that used to go to SEO and advertising moves into trust infrastructure: the sandbox, attestations, signatures, manifest quality, and a partner graph so that even a polite "we are not for you" leaves goodwill.

"Don't trust, verify" is your go-to-market

The smartest thing Sam can do is accept that Blake is right not to trust it, and stop demanding trust entirely. Instead of trying to prove trustworthiness, a vendor wins by making distrust cheap to resolve. This reverses traditional marketing: instead of asking for trust, the seller invites the buyer to verify and provides the tools to do it quickly. In a market of agents, don't trust, verify is the best go-to-market strategy a seller could ask for.

Bets worth placing

The strategy above assumes the buyer is already a machine; the honest version of the advice is a staged bet. Running a dual stack, keeping a human-facing site and an agent-facing layer side by side, lets agent traffic, not faith, show when budget should move from persuasion to verification. These habits are worth adopting early because they are cheap and reversible: conservative claims, an honest "no," signable receipts, and careful deal selection. A reputation record takes years to assemble and one verified breach to wreck, and every agent that queries you afterward will see it. The seller's market is also its own open space: clean-room-as-a-service so a vendor can offer proof without holding buyer data, receipt and attestation tooling that turns delivered performance into portable reputation, risk-tiering and anti-extraction defenses, and partner and referral graphs that make qualifying out profitable. The buyer's agent gets all the attention, but the infrastructure that lets sellers win honestly is just as large.

That is the table seen from both sides: Blake consuming the stack, Sam producing and optimizing it, both disciplined by the same engine of reputation in a repeated game. The further you go, the clearer it gets. The loudest promise does not win the web for agents. Whoever makes the truth cheapest to check wins.

Everything above assumes the machine buyer already exists, but today, for the most part, it does not. If your next question is the operator's concern: you run a company now, this quarter, so what do you actually build first? That answer lives outside the series, in the handbooks, starting with You run a SaaS. Now what?