AI Agent Product Owner (Agent Owner) in London

To own the business side of an agentic delivery.

Find the opportunity, prove its value, decompose the work into tasks an agent can execute, set what "good enough to ship" means, and carry adoption until the agent is part of how the team works.

Requirements documents do not make agents work.

This role exists because someone has to hold the business outcome while the engineer holds the build.

It is the counterpart to our forward deployed engineer, and neither side of the coin works alone.

Key responsibilities

• Opportunity and value
• Spend real time inside the business team's operation, sitting with the people doing the work rather than reading a process map of it.
• Map volumes, handling times, error rates, rework and exception paths using the operation's own data, not estimates offered in a meeting.
• Keep an opportunity list that is sized, ranked and visible, with the reasoning behind the ranking written down.
• Write the value case: what the process costs today, what the target state looks like, the benefit, the effort ask, and what happens if we do nothing.
• Present it to the budget holder and to technology leadership, and answer the hard question about the assumption sitting under the number.
• Kill your own ideas when the data says they will not pay back, and say so early.
• Process decomposition and design
• Break the process into its tasks and decisions, one at a time, to the level an engineer can build from without a translation step.
• Decide task by task what the agent does outright, what it drafts for a person to approve, and what stays entirely with a person.
• Design the exception paths, because that is where most agents fail in their first month live.
• Walk the decomposition with the operations lead until they agree it reflects how the work actually runs.
• Author and maintain the agent-ready backlog, own the order of build, and run refinement with the engineer every sprint.
• Write items that carry the task, the inputs and their source, the systems and tools touched, the decision made or deferred, what a correct output looks like, and how we will measure it.
• Reject items that are not ready, including your own, and never be the reason the engineer is idle.
• Track the dependencies the business team owns, and chase them until they close.
• Acceptance, evaluation and quality
• Set measurable acceptance criteria before the build starts, in numbers the business lead has agreed.
• Build the golden set of real cases the engineer evaluates against, including the awkward exceptions, and keep adding to it as live running surfaces more.
• Write the judge rubric used for automated scoring, then check it against your own human review so the scores mean something before anyone reports them.
• Set the groundedness and citation expectations for anything answered from retrieved documents, because a confident wrong answer with no source is the failure mode the business will remember.
• Review live agent output on a regular cadence, sample by sample, and log what you find.
• Sign off releases against the criteria, or decline to, and hold that line when a system misses.
• Governance, data and human oversight
• Define what data the agent may see, under what control, and record the decision.
• Name who stays accountable for each decision the agent makes or defers.
• Design where a person must remain in the path, and remove the checks that are theatre.
• Name the review path for anything touching business data or a governance gate, and start it early rather than at go-live.
• Adoption and benefit
• Train the team, sit with them through the awkward first fortnight, and take the complaints seriously.
• Change the design when reality disagrees with it.
• Measure the benefit landed against the case that funded it, and report both the hit and the miss.
• Requirement
• Delivered agentic outcomes
• Has owned the business side of agentic systems that went live and stayed live. Can name the process before and after, and what changed.
• Business value in numbers
• States current cost and future worth with evidence a finance reviewer accepts, not adjectives. Has defended a case to a budget holder.

Process decomposition- The core craft of the role. Turns human work into agent-executable tasks, written so an engineer builds from it directly.

Agent

-ready backlog authoring- Has written agent-ready items carrying inputs, tools, decision rights, correct output and measure. Not only user stories.

• Evaluation and acceptance design
• Required.

Strong exposure to how agentic systems are evaluated and instrumented in production: golden sets, judge rubrics, groundedness and citation standards, and reading a quality report without being fooled by it.

• Agentic fluency
• Knows what retrieval, tool calling and human-in-the-loop design actually make possible, so the backlog is buildable and the value case is not built on a demo.
• Data literacy
• Reads and interrogates operational data well enough to size an opportunity and to spot when an agent is being fed the wrong thing.
• Stakeholder credibility
• Holds a room containing an operations lead, a finance reviewer and an engineer, and keeps all three moving in the same direction.