When Intent Becomes the Interface: Why Applications Are No Longer the Starting Point

For many years, enterprise software has required users to decipher how various applications function.

They have to decide which screen to access, which fields to fill in, which workflows to initiate, which reports to create, and which applications to use next.

Take a sales executive, for example, preparing a renewal proposal. Customer relationships are managed in a CRM system, contract details are stored in SharePoint, support issues are documented in a different platform, and revenue data comes from finance. Conversations relevant to the task are scattered across Outlook and Teams. While the executive knows what needs to be done, the software presents them with a challenge: figuring out how to do it.

Interestingly, a shift is underway. We’re starting to separate the intent to complete work from the applications typically needed to achieve it. Recent innovations by Microsoft, including Copilot, Cowork, Code, Copilot Studio, and Microsoft IQ, indicate that this could be a significant turning point for enterprise software.

Now, the question isn’t just about making applications smarter. What if enterprise software focused on the tasks instead of the applications?

Traditional enterprise software organises business functions into reliable frameworks. ERP systems handle transactions, CRM systems manage customer interactions, and HR platforms oversee employee processes. These systems are not going anywhere. Their data structures, transaction controls, and business rules remain crucial. However, their user experiences were designed for an era where software needed clear instructions at virtually every step.

People have served as the integration layer, gathering information from one system, interpreting it, entering it into another, initiating approvals, and following up when delays occurred. While APIs and automation have enhanced individual tasks, the fundamental model often stayed the same. Users still needed to know which application to access and how to move the resulting information to the next step.

Now, we’re witnessing a transformation in the underlying architecture.

One of Microsoft’s major recent advances is the integration of applications, workflows, and agents through Copilot Studio. These represent fundamentally different functionalities.

Applications offer structured experiences for accessing information, making decisions, and taking actions.

Workflows ensure consistent execution for repetitive tasks, business guidelines, and integrations.

Agents introduce reasoning and adaptability when the next steps aren’t always clear-cut.

Not every business process needs an agent. Not every decision should be based on probability. And not every interaction requires a chat interface.

For instance, an approval for a purchase might need strict policy enforcement, while assessing a unique supplier proposal could benefit from AI reasoning. Similarly, handling a significant exception might need human intervention via a specially designed application.

Microsoft Copilot Studio is merging these capabilities into a more cohesive development environment, aided by agent orchestration, workflow execution, reusable skills, and interconnected tools. Notably, Microsoft revealed in a recent earnings call that over 80% of the Fortune 500 already have active agents built using its low-code tools.

This leads to an insightful architectural guideline: Apply reasoning where the path is uncertain. Employ workflows where the rules are established. Utilise applications where human interaction adds value. This is what I refer to as the Composition Rule.

The breakthrough lies not in replacing one component with another but in their intentional combination.

Returning to our sales executive handling a renewal proposal, instead of switching between multiple systems, they could start with a simple request: Prepare the renewal proposal, including the latest contract terms, unresolved support issues, and account obligations. Highlight any items that need approval.

The system would need to interpret this request, fetch reliable information, apply business regulations, compile the proposal, and identify where human judgment is required. Various Microsoft capabilities can enhance that user experience.

Microsoft 365 Copilot Cowork allows users to delegate intricate, multi-step tasks across interconnected productivity tools.

Work IQ offers context from Microsoft 365 collaboration, while Fabric IQ provides business semantics and insights across enterprise data. Foundry IQ facilitates the use of reusable business knowledge and retrieval. Together, they create the context layer I discussed in The Context Advantage, revealing the potential of intent-driven work.

Dynamics 365 and Power Platform link intelligence to operational records, business processes, and actions. Copilot Studio allows agents to manipulate tools and workflows, ensuring that applications provide structured experiences for human review.

These are complementary building blocks rather than a single automatic execution pathway. Merging them requires strategic solution architecture, connectors, permissions, and orchestration.

The executive receives a comprehensive proposal, supporting documentation, and decisions that need attention. While the foundational systems remain crucial, navigating them may no longer rest solely on the executive’s shoulders.

In classic enterprise architecture, applications arrange functionalities, and users move between them. With an intent-led architecture, the goal itself becomes the organising principle. Applications, workflows, agents, and enterprise services align with that intent.

The application still matters. However, it is no longer the sole focus of the user experience.

There’s another exciting development to note. Microsoft’s Copilot Code and Copilot Studio features are simplifying the creation of software experiences from natural language requirements. Copilot Managed Runtime offers Microsoft-hosted infrastructure for managing applications effectively. These capabilities are progressing through different stages of availability, but the direction is noteworthy.

