Why a product manager needs an AI agent: focus on the product, not the ops

While some are still arguing about whether AI will replace the product manager, a whole new profession has grown up in the market — the AI PM, with an average salary of around $133K and up to $200K for seniors. And anyone who never learned to work with AI is increasingly called quick to become obsolete. But the most interesting part is something else. “Using AI” and genuinely rebuilding the way you work are two very different things today, and only a handful have mastered the second one.

A PM’s job is supposed to be about thinking through the product, but in reality most of the week is eaten by something else entirely — pulling status across projects, updates to stakeholders, turning ideas into tickets, the endless reconciling of who did what and what got stuck where. Everyone has a chat at hand. Ask it to draft a PRD, polish an update, rephrase a thought. Except it only suggests text, while going into the tracker, digging up the correspondence, pulling status and breaking an idea into tasks — you still do all that by hand.

But whoever moved from the chat to an agent that walks through your systems on its own and closes out that routine entirely gets back hours, or even whole days, a week. And they spend that on the product itself — running more directions, taking ideas to done faster and picking up more complex and interesting work. In this piece we’ll look at where the profession is heading according to major research, what an agent even is and how it differs from an ordinary chat, and which concrete PM tasks it already handles.

Where the market is heading

Reviews of the product profession for 2026 all agree on one thing. AI has gone from a nice bonus to a baseline requirement, and a PM without it quickly falls behind. You’d think, if that’s the case, everyone has long since adjusted and the train has left. But the interesting part is that mastering the chat and genuinely changing the way you work are not the same thing at all. And the ones pulling ahead aren’t the flashiest with the new tools, but those who kept their own product judgment and amplify it with AI.

The thing is, “using AI” now means two very different things, and the gap between them is huge. The first format is conversational. You open a chat, paste in a chunk of a PRD, a feature description or a thread from the correspondence, explain the context, get an answer and move it back to yourself by hand — into the document, into the ticket, into the update for the team. The second format is agentic. You just set a task, and the system goes into your tracker, your knowledge base, Slack and analytics on its own, pulls up the relevant tickets and decisions, assembles a draft of the spec or the status by your templates and hands you a finished result that you just have to check. The first is a slightly smarter search box at hand; it barely changes your real speed, because you still do all the reconciling and switching between systems yourself. The second changes it radically. The status roundup that used to eat the first half of the day starts taking minutes. And this is where the real picture of the market becomes visible.

A recent large study run by top American universities together with OpenAI, “The Shift to Agentic AI: Evidence from Codex” (June 2026), shows where it’s all going. Agents have already moved beyond development into ordinary product work, into planning and communication, and they take on ever longer tasks. Over half a year, the share of those who trust an agent with at least one task worth an hour of human work or more nearly doubled, roughly from 35 to 70%. Simply put, people started handing agents not small hints but whole chunks of work — exactly the ones that usually sit on the PM. But so far this is the lot of a few. Most of those who say “I’ve been using AI for ages” are still stuck in the chat correspondence. They stopped googling and ask ChatGPT the same things, ask it to draft a meeting summary or a rough email, and get almost no gain. The ones who really win are the handful who moved to agents. For specialists inside that same OpenAI who switched to agents in research and product work, the volume done in a month grew many times over what it was half a year earlier, and at the same time spent. And that means you can run more directions, take on more complex and ambitious tasks and grow faster — both in the level of work and in money.

Employers are already baking this shift in. The ability to work with AI increasingly sits in the requirements for a PM right at the door. At the same time, only a few have genuinely learned it — at the agent level, not chat correspondence. And it’s in that gap that the opportunity lies. Figuring it out now means both securing yourself for the future, when it becomes the norm for everyone, and getting an advantage today in speed, in the number of directions you manage to run, and in money.

It comes down to a simple thing. The market already needs PMs who can do more than just ask a chat — who can hand the routine to an agent and tune it to themselves. So far there are few of them. Whoever learns it stops giving away half a week to coordination and status roundups and returns that time to the actual work on the product, while also carrying more directions. So the whole question is who moves into this camp first. And the good news is that getting there is far simpler than it seems. We’ll cover exactly how below.

