You've tried AI and hit a wall. The wall isn't more AI — it's the layer above it: the agentic operating system you don't have yet.
It was supposed to give me my time back. Instead I was working harder than ever. When I first started using AI in earnest, it astonished me in a way no software ever had. I could have a legal document reviewed, run a competitor analysis, draft something I'd been putting off for months — in minutes, for almost nothing. Hundreds of dollars of work, sometimes thousands, cleared off a backlog I'd always assumed was infinite.
Then it went further. It wasn't only doing the tasks I already had; it was doing tasks I'd never have attempted — the ones that needed know-how I didn't have. Whole projects I'd have had to hire out, or simply go without, were suddenly within reach.
The productivity was real. So was the catch: there are only so many projects one person can run in parallel.
AI produces so much, so fast, that keeping up becomes the work. I had more in flight than ever, and every one of them wanted me back — a question here, a follow-up there, an edge case, an exception. The context-switching never stopped. The tool that was supposed to take work off my plate had quietly made me its operator.
And somewhere in that nagging — the constant pull back to the screen — I realised something was missing.
I went all in. I learned to get more out of these tools than almost anyone I knew — automating what could be automated, scheduling what could be scheduled, building specialised agents for the jobs that needed them. My experience in product management was perfect training. I was good at this.
And it didn't matter. The agents still needed me for every next step. They didn't share what they knew. They didn't hand work to each other. Nothing decided what went where, and nothing checked whether the result was any good. So I did all of it. I became the memory the agents didn't have, the router moving work between them, the rulebook for what they were allowed to touch, the one set of eyes on every output. As I scaled my productivity, I became the bottleneck. Agents work 24/7. I did not.
My first instinct was that I'd grow out of it — that I'd get sharper with the tools, or the models would soon be "good enough" to carry the load themselves. But the models were already smart. Smart enough, by now, and getting smarter changed nothing. The thing in my way wasn't intelligence. It was that nothing tied the intelligence together.
So I stopped looking at my own desk and looked at everyone else's. The most capable people I knew were stuck in the same place — more hours spent feeding the AI and checking its work than doing the work itself, each of them alone in it. Now picture that across a firm of forty. Forty people, each running their own private AI setup. None of it shared. None of it governed. No one able to see across it. The firm's knowledge fragmenting into forty silos, and the silos walled off from each other. Every person privately doing by hand what a system should be doing for all of them.
What they were missing was orchestration. What they needed was an operating system.
What is an agentic operating system?
You use applications all day and never once think about the operating system underneath them. You don't feel Windows or macOS — and that's the point. It sits below everything, invisible, making your programs share files, enforcing what each one is allowed to do, keeping them from trampling each other. That silent layer is exactly what the agents never had.
Take it away, and someone has to do its job by hand. In my case, me. In a firm, whoever is most capable. Without shared memory, you become the memory — re-aligning the agents yourself. Without routing, the decision of which agent handles which task stays locked in your head, and half the firm quietly builds the same agent twice. Without governance, the rules for what each agent can touch live in your notes, if they're written down at all. Without a way to check the work, every output waits on your eyes — and there are only so many hours in the day.
None of this is plumbing. Routing is a decision about what goes where. Governance is a rule about what's permitted. An operating system doesn't just connect the agents — it decides, and it enforces. And in a regulated firm, what an agent is allowed to touch is not an administrative detail. It's the line between a decision you can defend and one you can't.
That layer, built for agents, is an agentic operating system. It makes a pile of separate agents into one machine you can actually run. Put plainly: an agentic operating system is the layer above a firm's AI agents — the shared memory, routing, governance, and outcome-tracking that turn a collection of agents into a system the firm can run, trust, and defend.
What does an agentic operating system give a firm?
With an agentic operating system, the most capable people stop being the bottleneck. No longer consumed by managing the agents, they get back to the work where they add the most value — judgement.
The firm's knowledge stops fragmenting and starts compounding. It lives in one foundation, and what one agent learns, the whole firm keeps.
Work routes itself under one set of rules. And for the first time, someone can see across the whole firm, instead of into one person's private setup.
Then there's the part siloed agents can never give you, no matter how capable they get. An operating system provides a governance layer. Client data stays where it should, instead of scattered across whatever tool each person happened to paste it into. Every consequential decision is recorded and defensible — to a regulator applying rules like the EU AI Act, a client, or a court. And the depth of the security matches what the firm is actually liable for: a firm holding privileged client data gets more than one that isn't.
For a regulated firm, this is not a question of efficiency. A pile of agents isn't just slower than a system — it's indefensible. And you cannot add defensibility afterwards. You can't retrofit it onto forty private setups once the work is already scattered across them. It's a property of the system, built in from the start, or it isn't there at all.
Which AI platform should you build on?
Where do you get an agentic operating system? What's the best one to buy? These are the wrong questions — and they're a familiar mistake in new clothes. Earlier I thought a smarter model would fix the bottleneck. Now the instinct is that the right platform will. Both look for the answer in the tool, when the answer is in the layer above it.
Anthropic, OpenAI, Google, an open-source stack running locally — the vendor platforms have converged. For the purpose of building your OS they're interchangeable, and the models underneath them are commodity too. Pick one, and swap it later if you need to. The operating system fits above whichever you choose.
That matters, because the substrate never stops moving. New model releases, new platform features, a change of vendor entirely — it churns underneath you constantly. None of it changes the work above it: deciding what your OS should do for your firm. That work outlasts whatever the vendors ship next.
So setting up your OS is not a build-or-buy decision. Setting up your OS is the work of figuring out what it should actually do for your firm — and that is an entirely different undertaking.
How do you design an agentic operating system?
Being an early adopter means diving in and trying things — which is exactly why everyone rushed to build an agent. But analysis comes before design. No agent should be defined until the work it might do is understood. The discipline is the restraint: resisting the urge to build.
The first step is to write down what the firm actually does, and decompose each activity into its constituent tasks. This sounds clerical. It isn't. Most firms have never described their own work at this grain — the real sequence of what happens, who touches it, what each step depends on. Getting it down honestly is harder, and more revealing, than anyone expects.
With the tasks laid out, the next step is to identify where human judgement is the value — and to classify everything else as a candidate for delegation. This is the step firms get wrong. The line between the two is rarely obvious, and putting a task on the wrong side is expensive: delegate something that needed judgement and you get a confident, polished mistake. For the tasks that can be delegated, an escalation threshold is set — which decisions an agent handles on its own, and which it must bring back to a principal.
Then, and only then, can the agents be defined. The instinct is to mirror the human org chart — one agent per role, the same boxes the firm already has. But the constraints that produced those roles — one person, limited hours, a single specialism — don't apply to an agent. Copy the org chart and you inherit limits that no longer exist. Designing the agents around the delegatable work, rather than around the people who used to do it, is its own design problem — not a remapping of the old one.
None of this is mechanical. Every step is a judgement call, made before a single agent is built. And it is this work — not the building — that decides whether a firm ends up with an operating system, or just a pile of agents.
Should you build it yourself?
Any firm could, in principle, do its own accounts. The tools exist. Most don't — not because they can't, but because it isn't where their attention should go. So they hire someone whose job it is, and get on with their business.
An agentic OS is the same. You could map the work, classify the judgement, design the agents — but it's a distinct discipline, and the cost of getting it wrong is an indefensible system and costly mistakes that look perfectly sound.
And like a good accountant — the trusted advisor who knows your business — the right partner works with you, not on you: the people who know the firm, alongside those who know how to turn it into a system. It's built with your team and co-owned by them. And it doesn't end at the build. They stay — as your firm grows, your tools change, and the models underneath keep moving.
That's what Aikin does.
So the only question left is the honest one: do you have agents, or do you have a system? If the answer is agents, that's where we start.
About Aikin. Aikin builds Agentic OS — agentic operating systems for sophisticated professional-services firms (5–200 people) that have tried AI and hit the wall. Aikin's Agentic OS respects how regulated professional firms actually have to work: client data stays where it should, every consequential decision is defensible, and security and compliance are primary inputs to the architecture, not bolt-ons. Delivery is done-with-you — forward-deployed engineers embed in the client's team and build alongside it, so the client co-owns the result from week one. Aikin is a member of the DFINITY Alliance and a four-time DFINITY Foundation grant recipient, with Cyso (Netherlands) as its sovereign-cloud partner and Okapion (Netherlands) as a design partner.