AI is reshaping enterprise SaaS, but service still drives value

At a glance

What this is: This is C1.ai's argument that AI will change how enterprise SaaS is built and consumed, but not erase the service, platform, and expertise layers that make software durable.

Why it matters: It matters to IAM practitioners because AI-native products will increasingly depend on MCP-based agent access, stronger authorization boundaries, and clearer governance over how humans and machines use enterprise software.

By the numbers:

• Only 5.7% of organisations have full visibility into their service accounts.
• 97% of NHIs carry excessive privileges, increasing unauthorised access and broadening the attack surface.
• NHIs outnumber human identities by 25x to 50x in modern enterprises.

👉 Read C1.ai's analysis of how AI is reshaping enterprise SaaS

Context

AI can write code faster than previous development models, but enterprise software is not just code. It is also deployment, support, migration, authorization, update management, and the operational discipline that keeps applications usable and secure over time. That is where SaaS still differentiates itself, especially as AI-driven development compresses the cost of software creation.

The identity angle becomes more important as software shifts toward machine-to-machine interaction. If AI agents begin to consume enterprise tools through MCP rather than human user interfaces, authorization decisions, workload identity, and lifecycle control become part of the product boundary, not just the security back end. That is a real governance change for IAM, PAM, and NHI programmes.

The broader thesis is plausible, but the starting position is typical of current market pressure rather than a sign that SaaS has already been commoditised. The more immediate change is not the disappearance of SaaS, but a change in how software is accessed, priced, and governed.

Key questions

Q: How should security teams govern AI tools that connect to SaaS data?

A: Treat each AI tool as a non-human identity with an owner, a defined scope, and an expiry path. Require approval for every new integration, limit access to the minimum necessary SaaS objects, and review delegated permissions on a recurring schedule. Governance fails when consent is treated as a one-time event instead of a lifecycle.

Q: Why do chained MCP workflows create extra identity risk?

A: Chained workflows multiply trust boundaries because each MCP server may forward the request to another server. If the originating identity is not preserved, downstream authorization loses context and may overgrant access or reject valid work. Identity propagation is essential so every hop can evaluate origin and scope.

Q: What breaks when platformized SaaS grows faster than access governance?

A: The control model falls behind the number of integrations, roles, and delegated permissions, so access accumulates faster than teams can review it. That creates over-scoped service accounts, unclear ownership, and larger blast radius when a token is misused. The failure is not software growth itself, but unmanaged authority growth.

Q: When should organisations require human approval for an AI agent action?

A: Require human approval when the action could change infrastructure, expose sensitive data, move laterally across systems, or trigger a business-critical workflow that is hard to reverse. Approval is also warranted when the agent’s decision depends on ambiguous input or external data that cannot be trusted at face value. High-consequence actions need a human stop point.

Technical breakdown

MCP changes the access layer, not the security obligation

Model Context Protocol gives AI agents a structured way to reach tools and data sources, which shifts the interface from human clicks to programmatic delegation. That does not remove authorization, it intensifies it, because every agent action now depends on the scope, identity, and trust relationship attached to the integration. In practice, the product boundary starts to look like an identity boundary, especially where agents can chain actions across systems.

Practical implication: treat MCP-connected tools as governed access paths and bind them to explicit service identities, scopes, and approvals.

Platformization creates data gravity and access concentration

A platform model accumulates business logic, integrations, and historical data in one place, which makes the product harder to replace and the access pattern harder to audit. That concentration is useful for differentiation, but it also increases the blast radius of a compromised token, overbroad role, or mis-scoped service account. In an AI-heavy product stack, that risk compounds because agents may request broader access than a human operator would ever need.

Practical implication: review platform entitlements and integration scopes as a single governance surface, not as separate app-by-app decisions.

Agentic automation increases reliance on non-human identities

If AI agents are expected to deploy, upgrade, and adapt enterprise software, they will need machine identities that can authenticate, authorize, and act across environments. That creates an NHI governance problem, because the system now depends on secrets, tokens, and certificates that may be created and consumed at machine speed. The control challenge is not just preventing misuse, but defining when an agent identity is allowed to initiate change without human intervention.

Practical implication: align agent permissions with NHI lifecycle controls, especially issuance, rotation, revocation, and task-scoped authorization.

NHI Mgmt Group analysis

AI does not kill SaaS so much as it relocates the control plane. The competitive moat moves from feature code to the operational and identity layer around software: authorization, integrations, support, and lifecycle management. That means the next wave of enterprise differentiation will be decided as much by governance as by engineering speed. Practitioners should expect the software product to become an identity-managed service fabric.