What an agent even is and how it differs from ChatGPT

Strip away the jargon and an agent is a program that doesn’t answer a question but performs a task. The difference is roughly like that between a consultant and a doer. The consultant tells you what needs to be done, but you still do it all yourself. The doer takes it and does it, and you check.

An ordinary chat waits for you to bring it all the context yourself. You copy the tickets and the discussion thread, explain what the feature is and what stage the project is at, and then move the answer back to yourself by hand. An agent is given access to the necessary tools once, and from then on it goes into the tracker, the knowledge base and the correspondence itself, pulls up the project history, prepares a draft of the spec or status and, if needed, creates tickets. All that’s left for you is to check and confirm.

It works quite simply. The agent runs in a loop. It got a task, decided what to do as the first step — say, pull up the tickets for the epic or read the thread with the accepted decision — did it, looked at the result, moved to the next step, and so on until the task is closed. You don’t need to get into it, exactly as you don’t need to understand how a mail server works to send an email.

There’s one important point, and it’s simpler than it seems. For the agent to work not at random but by the rules of your particular team and product, you don’t need to train it by hand and spell everything out in text. Setup is more of a joint effort. You hand it your spec templates, examples of past PRDs, the structure of your projects, the way you slice work into tickets and how you usually prepare updates for different audiences, and it figures all that out on its own and assembles a set of rules it will follow from then on. You check that and adjust where needed. From then on those rules are reused in every task, and any request runs just as evenly whether you launched it yourself or a colleague covering for you did.

Which tasks it already handles

If you look at what such agents actually do for PMs today, a few typical scenarios take shape. Below are the most common ones, just as examples, so it’s clear what we’re talking about. In practice you can automate almost any repeating chunk of work this way; these are taken for illustration.

The most common story is pulling status across projects. To understand what moved and what got stuck, a PM usually walks the tracker by hand, reads Slack, recalls what was agreed on calls, and reconciles it all in their head or in yet another spreadsheet. An agent that has access to the tracker, the correspondence and the codebase assembles such a summary itself. One manager set it up like this. Every morning, before the office, the agent sends him two short summaries in Slack. The first, what the team did over the last 24 hours, by tickets and open pull requests, with one line for each. The second, the release tracker, marking what’s stuck in review or testing. The agent goes into the systems itself, reads and, if needed, moves tickets, and once a week hands over a summary of team velocity and defects. That same person honestly notes that the summary sometimes starts ranking the team on its own and makes strange assumptions, so he reads those spots with skepticism and usually writes the release risks himself. And that’s the right frame. The agent assembles the picture, but the conclusions from it stay with you.

The second familiar scenario is turning an idea into a spec and into tickets. Usually it’s a separate chore. Gathering related tickets, pulling up past specs on the topic, recalling accepted decisions, laying it all out by your template and breaking it down into tasks for the team. The agent takes this chunk on. You describe what you want to do, and it gathers all the context for it that you usually never get around to. It pulls up related tickets and past tasks from the tracker, similar specs from your base, finds what was discussed on this topic on calls and in chats, picks up close support requests and discussions from notes of customer meetings. It brings all of this together and assembles a draft by your structure — already enriched with real context rather than written in a vacuum — and proposes a breakdown into an epic and tasks. There’s one detail here that practitioners point out. The difference between “just ask the chat to write a PRD” and a configured scenario is that in the second case it’s not a one-off text from a single request but your own process, wired into the rules. The same sections, the same level of detail and the same decomposition logic that you set yourself. You check the draft, edit it and put the tickets into work.

