Watch the flow, not the flood.
Last week a company that most crypto-native readers have never heard of published a product announcement that will matter more to the next three years of on-chain infrastructure than any L2 roadmap. Make, the workflow automation platform acquired by process-mining giant Celonis, unveiled MakeOS, an "agent governance and orchestration layer" for enterprise AI. The announcement came bundled with a customer testimonial from Stellantis & You, a Gartner citation relayed through Make's own marketing site, and zero independently verified third-party data. Every claim in the launch package traces back to the vendor.
I have spent eighteen years watching institutions discover that their capital flows are not what their dashboards say they are. In 2017 I tracked 140 hours of Ethereum gas fees and whale wallet movement to write a report titled The Illusion of Decentralized Capital, which concluded that 60% of ICO-era "decentralized" capital was recycling through wash-trading clusters. My bosses called it niche noise. The market called it a correction eighteen months later. The pattern I am looking at now is structurally identical, just relocated from token issuance to enterprise agent deployment.
Here is what nobody in the crypto press is saying: MakeOS is not an agent product. It is a governance tax collection mechanism, and the tax is being levied before anyone has proven the underlying asset produces yield.
The Liquidity Map Nobody Drew
To understand why this matters, you have to understand what Celonis actually owns. Process mining is the discipline of reconstructing how work actually happens inside an organization by analyzing the event logs that enterprise systems emit — SAP transactions, CRM record changes, ticket state transitions. Celonis built a multi-billion-dollar business on the observation that every company's documented process and every company's real process are two different things, and the gap is where the money leaks. Gartner has ranked it a leader in the category for years. That part is verifiable.
Make, acquired by Celonis in 2024, owns the other half of the equation: workflow orchestration. Make's visual builder lets non-developers wire together hundreds of SaaS applications into automated pipelines. Where Celonis discovers that a process is broken, Make can rebuild it. The two together describe a complete loop — see the flow, then fix the flow.
MakeOS is the third piece: a layer that sits on top of both and attempts to govern agents — autonomous or semi-autonomous AI systems that execute multi-step tasks across enterprise systems. The pitch is that agents, unlike deterministic workflows, make decisions you cannot fully predict, and therefore require a governance wrapper: discovery, construction, control, and observation. Four pillars, presented as a unified architecture, packaged under a phrase Make's CEO keeps repeating — the "glass box" agent.
Liquidity is a liar. And so is product architecture language. When you strip the four pillars down to their disclosed release status, the picture changes completely.
What Actually Shipped
The launch material is unusually candid if you read it closely, which is rare. Of the four pillars, exactly one has shipped in any meaningful form: a topology visualization called Make Grid that renders a graph of agents and their connections to automated workflows, plus a searchable execution audit log. Everything else — agent evaluations, AI spend tracking, OpenTelemetry support, Functions, Endpoints, MCP toolboxes — is marked "coming soon." There is no pricing. There is no general availability. There is a closed beta and a waitlist.
Let me be precise about what this means in engineering terms. By any reasonable technology maturity scale, MakeOS is at proof-of-concept. It has no SLA, no published price, and no production reference deployments beyond a vendor-supplied testimonial. The comparison the market is implicitly making — against Microsoft's Agent 365, against Salesforce Agentforce, against Datadog's AI Agent Monitoring — is a comparison between a shipped, priced, generally available product and an architectural diagram.
I have audited systems like this before. In 2020, during the DeFi Summer, I coded a Python simulation across 15,000 Uniswap v2 transaction sets to test whether yield farming returns were structurally sustainable. The conclusion, which I published as an internal memo that leaked to CryptoSlate and generated 200 hostile replies, was a single sentence: yield is just risk delay. The protocol interfaces looked identical. The economics underneath were not. The same discipline applies here. The interface MakeOS presents — a governance layer, a glass box, a closed loop — is not the same thing as a governance layer that functions.
The Only Real Technical Fork
Here is where the analysis gets interesting, and where I diverge from every commentary I have read on this launch.
Make made one genuinely consequential architectural decision, and it is buried in a single paragraph of the announcement. When an agent governed by MakeOS executes an action, it does not authenticate as itself. It authenticates as a proxy for its human owner, and the platform validates permissions against that owner's role and relationships. This is the opposite of what Microsoft, Okta, and Salesforce have chosen. Those vendors assign agents independent identities — a separate security principal with its own credentials, its own permissions, and its own revocation path.
The proxy model has real advantages. It reuses the enterprise's existing RBAC and ABAC infrastructure, which means deployment friction is low and no identity system needs to be rebuilt. For a mid-market customer with an existing Make subscription, this is a genuine selling point. You do not have to stand up a new identity plane to govern your agents.
But the proxy model violates the principle of least privilege as a design axiom. An agent executing as a proxy for a user inherits that user's entire permission set. If the agent is compromised through prompt injection, or simply misselects a tool, the blast radius is not scoped to what the agent needed to do. It is scoped to everything the owner can do. And when an agent is created by one employee, invoked by a second, and serves a third — a pattern that is already common in enterprise agent deployments — the question of whose permissions apply becomes genuinely ambiguous. The delegation chain is not obviously traceable in the proxy model.
The independent-identity camp solves this by giving each agent an explicitly enumerated permission subset and an independent kill switch. It is heavier to deploy. It is also the only model that survives a serious security review.
Make has framed this as a philosophical difference. It is not. It is a tradeoff between deployment friction and containment radius, and Make has chosen friction reduction. That is a defensible product decision for a mid-market launch. It is not a defensible security posture for an enterprise governance platform, and the announcement does not acknowledge the distinction.
The Hidden Constraint Nobody Is Naming
There is a second structural issue, and this one is more damaging to the product thesis than anything the competitors will say.
Process mining works because enterprise systems emit structured event logs. Every SAP transaction, every CRM update, every ticket transition is a discrete, timestamped, machine-readable record. Celonis's entire business rests on the availability of those logs.
Agents do not emit event logs. An agent's planning path, its tool-selection reasoning, its retry logic on failure, and the prompt context that produced any of it are not naturally instrumented. They exist inside a model's inference process and, unless someone explicitly captures them, they evaporate. MakeOS's discovery pillar can therefore observe which system events an agent triggered. It cannot observe why the agent made the decision that triggered them.
The gap between those two things is exactly the gap enterprise accountability requires. When something goes wrong — a payment executed, a record modified, an email dispatched — the question auditors ask is not "which events fired." It is "what was the decision path." MakeOS, in its current disclosed state, answers the first question and punts on the second. The OpenTelemetry support that would begin to close this gap is listed as unreleased.
I have seen this exact configuration before, in a different domain. In 2022, while running macro strategy at a Denver blockchain infrastructure firm during the liquidity crunch, I built a real-time dashboard tracking Tether and USDC reserve liquidity against on-chain derivatives exposure. The dashboard showed every reserve flow in near real time. It did not show why the flows were happening, and that distinction cost the industry two years of misattributed causality. Observability and explainability are not the same product, and vendors routinely sell the first while implying the second.
Make's "glass box" framing is a terminological borrowing from explainable-AI research, where glass-box models are those whose internal mechanisms are interpretable by construction. Make has repurposed the phrase to mean "agent behavior is auditable." Those are not equivalent. The first requires model-level interpretability, which is an unsolved research problem. The second requires log completeness and permission tracing, which is a solved engineering problem with a much lower bar. Using the language of the first to describe the second is a marketing decision, not a technical achievement.
The Rollback Problem
The CEO claims every action is reversible. I want to be direct about this, because it is the single most overstated claim in the launch.
In systems with cross-boundary side effects — emails sent, orders submitted, CRM records modified, payments triggered — true rollback is not technically achievable. What is achievable is a compensating transaction: a new action that attempts to undo the effect of a prior one. Compensating transactions can fail. They can produce their own side effects. They cannot un-send an email or un-submit a payment to a third-party processor that has already settled. Every distributed systems engineer knows this. It is the foundational constraint of the entire field.
Making the claim anyway is not unusual for a launch event. It is worth flagging because enterprise buyers will read "rollback" and hear "safety guarantee," and the engineering reality behind that word is considerably narrower. Regulation chases shadows — and so does enterprise procurement, when the shadow is cast by a vendor's own marketing language.
What This Signals About the Category
Strip away the specific product and something more interesting emerges, because MakeOS is not really an isolated announcement. It is a category signal.
Three previously distinct software categories are converging. Process intelligence, which lived in the back office as post-hoc diagnostic tooling, is moving toward real-time constraint enforcement. Observability, which lived in the developer toolchain, is moving toward the enterprise control plane. Workflow orchestration, which lived in the business-user automation stack, is moving toward the governance layer. The combined product is a closed loop: see the process, define the process, constrain the executor — human or agent — and verify the outcome.
Nobody owns that loop completely today. UiPath owns a fragment through RPA. SAP Signavio and IBM own fragments through process mining. Datadog, LangSmith, and a dozen observability vendors own the agent-monitoring fragment with considerably more technical depth than MakeOS currently demonstrates. Microsoft owns the identity fragment, which is arguably the most strategically valuable, because identity is where governance naturally attaches.
Make is the only vendor attempting all four layers simultaneously. It is also, by the disclosed feature matrix, the weakest in three of the four. That is not a fatal position — combination plays have won before — but it is not the position the launch narrative describes.
And the actual threat is not a competitor shipping a better product. It is a competitor shipping an adequate product for free. Microsoft has repeatedly demonstrated that it can absorb a standalone software category into its platform contracts and collapse the category's pricing power. Intune did it to MDM. Defender did it to endpoint security. Purview is doing it to data governance. If Microsoft bundles baseline agent governance into existing M365 and Azure enterprise agreements, the standalone governance market shrinks to whatever remains above the bundle line — which is a much smaller business than the launch narrative implies.
I suspect this is why MakeOS has not published a price. Not because the pricing model is undecided, though it may be. Because publishing a price anchors you in a comparison you may not win.
The Flow Beneath the Flood
There is a version of this story where MakeOS is a strategically rational move by Celonis, and I think that version is more likely than the cynical one. Celonis has been a perennial IPO candidate, and process mining as a standalone category has a growth ceiling that the market has already priced in. Repositioning from "process analytics tool" to "governance infrastructure for the agent era" is precisely the narrative expansion required to justify a higher multiple. MakeOS may generate modest revenue in its first two years and still deliver enormous value to its parent — not as a product line, but as a capital markets story.
That reading also explains the timing. Enterprise agent deployment in 2026 is overwhelmingly in pilot phase. The willingness to pay for governance is a second-order expense: it depends on the first-order expense — agent deployment itself — having produced quantifiable ROI. Most enterprises do not yet have that evidence. So MakeOS faces a demand-side constraint that has nothing to do with product quality. The question is not whether the governance layer is good. The question is whether anyone has a reason to buy it this year.
Code is law until it isn't. And governance software, like smart contracts, only accrues value when there is something of value flowing through it that people are afraid of losing.
So watch the flow, not the flood. The flood is the announcement — testimonials, Gartner citations, architectural diagrams, a waitlist. The flow is the harder question underneath: how many enterprise agents are actually executing consequential actions in production today, whose permissions are they inheriting, and who bears the loss when one of them does something irreversible?
Make has built a toll booth on a road that is still under construction. The interesting question is not whether the toll booth is well designed. It is whether the road gets built at all, and by whom.
I would not bet against agents. I would bet against anyone's ability to govern them before they exist at scale.
