Your Product Strategy Wasn't Built for Things That Make Their Own Decisions

Almost every tool product teams use to think about their products carries a hidden assumption: that there's a human on the other end. The persona is a person, with motivations and frustrations. The success metric counts a person doing something – clicking, returning, converting. The guardrails are written for software that does what it's told and nothing more. That bundle of assumptions has worked for decades because it matched reality. It quietly stops matching the moment one of your "users" is an AI agent that makes its own decisions.

And increasingly, one of them is. As companies ship agents – software that takes actions autonomously rather than waiting for a human to click – those agents start showing up as users of other software, as the thing your product has to serve or interoperate with. The strategy tools built for human users don't break loudly when this happens. They break quietly, by giving you confident answers to the wrong questions.

A 2026 paper tried to name what's breaking, and it's a useful place to start – as long as we read it critically.

What the paper claims, and how much to trust it

The paper is Rumalla's "Agentic Product Evolution" study, published in the International Journal of Computer Applications. Its core observation is hard to argue with: most product strategies were never designed to account for autonomous behavior, shared human-machine decision-making, or systems that reason on their own. Teams keep reaching for the familiar constructs – static personas, usage-based success measurement, guardrails built for predictable software – and applying them to agentic situations where they simply don't fit. The paper proposes a model it names APE for re-tooling strategy around orchestrating human-agent decision autonomy, drawn from 10 enterprise implementations and validated against input from more than 25 product leaders.

It also reports results: early adopters saw strategic rework drop by an average of 36%, and stakeholder confidence rise by an average of 48%. I want to be straight about how much weight those numbers can carry, because it matters. They come from a single paper, based on ten implementations, presenting a framework the paper is itself advocating for. That's directional evidence, not an established benchmark – and frameworks tend to look good in the data assembled to demonstrate them. Treat the 36% and 48% as a hypothesis worth testing in your own context, not as a fact to quote in a board deck. The paper's diagnosis is far more durable than its prescription, so let's spend our time on the diagnosis – which you can reason about from first principles, without anyone's proprietary model.

Why the old constructs actually break

Take the three core artifacts of product strategy and ask, of each, whether it still makes sense when the user doesn't think like a person.

Start with personas. A persona is a tool for capturing what a human wants and how they behave – "busy professional who values simplicity," that kind of thing. An agent has no wants. It has objectives it was given, boundaries on what it's allowed to decide, and a tolerance for acting without checking back. "Busy professional who values simplicity" tells you nothing about how to serve an agent. "Acts autonomously up to a spending limit, escalates above it, and needs every decision to be auditable" tells you almost everything – and it's a fundamentally different kind of object than a persona. The familiar template doesn't just need new content. It needs to be a different template.

Now metrics. Usage-based measures – sessions, clicks, time spent in the product – all rest on the assumption that more engagement is good, because for a human, engagement signals value. For an agent, the relationship often inverts. More interaction can mean the agent is struggling, retrying, failing to get what it needs efficiently. A well-functioning agent might touch your product briefly and decisively and leave. The metric that rewarded stickiness now rewards friction, and a dashboard built on engagement will cheerfully tell you things are going well while your agentic users are actually having a hard time.

Then guardrails. Software that does exactly what it's told fails in predictable ways, so you write rules for the failure modes you can list in advance: don't let the user do X, block input Y. An agent's failure modes are emergent. It can take a sequence of individually reasonable actions that add up to an unreasonable outcome nobody specified or foresaw. Guardrails written as "don't let the user do X" don't cover "don't let the system reason its way into X over six steps." The old model of safety – enumerate the bad inputs and block them – doesn't map onto something that generates its own path.

What actually has to change

The honest version of the fix isn't a branded framework you adopt wholesale. It's a short list of strategy objects that need rebuilding, and you can do the rebuilding yourself once you see the pattern.

Personas become autonomy profiles: what the agent is permitted to decide, where it must defer to a human, and what it has to be able to explain about its choices. Success metrics shift from engagement to the quality of delegated outcomes and the rate of appropriate escalation – did the agent make good calls, and did it correctly hand off the ones it shouldn't have made alone? Guardrails move from enumerated rules toward bounded autonomy with human checkpoints, especially early in deployment when trust hasn't been earned. And the roadmap stops being purely a list of features for people and becomes, in part, a plan for how much decision-making you're willing to delegate, and how quickly you're willing to expand that boundary as confidence grows.

None of that requires adopting anyone's three-letter model. It requires noticing that each of your strategy artifacts encodes an assumption about a human user, and asking what it becomes when that assumption fails.

The signal underneath the single study

There's a finding worth more than any one paper's effect size, because it comes from a much larger sample and points the same direction. Nylas's 2026 agentic AI report, drawing on more than a thousand product and developer respondents, found that 72.7% consider agentic AI important to their product strategy – and, crucially, that what shapes adoption is trust, control, and failure handling, not raw model capability. That last point is the whole game. The teams struggling with agents aren't struggling because the models aren't good enough. They're struggling because their strategy – their personas, metrics, and guardrails – was built for something that doesn't act on its own, and almost no one's was.

So you don't need to buy into APE, or any framework, to take the real point. You need to look at your personas, your success metrics, and your guardrails and ask one question of each: does this still make sense if the user doesn't think like a person? Everywhere the answer is no, you've found the work. And right now, for most product teams, the answer is no more often than they'd like to admit.