The third scenario is updates for stakeholders and release notes for different audiences. Essentially the same thing has to be told in different ways. To engineers in detail, to management in broad strokes with an emphasis on risks and timelines, to the neighboring team only what concerns them. Usually the PM writes this by hand, each time working out anew what goes where. The agent pulls up progress from the tracker and decisions from threads and prepares a draft for the right audience, in the right tone and at the right level of detail. And it’s not just about the text. Ready release notes it can assemble and format straight for publishing, to the site or a newsletter, rather than just handing over a draft that you then lay out yourself. You edit and send. What used to take an hour of shuffling the same thing across three formats turns into a quick check.

And the fourth scenario, the most telling, is when the agent assembles you, in effect, a junior PM for your product area. It keeps all your projects in memory and takes on the preparatory part that there’s usually never enough hands for. By morning it prepares status and risks, for the weekly sync it gathers what moved over the week, and for the metrics review it goes into the connected data sources itself, assembles a dashboard and hands over ready observations on the numbers, covering part of the product analytics you usually wait on an analyst for. But the most striking thing here is different. A PM at one company described writing a PRD in plain text and, twenty minutes later, getting a working clickable prototype from the agent — essentially a ready MVP. You can click through it, or you can ask it to walk the main scenario, record a short video and drop it to the team in chat. And instead of spending a week chasing edits on a document that everyone read their own way, the team immediately discusses a live prototype that everyone sees the same. So the assistant closes out not one task but a whole repeating layer of preparation, leaving you time for the actual work on the product.

And the most valuable part is that these scenarios only get better over time, as the agent accumulates the context of your projects. Set a scenario up once, and from then on it’s essentially a recorded playbook of your work, reused every time and one you can gradually improve. Your way of writing specs, slicing tasks and pulling status stops living in one person’s head. The same scenario can be handed to the whole team, and a new PM from day one prepares updates and breaks ideas into tickets exactly the way it’s done at your place, rather than feeling it out over months. You figure out how you run the product once, and from then on it works for you constantly.

What the limitations are

Two honest caveats are needed here. The first is that AI sometimes gets it wrong, and confidently at that. It can misread a status, pull the wrong ticket or, when the connector to the tracker has dropped, substitute a plausible but made-up conclusion just to close the request. So the agent is a first-pass doer, not the final authority. It takes on the routine and the drafts, but priorities, risks and the decision on what to build stay with you, and tickets and updates go out through your confirmation. In setup it’s given an explicit rule to rely only on real data and not to make anything up.

The second caveat is confidentiality. Product plans, metrics and internal correspondence shouldn’t leak into someone else’s cloud, so it’s wiser to keep files and access with you. That way you get the agent’s speed and control where the data sits yourself.

Keep these two rules in mind — a human checks and decides, and the data stays with you — and the agent stops being a risk. It’s simply a faster way to do the same work with the same responsibility for the result.

How to start using this

You can build such an assistant yourself. But it’s not just about spending an evening on setup. You also have to figure out how it all works, what to connect where, how to describe the scenarios, what baseline rules to lay in, try it, make mistakes somewhere and redo it. That takes time, and not every PM has the desire to dive into it, especially since there are already plenty of their own tasks and calls.

So there’s a simpler path: take a ready, pre-configured solution. There are solutions like kvelo.dev that already work as agents and assemble a personal workspace for you, where everything you need — including typical PM scenarios — is already laid in and set up automatically, without long manual fuss. It also brings together that zoo of tracker, knowledge base, correspondence and analytics that you usually bounce between all day. From then on you just work. The complex tasks you do at the computer, and the simple questions you handle right from the messenger. You write in Telegram or WhatsApp “pull status on the project for tomorrow’s sync,” and the agent went into the tracker and the correspondence, pulled up what moved and what got stuck, and sent back a ready summary. In effect you talk to it like a colleague.

The market has, by and large, already decided that working with AI in product is the new norm. The difference between those who stay in the chat correspondence and those who learn to delegate to agents will soon be visible in speed, in the number of directions a person carries, and in who on the team gets to think about the product and who drowns in pulling status and rewriting updates. So it’s worth starting to figure this out now. There’s still time, and the chance to be among the first is still large. And to figure it out as simply as possible and wire it into your work right away, you can start with a ready solution like Kvelo and just try it.