By Paul Scott, Chief Operating Officer, ClearPoint
Here's a claim I'd put to any board: the unit of enterprise value is quietly shifting — from people performing tasks, to processes that have been codified well enough for a governed agent to run them reliably. The task layer is being commoditised in front of us. The process layer is where durable value is moving. And most organisations, in their rush to "adopt AI," are pouring effort into the wrong one.
I didn't arrive at that view from a strategy deck. I arrived at it by spending two years rebuilding how my own company actually runs.
The market data is blunt. Despite enormous investment, only around a quarter of enterprises have deployed anything that qualifies as a genuine agent, and barely one in ten have real agentic capability. The overwhelming majority are still running assistants — a person chatting with a chatbot, copying and pasting, getting a faster first draft. It feels like progress, and it isn't nothing, but it has a hard ceiling: every copy-paste is data moved by hand, and the assistant never actually knows your business. It knows what someone remembered to paste in that morning.
Worse, the category is now thick with "agent-washing" — most leaders I talk to have been sold something branded as an agent that turns out to be a chatbot in a nicer wrapper. So let me be precise about the distinction that actually matters, because the whole argument hangs on it.
A personal agent works alongside one individual, on their machine, helping them with their own tasks. Useful, and increasingly everywhere. A managed agent is something else entirely: a workflow run centrally for the organisation — standardised, governed, working autonomously across many people, and ideally triggered by events in your systems rather than by someone remembering to press go. The first makes a person faster. The second makes the organisation more capable. Confusing the two is how companies spend a fortune and end up with a thousand faster individuals and no institutional gain.
We've been through the whole ladder, and I'll compress two years into a paragraph because the tools matter far less than the lesson. We started, like everyone, with the assistant-on-the-side. We then built our first real managed agents on the integration tooling available at the time — agents that take a signed client contract and set up everything downstream in our job-management and timesheeting systems, or run new-staff onboarding end to end. Most are still running today. In parallel, when the tooling finally let non-technical people build connected workflows easily, personal agents spread through our finance, talent, sales and marketing teams faster than any AI tool we'd ever tried.
That combination worked — and then it surfaced exactly the problem worth writing about. We had brilliant individual workflows, all slightly different, living on individual laptops. Genuine capability, almost none of it institutionalised. And the question that should keep any COO up at night: if that person leaves, does the process — and its value — walk out the door with them?
That question reframed the whole thing for me. The valuable thing was never the clever person at the keyboard, and it certainly wasn't the tool. It was the process — and a process only becomes an asset when it's written down precisely enough to be run by anyone, or anything, the same way every time.
This is where the recent emergence of an open standard for AI skills changes the economics. A skill packages a business process — the knowledge, the steps, the data connections — into a portable, repeatable unit. (It began as an open standard from Anthropic and is now supported across many AI tools; there's a good overview at agentskills.io.) We already run a simple one that holds our brand — voice, colours, type — so anything anyone produces comes out consistent. The prize is to do that for the core processes of every function: turn our hard-won operational know-how into a library of skills an agent can execute.
Treat that seriously and it stops being an IT project and becomes a balance-sheet one. A codified, runnable process is an asset in a way that tribal knowledge in someone's head never is — it's defensible, transferable, and it compounds. For any leader thinking about the long-term value of their business, "how much of our operating capability is captured as IP versus trapped in individuals?" is fast becoming one of the more important questions you can ask. Most companies can't answer it. The ones that can will be worth more.
There's a hard-won discipline attached to this. Because skills are an open standard and connect through open protocols (MCP), our processes are deliberately separated from the models and platforms they happen to run on. The logic is ours, in portable form, not trapped inside any one vendor's product.
That isn't theoretical. Recently we watched one provider's most capable models go from public release to being pulled from the market within days, under a government order — an external event no procurement plan could have anticipated. Any organisation that had hard-wired its operations to a single model was suddenly exposed. We weren't, and wouldn't be: capture the process as an open skill, and you can move it to another provider's models, or open-source ones, and carry on. In a market moving this fast, treating "portable across models and providers" as a design principle isn't caution — it's how you keep optionality while everyone else is quietly accumulating dependencies.
So here's the model I think most enterprises will land on, and the one we're building toward. Call it the 80/20: roughly 80% of your standard, repeatable processes should run as managed agents on governed, standardised skills — reliable, secure, consistent, server-side, running whether or not anyone's laptop is on. The remaining 20% — the ad hoc, the novel, the first-time-we've-done-this — stays with personal agents. The healthy rhythm is a pipeline: you explore and perfect something personally, and once it's proven, you promote it into the managed estate.
The part that turns this from a productivity story into a governance story is identity. A managed agent should have its own identity — not borrow a human's logins — with least-privilege permissions and full auditability of what it did. This matters more than it sounds: security and reliability are consistently cited as the top blockers to enterprise agentic AI, and the firms that put governance in early ship far more into production than those that bolt it on later. Giving every agent a scoped identity is, in effect, the next frontier of identity and access management — except the identities aren't people. We get to start there rather than retrofit it.
A pragmatic note, because dogma is expensive: the managed estate doesn't have to be one platform. Some processes are better served by a purpose-built agent native to a system you already run — a prospecting agent that lives inside your CRM, for instance, where the data already sits. Portability where it matters; best-of-breed where a specialised tool clearly wins.
Microsoft calls the end-state a "frontier firm" — an organisation built around human-and-agent teams. It's a useful label, and worth being honest that it's now a widely shared aspiration rather than a novel one. The interesting question isn't whether you want to be one; it's what actually changes when you get there. Three things, from where I sit:
First, the org chart gains non-human members with real permissions, and managing that population — their identities, their access, their behaviour — becomes a genuine leadership discipline, not an IT afterthought.
Second, enterprise value gets re-priced around captured process. The companies that have turned operating capability into a governed, runnable asset library will tell a materially stronger value story than those whose capability still walks out the door each evening.
Third, how work gets bought starts to change. We're already seeing agents priced per outcome rather than per seat — pay-per-qualified-lead, not per licence. That's a small signal of a large shift, and it has obvious implications for any professional-services or operations leader thinking about commercial models.
None of this is flashy, and that's rather the point. The genuinely valuable move in enterprise AI right now isn't adopting another tool — most organisations have plenty. It's the unglamorous discipline of capturing what you do best as portable, governed, ownable process, and running it with agents you can actually trust. That's the difference between a company that uses AI and one that is genuinely built on it. We're not all the way there. But I'm increasingly convinced it's the work that matters most.
If you're working through the same shift, I'd be glad to compare notes — paul.scott@clearpoint.co.nz.