Pattern 3: Workplace and IT services

Agents manage workplace services end-to-end, such as HR, IT help desk, finance, and facilities. They improve reliability, speed, and employee experience. These agents don't just answer questions. They execute service workflows.

In this pattern, agents act as a service, not an assistant. They handle intake, triage, and routine execution autonomously, and they escalate only when they encounter an exception that requires human judgment.

What this pattern is

Workplace and IT services moves agents from answering a question to delivering a service. The agent operates as a service, not as a personal assistant. It resets a password, provisions access, books leave, validates an expense, or routes a purchase order. It escalates anything it can't resolve.

When the agent executes, the four new demands of the execute side apply: a named owner, a defined response when something goes wrong, lifecycle management, and explicit limits on what the agent can do.

What agents do

Agents in this pattern handle the full lifecycle of routine service requests. For example:

  • IT help desk: Password resets, access provisioning, device troubleshooting
  • HR services: Leave requests, onboarding workflows, policy inquiries
  • Finance: Expense validation, invoice processing, budget inquiries
  • Facilities: Room booking, maintenance requests, workplace services
  • Procurement: Purchase order routing, vendor onboarding, approval workflows

This pattern removes friction from the workplace processes that employees interact with every day. When a user submits a leave request, the agent processes it. When a password reset is requested, the agent fulfills it. The goal is a smoother, better employee experience, not just faster ticket resolution.

What humans do

Service owners shift from processing every ticket to governing the service and improving it over time. Their responsibilities become:

  • Defining service levels and what "good" looks like
  • Monitoring quality and performance against those standards
  • Handling escalations that the agent can't resolve autonomously
  • Continuously improving the service based on data and feedback
  • Owning the end-to-end service lifecycle, not just the technology

This role change is significant. Service teams accustomed to ticket volume as a measure of productivity must shift to measuring resolution quality, satisfaction, and cost-to-serve.

How the operating model works

Successfully deploying this pattern requires changes across four dimensions:

Dimension Before After
People Task execution Service ownership and exception handling
Agents Intake + triage Routine end-to-end execution
Governance Tool-level controls Service-level controls with SLAs
Metrics Tickets handled Resolution time + satisfaction + cost per resolution

Target maturity profile

This pattern requires the following minimum maturity levels across the five capability drivers:

Capability driver Target level Why
AI strategy and experience 400 (Capable) The service is part of enterprise operations, not an experiment.
Business strategy 400 (Capable) The scale-breaker. The service flow must be designed end-to-end, not patched task by task.
Governance and security 400 (Capable) Agents act in systems of record, so decision rights and monitoring must be strong.
Technology and data 300 (Defined) Standardized architecture and integration with systems of record.
Organization and culture 300 (Defined) Service teams adapt to governing the service. You don't need to change the whole organization.

Key insight: This pattern requires stronger maturity in Business strategy (400) and Governance (400) than you might expect, because agents run operational services, not just help individuals. Service reliability and escalation discipline become critical.

Scale-breaker: Business strategy, specifically end-to-end service design. If you automate individual tasks without redesigning the service flow, you create islands of automation that don't connect. Design the service first, then build the agents.

Start centralized for control and consistency. As services mature, shift to hybrid: the CoE owns the platform and security guardrails, and service owners run their agents day to day. The CoE owns the platform. Service teams own the agents.

Tip

The make-or-break role for this pattern is the service owner. They must shift from processing tickets to governing a service. The operating model changes completely. If the service owner isn't prepared for this shift, the agent is built and abandoned when issues arise.

Learn more about structure, roles, and risk-tiered governance in Build an agentic Center of Excellence.

What you need and don't need

You need:

  • End-to-end service ownership: A named person accountable for the full service lifecycle, not just the agent build.
  • Decision rights: Define which requests the agent can resolve autonomously and which require escalation. Document this decision before deployment.
  • Monitoring and telemetry: Track uptime, accuracy, resolution time, and user satisfaction from day one.
  • A run model with escalation paths: Know what happens when the agent can't resolve a request. Escalation must be seamless, not an error state.
  • Service-level agreements: Define what "good" looks like and measure against it. Without SLAs, there's no objective standard for success.
  • Integration contracts: Define clear inputs, outputs, and handoffs between agents and the systems they interact with.

You don't need:

  • Domain product ownership: These services are shared services, not business products with a product owner.
  • External identity models: These agents serve internal employees only.
  • Full organizational culture transformation: Service teams adapt. The whole organization doesn't need to change.
  • Custom-built AI infrastructure: Platform capabilities are sufficient for most workplace service scenarios.
  • Perfection before launch: Start with one service and iterate based on data. Don't wait until every edge case is handled.

Value and success metrics

Value shows up as faster, more consistent service at a lower cost to serve, and a better employee experience. Measure the service the way you'd measure any operational service: resolution, speed, cost, and satisfaction.

What value looks like

  • Faster resolution and smaller service backlogs.
  • More consistent, predictable service delivery.
  • Lower cost to serve through automation of routine execution.
  • A better employee experience across IT, HR, and finance.
  • Service teams that focus on outcomes and improvement, not ticket handling.

Success metrics to track

Category Example measures What it tells you
Containment and resolution Auto-resolution rate, deflection rate, ticket-volume reduction, first-contact resolution How much of the service the agent runs without a human.
Speed and reliability Average resolution time, first-response time, SLA adherence, uptime Whether the service is fast and dependable.
Cost and capacity Cost per ticket, hours saved, cases handled per period Whether automation lowers cost to serve and adds capacity.
Experience and quality Employee satisfaction, adoption, automation success rate, escalation rate Whether people trust the service and whether handoffs work.
Governance Exception and error rate, approval-adherence, agent inventory coverage Whether the service stays in control as it scales.

