← All blog posts

Enterprise Architecture · Workforce6 min read

Stop standardising what you can no longer justify

AI has made application code cheap to write, and that moves the line between what an enterprise should centralise and what it should not.

A cartoon of a service counter under a burgundy sign reading Enterprise AI Platform. A tired clerk with a rubber stamp sits behind stacks of paper; a display says Now serving 4812 and a calendar says Next quarter. A developer at the front of a long queue holds ticket 9347 and a laptop with a green tick and a sticker, Done in 2 days. Everyone behind holds a laptop with a green tick too.
Cover: Prabhat Kumar

Many enterprises are building brand-new AI platforms on an old belief: that writing software is slow and expensive. AI has quietly made that belief untrue. You can see it in the platform team’s backlog, where teams that could build what they need themselves file a ticket and wait their turn.

The right answer to an old question

I have spent years building large enterprise platforms, and I have helped write the kind of standards I am about to question. When software was expensive to write and engineers were scarce, building the same thing in dozens of teams was waste. So we built things once and made everyone use them, and one belief took hold: standardisation equals efficiency.

Platform teams grew up with the cloud. As infrastructure moved to cloud vendors, somebody had to configure what the enterprise rented, and that was the platform team’s first job: a thin layer of configuration on top of someone else’s servers. Then the bills arrived: anyone could start a server, and a surprising number of people did. Finance asked who was spending what, and the platform team became the place that could show them. The answer that worked was visibility, not a queue.

Over time the platform became the thing itself, with its own roadmap and its own queue. That made sense while every application was expensive to write.

All of this rested on a simple fact: writing and maintaining software took a great deal of human effort. I now build AI applications myself, and I have watched that fact change. Coding agents, AI assistants that write and test code from plain instructions, have cut the effort of building many kinds of application.

With a few experienced developers, we built the content management system AIforAll Global runs on, in a few weeks. The organisation onboards its hundred or so trainers there and runs more than thirty programmes, bootcamps and a hackathon on it for thousands of attendees. Built the old way, it would have taken many months, possibly years.

When application code becomes this much cheaper to write, building it centrally for everyone is no longer the efficient choice.

When avoiding duplication costs more than duplication

I keep seeing the same decision. An enterprise builds one central platform for all its AI agents: programs that use an AI model to do a task on their own. The platform team provides the foundations, the basics everyone needs: who may log in, security, access to data, the AI models, a register of every agent and a record of what each one did. That part is sensible.

But the organisation adds one rule: every agent is built by the central team. The platform may be brand new. The thinking behind the rule is not.

Now imagine a procurement team needs an agent that checks incoming supplier invoices against their contracts and flags the discrepancies. The team knows its contracts, exceptions and approval steps, and on the shared foundations it could build that agent in two days.

But the rule applies, so it submits a request instead. The platform team reviews it, weighs it against other requests, fits it into the central team’s code and puts it in the next release. Weeks later the procurement team gets its agent, by which time it has learned to live without one.

The organisation has successfully avoided duplicated code. But has it created efficiency? It has saved a little engineering effort and paid for it in meetings, weeks of waiting and an agent that arrives late. Few enterprises measure what their standards cost; they measure whether people follow them.

Via the central team

By the procurement team

Central platform
front481248139347
coding agentagent: invoice-checkread invoicematch contractflag mismatchtests pass

Week 1Week 2Week 3Week 4Week 5Week 6

Day 1Day 2

Invoice agent
Invoice agent
Shared foundations: identity, security, data access, models, logging, registry
The same invoice agent: six weeks in the queue, or two days on the shared foundations.

Centralisation is not disappearing. Its boundary is moving.

I am not arguing against central platforms, and the platform team’s case for its rule is worth hearing. Two hundred teams building two hundred agents means two hundred security reviews, code nobody can list, agents orphaned when their builders move on, and nobody knowing what any of them does.

Every one of those is a real problem, and every one of them is a foundations problem. Access, permissions, a register of every agent and a record of what each one did belong in the shared foundations, and they stay central. The cloud bill taught the same lesson.

So the line runs here. The centre holds the shared foundations, the same for everyone and easy for every team to use. Above that line, each team has its own knowledge, terms and rules, and forcing every agent through one central team makes everyone wait.

You can see why when you look at what an agent needs to know. An agent is only as good as what it is given to work with: the documents it can see, the rules it follows and the tools it can use. Getting that right is called context engineering.

A procurement agent needs contracts, purchasing rules and invoice exceptions. A finance agent needs different controls and different checks, and a learning agent needs the course rules and each learner’s progress. They may all use the same models and the same shared foundations, but what makes each one useful is the work it knows.

This is the part the central team never had. It could own the code because code was the scarce thing. The scarce thing now is knowing the work, the contracts, the exceptions, who signs what, and that has always lived with the team. Nothing has moved to the teams. The code has moved out of the way.

The foundation should be shared. The agent and its context should be owned by the team that needs it.

Invoice agentProcurement
  • Context engineering
  • Reusable capabilities
  • Knowledge and workflows
contracts, invoice exceptions
Learning agentEducation
  • Context engineering
  • Reusable capabilities
  • Knowledge and workflows
course rules, learner progress
Forecasting agentFinance
  • Context engineering
  • Reusable capabilities
  • Knowledge and workflows
controls, month-end checks
Enterprise foundationsIdentity · Security · Data access · Models · Logging · Registry
Same foundations, different context, many agents.

Two questions for the people who set the standards

Anyone who decides how an organisation builds software, from the top of IT down, should put two questions to their own standards.

  1. Why did we introduce this standard? Was it for security, reliability, integration or regulation, or mainly because writing and maintaining custom code was expensive?

  2. Are we centralising the right layer? Does this belong in the shared foundations, or with the team solving the problem?

Here is a rule you can adopt on Monday. Every standard that goes past the foundations gets an expiry date and a cost line: who waits because of it, and for how long. When it expires, it is renewed only if it can be justified again against today’s cost of building. No justification, no renewal.

Test it, then decide

For the standards you are least sure about, test the assumption. Pick one standard or central platform that keeps teams waiting on each other. Let the team that needs it build its own version with coding agents, on the shared foundations. It follows the same security and compliance rules as everyone else, and controls its own logic.

Then compare the two, from the first delivery to years of maintenance. If the central version wins, keep it. If the team’s version wins, change the standard.

What platform teams are for now

Platform teams matter more now, but their job changes. A team should be able to get the shared foundations in an afternoon, without landing in anyone’s backlog, so the secure way is also the easy way. A platform team measured on how little anyone waits behaves very differently from one measured on compliance.

Somewhere today a procurement team that could have built its agent by Wednesday is holding ticket 9347, and the cheapest thing its platform team can do is let it build.

Read next