• Three proposals arrive for the same business outcome, each argued on its technical merits. The decision does not turn on the technology. It turns on how the work is organized and on who is out of pocket if it is late.


    The Decision


    What Is On The Table

    Your technology team wants to build it. AI tools have made development far faster, the cost is one-time, and they price it at roughly two years of licensing.

    Your consulting partner proposes their own orchestration platform, or a formal process to survey the market first.

    Your architecture team recommends an accelerator, which is the option most likely to be unfamiliar.

    An accelerator is a partly finished solution to a specific business problem in your industry. The common work is already built — the process itself, the rules everyone in your sector shares, the connections into the systems everyone in your sector runs. What remains is fitting it to how you work, and the vendor’s own engineers do that inside your business rather than shipping software over the wall.

    It is not a platform that replaces your systems, and it is not a blank page. You license it a piece at a time, pay for what you use, and it runs on your own systems with your data staying where it is.

    One option can go immediately. An orchestration platform carries no knowledge of your business, so everything that makes your outcome yours still has to be built on top of it — you pay for the foundation and still owe the building. Ask them to show it solving your problem, in your industry, for a customer in production. If that does not exist, you are buying plumbing.

    The key point:

    A platform with no domain knowledge in it leaves the real work undone.


    What AI Changed, and What It Did Not

    The build case is stronger than it was two years ago, and your team is not exaggerating that part.

    What moved is the time to write software.

    What did not move is the time it takes your organization to agree, decide, and hand off. On most builds, that is the larger number — and it is the number nobody puts in the estimate.

    The key point:

    AI writes software faster. It does not make ten leaders agree faster.


    Count the Reporting Lines

    Ask who owns the build and you will hear a name, usually the CIO. That settles nothing. Eventually everyone reports to the CIO.

    The question is how many separate lines the work crosses before it reaches that person.

    Infrastructure, networks and data sitting apart is normal, and projects survive it. The narrower test is the five functions closest to the work: the person defining what to build, the people building it, the people testing it, the people connecting it to your other systems, and the person coordinating all of them, who usually sits in a group of their own.

    Five functions in one line is a team. Their estimate probably holds.

    Five functions in five lines has no single place where a decision gets made. Your sponsor can convene, escalate and ask. They cannot direct. The project turns red gradually and nobody can tell you which week it happened.

    The key point:

    Everyone reports to the CIO eventually. Ask how many lines the work crosses before it gets there.


    Who Writes the Definition

    You know what happens when requirements are weak. The part worth noticing is what AI did to that problem.

    Nothing.

    AI turns a definition into software very quickly. It does not produce the definition. So the constraint that was always there is now the whole constraint, and it decides most builds.

    Which makes the question concrete rather than philosophical: name the person who will write it, and confirm they are available for the duration.

    If you cannot, a product is somebody else’s definition, argued out across many customers before you arrived. Reacting to that is a far easier thing to ask of a busy organization than starting from a blank page.

    It also arrives with an edge. A product does what it does, and crossing that line has a price attached to it. A build has no edge, so every request is possible and every request gets discussed. That is not indiscipline. There is nothing to refuse against.

    The key point:

    AI turns a definition into software. It does not write the definition.


    Who Is Late At Their Own Expense

    This is the part that rarely gets said out loud.

    An accelerator vendor does not get paid until it is running. Their revenue depends on your deployment date, which puts their money at risk on your timeline.

    On an internal build, nobody’s money is at risk. The team is paid the same whether it ships in March or September.

    Two more things come with the vendor. They start closer to the finish line, so the work is configuration rather than development, done by people who have done it before. And their team reports to them — the coordination problem you were just counting lines for is theirs, already solved.

    None of which makes the accelerator automatically right. It still has to meet real criteria on pricing, deployment and engineering model, which I have covered in what the model is and how to select a vendor for it.

    The key point:

    A vendor who gets paid on delivery has something at stake that your own team does not.


    Final Thoughts

    The discussion in the room will be about technology. Almost none of it decides the outcome.

    Three things do. How many organizations have to cooperate. Whether anyone can say precisely what the system should do. And whose money is at risk if the date slips.

    All three can be answered without knowing anything about the technology, which is the point. You are not being asked to evaluate an architecture. You are being asked whether this organization, as it is currently arranged, can deliver what is being promised.

    A build under one leader with a real definition behind it is often the right answer, and more often than it was two years ago. A build spread across five organizations with nobody to define it is a red project that has not started yet, and no amount of AI changes that.

    And if only one option reaches you, that is its own answer. Send them to survey the market. Surveying it is a delay when you already know the alternatives, and the only sensible step when you do not.

    Ask how many lines the work crosses.

    Then decide.

  • Part one of three on the shape of the enterprise technology organization.

    The constraint on how fast a large company can change itself has been technology capacity for thirty years. That is ending, and what replaces it is an organization that looks considerably less like a technology department and considerably more like the business it serves. This is written for enterprises anchored on large systems they did not build.


    The Enterprise This Is Heading Toward

    Thirty or forty small teams, each owning a piece of how the company actually runs.

    Admission. Claims denial. Pricing. Store fulfillment. Each team four to eight people, led by someone who knows that part of the business, sitting inside the business rather than alongside it. Each able to define what should happen, build it, test it, connect it and see whether it worked — without leaving the team.

    Underneath them, three utilities: infrastructure, security and identity, and the data platform. Consumed on demand, the way a company consumes electricity. Not queued for.

    Above them, the ordinary management structure of any large organization — engineering leaders owning groups of domains, running down the business lines rather than across the technical functions. The hierarchy does not disappear. The leadership bench does not shrink. It stops being organized by what people do and starts being organized by what they are responsible for.

    And then the consequence that matters outside the technology organization.

    Changing how admission works becomes a decision rather than a program. It is made by the person accountable for admission, executed by the team that reports to them, in weeks.

    The key point:

    The limit on how fast the enterprise can change stops being technology capacity and goes back to being judgment.


    Why This Is Possible Now, and Was Not Before

    Every enterprise technology organization exists to close a gap — between what the business wants and what the systems actually do.

    That gap was real, and it was wide. Spanning it required analysts, developers, testers, integration specialists and the managers to coordinate them. The organization was the bridge.

    Two decades of reorganization were attempts to build a better bridge. Centralize for efficiency. Decentralize for responsiveness. Shared services. Centers of excellence. Agile at scale. Value streams with a platform organization behind them.

    Each one improved coordination. None shortened the distance, because none could.

    Then the distance closed, and not because anyone redesigned an operating model.

    The vendor took the systems. Nobody staffs a database tier for Workday or writes a scheduling engine for an EHR. The hard subsystem now sits inside software you license, along with the specialists who used to tend it.

    AI took the translation. Writing the requirement down, interpreting it, building to the interpretation, checking the interpretation was right — most of that chain is translation between people who cannot see each other’s work. Translation is what this technology does.

    What remains at the two ends is knowing the business well enough to say what should happen, and judging whether what came out is good enough to use.

    Both are business judgment. Neither is a bridge.

    The key point:

    How the bridge was organized was always a constraint. It was never the unlock. The unlock is that the gap closed.


    Why the Current Shape Cannot Get There

    A health system set out to automate admission. Twelve months, six business groups, ten technology groups — product ownership, development, testing, integration, data, network, cloud, middleware, robotic process automation, project management.

    The result was partial automation and a queue of exceptions.

    The exceptions were not technically hard. They were undecided. The payer response does not match what the patient said, the coverage is unusual, the situation had never been defined — so it could not be automated.

    Every one of those ten technology groups could build. Not one could decide.

    That is the failure mode of the current shape, and more people will not fix it. Neither will faster tooling. The project automated what had already been decided and queued everything that had not, because deciding required standing with the business that no technology group had.

    The key point:

    The exception queue is the organization chart, re-expressed as work.


    The Lineage, and What Changes

    Almost every operating model an enterprise has adopted in twenty years was written by people building their own software. Agile, Scrum, scaled agile, DevOps, platform engineering, Team Topologies. All of it assumes you control the codebase, the release cadence, the architecture and the backlog.

    Anchor a company on an EHR or SAP and it controls none of those. The vendor sets the release calendar, the data model, and what is configurable at all. So enterprises run ceremonies designed for teams who can refactor, over work that is mostly configuration, validation and workflow design. Sprints exist, and the release date belongs to the vendor.

    Team Topologies described teams aligned to value, with platform and enabling teams beneath to carry the load those teams could not.

    That was right, and it was written for organizations that build and run their own software. The platform team existed because the cognitive load was genuinely too high for one team to hold. Enterprises then adopted platform teams from a framework written for people who needed to build a platform. They already had one. They had licensed it.

    The vendor now carries that load. So does the machine.

    What follows is a simpler structure than the one it replaces. Two kinds of team, not four. Domains that own a piece of the business end to end, and utilities that are consumed rather than requested.

    The suppliers reached this conclusion before their customers did. Five of them launched units this year staffed by engineers who sit inside the client organization and work directly with the business — Accenture with Google Cloud in September, Microsoft and Amazon before that, OpenAI and Anthropic with their own. They are not selling more platform. They are selling proximity to the decision.


    The Hard Question This Raises

    If every domain owns its own work, who owns what crosses between them?

    The patient’s experience of being admitted and then billed spans four domains. Each has its own leader, its own priorities and its own backlog. Autonomy inside a domain does not answer what happens at the edges of it, and the old shape at least had a program manager who could force a sequence.

    The towers never solved this either. They made everything slow enough that the seam was not visible as a separate problem.

    This model makes it visible, which is progress and is not a solution. Part three takes it seriously.


    Final Thoughts

    The organization most enterprises run today was built to supply resources to demand. An idea becomes a request, a request becomes an allocation, and the outcome is whatever survives sixteen groups touching it part-time.

    Nobody built that badly. It was the correct design for a problem that no longer exists.

    For anyone approving a technology operating model, there is one test worth applying, and it needs no technical knowledge. The last time an automation effort ended in an exception queue — were those cases hard, or had nobody decided what to do with them?

    If it is the second, more technology will not help. The shape is the answer.

    Part two covers where the system boundaries belong, and why a shared system is a shared queue however the organization above it is arranged. Part three covers the people the model depends on, and why the current shape has hidden them.

    Series — overview: The Agentic Enterprise Needs a Spine, Not a Mesh · Part one: The Enterprise Without a Bridge · Part two: Where the Lines Should Be Drawn · Part three: The Contract Is the Crossing

  • Part two of three on the shape of the enterprise technology organization.

    An organization can collapse every reporting line it has and still be slow, because the systems underneath have boundaries of their own. Those boundaries were drawn on a cost argument that no longer holds.


    A Shared System Is a Shared Queue

    Take a firm with clinics, a manufacturing operation, and the usual enterprise functions. No single application covers that. There will be an EHR, a manufacturing system, SAP or Workday, and if the firm sells direct, commerce and order management as well.

    Give every domain its own team and its own leader, exactly as part one describes. Then put two of them on the same SAP instance.

    They now share a release calendar, a change board, a regression cycle and a configuration namespace. Neither moves without the other. The reporting lines are clean and the queue is still there, because the queue was never really about the people.

    The key point:

    A shared system is a shared queue, however the organization above it is arranged.


    The Argument That Built Those Queues

    Consolidation won for a good reason. Every extra system meant another integration, another reconciliation, another environment, another team who knew how it worked. One platform serving three domains was genuinely cheaper than three.

    So arguments about where a boundary belonged got settled that way — by whichever system was biggest, or whichever leader argued hardest.

    Then the thing that argument rested on collapsed. The cost of integration — the reason an extra system was expensive — has fallen by an order of magnitude, because connecting two systems is mostly translation, and translation is what AI now does. Building a system got cheaper; connecting one got cheaper faster. And the reconciliation that once required identical systems now happens in the data platform afterward.

    Two arguments were built on that cost, and both have to be revisited. The first is reuse — one system serving many domains, justified because a second system meant a second integration bill. That bill has collapsed. The second is the shared backlog — the idea that domains coordinating their changes on one platform is an acceptable price for not running two. When integration was expensive, it was a reasonable trade. Now the shared backlog is just the queue, paid for with a cost that no longer exists.

    License cost did not change. But license cost is a line item and dependency is a constraint on the business, and enterprises have spent twenty years optimizing the line item.


    The Rule

    No system sits inside the workflow of more than one business line.

    This is about what a system runs, not which vendor supplies it. One finance instance serving every business line is correct — that is the ledger doing its job. Where the same product is customer-facing, separate instances per line are usually the cheaper answer: two lines on the same CRM, each with its own configuration and release calendar, stay independent of each other. If a system has to serve two boundaries, it serves them as two instances, not one shared one — a second Salesforce org, not a shared one with both lines negotiating every release.

    The simpler version — one system per domain — is also wrong. Epic spans scheduling, clinical documentation and revenue cycle, and that is correct: one value chain, one business line, and revenue cycle in healthcare moves with clinical workflow rather than with finance.

    The violation looks different. SAP running the general ledger is finance doing its job. SAP running patient revenue cycle puts a finance release calendar inside a clinical workflow, and the clinic has lost control of its own speed.

    The same test kills the obvious efficiency on the retail side. Patient billing and eyewear order billing look like one capability. They serve two businesses with different cadences, regulators and customers. Share the system and retail waits on a clinical release.

    The hardest instinct to drop is the one that sounds most responsible: several domains need the same capability, so the capability should move down into a shared layer everyone draws on. Common need feels like it justifies a common system. It does not. A shared need is a reason to buy the same product, not to run one instance of it across two workflows. The vendor will carve a separate instance per business line at low marginal cost — and, this is what changed, share data between those instances cheaply, because moving data between two copies of the same system is exactly the integration that used to be expensive and no longer is. You get the commonality without the queue: the same capability, the same data where it matters, separate release calendars where the work happens. A common need is a reason to buy the same product, not to share one instance of it.

    Duplication is the price, and two horizontals make it affordable. Identity, because the same person is a patient and a customer. The data platform, because independent systems do fragment reporting — and that is answered by converging at the analytical layer rather than the transactional one.

    Independence where the work happens. Convergence where the questions get asked.

    The key point:

    Enterprise systems receive results. They do not run workflows.


    What You Build, Not Just What You Buy

    Most of a large enterprise runs on software it bought. But some of it is built — the strategic components that differentiate the business, where owning the software is the point. The rule does not change for them.

    Built components can share a consistent framework: the same platform conventions, the same utilities, the same standard for how a contract is published. What they do not share is a workspace. A framework is consumed; a workspace couples. A domain large enough to justify its own team is large enough to justify its own data and its own experience, rather than being folded into a shared store or a shared front end that every other domain waits on.

    Consistency is a standard everyone meets. It is not a room everyone works in.

    The key point:

    Share the framework, not the workspace.


    When Nothing Owns the Experience

    Where one system spans a business line end to end, it owns the customer experience too. A health system on a single EHR has a natural home for scheduling, results and balances. Take that when it exists.

    Three chains on three EHRs is the harder and more common case. The conventional answer is a multi-year consolidation program where the patient notices nothing until the end.

    The alternative is to build the digital layer and leave the EHRs different. It breaks no rule — a layer spanning three EHRs serves one business line that happens to run on three systems. And it changes the strategic position: consolidation becomes optional rather than a precondition for improvement.

    Two constraints worth stating. Reading across systems is achievable; writing back is hard, and scheduling is the worst of it. And identity is the precondition, because showing one patient another patient’s results is the failure that ends the program.

    The key point:

    The digital layer is the alternative to consolidation, not a step toward it.


    Who Owns It, and What Is Left

    The digital layer is a domain team with a business owner, not a service bureau. Each clinical domain exposes a contract — appointments, results, balances — and the digital domain consumes contracts rather than reaching into an EHR.

    Exposing that contract used to be a project in itself: the integration layer, the interface team, the months. That is the other cost that collapsed. Publishing what a domain knows, as a contract another domain can consume, is now cheap enough that it stops being a reason to merge the systems instead. The contract, not the shared instance, is how domains meet.

    That distinction is the whole thing. The digital team owns the patient-facing product. Domains own their capability and their content. When billing wants to change what a patient sees about a balance, billing changes it.

    The failure mode is specific and it happens every time: the digital team starts building on behalf of a domain because that domain is slow. At that point it becomes the queue everyone waits in.

    And something real remains. Two domains sharing a contract still have to agree on when it changes — two backlogs, one release, a conversation between two leaders about sequence. No structure removes that. It is genuine coupling, not organizational residue.

    It can eventually be automated, but only afterward. Automating the handoff while sixteen groups still exist is what produced middleware and robotic process automation, and how a twelve-month project ends in an exception queue.


    Final Thoughts

    For twenty years the answer to where a system boundary belonged was whoever argued hardest, defended by a cost case nobody could check.

    That cost case has changed. Integration is cheap, instances are cheap, and sharing data between them is cheap. What replaces the old answer is a principle: boundaries follow business lines, duplication is affordable, and convergence happens where the questions are asked rather than where the work is done.

    Collapse the bridge first. Then automate what remains.

    Part three covers the people the model depends on — and why nothing sits in the middle to own.

    Series — overview: The Agentic Enterprise Needs a Spine, Not a Mesh · Part one: The Enterprise Without a Bridge · Part two: Where the Lines Should Be Drawn · Part three: The Contract Is the Crossing

  • The AI era forces one architectural choice on every large enterprise. Most are making the expensive one without noticing they had a choice.

    Every large enterprise is about to make the same decision, and most will make it by default.

    The AI era has reopened the oldest question in enterprise technology: how do you connect a business that is many things to systems that were bought separately? For thirty years the answer was a layer in the middle — a technology organization that stood between what the business wanted and what its systems did, translating one into the other, with a growing stack of integration underneath it. The middle was where coordination happened. It was also where the waiting happened. For most of that time there was no way to remove it.

    Agentic AI is now being sold as the way to perfect that middle. The dominant advice this year — from the largest advisory firms — is to build a smarter one: an orchestration layer, an “agentic mesh” that coordinates across systems and maintains a shared source of truth, a shared enterprise ontology so agents can reason across domains, a clean central core that everything still routes through. The instinct is understandable. It is also the wrong answer, and an expensive one.

    There is a different answer, and it comes from taking the same facts seriously. The forces that make a smarter middle possible — vendors who now supply the hard systems, and AI that now does the translation — are the same forces that remove the reason for a middle at all. The middle existed to bridge a gap. If the gap has closed, you do not re-platform the bridge. You delete it.


    What the Middle Costs

    The middle never showed up as a line item. It showed up as time.

    Every initiative that touched more than one system waited on a shared release calendar, a shared change board, a shared integration team, a shared source of truth that someone had to reconcile. The cost of the middle was the speed you did not have. A process change that should have been a decision became a program, because the program was how you got everyone in the middle to move at once.

    The enterprise paid for this because the alternative was worse. Building and connecting systems was expensive, so consolidation won: fewer systems, fewer connections, one place to coordinate. The middle was the price of consolidation, and consolidation was the price of affordability. That bargain is what has changed.


    The Enterprise Without a Middle

    Picture the enterprise organized a different way.

    It is a set of business-owned domains — the real divisions of the business, each owning its own systems — bought or built — its own decisions, and its own outcomes. The strategic things it builds for itself share a consistent framework, never a shared workspace: standards everyone meets, not a room everyone works in. Underneath them is a thin spine that the technology organization owns: infrastructure, security, and a data platform. That is the entire remaining footprint of central IT. Everything else — the applications, the delivery, the people who make technology serve the business — lives inside the domains, owned and funded by the business.

    Two rules hold it together. No system sits inside the workflow of more than one business line. And anything shared that sits inside a workflow is not an economy — it is a blocker. The three spine services are allowed to be shared precisely because they sit underneath every workflow and inside none of them.

    And the domains connect in exactly one way: by contract. A domain publishes what it will share — an appointment, a balance, a result, an action it will take on request — and the domain that needs it consumes that contract directly, peer to peer. There is no orchestrator in the middle moving work across. The domain accountable for an outcome reaches for what it needs. Ownership is never ambiguous: whoever publishes a contract owns that it is correct; whoever consumes it owns what they do with it. The crossing is not a place, so there is nothing in the middle to own.


    What This Changes for the Business

    This is not a technology reorganization. It is a change in who owns, funds, and runs the enterprise’s capabilities.

    The technology organization stops trying to own teams embedded across every business line and shrinks to running the spine. The business stops waiting on a central function and takes ownership of the domains it already depends on — including the budget and the accountability that come with them. The customer-facing functions follow the same logic: support becomes a domain that owns the conversation and routes requests to the domains that can act; field service becomes a domain that receives them. No shared function reaches across everything to resolve anything, because reaching across is what rebuilt the middle in the first place.

    What the business gets in return is the thing the middle always cost it: a change to a process becomes a decision, not a program.


    The Honest Limits

    A model earns trust by naming what it does not solve. Three things are real.

    The end-to-end promise — the commitment made to a customer whose issue spans several domains — is owned by whoever faces the customer, but the clock runs inside domains they do not control. Action across a boundary — getting one domain to reliably act on another’s request — is harder than reading, and it is the genuine integration work that remains. And the economics of duplication — running two systems where you used to run one — rest on integration having become cheap: vendors now carve a separate instance per business line and share data between them at low cost, and AI has collapsed the price of connecting systems at all. That shift is real, but uneven across vendors, so the economics are strongest where your core platforms already support multiple instances and managed data sharing.

    These are not reasons the model fails. They are the places where the real work is, once the structure is right. Everything else the old enterprise spent its coordination budget on was self-inflicted — the cost of a middle that no longer needs to exist.


    What This Builds On, and What It Argues Against

    None of this is built from nothing. The shape of it has been described before — by people who were right, and early, and held back by the same thing: the cost of implementation.

    Team Topologies (Matthew Skelton and Manuel Pais) worked out how to organize teams for fast flow — but it was written for organizations that build and run their own software. MIT CISR’s work on the componentized organization (Jeanne Ross and colleagues) argued for business-owned components connecting through APIs, studied in large traditional enterprises rather than tech firms. Each described a version of the enterprise this series describes. Each ran into the same wall: building and connecting systems was slow and expensive, so the destination stayed mostly out of reach.

    That wall is what has come down. The contribution here is not a new shape — it is that the shape is finally affordable, and that it extends past the data plane to the whole system estate and operating model.

    Which is why the current consensus is worth arguing with. The dominant 2026 advice — most clearly from McKinsey, in its work on enterprise architecture and ERP for the agentic era — reads the same moment and reaches the opposite conclusion: build a smarter central layer. An “agentic mesh” acting as a coordination fabric with a shared source of truth; a shared enterprise ontology so agents can reason across domains; a clean central core that everything still routes through. It is a serious position, argued by serious people. It is also the instinct to perfect the middle at exactly the moment the middle became optional — and a better middle still charges, in a new currency, the tax the middle always charged.


    The Choice

    So the decision in front of every enterprise is not whether to adopt AI. It is what to do with the middle that AI makes optional.

    One path builds a better one: a smarter orchestration layer, a shared brain, a cleaner core — and keeps paying, in a new currency, the tax the middle always charged. The other deletes it: business-owned domains on a thin spine, connected by contracts, accountable where the work lands.

    Most enterprises will build the middle, because it is the familiar move and the one the market is selling. The ones that delete it will be faster, and they will spend the AI era removing coordination instead of re-buying it.

    This is the argument in brief. Three companion pieces work it out in full: the shape of the organization, the boundaries of the systems, and why there is nothing in the middle to own.

    Related reading: The Mesh Keeps Coming Back. The Reason For It Doesn’t. — why the agentic mesh is the latest in a long lineage, and why its cost case has expired.

  • Part three of three on the shape of the enterprise technology organization.

    Part one changed the shape of the organization. Part two changed the boundaries of the systems underneath it. Both left the same question open, and it is the one that decides whether any of this works: when something has to move from one domain to another, who owns it?

    The instinct is to put someone in the middle. A coordinator, an integration team, a journey owner, a platform that everything routes through. Every enterprise has tried some version of this, and it is always where the slowness comes back.

    The instinct of the moment runs the same way, dressed in new clothes. The prevailing advice for the AI era is to build a better middle — a central orchestration layer, a shared ontology, a clean core that everything still routes through. This argues the opposite: the AI era is precisely when the middle becomes removable. The answer to who owns the crossing is that there is nothing in the middle to own, because the crossing is not a place. It is a contract.


    What IT Keeps

    Start with what the technology organization is for, because in this model it is for much less than it used to be.

    IT keeps three things: infrastructure, security, and a data platform. It owns them, funds them, and runs them. That is the entire remaining footprint of a central technology organization. Everything that used to sit under it — the application teams, the delivery groups, the product owners embedded in the business — moves into the domains, where the business owns them, funds them, and runs them.

    This is not a smaller version of the old IT organization. It is a different object. The old one existed to stand between the business and its systems and translate. That gap is what vendors and AI have closed. What is left is not a translator. It is the keeper of three utilities that every domain consumes and none of them coordinate around.

    The test for whether something belongs to IT is simple: does it sit inside a business workflow, or underneath all of them? Infrastructure is underneath. Security is underneath. The data platform is underneath. Anything that sits inside a workflow belongs to the domain that runs that workflow, and to no one else.


    The Only Way to Cross

    A domain owns its work, its systems, and its decisions. It does not reach into another domain, and nothing reaches into it. So when information or work has to cross a boundary, it crosses in exactly one way: through a contract the domain publishes.

    A domain exposes what it is willing to share — an appointment, a balance, a result, an action it will take on request — and the domain that needs it consumes that contract directly. Peer to peer. No broker.

    Publishing a contract used to be a project in itself — an integration layer, an interface team, a year of work. That cost has collapsed. Standing up an endpoint that exposes what a domain knows — an MCP server over its data and the actions it will take — is now a day’s work, not a program. When enabling the contract is that cheap, a domain can expose what it knows without any reason to merge systems instead. The contract stops being the hard part. It becomes the crossing.

    Ownership falls out of this without anyone appointing it. The domain that publishes a contract owns that what it publishes is correct. The domain that consumes it owns what it does with it. When one domain needs another to act, the asking domain owns the request and the owning domain owns the act. There is no third party, because the contract is the only thing that crosses.

    The key point:

    The contract is the only thing that crosses, and a contract has two ends and no middle.


    There Is No Middle to Own

    Return to the question parts one and two left open: a patient is admitted, treated, and billed. The work crosses admissions, clinical, and revenue cycle. Who owns the journey?

    In the old enterprise, the answer was a program, or a platform, or a person whose title contained the words “end to end.” Something sat in the middle and moved the work across. And it was always the bottleneck, because everything waited on it.

    In this model no one owns the journey, because the journey is not a thing. It is a sequence of domains, each accountable for its own part, connected by contracts. What is owned is the outcome, and the outcome is owned by the domain where it lands. Revenue capture is owned by revenue cycle. So revenue cycle pulls what it needs — the admission, the eligibility, the clinical fact — through the contracts those domains publish, and raises a request when it needs one of them to act.

    The shift is small to state and large in effect. Stop putting a function in the middle to push work across boundaries, and let the domain that is accountable for the result reach for what it needs. The middle disappears, and the queue goes with it.

    The key point:

    Replace the orchestrator with the consumer.


    The Data Platform Is a Consumer, Not a Switchboard

    This raises the obvious objection. The data platform is shared. Anything shared that sits in the path becomes the blocker. So is the data platform not the middle, wearing a different coat?

    It is not — as long as it is never in the path. Domains do not talk to each other through the data platform. They talk to each other directly, through contracts. The data platform is simply another consumer of those same contracts. It reads from the domains to answer the questions no single domain owns: the enterprise view, the analytics, the reporting, the trends.

    It converges information where the questions are asked, not where the work is done. It sits underneath every workflow and inside none of them. The moment a domain has to route through it to reach another domain, it has become the switchboard, and the model has failed. Keep it a reader and it stays a utility.


    Support Is a Conversation, Not a System

    Support looks like the exception, because a customer’s problem does not respect domain boundaries. A single call can touch scheduling, billing, and a device in the field. The temptation is to build one support function that reaches into every system to resolve it — which is to rebuild the middle with a headset on.

    Support is a domain. It owns the conversation, not the systems behind it. It captures the contact, confirms identity, triages, routes, tracks, and owns the promise made to the customer. When resolution needs another domain to act, support raises a request through that domain’s contract. It does not log into the domain’s system and fix it.

    Field service is a separate domain, not a part of support. It owns dispatch, scheduling, parts, and the technician’s work, and it receives requests the way any domain does. Support routes to it. Neither owns the space between them, because there is no space — only a contract.

    The key point:

    Support owns the conversation, never the system of record.


    What Is Left Unowned

    A model earns trust by naming what it does not solve, so here is the edge.

    Two things genuinely resist this structure. The first is the end-to-end promise. Support owns the commitment made to the customer, but the clock runs inside domains support does not control. Accountability for the whole is real, and it does not sit cleanly in any one domain. The second is action across a boundary. Reading another domain’s contract is easy. Getting another domain to reliably act on a request — to write back, to change its own state on someone else’s behalf — is the hard, unglamorous integration problem that every version of this has run into.

    These are not reasons the model fails. They are the two places where the work actually is, once the structure is right. Everything else the old enterprise spent its coordination budget on was self-inflicted — the cost of a middle that did not need to exist.


    Final Thoughts

    The old enterprise held itself together with a middle. A technology organization that stood between the business and its systems, a platform that everything crossed, a layer of coordination that grew every time the business did. The middle was where the translation happened, and it was where the waiting happened, and for thirty years there was no way to remove it.

    There is now. Collapse the bridge, draw the lines, and delete the middle. What is left is an organization that owns nothing in common but the ground it stands on — three utilities underneath, business-owned domains above, and contracts where they meet. Nothing in between, because nothing in between was ever the point.

    Series — overview: The Agentic Enterprise Needs a Spine, Not a Mesh · Part one: The Enterprise Without a Bridge · Part two: Where the Lines Should Be Drawn · Part three: The Contract Is the Crossing

  • A supporting read for The Agentic Enterprise Needs a Spine, Not a Mesh. The agentic mesh is not new. It is the latest name for a layer the industry rebuilds every technology wave — and the reason it kept coming back has finally gone away.

    The agentic mesh is being sold as the architecture of a new era. It is not new. It is the fifth time in twenty-five years that the industry has promised autonomy at the edge and then built a coordinator in the center — and the fifth time the center is set to become the thing everything waits on.

    It is worth walking the lineage, because the pattern is the argument.

    A hub-and-spoke network schematic: many nodes all routing through one central hub.

    Five Names for the Same Layer

    SOA gave us the bus. Service orientation promised loose coupling: independent services, composed freely. What it delivered was the enterprise service bus — a central mediation layer that every call traversed and every team queued behind. The ESB was the middle, and governing it became a department.

    Microservices gave us the mesh. The reaction to the monolith promised decentralization: small services, owned by small teams. What it reintroduced was the API gateway and, literally, the service mesh — Istio, Linkerd — a dedicated layer for everything to talk through. The word “mesh” is not new to this moment. It is already an era old.

    Integration gave us the hub. The work of connecting systems became a product category: EAI, then the ESB again, then iPaaS — MuleSoft, Boomi, Workato. A central hub whose entire purpose was to sit between everything else.

    Cloud gave us the control plane. Elastic, distributed, self-service — and then the landing zone, the shared-services account, the central platform team, the control plane that every workload depends on. A new middle wearing an infrastructure badge.

    AI gives us the agentic mesh. An orchestration layer that coordinates agents, a shared ontology so they can reason across domains, a clean core that everything still routes through. The same organ, the latest costume.

    Five similar hub-and-spoke diagrams in a row, the same central pattern repeating across eras.

    Each wave began by promising to dissolve the center. Each one rebuilt it. And each center became the constraint — the place where change slowed down, where coordination turned into a queue.

    And the center was never only the technology. Each central tool gathered an organization around it — an integration team that owned it, a governance board that gated every change, a release train everyone had to synchronize to. The software was the smallest part. What made the queue slow was the standing apparatus of teams and process the center required.

    The key point:

    The middle is not a technology. It is a reflex. The names change every decade; the organ does not.


    Why It Kept Coming Back

    The reflex was not stupid. It was rational, every time.

    Connecting two systems used to be expensive. Each new connection was a project — an interface, a transform, a team that understood both ends. When connection is costly, a shared coordinator is the economical shortcut: build the integration once, in the center, and let everyone draw on it. The ESB, the mesh, the hub, the control plane — each was a sensible answer to the same real problem. Point-to-point did not scale, so the industry centralized.

    That is the part the vendors are right about. For twenty-five years, the middle earned its place — connectivity, standardization, governance, reliability were real needs, and these technologies met them. The one thing none of them ever delivered was speed.


    What Is Different Now

    One thing has changed, and it is the only thing that matters: the cost that forced the middle has collapsed.

    Standing up a contract between two domains — an API, an MCP endpoint over a domain’s data and the actions it will take — is now a day’s work, not a project. When connection is nearly free, the economic reason for a central coordinator is gone. There is no integration to amortize, no transform to reuse, no reason to route through a center to avoid paying for the edge.

    So this time the move is not to replace the mesh with a better mesh. It is to notice that the condition that made a mesh necessary has lifted. Domains connect directly, by contract, peer to peer. There is no center because there no longer needs to be one — and with no center, there is no apparatus to staff around it, which is where the speed finally comes from.

    A peer-to-peer network schematic: nodes connected directly with the center empty, no hub.

    The key point:

    Every prior wave rebuilt the middle because it had to. This is the first wave that doesn’t.


    The Objections, and Why They Don’t Hold

    This argument will be challenged, and the challenges are worth taking at their strongest — not their weakest.

    “Point-to-point connections explode into N². The mesh exists to tame that.” This was true when every connection was bespoke. It is not true when contracts are standardized: connections are not hand-built, most domains talk to only a few others, and the many-to-one analytical fan-in is absorbed by the data platform. The result is a sparse graph of cheap, standard edges, not a dense web of custom ones. And a mesh does not remove the connections — it routes them through a center. It trades N² edges for one chokepoint, and the chokepoint is what becomes the queue.

    “Agents need a shared ontology to reason across domains.” Semantics belong at the edges of a contract — two domains agree what a term means in the contract between them — not in a central brain every domain must conform to. A universal enterprise ontology is the consolidation fantasy in a new suit: it never converges, it becomes a program. Local agreement scales. Global agreement does not.

    “A modern mesh is not the old ESB — the data plane is distributed.” True, and beside the point. What hurt the enterprise was never the deployment topology; it was that everyone conformed to and waited on a shared layer. A distributed data plane with a central control plane still has a control plane that everything depends on. The control plane is the queue even when the data plane is not.

    There is one objection that does hold, and it is worth conceding plainly. Someone still owns the end-to-end promise to a customer whose work spans several domains, and getting one domain to reliably act on another’s request — writing back across a boundary — is genuine, unglamorous work. Removing the middle does not remove that. It just stops pretending a coordinator was ever doing it well. That is the real work the structure leaves behind, and it is addressed where it belongs, in the piece on how domains cross.


    Build, Buy, and Where the Mesh Belongs

    An organization that builds and runs its own software at scale still needs a mesh, and this is not an argument against that. Service-to-service traffic, observability, policy enforcement across systems you actually control — a mesh is the right tool for that work, and the teams doing it are not the audience here.

    This argument is for the other enterprise: the one anchored on software it bought, whose goal is to simplify its domains rather than to operate a distributed system of its own making. There, a mesh does not solve a problem you have — it imports one. You take on the cost and the center of a thing built for people who write their own platforms, to coordinate systems you only configure.

    This cuts the other way too, and it matters. A domain large enough to build, buy, and run real systems of its own may well need a mesh inside its own boundary — and it should have one. The argument is not against a mesh anywhere; it is against one mesh across the whole enterprise. What changed is the economics of that larger bet: centralizing to capture synergies across the entire organization used to be worth the dependence it created, and it no longer is. So the rule is independence first — keep the mesh, where it is needed, inside the domain that runs it, and stop paying for a center whose synergies no longer cover its cost.

    So the line is not that the mesh is wrong, and it is not that the integration tools before it failed — most did exactly what they were built to do. It is that the mesh is for builders, and that none of these layers ever gave the enterprise the one thing it most needs now: speed, because a shared center is always a queue. For the enterprise that buys and wants to move, what finally changed is not the sixth name. It is that the reason for the center is gone.