How to measure

Tip

Faster fragments aren't a working service. Automating individual tasks inside a broken flow speeds up the broken parts and leaves the handoffs intact. Redesign the end-to-end service first. Define what the agent resolves and what it escalates. Track the entire flow, not just the automated step.

Learn more:

Common anti-patterns

The failures in this section come from automating pieces instead of designing a service.

Anti-pattern What it looks like What to do instead
Islands of automation Individual tasks are automated, but the handoffs between them aren't. The service still has issues, but some parts are faster. Redesign the end-to-end service first, then build agents to run the whole flow.
No escalation path The agent has nowhere to send a request it can't resolve, so users get stuck. Build a clean handoff to a human with full context for every agent.
Undefined decision rights It's unclear what the agent may resolve on its own versus escalate, so it either overreaches or stalls. Define decision rights explicitly, and require approvals for sensitive actions.
No monitoring or SLA The agent runs without uptime, accuracy, or resolution-time tracking. Problems surface as complaints. Set SLAs and monitor from day one. Treat the agent as a production service.
Waiting for perfect The team delays launch until the agent covers every use case. Start with one well-defined service and iterate on real data.
Treating shared services like products Heavy product-ownership overhead is applied to a shared service. Use shared-service ownership: a service owner accountable for the lifecycle.
No integration contracts Inputs, outputs, and handoffs between agents and systems are improvised. Define integration contracts so agents and systems exchange data predictably.
Ungoverned sprawl Service agents multiply with no registry or oversight. Register agents and govern the estate with Agent 365 and Purview.

Customer stories

These published Microsoft customer stories show agents running internal services with people governing quality.

Customer Reported outcome
Epiq An IT agent handles a wide range of employee IT requests across ServiceNow and Microsoft 365. A companion onboarding automation saves about 2,000 hours a month and more than 500,000 US dollars a year.
Coca-Cola Andina An HR agent answers personalized questions and escalates to the right HR manager through an automated ticket. Used by more than 300 employees, with HR reporting much less time on routine questions.
Microsoft (AskHR) An employee HR-service experience built on Dynamics 365 increased case throughput by 20%, with strong monthly and daily adoption.
LTIMindtree (RAIma) The RAIma HR super-agent in Microsoft 365 Copilot and Teams lets employees apply for leave, book seats, raise asset requests, and create service tickets in chat, across SharePoint, ServiceNow, and HR systems. It handled around 500,000 interactions with more than 78,000 monthly active users, delivered in under four months.
mobilezone Cut incident-resolution time by 50% with an internal IT service-desk agent ("Supporto") in Teams.
La Trobe University The "Troby" agent solves 71% of inquiries, with Copilot Studio agents streamlining internal processes.
Kantar Readied 4,000 HR artifacts in six weeks across 60 countries/regions with a Copilot Studio HR advisory agent (a team of 10 agents).

Microsoft agentic capabilities for this pattern

The following examples highlight capabilities that are particularly relevant to Workplace and IT services. These capabilities let agents act in systems of record, escalate cleanly to people, and be governed as production services. Use these examples as a starting point for matching capabilities to your scenarios and user segments, and then explore Microsoft's agent ecosystem for the complete picture.

Build agents that act

  • Copilot Studio agents with actions and tools answer requests and complete them by calling flows, prompts, and APIs into systems of record.
  • Copilot and Power Platform connectors—more than 1,400 of them, plus custom connectors—integrate agents with ITSM, HR, and finance systems such as ServiceNow, Workday, and SAP.
  • Workflows add deterministic, rule-based automation for the repeatable parts of a service, such as creating a ticket or provisioning access.
  • Autonomous and triggered agents start work from an event or a schedule so a request can be triaged without a person kicking it off.
  • Multi-agent orchestration lets a lead agent route to specialized IT, HR, or finance sub-agents.

Keep a human in control

  • Human-in-the-loop approvals in flows require sign-off for sensitive actions, such as granting access or approving an expense.
  • Escalation and handoff, through the escalate and transfer-conversation capabilities, pass a request to a live agent or service desk with full context when the agent can't resolve it.

Govern and observe at scale

Evaluate and test before you ship

For agents running production services, validate agents before deployment, and run regression tests as services evolve.

  • Agent evaluation in Copilot Studio runs structured evaluations against your agent, scoring responses across quality dimensions such as accuracy, groundedness, and task completion. Use it to verify that routing, escalation, and resolution paths behave correctly before the agent handles live service requests.
  • Copilot Agent Kit (formerly known as Copilot Studio Kit) extends test coverage with bulk testing, automated regression runs, and a scoring dashboard, so you can validate the full range of service scenarios and catch regressions when the agent or its knowledge is updated.

How to know you're ready

Start this pattern if most of these statements are true:

  • You designed the end-to-end service, not just a list of tasks to automate.
  • A service owner is accountable for the full lifecycle.
  • You defined what the agent resolves on its own and what it escalates.
  • You can integrate with the relevant systems of record.
  • You can monitor resolution, accuracy, and satisfaction against a service-level-agreement (SLA).

Next steps

Take the Agent Readiness Assessment

Or explore the full Agentic AI adoption maturity model.

Explore other patterns in more detail:

  • Last updated on