MCP-driven access will turn enterprise software into a machine-consumed service surface. Once agents begin interacting with tools directly, human-centric UX becomes only one part of the access model. The real security issue is whether each agent action can be tied to a bounded identity, a specific permission scope, and a reviewable policy. That is why MCP and NHI governance will increasingly converge in mature programmes.

Platformization intensifies identity risk because it concentrates authority in fewer integration paths. A broad platform can reduce point-solution sprawl, but it also creates larger privilege clusters and a more consequential failure domain when tokens or service accounts are over-scoped. This is a familiar IAM pattern in a new form: concentration improves capability while widening the blast radius. Practitioners should re-evaluate where access is concentrated and who can expand it.

Data gravity will matter more than feature velocity as AI commoditises surface functionality. C1.ai's thesis implies that durable SaaS value will come from embedding business context, permissions, and process logic into the platform. For identity teams, that means product strategy and access strategy are no longer separate conversations. The programmes that win will govern business data, machine identities, and workflow authority together.

Named concept: machine-to-service governance. As AI agents increasingly consume enterprise applications, the core risk is no longer only human access misuse but unmanaged machine delegation across service boundaries. This concept captures the need to govern how agents authenticate, what they may invoke, and when delegated action must stop. Practitioners should design controls for the service relationship itself, not just the user session.

What this signals

Machine-to-service governance will become a practical programme issue as soon as AI agents are allowed to invoke business tools directly. The first control gap will not be model quality, but delegated authority that nobody can clearly inventory or revoke. That is why teams should align AI access design with the NHI lifecycle controls discussed in the Ultimate Guide to NHIs.

The likely near-term signal is not the collapse of SaaS, but the expansion of access surfaces hidden behind cleaner user experiences. Teams that already struggle to catalogue service accounts will find agent-driven workflows harder to govern, especially where integrations and tokens proliferate across platforms.

Identity teams should expect product architecture reviews to start including agent permissions, connector scopes, and machine revocation paths. That makes governance a product design issue as much as an operations issue, and the programmes that adapt early will have less cleanup later.

For practitioners

• Map agent-to-service authorization paths Identify where AI agents or automation could call enterprise tools through APIs, MCP connectors, or service accounts, then document the exact permissions each path requires. Prioritise workflows that can create, approve, or change records because those actions carry the highest governance risk.
• Reduce standing privilege in platform integrations Review every integration that gives an application or agent broad access to customer data, configuration, or workflow engines. Replace persistent high-scope access with narrowly scoped service identities and time-bound access where the workflow allows it.
• Separate human UX from machine UX governance Set different control expectations for human users and AI agents. Human interfaces can tolerate interactive approval points, while machine interfaces need explicit policy, token scope, and revocation logic that is enforced at the integration layer.
• Treat platform expansion as an authorization event Whenever a SaaS platform adds adjacent modules, integrations, or AI-assisted workflows, re-run access reviews for data sharing, role expansion, and delegated admin rights. New capability often brings new trust paths before anyone updates the governance model.

Key takeaways

• AI is changing SaaS economics, but the operational value of service, support, and governance still matters more than code generation alone.
• As software becomes more machine-consumed, the identity boundary moves into the product itself through MCP, service identities, and delegated authority.
• Security teams should prepare for a larger non-human access surface by tightening scopes, revocation, and review across platform integrations.

Key terms

• Machine-to-service governance: The discipline of controlling how AI agents, automation, and other non-human systems authenticate to and act on enterprise software. It extends identity governance into machine-consumed workflows, where permissions, delegation, and revocation must be explicit and reviewable.
• Platformization: The process of expanding a product into a broader integrated platform with shared data, logic, and workflows. In security terms, platformization concentrates authority and integrations, which can improve visibility but also increase the blast radius of a compromised credential or over-scoped role.
• Data gravity: The tendency for a platform to accumulate enough business context, history, and linked services that value increasingly depends on staying within it. For identity teams, data gravity often means access control, workflow authority, and administrative privilege become more concentrated and harder to unwind.
• Model Context Protocol: Model Context Protocol is an open protocol that lets AI agents connect to tools and data sources. It expands what an agent can reach, so governance has to cover not only the model and its prompts, but also every system that can receive or return agent-driven data.

What's in the full article

C1.ai's full blog covers the operational detail this post intentionally leaves for the source:

• How the vendor frames MCP-based UX for AI agents in enterprise software
• The specific business assumptions behind platformization and data gravity
• The article's examples of how SaaS differentiation shifts from feature velocity to service depth
• The vendor's own view of how human interaction may shrink as machine interaction grows

👉 C1.ai's full post covers the platform, service, and MCP implications in more detail

Deepen your knowledge

The NHI Foundation Level course covers NHI governance, machine identity security, secrets management, and identity lifecycle control through the industry's only accredited NHI security programme. It helps practitioners translate access risk into a governed operating model across both human and machine workflows.