We spent twenty years keeping bots out. Now they're the ones we need to let in
the highest volume users of your software in three years can't fill out your signup form, and that's not their problem
Disclaimer: The views here are my own and do not represent my employer or anyone else.
There’s a quiet assumption baked into almost every B2B SaaS product ever built, and nobody wrote it down because it was pretty obvious: the customer is a human.
You can see that assumption everywhere once you look:
signup flow that requires a verified email and a credit card (oh yes, that card has to be linked to a human)
onboarding sequence that sends three welcome emails and waits for someone to click through them to decide what’s the next best event-based nurture they should put you in (we’ve all built event-based nurtures, haven’t we?)
the permission prompt written for someone who is reading it carefully
Billing page designed around a person who will notice the charge, react to an anomaly, and make a decision
Every friction point, every design choice, every assumption about how a new user enters and moves through a product - all of it was built for someone with eyes, opinions, and a mouse.
But, that assumption is quietly becoming the most expensive technical debt in B2B software.
For most of the history of the internet, bots attempting to automate account creation were a problem to be eliminated, not a segment to be served. They were spammers, scrapers, fraudsters running volume plays, so the industry responded rationally: CAPTCHA, email verification, manual review queues, credit card requirements on free tiers, and tons of startups and enterprises who helped you solve for it. There were still gaps in the tooling, and that’s why you saw your monthly activations climb to a 25% Y/Y growth on Sep 1, but after 6 weeks of manual bot/fraud tagging and threshold adjustments, it’d dip to 12%. Every tooling was designed to ensure a human being was on the other end of every new account.
This is what Jared Friedman shared last week:
Agents are being deployed inside enterprises to research vendors, evaluate tools, spin up trial accounts, run integration tests, and return a recommendation. They are doing work that a junior analyst or solutions engineer used to do, acting as the first touch in a procurement motion before a human ever gets involved. And they are hitting walls at every step - because the entire infrastructure of B2B software was built for someone who can read a modal, click a verification link, and fill out a form.
The shift that is coming is not about adding an API to a product that was built for humans- most SaaS products already have APIs.
The gap is everything around the API: the human-assumed infra that agents cannot navigate and were never meant to:
Account creation requires clicking a verification link sent to a human inbox
Core functionality sits behind an onboarding flow designed for people who need to be taught
Scoped access requires navigating a permissions UI that assumes someone is reading and deciding
billing requires a credit card attached to a human account
Error states return modal dialogs written for a person to read and respond to, not structured data a system can parse and act on.
An agent encounters all of this and stops; not because it isn’t capable -but because the product wasn’t designed to be used by anything other than a person. The product either supports programmatic interaction from the first touchpoint or it doesn’t, and there is no patient middle ground where an agent eventually figures out your welcome email sequence.
Agent-native software is built differently from the ground up - (a) account creation via API without human verification steps, (b) scoped, programmable access controls configurable without a UI, (c) usage-based billing attached to an agent identity rather than a human credit card, (d) onboarding expressed as documentation and endpoint behavior rather than guided tours and drip campaigns, (e) errors that return structured, actionable data rather than messages written for human eyes etc.
For most SaaS companies, closing that gap means revisiting assumptions that run years deep - the signup architecture, the billing model, the permission layer, the way errors surface..none of it is cosmetic, ha! All of it was designed around a user who shows up, clicks around, develops preferences over time, and has a relationship with the product. Alas, agents don’t do any of that.
The second order implication is the one most product teams aren’t thinking about yet: who gets chosen. In a world where agents are assembling their own stacks, the selection dynamic changes fundamentally.
E.g., a human evaluating tools does research, reads reviews, sits through demos, and builds vendor relationships over weeks. An agent picking a stack reaches for the tool it can use without friction - fully API-accessible from the first interaction, programmable, no human-in-the-loop required to get started. The decision happens in a planning loop, not a buying committee, and it is based entirely on what is available and what works.
The developer tools that understand this are not treating agent-readiness as a roadmap item for next year. They are rebuilding the front door - signup, access, billing, error handling - as if the first user through it might be a system rather than a person. That is not a small change in how a product is built, but rather in who the product is built for.
The companies that move fastest here don’t just acquire agent users. They get chosen first, repeatedly, at scale, by systems that don’t browse review sites or respond to outbound sequences. That is a fundamentally different kind of product-market fit than anything B2B SaaS has optimized for, and the window to build for it before it becomes table stakes is closing faster than most roadmaps reflect.
Your best future customer might not be human…the question is whether your product is aware of that.