Traditionally, developing an enterprise application followed a project-based approach: requirements gathering, design, engineering, testing, deployment, and maintenance. This is still vital for complex, mission-critical systems but not every business need demands such an extensive development cycle.

A procurement manager might just need a straightforward interface to compare supplier proposals, or a finance team may require a temporary application to review reconciliation discrepancies. Increasingly, it’s becoming feasible to generate experiences, link them to governed data, and share them with colleagues.

The gap between identifying a business requirement and crafting a useful software experience may shrink significantly.

However, quicker creation raises critical issues. Who owns the generated application? How will it undergo testing? What identities and permissions does it operate under? How is it maintained or eventually retired?

Microsoft Copilot Managed Runtime, currently in preview, addresses some of these challenges by offering managed hosting, Microsoft Entra authentication, and application governance features.

While generating software becomes easier, responsibly managing that software remains a crucial engineering responsibility.

Software creation may evolve to be more accessible, but accountability cannot be overlooked.

As AI integrates deeper into enterprise processes, there’s one distinction I’ve found myself drawing on whiteboards more frequently than any other.

Large language models are valuable for tasks that need interpretation, synthesis, and adaptability. However, enterprises also rely on predictability. An invoice approval threshold shouldn’t vary due to a model’s reasoning changes. A financial transaction must maintain the integrity of the recording system.

Consider an insurance claim process. An agent reviews submitted documents and identifies missing pieces. A workflow enforces established eligibility guidelines and directs the claim. A human reviewer evaluates complex exceptions through an application that presents the pertinent information.

In this scenario, the model aids interpretation, the workflow ensures repeatability, the application facilitates human judgment, and the system of record captures the authoritative transaction.

This also necessitates that business capabilities are accessible beyond application interfaces. APIs, Model Context Protocol (MCP) tools, Power Platform connectors, and reusable services become fundamental building blocks for operationalising intelligent workflows across systems.

Microsoft Copilot Studio supports this progress with workflow triggers, agent handoffs, connected tools, and evaluation capabilities, while Microsoft Foundry complements development, evaluation, tracing, and operational monitoring functions for agents.

Ultimately, the quality of user experience increasingly hinges on how well these capabilities can be integrated—not just on the intelligence of the underlying model.

For enterprise architects, this fosters a more important question than simply where to implement another agent: Which aspects of this process should be intelligent, which need to be deterministic, and which require human input? This illustrates the Composition Rule in practice.

Most architecture discussions bring up a counterpoint. If every employee can create applications and departments can assemble workflows, enterprises might end up replicating decades of software fragmentation at an unprecedented pace. An abundance of individually beneficial applications doesn’t automatically lead to a cohesive enterprise architecture. The solution isn’t to stifle innovation but to build reusable foundations.

This includes unified identity through Microsoft Entra, reliable business semantics via Fabric IQ, sanctioned connectors, and MCP tools, alongside shared engineering standards, managed execution environments, and clear oversight regarding ownership and lifecycle management.

Microsoft Agent 365 introduces an enterprise control framework for identifying, securing, and governing agents across supported environments.

These capabilities tackle various parts of the challenge. They do not eliminate the necessity for enterprise architecture.

As software creation becomes more reachable, shared foundations grow increasingly crucial. Otherwise, we risk simplifying software development while complicating enterprise operation.

I don’t foresee the end of enterprise applications. Businesses will still require ERP, CRM, finance, HR, and industry-specific platforms. Systems of record remain essential. Yet, the relationship between users and applications is evolving.

Today, enterprise users must learn which application serves which purpose. Tomorrow, more experiences might begin with a desired outcome, with intelligence coordinating the capabilities underneath and displaying the appropriate interface when needed.

Sometimes, this interface may take the form of a conversation, other times a generated application, a familiar enterprise screen, or a workflow that completes a task without further interaction.

Microsoft’s integration of Copilot, Copilot Studio, Microsoft IQ, Power Platform, and managed execution infrastructure makes this architectural vision increasingly achievable.

We seem to be transitioning from a landscape where people navigate software to get work done, to one where software is built around the work people need to achieve. Although this shift won’t happen overnight, it calls for robust architecture, reliable data, well-defined execution boundaries, and thoughtful engineering choices.

It compels us to ask a significant question before making the next enterprise software investment: Are we designing yet another application for users to learn, or are we creating a capability that understands the work they aim to complete?

Image Credit: OpenAI