Who Owns the Last Mile of an AI Agent? From Vendor-Led to Client-Owned in Three Phases
Every agent deployment has a last mile: the point where the agent stops being a project and becomes part of how a team works. Someone has to own it. If it is the vendor forever, the client has bought a service with a software bill attached. If it is the client from day one, the pilot usually never ships.
We run it in three phases, with the ownership share moving deliberately from us to the client. The percentages below describe who is doing the building, not who is in charge; the client owns the outcome throughout.
Phase 1: Phinite-led. Get the right process into production, fast.
Roughly three quarters of the work is ours. We start with one process the owner already measures, agree the bridge metric and the baseline, and ship the agent to production so value is real before anyone talks about scale.
The deliverables are concrete: discovery and scoping, the metric and baseline written down and accepted, and a production pilot running against the live baseline with success criteria fixed up front. The client's role is to grant access to systems, approve the actions the agent holds, and see the number move, run by run.
Phase 2: Shared. Scale across processes, with the client's team building.
The second and third processes are where the client's engineers and process owners build alongside us, and the share moves to about half. This is possible because the first process left behind more than an agent. It left policies, integrations, evaluation suites and a budget profile in the workspace library, all reusable. The next agent starts from what the last one proved.
Governance rolls out in this phase too: the same gate, the same approvers, the same audit trail, applied to every new flow by default rather than configured per project.
Phase 3: Client-owned. Their team owns it. We stay on call.
By the third phase the client's team does most of the building and we are on call. They have the versions, the evaluations and the audit trail that make it safe to change an agent without asking permission. Managed evaluations continue, and a quarterly value review checks the figures against the agreed baseline, with Finance validating.
The end state is a client that can build on the platform, not just run it.
Why the handover has to be designed in
Three things make this work, and none of them is goodwill.
- Everything is versioned from the first save. A client cannot own what they cannot see change. Versions of the agent, the prompt, the model, the evaluator, the metric definition and the baseline are the handover document.
- Governance is set once and applies to every agent. If each new agent needed its own approval design, the client's team would be rebuilding control instead of building value.
- The number is the client's number. Because the bridge metric is one the process owner already tracks, and Finance validates the value figure, the client never needs us to tell them whether it is working.
For partners, the same model with one difference
Systems integrators and managed-service partners run this model with their own engineers in our seat. The partner owns the client, the contract and the services margin; Phinite runs the platform; the client owns the outcome. The next client the partner brings starts from the agents, policies and evals the last one proved, which is how the economics of outcome-priced services start to work.
Whoever sits in the first seat, the destination is the same. The last mile belongs to the people who will be there after the project ends.