For thirty years, the interface between a business and its customer was a human staring at a screen. Every dollar of product design, every conversion experiment, every brand impression assumed a person on the other side of the glass — reading, feeling, deciding, clicking. That assumption is dissolving. The party that discovers your product, evaluates it, chooses it, transacts, and comes back is increasingly not a person at all. It is a piece of software acting on a person's behalf: an agent calling a capability. The interface is not being redesigned. It is changing species.
This is a change in who the customer is at the moment of transaction, and it rewrites the fundamentals — distribution, trust, pricing, defensibility, the shape of the product itself. The businesses that thrive in the agent economy will not stumble into it by bolting an API onto a website. They will be built for it on purpose. Below are the twelve principles I am building Kommerce and Velya by. The timeline is a forecast, and I flag it as one throughout. The direction is not.
1. Your customer's agent is your new buyer
The entity that evaluates and selects your product is shifting from a human reading a page to a planner parsing a declaration. An agent doing a job — book the freight, qualify the lead, reconcile the invoice — never loads your homepage. It reads a machine-facing description of what you can do and how to invoke it, and it decides. If that description does not exist, the task completes without you and no log line tells you it happened.
Build the machine-facing capability as a first-class product, not a website afterthought. The specific verb an agent wants — clean inputs, a clear output, real value when performed autonomously — is the thing to design, name, and describe with the care you now reserve for a landing page. Your product needs to be an agent skill, not just a website, because a fifty-word functional description is the entire competition on that surface — and almost everyone has built the human surface and no one the machine one.
2. Distribution moves to the registries agents consult
For twenty years, distribution meant ranking — being the link a person clicks. In the agent economy it means being the entry in the catalog an agent already has connected, and being the one its planner selects when two entries overlap. An agent closing the books each month does not run a fresh search; it reaches for the reconciliation tool it is wired to. Acquisition stops being "rank for the query" and becomes "be in the configuration."
The implication is concrete and uncomfortable. Get your capability listed in the directories agents consult early, while curation is loose and being a reliable connector is cheap — not late, when the slots are effectively auctioned. Forecast: the incentive gradient points hard toward a small number of consolidated registries acting as gatekeepers, the way the App Store did, and the switching cost will live inside someone else's agent configuration, which is stickier than any human habit. No single registry has won yet. That is precisely the window.
3. Decide whether you are the agent or a service it calls — you cannot be neutral
There are two positions in this economy and they demand opposite strategies. You are either building the personal agent that acts for the user — holding the relationship, the context, the trust, the defaults — or you are building a service that agent calls. One is the platform; the other is a supplier to it. Pretending you can be both, or deferring the choice, means you optimize for neither and get disintermediated by whoever chose.
Pick deliberately, because the platform war over the personal agent determines who owns the customer relationship and who merely fulfills against it. If you are the agent, you must win distribution to the human and earn the right to hold their context. If you are the called service — which is most businesses — your job is to be the most reliable, best-described, most fairly-priced capability in the catalog, and to protect a direct line to the end customer so the agent never fully owns them (Principle 8). Velya sits on the service side on purpose: it is a capability a clinic's stack calls, and knowing that shapes every decision from pricing to error semantics.
4. Trust becomes a protocol problem, not a brand feeling
When a human transacts, trust is psychological — a logo, a review count, a sense of legitimacy assembled from design cues. An agent cannot be reassured by a testimonial wall. It needs machine-checkable answers to hard questions: Is this counterparty who it claims to be? Did this data come from where it says? Is this action authorized within the budget and permissions the user granted? Trust stops being a vibe and becomes identity, provenance, and permission — enforced in a protocol.
Build for verifiable trust as infrastructure, not marketing. This is the premise of the agent-to-agent economy where software negotiates with software: before value moves, both sides need cryptographic answers about identity and authorization, not brand impressions. I feel this acutely with Kommerce, which exists because trust is scarce in cash-on-delivery markets — we already encode trust as verifiable signals rather than reputation, and that is the muscle the agent economy will demand from everyone.
5. Verification is the scarce good — and a product category
When generation becomes cheap and abundant — text, code, offers, transactions, counterparties — the bottleneck moves to checking. An agent can produce or solicit a thousand actions a second; the expensive, valuable, scarce step is confirming which ones are real, correct, authorized, and safe to act on. In an economy of infinite cheap output, verification is the new bottleneck, and a bottleneck is a business.
Treat verification as something you sell, not just a cost you absorb. If you can vouch — provenance of data, correctness of a computation, legitimacy of a counterparty, delivery of an outcome — you hold a position that only grows more valuable as generation gets cheaper. Forecast: verification services (identity attestation, outcome auditing, provenance proofs) become a distinct and durable category in the agent stack, the way security tooling became its own industry once software ate everything. Build the check, not just the output.
6. Price for outcomes, because agents comparison-shop on outcome, not brand
A human pays partly for how a product makes them feel, which is why brand premiums survive functional parity. An agent has no such loyalty. It re-decides every call on the observed facts: did this capability deliver the outcome, at what cost, at what latency, at what reliability. It will migrate to a crisper, cheaper, more reliable equivalent silently, mid-workflow, with no rebrand and no human comparing you side by side.
Price and package around the outcome the agent is buying, not the seat or the brand. A per-seat SaaS price aimed at a human buyer is illegible to a planner optimizing cost-per-successful-task. Expose a clear unit — per qualified lead, per reconciled invoice, per successful shipment — with predictable cost and measurable success, so the agent can reason about you. If your pricing can only be understood by a salesperson, no planner will ever choose it.
7. Keep a thin human interface for the trust-and-taste moments an agent can't hold
Not everything routes through an agent, and the exceptions are where the margin lives. Irreversible decisions, high-stakes judgment, the moment someone wants to feel a brand or exercise taste — these stay human, and an agent handing off to a person at exactly those moments is a feature, not a failure. The mistake cuts both ways: automating the moments that need a human, or building a heavy human interface for the moments that don't.
Keep one interface — thin, excellent, aimed only at the trust-and-taste moments. Design effort concentrates there and drains away from the routine calls agents will handle. The question for every screen you own becomes: is a human supposed to be here, or am I making a person do an agent's job? Cut the interface everywhere the answer is the latter, and make it beautiful everywhere the answer is genuinely the former.
8. Own the direct relationship the agent can't fully intermediate
If a personal-agent platform sits between you and every customer, it can commoditize you, throttle you, or swap you for a cheaper equivalent — exactly what marketplaces and app stores did to the businesses inside them. The defense is a relationship the intermediary cannot fully own: a direct channel, first-party data, an account, a reason the end customer knows your name even when their agent does the calling.
Build at least one line to the customer that does not run through the agent — a direct relationship, a first-party identity, a moment of contact you control. This is not nostalgia for the human web; it is insurance against becoming an interchangeable row in someone else's catalog. The service that is only ever reached through an intermediary has handed that intermediary the power to set its price to zero.
9. Build reversible, because agents act fast and at scale
A human makes one mistake at a time and usually catches it. An agent can make ten thousand mistakes before you notice, because it acts at machine speed and machine scale — a bad loop, a misread schema, a hallucinated argument, multiplied across every call in a workflow. The blast radius of an error is categorically larger when the actor is software.
Engineer reversibility and containment as a first principle: idempotent operations, dry-run modes, spending and rate limits per agent, confirmation gates on the irreversible actions, clean undo on everything else. Assume the agent calling you will occasionally do something wrong at volume, and design so that "wrong at volume" is recoverable rather than catastrophic. The businesses that survive agent traffic will be the ones that made the expensive mistakes cheap to unwind.
10. Instrument agent traffic now, before it is most of your traffic
You cannot manage a channel you cannot see, and today most analytics stacks bucket agent traffic as bot noise or misread it as a human session. By the time agent-driven revenue is obvious in the numbers, you are a year behind the teams who separated the streams early and learned how planners actually select, call, and abandon.
Start measuring the machine-initiated funnel immediately: capability discovered, tool selected, call succeeded or failed, outcome delivered, payment settled — separated cleanly from human sessions at the log level. Watch which descriptions get chosen, which schemas cause failed calls, where planners abandon. Forecast: the agent share of transactions rises fast enough that the instrumentation you build this year is what lets you optimize the channel next year, while competitors are still guessing why their beautiful homepage stopped converting.
11. Make correctness observable, because your customer can't feel it
A human customer forgives a rough edge because the overall experience feels right. An agent has no gestalt to forgive with — only the observable result of each call. If your capability is correct but you give the planner no clean signal of that correctness, you are indistinguishable from a capability that fails silently, and the planner will route around you at the first ambiguity.
Emit structured, honest signals of success and failure: explicit status, error semantics a planner can reason about, confidence where it matters, and never a false success. A tool that fails loudly and legibly is more valuable to an agent than one that fails quietly and beautifully. When the buyer is a planner, observable correctness is the product experience.
12. Compete on reliability, latency, and description — the new triad of quality
Strip away brand, design, and narrative — the things that differentiate for a human — and what is left for an agent to judge you on is narrow and measurable: does the call reliably work, how fast does it return, and how well does its description let the planner select it correctly. That triad is the entire quality surface on the machine-facing side, and it is where the next decade of competition concentrates.
Invest there like your survival depends on it, because on this surface it does. Drive down failure rates and tail latency the way you once tuned a checkout flow, and treat the tool description and schema as load-bearing copy owned by your best people, not a junior afterthought. The competitor who wins your customer's agent will not have a better story. They will have a lower error rate, a faster response, and forty better words.
None of this asks you to abandon the human customer, who is not going anywhere. It asks you to stop building as if the human is the only customer, when a second buyer — faster, more rational, utterly indifferent to your brand — is already calling your competitors and logging the results. The interface is changing species. Ship the callable capability this week, instrument the traffic this month, and be in the catalog before the slots are gone.