Enterprise software has run this arc before. Agentic AI is running it again — faster, and with higher stakes.
For thirty years, enterprise software repeated a single arc: bespoke builds gave way to platforms, platforms hardened into standards, and standards crystallised into packaged industry solutions that a foundry tailored to each customer. We argue that agentic AI is sprinting through the same arc — only compressed into a handful of years.
We have already moved from agent frameworks, to bespoke agents, to open standards such as MCPModel Context ProtocolAn open standard for connecting AI agents to tools, data, and services through a common interface — the agent world's equivalent of a universal driver layer.modelcontextprotocol.io ↗, Agent SkillsAgent SkillsPackaged, reusable units of know-how — instructions, scripts, and resources — that an agent can load on demand to perform a specialised task.anthropic.com/news/skills ↗, and PluginsPluginsBundled extensions (commands, agents, skills, hooks, connectors) that add a coherent capability set to a harness in one install.docs.claude.com ↗, to the agent harnessAgent HarnessThe runtime that wraps a model with everything it needs to act safely and usefully: context management, memory, tool access, planning, permissions, verification, and observability. Claude Code, Codex, and Cursor are harnesses. itself. Today we build domain-specific harnesses one vertical at a time. The next step is unmistakable.
We should build a packaged layer of industry harnesses and a foundry to customise them — the SAP moment for agent harnesses. This note traces the arc, names exactly where we stand, and sketches what we ought to build next.
Strip away the vocabulary and the last three decades of enterprise computing tell a single, repeatable story. It is worth retelling, because it is about to repeat.
Teams hand-built applications in standard Java, each project re-implementing the same plumbing — sessions, persistence, transactions, security.
Design patterns, modularity, and the sheer waste of rebuilding horizontals pointed to an obvious need: a common platform underneath the apps.
That need produced Enterprise JavaJ2EE / Jakarta EEA standardised set of specifications for building server-side enterprise applications — defining the common services every business app needs so vendors could compete on implementation, not interface.jakarta.ee ↗ — a shared contract for the horizontals every business application needs.
Vendors raced to ship compliant application servers — WebSphere, WebLogic, and their peers — competing on the same standard. Developers now built on top of a server, not from bare metal.
Builders noticed that players within an industry share process and entity models. Banks resemble banks; insurers resemble insurers. Industry model frameworks codified that commonality.
The endgame: packaged vertical solutions — the ERPERP — e.g. SAPEnterprise Resource Planning: pre-built, deeply configurable business software covering finance, supply chain, HR and more. You buy the package and a consulting foundry tailors it to your enterprise rather than coding it from scratch.en.wikipedia.org ↗ wave led by SAP and its kin. The work shifted from building bespoke apps to deploying and configuring a package for one enterprise's needs.
The value migrated upward — from code, to platform, to standard, to package & foundry.
The agentic stack is climbing the identical ladder. The rungs even rhyme — and we are most of the way up.
LangChain, CrewAI, watsonx Orchestrate, the OpenAI and Claude Agent SDKs — all centred on common LLM APIs, no-code/low-code/SDK builders, and shared observabilityObservabilityThe ability to see inside a running agent — its traces, tool calls, token costs, and decision steps — so you can debug, evaluate, and govern it.opentelemetry.io ↗ stacks.
Engineers assemble agents by declaring four things: an LLM, prompt instructions, tools, and an agentic pattern such as ReActReActReason + Act: the agent interleaves chain-of-thought reasoning with tool actions, observing results before deciding its next move.arxiv.org/abs/2210.03629 ↗ or Plan-ActPlan-and-ActThe agent drafts a full plan first, then executes (and re-plans) — trading some flexibility for foresight and reliability on multi-step tasks.arxiv.org/abs/2305.04091 ↗.
Shared patterns and shared pains call for an "AI-OS." At the same time, agents grow dramatically better at writing and running code, so CodeAct / PTCCodeAct / Programmatic Tool CallingInstead of emitting one tool call at a time, the agent writes executable code that orchestrates tools in a loop — composing, filtering, and chaining them as a program.arxiv.org/abs/2402.01030 ↗ joins ReAct and Plan-Act as a first-class pattern.
MCP, Agent Skills, and Plugins become the shared contracts — the J2EE-grade interfaces of the agentic era.
Claude Code, Codex, and Cursor emerge as harnesses: they speak the standards and provide the AI-OS horizontals — context, memory, tools, planning, permissions, verification, observability, human approval, and failure recovery.
Engineers ship vertical capability as domain plugins. Each plugin turns a general harness into a higher-order, domain-specific one. The work is real — and it is bespoke, repeated vertical by vertical, client by client.
The endgame we are arguing toward: packaged industry harnesses, plus a foundry that customises them for a specific customer's environment, data, and policy. The SAP of agent harnesses.
We are firmly in the "industry model frameworks" rung, doing genuinely impressive work — and doing it the hard way. When a college needs an agent for course materials, or a law firm needs one for matter intake, we assemble a domain harness by hand: we pick the tools, write the domain instructions, wire the memory, design the evaluations, and tune the guardrails. Then the next client in the same vertical arrives, and we discover we are rebuilding eighty percent of the same thing.
This is precisely the moment, in the enterprise story, where the waste of rebuilding horizontals became impossible to ignore — except now the "horizontals" are not sessions and transactions. They are domain ontologies, golden trajectories, evaluation suites, policy guardrails, and the slow-won procedural memory of how work is actually done in a vertical. Rebuilding those per client is the expensive part. It is also the part most amenable to packaging.
The bespoke era is not a failure. It is the data-gathering phase of the packaged era.
Picture the agentic platform as three stacked layers. The bottom is general; the middle is vertical; the top is where a customer becomes a deployment.
The implementation layer — the SAP-consultant equivalent. It takes a packaged domain harness and binds it to a specific customer: their data sources and identity, their policies and risk posture, their brand and house style, their environment. Crucially, the foundry is where the harness learns this customer — accruing procedural memory and client-specific evaluations rather than discarding them at the end of an engagement.
Pre-built harnesses for a vertical — course-material generation, legal operations, claims adjudication, clinical documentation, financial analytics. Each ships not as raw code but as a coherent package: the tools that vertical needs, the ontology it reasons over, the skills and plans for its common tasks, the guardrails its regulators expect, and a benchmark suite that knows what "good" looks like in that domain.
The standard, vertical-agnostic runtime — what Claude Code and its peers already provide. It is the WebSphere of this story: stable, governed, and the same underneath every vertical built on top.
The shape of the business changes with the layers. Layer 1 is a platform play. Layer 2 is a product catalogue — you build a vertical once and sell it many times. Layer 3 is a foundry: repeatable, tooled customisation that turns a package into a running system for a named customer. SAP did not get large by writing software for one company. It got large by packaging a vertical and industrialising the customisation.
If Layer 2 is the leverage, then "what goes in a package" is the question that decides whether this vision is real. A domain harness package is the codified answer to "how is this kind of work done well?" — expressed in artefacts a harness can load.
Connectors and tool definitions the domain depends on — the LMS for a college, the matter system for a firm — exposed over MCP so they swap cleanly per client.
The entity and process model — the agentic descendant of the industry model framework. It gives the agent a shared, structured world to reason over instead of free text.
Reusable skills and planning templates for the vertical's recurring tasks, so the harness does not rediscover the workflow on every run.
Reference runs of real tasks, end to end, that define correct behaviour — the package's regression memory and the seed for evaluation.
Graded question sets — simple, complex, and deliberately ambiguous — plus complexity-hotspot detection, so quality is measured, not asserted, before anything ships.
Policy, compliance, and safety constraints baked in — the determinism a regulated domain demands, expressed as enforceable controls rather than hopeful prompts.
The foundry is the part we under-appreciate, because in the enterprise world it was "just consulting." In the agentic world it can be far more leveraged, because much of it is tooled. A foundry engagement binds a package to a customer along a few predictable seams: data & identity (point the tools at this customer's systems, under their auth), policy (tune guardrails to their risk posture and jurisdiction), and voice (their house style and brand). Then it does the thing bespoke engagements throw away — it keeps the learning.
Every engagement produces something durable: corrections become new golden trajectories; a tricky case becomes a new eval; a repeated manual step becomes a new skill. Fed back into the package, this is a codification flywheelCodification FlywheelA loop in which the results of real work — corrections, edge cases, repeated procedures — are captured as reusable assets (skills, evals, trajectories) that make the next engagement faster and better. — each customer makes the vertical package smarter, and the next deployment starts further ahead. It is the agentic answer to SAP's accumulated industry know-how, except the know-how is executable.
Two horizontals make this safe at enterprise scale, and they are exactly the ones a serious base harness already cares about. First, governed tool access inside a constrained, ideally zero-egressZero-Egress SandboxAn execution environment that can use approved tools and data but cannot send data out to the open internet — so sensitive enterprise information never leaves the perimeter. sandbox, so a course college's student records or a firm's privileged files never leave the perimeter. Second, observability over every trajectory, so each customer deployment is auditable, debuggable, and improvable — the raw material the flywheel runs on.
Each of these is a vertical we already meet as a bespoke build. Each is a Layer-2 package waiting to be packaged.
"We built a beautiful course-material generator for one college — book-reader layout, rendered mathematics, a concept glossary, citation tokens, reusable chapter templates. Then the second college called."
The second college wanted the same engine pointed at its own units of competency, its own assessment rules, its own brand. Almost nothing about the generation changed; almost everything about the binding did. That gap is the argument in miniature. As a Layer-2 package, the generator carries the domain ontology (qualifications, units, learning outcomes), the skills (build a chapter, render a worked example, attach citations), and an eval harness that checks pedagogical soundness. The foundry binds it to one college in days, not a quarter — and every correction a teacher makes flows back as a golden trajectory the next college inherits.
"A practice wanted an agent for matter work, but the first question was not 'can it draft?' It was 'can you prove what it did, and stop it doing what it must not?'"
Law is where guardrails stop being a feature and become the product. A legal Layer-2 package would govern the determinism spectrum directly — some steps free-form, others strictly constrained — with the harness enforcing which is which. Privilege boundaries, citation discipline, and jurisdictional rules ship inside the package; the foundry tunes them to the firm's jurisdiction and risk appetite. The bespoke version of this is months of careful, repeated work. The packaged version makes that work an asset rather than a recurring cost.
"They loved the analytics agent in the demo. Then procurement asked where the data went, and the demo had no answer."
For sovereign and regulated buyers, the deployment story is the value story. A data-analytics package leans hardest on the base harness: zero-egress execution, full trajectory observability, and tool access governed down to the column. The vertical contribution is the analytical ontology and the query patterns; the foundry contribution is binding it to the customer's lakehouse under their identity, inside their perimeter, with an audit trail their regulator will accept. Nobody wins this with a bespoke prototype. You win it with a package whose answer to "where does the data go?" is already written.
"The model could write the note. The hard part was every constraint that surrounds the note."
Clinical work is dense with ontology (problems, medications, codes) and unforgiving on guardrails. It is the clearest case for packaging, because the cost of getting the horizontals wrong is measured in patient safety, and no single hospital should re-derive those horizontals alone. A clinical Layer-2 package concentrates that hard-won safety once; the foundry adapts it to one health system's workflows. The flywheel — each de-identified correction sharpening the shared package — is how the vertical gets safer over time instead of merely larger.
The lesson of enterprise software is not that bespoke work is bad — it is that bespoke work is a phase. The teams that thrived were the ones who recognised the phase for what it was, harvested the commonality, and moved the value up the stack: from code, to platform, to standard, to package and foundry. The base harnesses are here. The standards are here. The bespoke domain harnesses are being built, by us, right now.
Our argument is simply that we should build them as if the foundry era has already begun — capturing every vertical as a package, every correction as codified memory, every engagement as a deposit in a flywheel rather than a sandcastle washed away at sign-off. Do that, and the SAP of agent harnesses is not a moonshot. It is the natural next rung, and the climb has already started.
The next platform giant in AI will not write an agent for every customer. It will package the vertical and industrialise the customisation.