Your AI Strategy Is Missing a Runtime
Here is a scene playing out in a large enterprise somewhere right now.
An email gets forwarded up and down a leadership chain. Someone in the organization built an AI "skill" — a packaged set of instructions that walks a user through understanding a complex case well enough to make genuinely good recommendations. The forward comes with a note: wow, what a cool idea.
The people replying to that thread know something the sender may not: skills like that are trivially easy to build. The authoring cost is an afternoon. Sometimes an hour. Adaptive surveys that write results back to shared storage, code validators, comparison engines, data-gathering workflows, site publishers, a single motivated practitioner can produce dozens of these.
But there's a harder question hiding under the enthusiasm, and it's the one almost nobody on the thread asks: where would that skill live? Is there a shared tool every colleague is guaranteed to run? A distribution channel? Any assurance that a capability built by one employee can execute on the next desk over?
In most enterprises the honest answer is no. And that answer, not model quality, not licensing spend, not enthusiasm, is the real ceiling on AI adoption.
That's the article. Not the skill. The runtime.
Two archetypes, two substrates
Consider two organizational archetypes. Both exist today; neither is hypothetical. Treat them as composites.
Organization A is small, lightly regulated, and staffed largely by contractors on their own equipment. Governance is close to nonexistent: people install anything, try anything, wire anything together. Critically, AI use isn't just encouraged, it's required. Walk the (virtual) halls and you'll find every major tool in production use: multiple frontier chat products, coding agents, voice and video tools, open-weight models, gateways, terminal agents, orchestration frameworks. No two desks look alike.
Organization B is large, regulated, and serious about AI, genuinely leaning in, funding capability teams, running education programs. But everything is vetted, standardized, and centrally provisioned. Nothing installs without an exception process. The sanctioned AI surface is, for most employees, a single enterprise productivity copilot.
Here's the counterintuitive part. Organization A, with zero standardization, has near-perfect capability portability. Organization B, with total standardization, has almost none.
Why? At Organization A, the mandate that everyone use AI means every single person has some agentic tool on their machine. A skill is, at its core, a structured file, markdown, instructions, maybe a script. When everyone runs something that can consume that file, distribution is an attachment. Ship an adaptive survey skill to the whole company and it executes, because the substrate, heterogeneous as it is, has converged on a shared floor of capability.
At Organization B, the sanctioned tool is a closed runtime. It answers questions, drafts documents, summarizes meetings. What it doesn't do, at least not in the hands of an ordinary practitioner, is accept a capability that a colleague authored, packaged, and handed over. Capability creation is gated behind platform teams and admin consoles. The flywheel spins exactly as fast as the platform team can turn it.
The trap reading, and why it's wrong
The lazy conclusion is "governance kills AI, freedom enables it." Reject that. Organization A's model is non-replicable for most enterprises: contractor workforce, bring-your-own-device, minimal regulatory surface, and a risk posture no bank, insurer, or healthcare company could survive. Any large organization that tried to copy it would deserve the breach that followed.
Organization A doesn't work because it's ungoverned. It works because of one accidental property: a guaranteed baseline. Every employee is known to have an agentic runtime. That's it. That single guarantee is doing all the work, and it's fully separable from the anarchy surrounding it.
Skills are the new spreadsheets
Excel didn't win because it was the best modeling tool. It won because everyone had it. A spreadsheet built by one analyst ran unmodified on ten thousand desks, and that portability, not the formula engine, is what made it the enterprise's shadow application platform for thirty years.
AI skills follow the same law. The value of a packaged capability is a network effect:
value(skill) ∝ number of people who can execute it
A brilliant skill that runs on one laptop is a demo. The same skill running across a 10,000-person org is infrastructure. Most enterprises are measuring AI maturity in seats licensed and models approved, inputs. The output metric that matters is portability.
The skill portability test
Here's the lens, and it fits in one sentence:
Can an ordinary employee package an AI capability, and can a colleague run it in under a minute — without a ticket, an exception, or a platform team?
If the answer is no, the organization has an AI adoption ceiling that no amount of licensing spend will raise. It has deployed AI access without deploying an execution substrate, and every clever thing its people build will die on the machine where it was born.
Run the test honestly. "We have a copilot" usually fails it. "We have an approved-tools list" almost always fails it, shareability degrades to the intersection of capabilities across tools, which in practice is the empty set.
The maturity ladder
Most AI adoption frameworks stop too early. The ladder actually has four rungs:
Access — employees can reach an AI tool.
Usage — employees use it regularly for real work.
Authoring — employees can build reusable capabilities: skills, agents, workflows.
Distribution — capabilities move between people and execute reliably.
Most enterprises believe they're at rung four because they're at rung two. The gap between "everyone uses AI" and "everyone can run what anyone builds" is where compounding returns live, and where they're currently being forfeited.
So how do you actually do it?
Three honest options, and a recommendation.
Option 1: Standardize on a single agentic runtime. Pick one vendor's agentic platform, one with a real capability-packaging model, and deploy it universally. Fastest path to a working substrate, best frontier-tracking, and yes, real lock-in risk that you mostly just accept. Lock-in to a substrate that compounds beats independence on a substrate that doesn't exist.
Option 2: A sanctioned menu of tools. Politically the easiest, everyone gets their preference. Structurally the worst. Portability collapses to whatever every tool on the menu can execute, and no packaging format survives that intersection. This is the option that feels safe and guarantees rung two forever.
Option 3: Build a custom internal platform. Maximum control, genuine appeal for extreme scale or extreme regulatory constraint. Also a permanent commitment to running 12–18 months behind the frontier while competing with the labs on developer experience. Most organizations that choose this are choosing it for reasons that stopped being true a year ago.
The recommendation: Option 1, governed hard at the substrate and open at the top. Lock down identity, data loss prevention, audit, and model access with all the rigor a regulated enterprise demands, that's the layer where governance belongs. Then leave capability authoring open to every practitioner. Govern the runtime, not the creativity running on it. The organizations that get this right will look, from the inside, surprisingly like Organization A, not in its chaos, but in its one load-bearing guarantee.
The takeaway
It's easy to take portability for granted inside an organization that has it, capabilities move so freely that the substrate becomes invisible, like asking a fish about water. And it's easy to miss its absence inside an organization that doesn't, because every input metric (seats, spend, enthusiasm, executive sponsorship) can look excellent while the output metric sits at zero.
So before the next AI investment decision, ask the one-sentence question: if your best employee builds something brilliant tomorrow, can the person at the next desk run it?
If not, there's no AI strategy yet. There are licenses.
David Proctor leads enterprise AI capability programs. He writes about AI infrastructure, agent protocols, and what actually works in production.