AI agents are spreading through enterprises at an extraordinary pace.
A year ago, an organization might have had five developers experimenting with AI agents. Today, that same organization could have dozens of citizen developers building them across finance, operations, HR, sales, supply chain, and other business functions.
Five developers can become 50.
Fifty can become 100.
And before anyone realizes it, an organization could have hundreds of AI agents running across its technology ecosystem.
At first glance, this looks like exactly what digital transformation is supposed to achieve.
Employees closest to business problems are empowered to solve those problems themselves. Instead of waiting months for an IT development team, a business user can identify an opportunity, build an agent, demonstrate its value, and potentially move it into production.
That is powerful.
But there is another side of this movement that enterprises need to start discussing:
What happens when building AI agents becomes easier than governing, funding, securing, and maintaining them?
That, in my view, could become one of the next major enterprise AI challenges.
From Five AI Developers to an Enterprise of Citizen Developers
Consider a scenario I have observed.
An organization begins its AI journey with roughly five people actively developing agents.
As enthusiasm grows, the organization encourages employees across different departments to experiment.
“Have an idea? Build an agent.”
Citizen developers receive access to tools such as Microsoft 365 Copilot and the broader Power Platform ecosystem. Functional champions review solutions before they progress further, followed by architecture and production reviews where appropriate.
The intention is good.
Innovation should not always be centralized within IT.
Business users understand problems that centralized development teams may never encounter. Giving those users tools to solve their own problems can dramatically accelerate innovation.
But something interesting happens when this model succeeds.
Five citizen developers become 20.
Twenty become 50.
Eventually, there may be 80 or 100 people experimenting with AI agents.
The organization celebrates because AI adoption is increasing.
But there is a question that often receives much less attention:
What is the total cost of everything we are creating?
Building an Agent Is Not the Same as Operating an Agent
The initial prototype is often the easiest part.
A citizen developer has an idea.
Perhaps the agent summarizes information, retrieves documents, automates an approval, interacts with enterprise data, generates reports, or assists employees with a particular business process.
The prototype works.
Everyone gets excited.
Then reality arrives.
The solution may require premium capabilities.
It may require Power Apps Premium.
It may require Power Automate Premium.
It may depend on premium connectors.
It may interact with Dataverse or other enterprise data platforms.
It may consume AI capacity or other usage-based services.
It may require additional security controls.
It may require monitoring.
And once the agent becomes important to a business process, somebody needs to support it.
Suddenly, the “simple agent” isn’t quite so simple.
The citizen developer was solving a business problem.
They were not necessarily thinking about enterprise architecture, licensing optimization, security, scalability, support models, disaster recovery, or the three-year total cost of ownership.
And frankly, we shouldn’t expect every citizen developer to think like an enterprise architect.
That’s exactly why governance exists.
The Real Cost of an AI Agent Is Larger Than Its License
When organizations calculate the cost of AI adoption, it is tempting to look primarily at licensing.
But licensing is only one part of the equation.
The real cost of an enterprise AI agent can include platform licensing, premium connectors, API consumption, data storage, compute or AI consumption, integration infrastructure, security reviews, identity and access management, monitoring, compliance, ongoing development, support, documentation, training, and eventual retirement.
Multiply those costs across hundreds of agents and the economics become much more interesting.
One $20, $50, or $100 incremental expense may not attract executive attention.
Multiply recurring expenses across hundreds or thousands of users, workflows, connectors, environments, and agents, however, and suddenly the organization has created a substantial technology portfolio without necessarily treating it like one.
This is where AI agent sprawl can begin.
Today’s AI Experiment Can Become Tomorrow’s Technical Debt
There is another problem that worries me even more than licensing.
Maintenance.
Imagine an employee creates an agent that becomes valuable to their department.
Six months later, that employee changes roles.
A year later, they leave the company.
Who owns the agent?
Who understands how it works?
Who knows which connectors it uses?
Who knows which credentials, service accounts, APIs, data sources, workflows, or dependencies it relies upon?
What happens when an underlying API changes?
What happens when a data source moves?
What happens when a premium connector changes?
What happens when the AI model changes its behavior?
What happens when the business process itself changes?
The organization may eventually inherit hundreds of small applications and agents that nobody centrally understands.
We have seen versions of this problem before with spreadsheets, Access databases, macros, shadow IT, SaaS applications, and low-code platforms.
AI agents could magnify the problem because they don’t simply store or process information.
Increasingly, they can take actions.
IT Governance Is Not the Enemy of Innovation
This creates an uncomfortable relationship between citizen developers and enterprise IT.
From the citizen developer’s perspective, the situation can feel simple:
“I have a good idea.”
“I built it.”
“It works.”
“Why won’t IT let me put it into production?”
IT can then appear to be the department blocking innovation.
But from IT’s perspective, the questions are very different.
What data can this agent access?
Who can use it?
What permissions does it have?
Which systems can it modify?
What does it cost per transaction?
What happens if usage increases tenfold?
Who supports it?
What happens when its creator leaves?
Is there another agent already solving the same problem?
Does it comply with enterprise security policies?
And perhaps the most important question:
Does the business value justify the long-term cost and risk?
These questions aren’t designed to kill innovation.
They are what turns an experiment into an enterprise capability.
The Answer Is Not to Stop Citizen Development
Organizations should not respond by shutting down citizen development.
That would be a mistake.
Citizen developers can become one of the most powerful sources of enterprise innovation because they understand business processes at a level centralized technology teams sometimes cannot.
The objective should therefore be:
Democratize innovation while centralizing governance.
Let people experiment.
Let departments prototype.
Let employees discover new AI use cases.
But create clear boundaries between an experiment and a production enterprise agent.
That distinction is critical.
Every Enterprise Needs an AI Agent Lifecycle
Organizations need to start treating AI agents as managed technology assets.
A simple lifecycle could look something like this:
Idea → Prototype → Business Case → Functional Review → Architecture & Security Review → Cost Assessment → Production → Monitoring → Periodic Review → Retirement
Notice something important in that lifecycle.
Production is not the final stage.
An agent that enters production creates an ongoing responsibility.
Organizations should maintain an inventory of production agents and understand who owns each one, which business process it supports, what data it accesses, what systems it interacts with, how much it costs, how frequently it is used, what measurable value it produces, and when it should be reviewed or retired.
Without this discipline, today’s innovation portfolio can become tomorrow’s technical debt portfolio.
Cost Should Become Part of AI Governance
Security governance is already becoming an important part of enterprise AI.
Cost governance needs to receive similar attention.
Before promoting an agent into production, organizations should be able to answer a relatively simple question:
What will this agent cost if it succeeds?
That last part matters.
The financial danger is not necessarily that an agent fails.
Sometimes the bigger surprise comes when it succeeds.
An agent designed for 20 employees may suddenly be requested by 2,000.
A workflow executing 100 times per month may eventually execute 100,000 times.
A premium connector that seemed insignificant during development may become material at enterprise scale.
AI architecture therefore needs to consider not only whether something can be built, but whether it can be operated economically at scale.
We Need FinOps for AI Agents
Cloud computing eventually created the discipline of FinOps because organizations discovered that democratized access to cloud infrastructure could also produce uncontrolled spending.
AI may be heading toward a similar moment.
Enterprises may increasingly need something resembling Agent FinOps—a discipline connecting AI usage, infrastructure, licensing, consumption, business ownership, and measurable value.
Instead of asking only:
“How many AI agents did we build this year?”
leadership should ask:
“How many are actively used?”
“How much are they costing us?”
“What business value are they generating?”
“How many duplicate capabilities exist?”
“How many should be retired?”
“Which agents justify additional investment?”
Those are much healthier measures of AI maturity.
The Number of Agents Is the Wrong KPI
This may ultimately be the biggest lesson.
Organizations should be careful about celebrating AI adoption purely by counting agents, Copilot licenses, citizen developers, or use cases.
More agents do not necessarily mean more innovation.
Sometimes they simply mean more complexity.
An organization with 500 poorly governed agents may be far less mature than an organization with 50 agents that are secure, widely adopted, economically sustainable, and producing measurable business outcomes.
The goal of enterprise AI shouldn’t be to create the largest possible number of agents.
The goal should be to create the smallest number of well-designed agents necessary to generate the greatest sustainable business value.
Citizen development can absolutely help organizations reach that goal.
But democratizing development without democratizing accountability creates a dangerous imbalance.
Give employees the freedom to experiment.
Give them platforms to innovate.
Give them AI tools.
But before an experiment becomes an enterprise dependency, somebody must understand its architecture, security, ownership, operating model, and total cost.
Because the next challenge in enterprise AI may not be convincing employees to use AI.
We may already be solving that problem.
The next challenge could be figuring out what to do when everyone starts building it.