← Voice of Volge
VOLGE · VOICE OF VOLGEMicrosoft · 2026
OUR POINT OF VIEW · MICROSOFT SERVICE OFFERINGS

The unattended agent

The rise of the always-on worker
Voice of Volge: Our Point of View on Microsoft Service Offerings · June 2026
In this point of view

Contents

: About Microsoft
01Executive summary
02Chapter one: Why background agents fail, and what separates the ones that hold
03Chapter two: The engineering core: memory, state, and durable orchestration
04Chapter three: The operating model: triggers, guardrails, and AgentOps for background fleets
05Chapter four: Reference architecture and the adoption roadmap
06Chapter five: Implications for the IT leadership agenda
07Appendices
08Addendum: How Volge's forward-deployed engineers shall help: Digital Product Engineering
Introduction · About Microsoft

About Microsoft

Microsoft, founded in 1975 by Bill Gates and Paul Allen, headquartered in Redmond, Washington, and led by chairman and chief executive Satya Nadella since 2014: is one of the world's most valuable companies (NASDAQ: MSFT). The Microsoft Cloud spans Azure, Microsoft 365, Dynamics 365, Microsoft Security, Microsoft Fabric and GitHub. Volge delivers across that estate through six alliance offerings.

What Volge delivers on Microsoft: six offerings

The offering this book covers: marked ◆: is Digital Product Engineering, delivered on GitHub & GitHub Copilot.

Volge offeringWhat it coversAnchored on
Modern Workspace & E7Secure modern work on the E7 bundle; human-agent collaborationMicrosoft 365 · Copilot
Applied AIBuilding, governing and running enterprise AI agents and appsAzure AI Foundry
Zero Trust SecurityIdentity, threat protection and data governanceMicrosoft Entra · Defender · Purview
Business ApplicationsERP, CRM and low-code, with in-process agentsDynamics 365 · Power Platform
Digital Product Engineering ◆Autonomous software engineering and CI/CDGitHub · GitHub Copilot
Cloud Infrastructure & OperationsCloud build, run and cost governance (FinOps)Microsoft Azure

Sources: Microsoft corporate and product documentation, 2025–26.

This book: Digital Product Engineering on GitHub & GitHub Copilot

GitHub is Microsoft's cloud developer platform for hosting code, collaboration, CI/CD and security; GitHub Copilot is its AI pair-programmer and autonomous coding-agent suite, acquired by Microsoft in 2018 and, by 2026, grown into agentic software engineering.

In the field in 2026

  • Copilot coding agent: a cloud agent that autonomously fixes issues and opens pull requests
  • Agent HQ: run and manage coding agents from multiple vendors (Anthropic, OpenAI, Copilot) in one place
  • The GitHub Copilot app: an agent-native desktop to orchestrate multiple coding agents (2026)
  • GitHub Actions CI/CD and GitHub Advanced Security, with multi-model Copilot (Claude, GPT, Gemini)
01
Chapter

Executive summary

Chapter 01 · Executive summary

A new category of worker entered the enterprise during 2026, and it does not behave like software that came before it. It has no login, waits for no prompt, and observes no shift boundary. It is a background, event-triggered agent that runs continuously, remembers what it has done, and acts within engineered limits. This document calls it the always-on worker. The shift it forces is from artificial intelligence summoned by a person at a keyboard to artificial intelligence that stands by as continuous capacity.

Start with the failure mode, because that is where the engineering reality lives. A background agent that forgets yesterday's work, loses its place when a process restarts, or cannot be coordinated across a workflow that spans hours is not capacity. It is an unattended liability burning tokens. Gartner forecasts that more than 40 per cent of agentic AI projects will be cancelled by the end of 2027, and attributes the failures to weak engineering and governance rather than to model capability (Gartner, 2025). Against that, the same body forecasts that 40 per cent of enterprise applications will carry task-specific AI agents by the end of 2026, up from fewer than 5 per cent in 2025 (Gartner, 2025). The distance between aggressive adoption and a cancellation rate above two in five is the distance this paper measures, and it is an engineering distance, not a model one.

What changed on the supply side is that the hard infrastructure stopped being the enterprise's problem to build. At Build 2026, Microsoft made hosted agents on Foundry run as long-running autonomous workers with durable state, and added routines that place any agent on a timer or schedule (Microsoft, 2026). Microsoft's own framing describes such agents as operating continuously in the background, monitoring data, reacting to conditions, and running workflows at scale (Microsoft Learn, 2026). The plumbing that enterprises previously hand-built, persistent memory, checkpointed state, durable orchestration, now ships as managed infrastructure.

One naming note, stated once and not repeated. Azure AI Foundry became Microsoft Foundry at Ignite on 18 November 2025, formalised in the January 2026 product terms (Microsoft, 2025; SAMexpert, 2026). This document uses the current name throughout.

The thesis of this paper. The model is the part of the always-on stack that is already solved. Memory, durable state, and orchestration are not, and they decide whether a background agent becomes standing capacity or becomes the next cancelled project. The enterprises that capture value treat those three as first-class engineering concerns and wrap the resulting fleet in the operational discipline, governed triggers, engineered guardrails, continuous observability, and runtime cost control, that any unattended system demands.

Two numbers reframe memory from an accuracy feature into a cost control. Microsoft reports that the memory features in Foundry Agent Service deliver an absolute task-success gain of 7 to 14 percentage points when agents learn across runs (Microsoft, 2026). Independent benchmark work shows that a managed, retrieval-based memory layer cuts the active context an agent carries by 70 to 85 per cent, holding roughly 7,000 tokens per retrieval against the 25,000 or more consumed by a full-context approach (Mem0, 2026). For an agent that runs around the clock, every retrieval that replaces a full context dump is money saved on every cycle.

Five conclusions are advanced, each developed in the chapters that follow.

First, three properties define the always-on worker, and the model behind it does not. It is event-triggered rather than prompt-driven. It is persistent, carrying memory across runs. It is autonomous within guardrails. Strip any one property and the engineering category collapses, because each property carries a distinct and non-substitutable engineering requirement.

Second, memory and durable state are the binding constraints. Thread state holds coherence inside a session. Persistent memory holds knowledge across sessions. Durable orchestration holds progress across crashes, restarts, and redeployments. Foundry now supplies a managed layer for each (Microsoft Learn, 2026).

Third, the operating model inverts when the human leaves the screen. A background fleet needs triggers that are governed, guardrails engineered in advance rather than approved per action, observability that runs continuously, and cost controls that stop a single runaway loop from draining a budget. One such loop can exhaust a monthly token allocation in hours (Microsoft, 2026).

Fourth, the architecture is layered and durable by design. A model layer, a tool and data layer, a memory and state layer, a durable orchestration layer, and a governance layer, connected through open standards, let the estate scale and survive failure. Durable Task workflows on Azure run for hours, days, or months, resuming from the last completed step after any interruption (Microsoft Learn, 2026).

Fifth, sequence adoption on engineering readiness, not on enthusiasm. Enterprises stall when they push agents into unattended operation before the memory, durable state, and monitoring exist. The roadmap in chapter four orders the build so that autonomy never outruns control.

Microsoft Foundry is the primary lens here, reflecting its standing as the default model, agent, and data platform of the large Microsoft enterprise. The patterns, persistent memory, durable orchestration, event triggers, fleet observability, are general, and the architecture is portable. Volge's position is plain. Platform commitments have already settled the model decision for most enterprises. The engineering and operating decisions that turn a background agent into reliable standing capacity remain open, and that is where this paper concentrates.


02
Chapter

Chapter one: Why background agents fail, and what separates the ones that hold

Chapter 02 · Chapter one: Why background agents fail, and what separates the ones that hold

The takeaway

A background agent earns its keep only when it holds three properties at once: it is triggered rather than prompted, persistent rather than stateless, and autonomous within guardrails rather than supervised per action. Drop one and the agent reverts to a slower, less reliable version of the interactive assistant it was meant to surpass. The strategic question has moved past whether such workers can exist. It is which workloads carry the process characteristics that survive the move to unattended operation, and under what engineering controls.

2.1 The shift the assistant cannot make

The first wave of enterprise artificial intelligence was tethered to a person. Someone opened an application, typed a prompt, read a response, and moved on. Throughput rose, but it rose in proportion to the attention of the person at the keyboard. This is the copilot pattern, and it remains genuinely useful within its bound.

The always-on worker breaks that bound. Work is initiated not by a person but by an event, a condition, or a clock. The agent runs in the background without per-action supervision and reports an outcome. Microsoft describes this class as agents that perceive events, make decisions, and execute tasks independently, operating continuously in the background to monitor data, react to conditions, and run workflows at scale (Microsoft Learn, 2026).

The economic consequence is the point worth holding. An interactive assistant adds throughput to one person's working day. An always-on worker adds a unit of standing capacity that runs whether or not anyone is present. The working day stops bounding the work. That single shift, from attention-bounded to clock-independent, is why the category earns separate engineering treatment rather than being folded into the copilot.

2.2 Three properties, and the engineering each demands

Loose terminology drives loose engineering, so the definition is set precisely and early. Three properties constitute the always-on worker, and each maps to a distinct layer of the build.

Event-triggered, not prompt-driven. A business event, an external signal through a service such as Azure Event Grid, a schedule, or a timer starts the worker, never a human prompt (Microsoft Learn, 2026). The requirement this creates is a governed trigger surface.

Persistent, not stateless. The worker carries memory across runs. What it learned yesterday informs what it does today. The requirement this creates is a memory and state layer, the subject of chapter two.

Autonomous within guardrails, not supervised per action. No person signs off each step. The worker acts inside engineered limits and escalates exceptions. The requirement this creates is a guardrail, monitoring, and cost-control layer, the subject of chapter three.

The properties are independent, which is precisely why partial implementations fail quietly. An agent can be persistent yet prompt-driven, or autonomous yet stateless. Each combination is a real system someone has shipped, and each is missing a load-bearing layer. Only the agent that holds all three is an always-on worker in the sense used here, and only it carries all three engineering requirements.

2.3 The taxonomy of work, mapped to the worker

Engineering demand rises monotonically as work moves from interactive assistance to autonomous background operation, and that progression, not the department or the function, is the planning insight that decides where to start. The table below sets out four patterns, the trigger for each, the memory each requires, and the human's role.

Pattern What it does Trigger Memory required Human role
Interactive assistant Drafts, summarises, answers within a session Human prompt Thread state only Actor and approver
Supervised agent Plans and executes a task on request; calls tools Human request Thread state; some retrieval Reviewer of outcomes
Scheduled background worker Runs a defined job on a timer or schedule Clock or routine Cross-run memory; durable state Supervisor; exception handler
Event-triggered always-on worker Watches data, reacts to conditions, runs workflows continuously Business event or signal Cross-run memory; durable orchestration Fleet supervisor; exception handler

The two lower rows are the always-on workers, and they are exactly the rows where memory and durable state cross from optional to mandatory. Thread state cannot carry a genuinely continuous workload, because thread state does not survive the gap between runs. Moving a workload into either bottom row is therefore not a model decision dressed up as an operations decision. It is a commitment to build the memory and durable-state layer that the pattern requires, made at the moment the workload is selected.

2.4 The screen that predicts which workloads hold

The always-on worker pays where work is continuous, event-driven or schedulable, rules-bound, and tolerant of a measurable error rate. Microsoft's framing points straight at the candidates: agents that watch queues, triage tickets, reconcile files, produce daily reports, route tasks, and hold context over hours and days (Microsoft, 2026). The leading domains across the IT estate follow.

Data processing. Continuous ingestion, validation, reconciliation, and enrichment of files and records, where the work arrives steadily and the rules are explicit.

Reporting. Scheduled and event-driven report generation, where an agent assembles, summarises, and distributes on a timer. Microsoft cites the canonical case of an agent that monitors a repository overnight, triages new issues by morning, and posts a summary before the working day begins (Microsoft, 2026).

Backend and operations tasks. Overnight issue triage, service-level-agreement risk monitoring, queue watching, ticket triage, and routine remediation, where work flows through systems and actions are well-defined (Microsoft, 2026).

Read those three and the common thread is not the function. It is the process shape: continuity, a clear trigger, rule density, and verifiability. Sporadic, judgement-heavy, or poorly instrumented work is a weak early candidate wherever it sits in the organisation. Screening on process characteristics rather than on department is the recommended basis for the early portfolio, and the table below applies that screen to common IT-estate workloads.

Candidate workload Trigger Memory required Early-portfolio fit
File reconciliation and validation Event or schedule Cross-run rules and exceptions Strong: continuous, rules-bound, verifiable
Overnight issue and ticket triage Schedule or routine Procedural memory of prior triage Strong: schedulable, well-defined actions
Daily and event-driven reporting Schedule or business event User and semantic memory of context Strong: schedulable, verifiable output
Service-level-agreement risk monitoring Business event Durable state across the monitoring window Strong: continuous, clear escalation
Data ingestion and enrichment Event Grid signal Semantic memory of source structure Moderate: depends on source instrumentation
Judgement-heavy case handling Mixed Extensive context Weak: low verifiability, high escalation rate

The screen is characteristic-based, not function-based. A workload qualifies on continuity, a clear trigger, rule density, and verifiability rather than on the department it belongs to.

2.5 The implication for the IT leadership agenda

Capability is no longer the constraint. Trigger surfaces, the memory layer, and the durable runtime now arrive from the platform. The question for the IT estate moves with that supply: not whether a workload can run as a background worker, but whether the memory, durable state, and monitoring that the pattern demands are engineered to a standard that makes unattended operation safe. The rest of this paper answers that question, layer by layer.


03
Chapter

Chapter two: The engineering core: memory, state, and durable orchestration

Chapter 03 · Chapter two: The engineering core: memory, state, and durable orchestration

The takeaway

The hard problem in the always-on enterprise is memory, state, and orchestration, and the model is not on the list. Three distinct mechanisms solve three distinct problems: thread state preserves coherence within a session, persistent memory preserves knowledge across sessions, and durable orchestration preserves progress across failures. Microsoft Foundry now supplies a managed layer for each, retiring the plumbing enterprises once built and operated themselves. The payoff is measured, not asserted: memory that learns across runs raises task success by 7 to 14 percentage points and cuts the context an agent carries by 70 to 85 per cent.

3.1 The bottleneck moved, and it did not move to the model

Through 2026 the industry settled on a finding that reorders the build priorities: the model is no longer the limiting factor for background agents. Coordination overhead between steps and agents becomes the bottleneck, not the individual model calls (MachineLearningMastery, 2026). The hardest part of the stack to build and keep running is the orchestration layer, and the hardest open problems in agent memory are cross-session identity, temporal abstraction at scale, and memory staleness (MachineLearningMastery, 2026; Mem0, 2026).

The cause is structural rather than incidental. An interactive assistant lives for the length of a conversation; its state begins and ends with the session. An always-on worker lives indefinitely. It must remember across runs, survive restarts, and coordinate work spanning hours or days. Those are state-management problems, and a better model does not dissolve them. Engineering effort therefore belongs on memory, state, and orchestration, and the three are taken in turn.

3.2 The three layers of state

An always-on worker needs three mechanisms, each solving a different problem and each engineered separately. The diagram distinguishes them.

Volge schematic

Thread state is the in-session conversation context. Foundry manages this short-term, in-session state server-side through a built-in conversation and thread model (Microsoft Learn, 2026). It preserves coherence while a run is in progress and, by design, does not persist across the gap between runs.

Persistent memory is the durable knowledge the worker carries across sessions: the mechanism that lets an agent remember what it learned yesterday. Section 3.3 examines it.

Durable orchestration state is the record of progress through a long-running workflow: the mechanism that lets a workflow resume from its last completed step after a crash. Section 3.4 examines it.

The discipline is to keep the three apart. Microsoft's own framing is that separating ephemeral session context from durable user memory preserves conversational coherence while avoiding uncontrolled accumulation of long-term state within the agent runtime (Microsoft Learn, 2026). Conflate them and the agent either forgets too much or hoards state without limit.

3.3 Persistent contextual memory

Memory in Foundry Agent Service reached public preview in late 2025 and was extended at Build 2026 (InfoQ, 2025; Microsoft, 2026). It provides a managed long-term store that automates the extraction, consolidation, and retrieval of context, giving the agent a native state layer instead of obliging the enterprise to build and operate the plumbing (InfoQ, 2025).

The service now separates memory by kind. User memory holds preferences and facts across sessions. Semantic memory holds durable facts about the business and its entities, independent of any one user. Procedural memory, new at Build 2026, lets an agent learn how to do the work across runs rather than only recall what was said (Microsoft, 2026). The change is from retrieval-augmented generation, which behaves like a search engine over documents, to a persistent-state layer that consolidates durable knowledge (InfoQ, 2025).

By the numbers. Microsoft reports these memory features delivering a 7 to 14 percentage-point absolute gain in task success when agents learn across runs (Microsoft, 2026). Independent benchmark work shows a managed memory layer cutting active context by 70 to 85 per cent and holding roughly 7,000 tokens per retrieval against 25,000 or more for a full-context approach, while keeping recall above 91 per cent on long-horizon benchmarks (Mem0, 2026).

The control surface matters as much as the accuracy gain, and for an unattended worker it matters more. Foundry memory supports item-level create, read, update, and delete operations, store-level retention through a time-to-live setting, and direct commands for immediate remember-or-forget behaviour (Microsoft Learn, 2026). Retention limits and forget-on-command are governance requirements for an agent no one is watching, not conveniences. Without them, long-term state accumulates without bound and without audit, which is how a persistent agent quietly becomes a compliance exposure.

The lifecycle of a single memory item is shown below.

Volge schematic

3.4 Durable orchestration

Durable orchestration is the layer that separates a production background worker from a prototype, and the reason is brutally practical. An always-on worker runs unattended for long stretches. It will meet process crashes, restarts, scaling events, and redeployments, not as exceptions but as routine. Without durable state, each of those wipes the agent's place and forces the work to begin again, which on a multi-hour workflow means paying the token cost twice and missing the deadline once.

Azure Durable Functions, and the underlying Durable Task framework, supply the mechanism. The runtime manages state, checkpoints, retries, and recovery, so workflows run reliably for long periods (Microsoft Learn, 2026). Durable Task workflows run for hours, days, or even months, resuming from the last completed step after any crash, restart, or redeployment (Microsoft Learn, 2026). Agent sessions survive process crashes, restarts, and scaling events without losing context (Microsoft Learn, 2026).

At Build 2026, Microsoft wired this substrate directly into agents. The Durable Task extension for the Microsoft Agent Framework coordinates specialised agents in deterministic workflows with automatic checkpointing and failure recovery (Microsoft Learn, 2026). Microsoft also previewed a serverless agents runtime for Azure Functions, letting agents be defined in markdown files and run with auto-scaling, event-driven triggers, and durable functions for stateful conversations (Windows News, 2026).

The principle reduces to one rule: checkpoint progress, do not hold it in memory. An interactive agent can keep its state in process because it lives only for the session. An always-on worker cannot, because it lives indefinitely and will be interrupted. Durable orchestration makes interruption survivable, which makes it non-negotiable for any workload that outlives a single short invocation.

3.5 The Foundry hosted runtime

The hosted-agents runtime brings the layers above together, and it moved towards general availability in mid-2026 (Microsoft, 2026; InfoQ, 2026). It runs production agents in a managed runtime where every session sits in its own sandbox with dedicated compute, memory, and filesystem access (Microsoft, 2026). The runtime supports long-running autonomous agents with durable state and adds routines, in public preview, that put any agent on a timer or schedule (Microsoft, 2026).

It is framework-agnostic. Agents built with the Microsoft Agent Framework, the GitHub Copilot software development kit, LangGraph, or other kits deploy without rewrites (Microsoft, 2026). The significance for an enterprise is that memory, durable state, and orchestration come from the platform rather than being rebuilt for each agent. This is the plumbing that the most underestimated cost of an agent programme has always hidden in, and Foundry now ships it as managed infrastructure.

3.6 The implication for the IT leadership agenda

The engineering core of the always-on enterprise is the memory, state, and orchestration layer, and Microsoft Foundry now supplies a managed form of each. The model layer is largely a commodity, substitutable as price and capability evolve. The state layer is where reliability is won or lost. The leadership decision follows directly: direct engineering effort at memory, durable state, and orchestration first, and treat the model as the layer most safely deferred. Chapter three governs the workers this core produces.


04
Chapter

Chapter three: The operating model: triggers, guardrails, and AgentOps for background fleets

Chapter 04 · Chapter three: The operating model: triggers, guardrails, and AgentOps for background fleets

The takeaway

Take the human off the screen and every assumption behind the interactive operating model breaks. A background fleet therefore needs four disciplines engineered in: governed triggers that start work safely, guardrails that replace per-action approval, continuous observability that makes unattended behaviour visible, and cost controls that stop a single runaway loop from draining a budget. The absence of a person in attendance is exactly what makes these mandatory rather than advisable. One runaway loop can exhaust a monthly token budget in hours, which makes cost control an engineering control in the runtime, not a finance report after the fact.

4.1 The trigger surface

Something other than a person starts an always-on worker, and that something is the first thing to govern. An ungoverned trigger is an uncontrolled entry point into autonomous action: the background equivalent of an unauthenticated endpoint.

Three trigger types run in production across the Microsoft estate. Agents can be scheduled to run at set times, triggered by external events through Azure Event Grid, or triggered by business events raised inside line-of-business systems (Microsoft Learn, 2026). Foundry routines add a managed timer and schedule for any agent (Microsoft, 2026). Copilot Studio exposes the same model: connect business events to agents and event-driven automation runs without a user prompt (Microsoft Learn, 2026).

Govern the trigger by registering, owning, and rate-limiting every one. A trigger that fires more often than expected, or that connects to an agent with no owner, is an open door into autonomous action. Treat the trigger as part of the agent's identity and subject it to the same registration discipline as the agent itself, because in operational terms it is the agent's ignition.

4.2 Guardrails in place of per-action approval

The interactive model leans on a human approving consequential actions. The background model has no human to lean on, so the approval a person would grant per action must be engineered into the agent in advance.

Microsoft frames the autonomous agent as operating through triggers, instructions, and guardrails (Microsoft Learn, 2026). The guardrails are the engineered substitute for human approval. They define the data the agent may touch, the actions it may take, the limits within which it may act, and the conditions under which it must escalate to a person rather than proceed.

A guardrail is only a control if it is explicit and testable. A limit that exists solely as a line in a prompt is a suggestion the model may ignore under pressure. A limit enforced by the runtime, logged when it fires, and tested against defined scenarios is a control. The migration from supervised to background operation is, stripped to its engineering, the migration from human-in-the-loop approval to engineered-and-tested guardrails, and it is only sound where those guardrails are demonstrably in place and demonstrably exercised.

4.3 Observability for the unattended fleet

An unattended worker produces no natural moment at which a person inspects its behaviour, so observability has to run continuously to manufacture one. What an interactive user would catch on the screen must instead be surfaced by instrumentation, span by span.

Foundry provides end-to-end tracing on OpenTelemetry, following every agent run from input through each tool call (Microsoft, 2026). Every tool call, model invocation, and handoff lands in a single trace view, whatever framework produced the agent (Microsoft, 2026). The OpenTelemetry GenAI conventions define agent, workflow, tool, and model spans, together with the required latency and token-usage metrics (Microsoft, 2026). Building to this emerging standard preserves one observability model across a multi-framework estate, rather than a different dashboard per agent kit.

Evaluation runs continuously for the same reason. Foundry supports evaluation in the playground, on test datasets in a continuous-integration pipeline, continuously on production traffic, and on a schedule to catch drift (Microsoft, 2026). A worker that behaves non-deterministically and runs without supervision makes scheduled and continuous evaluation a standing requirement, not a one-time acceptance test that a release passes once and never repeats.

The end-to-end path of an event-triggered worker, including where it is observed and governed, is shown below.

Volge schematic

4.4 Cost and runaway control

The economic risk of a background fleet has a different shape from anything an interactive deployment carries, and it follows directly from the missing human. An interactive session ends when the person walks away. A background loop does not end; it iterates until something stops it. One runaway loop can burn a monthly token budget in hours (Microsoft, 2026). Cost control is therefore an engineering control applied in the runtime, not a finance function applied after the invoice.

Foundry provides per-agent and per-model cost attribution, which becomes essential to budgeting and optimisation as agent counts climb (Microsoft, 2026). Unified dashboards track agent cost, performance, and safety in one view (Microsoft, 2026). The discipline is to set a budget, a token ceiling, and a maximum run frequency per agent, and to halt or alert the moment any one is breached. Memory pays in again here: a managed layer that cuts context by 70 to 85 per cent cuts the token cost of every single run (Mem0, 2026), which compounds across a fleet that never stops cycling.

4.5 AgentOps for background fleets

The four disciplines above are the operations function for an always-on fleet, increasingly named AgentOps. It runs as a continuous operational framework integrating observability, evaluation, governance, cost control, resilience, and versioning across the agent lifecycle. It is the discipline that turns a pile of background scripts into a reliable, accountable, and scalable enterprise layer.

The table sets out how the operating model differs between an interactive agent and a background fleet. Every row traces back to one fact: there is no human in attendance.

Concern Interactive agent Always-on background fleet
Start Human prompt Governed trigger, schedule, or event
Approval Human approves per action Engineered, tested guardrails
Visibility User sees the screen Continuous OpenTelemetry tracing
Evaluation Acceptance test at release Continuous and scheduled drift detection
Cost ceiling Bounded by session length Explicit budget, token, and frequency limits
Failure User retries Durable checkpoint and automatic resume
Memory Thread state for the session Persistent cross-run memory with retention

4.6 The implication for the IT leadership agenda

The operating model for background workers is defined by one absence: the human in attendance. Governed triggers, engineered guardrails, continuous observability, and runtime cost control all exist to replace a supervision that is no longer there. The leadership decision is to stand up the AgentOps function before the first unattended worker reaches production, not after the first runaway loop reaches the budget. Chapter four lays out the architecture that supports this fleet.


05
Chapter

Chapter four: Reference architecture and the adoption roadmap

Chapter 05 · Chapter four: Reference architecture and the adoption roadmap

The takeaway

A durable always-on architecture is layered and built to fail without losing work. It separates the model layer, the tool and data layer, the memory and state layer, the durable orchestration layer, and the governance layer, and connects them through open standards so the estate scales and spans frameworks without re-engineering. The roadmap that follows is staged on engineering readiness: one scheduled worker on managed state, proven under full observability, extended to an event-triggered fleet only as the memory, durable orchestration, and AgentOps disciplines mature. Build the state layer before the autonomy, every time.

5.1 A reference architecture in five layers

The architecture below is anchored to Microsoft Foundry, consistent with the paper's primary lens, and the layering is portable. Stating it as layers buys one thing that matters: each layer can be sourced, governed, and replaced on its own, without disturbing the others.

Volge schematic

The model layer. Foundry models, reached through a single platform that supports multiple providers (Microsoft, 2025). The principle is model independence, so the model swaps out as price and capability move.

The tool and data layer. The connectors, application programming interfaces, and data sources the worker acts upon, exposed through the Model Context Protocol. This is the layer through which a background worker reads and writes the systems it operates against.

The memory and state layer. Thread state, persistent memory, and durable checkpoints, as set out in chapter two. This is the layer that separates an always-on worker from an interactive agent, and the layer most often missing from a stalled programme.

The durable orchestration layer. The Durable Task framework, the Microsoft Agent Framework, and Foundry routines, which plan, sequence, checkpoint, and resume the work (Microsoft Learn, 2026; Microsoft, 2026).

The governance layer. Identity, guardrails, observability, and cost control, spanning the estate rather than embedded per agent. This is what lets a single control plane govern a fleet built across frameworks.

5.2 Build, buy, or compose

The architecture sharpens the make-or-buy decision, which is better framed as build, buy, or compose.

Buy a pre-built agent where a vendor offers one matched to a standard background process and that process does not differentiate the enterprise. Fastest return, lowest operating burden.

Compose a worker from existing tools, connectors, and the managed memory and orchestration layers, on Foundry or in Copilot Studio, where the process is specific to the enterprise but built on standard systems. This is the modal choice for most background workloads and the one the Foundry estate is tuned for, because memory, durable state, and observability are supplied rather than rebuilt.

Build a bespoke worker only where the process is both differentiating and unsupported by available tooling. Hold the bar high, because a bespoke background worker carries the full weight of memory, durable state, monitoring, and cost control on its own.

Default to compose. Reserve buy for commoditised processes and build for genuine differentiation.

5.3 The adoption roadmap

The roadmap is staged on engineering readiness because the disproportionate share of failures comes from workloads pushed into unattended operation before the state and monitoring layers were ready. Sequencing is the intervention.

Volge schematic

Stage one, the first 90 days: one scheduled worker on managed state. Pick a single workload that clears the characteristic screen of chapter one: continuous or schedulable, rules-bound, verifiable. Compose a scheduled worker using Foundry routines and the managed memory layer. Instrument it with OpenTelemetry tracing from the first run, not the first incident. The objective is one audited, observable background worker in production, not a spray of pilots.

Stage two, months three to nine: durable orchestration and engineered guardrails. Extend the worker onto the Durable Task substrate so it survives crashes and restarts. Replace any remaining per-action approval with engineered, tested guardrails. Set explicit budget, token, and frequency ceilings. The objective is a worker that runs unattended and survives failure within demonstrable limits.

Stage three, months nine to eighteen: the event-triggered fleet. Move from schedules to governed event triggers. Extend to adjacent workloads. Introduce coordination across workers where it is governed. Run the result as a fleet through the AgentOps function. The objective is a portfolio of always-on workers under continuous observability and cost control.

The cadence is deliberately conservative on autonomy and aggressive on the state and monitoring layers. That is the exact inverse of the failed-project pattern, in which autonomy races ahead of the engineering that would have made it safe.

5.4 An always-on maturity model

The model below gives leadership a way to locate the enterprise and define the next increment. It is the diagnostic counterpart to the roadmap.

Level Description Memory and state Operating discipline Typical outcome
0: Interactive only Prompt-driven assistants; no background work Thread state only None for background No standing capacity
1: Scheduled A scheduled worker on a timer or routine Managed persistent memory Tracing in place First background job in production
2: Durable Long-running workers that survive failure Durable checkpoints; cross-run memory Guardrails and cost ceilings Unattended workers that resume after crashes
3: Event-triggered fleet Multiple workers started by governed events Full memory and orchestration layer AgentOps; continuous evaluation Standing capacity across processes
4: Coordinated estate Workers coordinating across frameworks Estate-wide state and observability Fleet supervision; human-on-exceptions Process-level continuous operation

Most large enterprises sit between Level 0 and Level 1 as of mid-2026, consistent with Gartner's finding that task-specific agents were present in fewer than 5 per cent of enterprise applications in 2025 (Gartner, 2025).

5.5 The implication for the IT leadership agenda

The architecture and the roadmap are one decision viewed from two angles, and both are inseparable from the engineering core of chapter two and the operating model of chapter three. The layered architecture supplies the memory, durable state, and orchestration that make a background worker reliable. The staged roadmap keeps unattended operation from outrunning the monitoring and cost control that make it safe. The enterprise that builds the state layer first, composes by default, and migrates only on the evidence of audited, observable runs is the enterprise that converts the always-on worker into standing capacity.


06
Chapter

Chapter five: Implications for the IT leadership agenda

Chapter 06 · Chapter five: Implications for the IT leadership agenda

The always-on worker is the operating-model change that follows the move from copilot to autopilot, and the evidence assembled here resolves to a small set of clear conclusions for the IT leadership team.

Supply is settled. The triggers, the managed memory layer, and the durable runtime now arrive from Microsoft Foundry and the surrounding Azure substrate. The constraint is the enterprise's own capacity to engineer and operate that capability safely, a matter of memory, state, orchestration, and operating discipline, not of model selection. The returns are real and conditional in equal measure: they land only on the far side of reliable, observable, unattended operation, a threshold most enterprises have yet to cross.

Five questions are recommended for the IT leadership agenda. First, is engineering effort directed at the memory, state, and orchestration layer first, or at the model. Second, does every background worker carry persistent memory with defined retention, and durable orchestration that survives a crash. Third, is every trigger governed, owned, and rate-limited, and is every guardrail engineered and tested rather than written as a prompt instruction. Fourth, is observability continuous and cost control enforced in the runtime, so that no unattended loop can run blind or drain a budget. Fifth, is adoption staged on engineering readiness, so that unattended operation never outruns the state and monitoring that make it safe.

Volge's role sits in the engineering and the operating model. Microsoft Foundry commitments have already settled the model decision for most enterprises. The disciplines that turn a background agent into reliable standing capacity, the memory and state layer, durable orchestration, governed triggers, engineered guardrails, and the AgentOps function, are where programmes succeed or stall, and they are where Volge concentrates its work. Volge looks forward to discussing the application of this framework to specific operating contexts in detail.


07
Chapter

Appendices

Chapter 07 · Appendices

Appendix A: Capability comparison: interactive agent versus always-on worker

Capability Interactive agent Always-on worker Foundry mechanism
Initiation Human prompt Event, schedule, or signal Event Grid triggers; Foundry routines
Lifespan One session Indefinite Hosted-agents runtime with durable state
Within-session state Thread state Thread state Server-side conversation and thread model
Cross-session knowledge None by default Persistent memory User, semantic, and procedural memory
Failure recovery User retries Checkpoint and resume Durable Task framework
Coordination Single agent Multi-agent workflows Agent Framework with Durable Task extension
Observability Optional Continuous and mandatory OpenTelemetry-based tracing
Cost control Bounded by session Runtime budget and ceilings Per-agent, per-model cost attribution
Isolation Shared Sandbox per session Dedicated compute, memory, filesystem

Sources: Microsoft and Microsoft Learn, 2025–2026. Several capabilities (memory, routines, hosted agents) were in public preview as of June 2026; reconfirm general-availability status before relying on them.

Appendix B: Implementation and governance checklist for background workers

The following is a minimum control set for moving a workload to unattended background operation.

Trigger and initiation

  • Every trigger is registered, owned, and rate-limited.
  • Schedules and event subscriptions are documented and reviewed.
  • A maximum run frequency is set per worker.

Memory and state

  • Persistent memory is configured with a defined retention or time-to-live.
  • Item-level forget and audit are available and tested.
  • Long-running work is checkpointed through durable orchestration, not held in process.
  • Resume-after-crash is tested, not assumed.

Guardrails and authority

  • Data scope and permitted actions are defined and enforced in the runtime.
  • Escalation conditions are defined; the worker escalates rather than proceeds on exception.
  • Guardrails are tested against predefined scenarios, not written only as prompt instructions.

Observability and evaluation

  • OpenTelemetry tracing is enabled from the first production run.
  • Continuous and scheduled evaluation is configured to detect drift.
  • Every run, tool call, and handoff is captured in a single trace view.

Cost control

  • A token budget and a cost ceiling are set per worker.
  • Per-agent and per-model cost attribution is monitored.
  • A halt or alert fires when a budget, token, or frequency limit is breached.

Ownership and resilience

  • A named owner is accountable for each worker.
  • Version control and rollback are in place.
  • An estate-wide halt and credential revocation are tested.

Appendix C: Glossary

  • Always-on worker. A background, event-triggered agent with persistent contextual memory that runs autonomously within guardrails.
  • AgentOps. The operations discipline integrating observability, evaluation, governance, cost control, resilience, and versioning across the agent lifecycle.
  • Durable orchestration. A pattern in which workflow progress is checkpointed so that a long-running process resumes from its last completed step after a crash, restart, or redeployment.
  • Durable Task framework. The Azure substrate that provides durable, stateful, long-running workflows, extended at Build 2026 to coordinate AI agents.
  • Event trigger. A business event, external signal, schedule, or timer that starts an agent run without a human prompt.
  • Microsoft Foundry. Microsoft's model, agent, and tool platform, renamed from Azure AI Foundry at Ignite, November 2025, and formalised in the January 2026 product terms.
  • Foundry Agent Service. The managed service within Foundry for building and running production agents, including the memory, routines, and hosted-agents capabilities.
  • Hosted agents. A Foundry runtime in which each agent session runs in its own sandbox with dedicated compute, memory, and filesystem, supporting long-running autonomous workers.
  • MCP (Model Context Protocol). An open protocol standardising how an agent connects to tools and data.
  • Persistent memory. A managed store that extracts, consolidates, and retrieves durable knowledge across sessions, distinct from in-session thread state.
  • Procedural memory. Memory that allows an agent to learn how to perform a task across runs, introduced in Foundry at Build 2026.
  • Routine. A Foundry capability that operationalises any agent on a timer or schedule.
  • Thread state. In-session conversation context, managed server-side by Foundry, that preserves coherence within a run but does not persist across runs.

Appendix D: Sources

This paper draws on the following, accessed June 2026. Figures are attributed in-text to their primary source. Where a statistic appears across multiple secondary outlets, the most authoritative primary attribution is given.

  • Microsoft: Foundry Agent Service, hosted agents, routines, memory (user, semantic, and procedural), observability, and cost-attribution announcements at Build 2026 and on the Microsoft Foundry Blog.
  • Microsoft Learn, guidance on memory in Foundry Agent Service, thread and conversation state, autonomous agents and event triggers in Copilot Studio, the Durable Task framework, and the Agent Framework Durable Task extension.
  • Microsoft: Ignite, November 2025, renaming of Azure AI Foundry to Microsoft Foundry and the "AI app and agent factory" positioning.
  • SAMexpert: Microsoft Product Terms update, January 2026, formalising the Microsoft Foundry name.
  • InfoQ: coverage of the Foundry Agent Service long-term memory preview (December 2025) and the Build 2026 runtime, tooling, and governance updates (June 2026).
  • Gartner: forecast that 40 per cent of enterprise applications will feature task-specific AI agents by the end of 2026 (up from fewer than 5 per cent in 2025), and that more than 40 per cent of agentic AI projects will be cancelled by the end of 2027.
  • Mem0: State of AI Agent Memory 2026 and the 2026 token-optimisation analysis on memory benchmarks, context reduction, and token-per-retrieval figures.
  • MachineLearningMastery: analyses of 2026 production-scaling and orchestration challenges for agentic AI.
  • Windows News: coverage of the serverless agents runtime for Azure Functions previewed at Build 2026.
  • McKinsey & Company: generative-AI value-pool estimates referenced for macroeconomic context.

08
Chapter

Addendum: How Volge's forward-deployed engineers shall help: Digital Product Engineering

Chapter 08 · Addendum: How Volge's forward-deployed engineers shall help: Digital Product Engineering

The Volge engagement team

Volge delivers through one accountable team that runs from the boardroom to the production branch. Four roles carry the engagement, and they hold their remit from the first workshop to operational handover rather than handing off between phases.

Role What they own
Principal The client relationship and the account. Sets the engagement's business outcomes, the governance cadence, and the value tracking, and stays the single point of accountability throughout.
Architect The target architecture and the transformation roadmap. Sequences the work, sets the standards, and makes the platform, build-versus-buy, and control-design calls.
Principals The senior engineering leads. Each owns a workstream, makes the hard technical calls, sets the quality bar, and mentors the embedded engineers.
Forward-deployed engineers The embedded build. They sit inside the client's team, build and ship in the client's own environment, and own the last mile to production.
Volge schematic

The Principal holds the outcome, the Architect holds the design, the Principals hold the workstreams, and the forward-deployed engineers hold the keyboard, one team, accountable from strategy to shipped software.

Volge delivers this work through forward-deployed engineers, and the always-on worker described in this paper is, in the end, a production-software problem before it is a model problem. A forward-deployed engineer is a senior Volge engineer embedded directly in the client's team, building and shipping in the client's own environment, its cloud tenancy, its repositories, its pipelines, and staying through to production rather than handing a slide deck across a wall. The Digital Product Engineering practice exists to turn the argument advanced here, that durable, memory-bearing, autonomous agents become standing capacity only when they are engineered, observed, and operated as production systems, into systems that hold under load, with the engineer who designed them present when they first run unattended.

The model matters precisely because the failure modes this paper sets out live in the last mile. The forward-deployed engineer owns the real-world engineering that separates a prototype from standing capacity: durable state and persistent memory, orchestration and idempotency, runaway-loop and backpressure handling, observability and SRE, and the disciplined path from a working demonstration to a production system that resumes after a crash. That work is done inside the client's estate, against the client's data and constraints, not in a reference environment that will never see production traffic.

The arrangement benefits the firm and the client together. Embedding closes the feedback loop: what the engineer learns in the client's runtime feeds the next increment directly, with no translation layer between the people who observe a problem and the people who fix it. Each engagement also deposits reusable accelerators and reference architectures, golden-path templates, durable-orchestration patterns, AgentOps tooling, that compress the next build. The relationship is structured around outcomes: a production worker proven under full observability, not a quantity of delivered artefacts. Outcome figures cited in any engagement are illustrative until measured against the client's own baseline.

What the forward-deployed engineer delivers

The Digital Product Engineering practice treats the agent estate as a product to be built, run, and continuously improved rather than a portfolio of projects to be finished. The capability set the embedded engineer brings maps directly onto the layers this paper identifies as binding: memory, durable state, orchestration, and the operating discipline around them.

Capability Client outcome
Custom software and product engineering Bespoke workers built only where a process both differentiates and is unsupported by packaged tooling, with the memory, durable state, and cost control carried as engineered concerns rather than afterthoughts.
Cloud-native build on Azure Workloads composed from managed services, App Service, Functions, Container Apps, and Azure Kubernetes Service, so durable orchestration and elastic scale arrive from the platform rather than being rebuilt per agent.
Application modernisation Monoliths decomposed by strangler-fig migration into independently deployable, Azure-native services, with AI-assisted tooling compressing the mechanical work of assessment, transformation, and containerisation.
Agent and app engineering Background workers composed on the managed memory, routine, and durable-orchestration layers, framework-agnostic across the Microsoft Agent Framework, LangGraph, and adjacent kits, so the model layer stays substitutable.
DevOps and platform engineering A governed path from commit to production, CI/CD on GitHub or Azure DevOps, golden paths, GitOps, and an internal developer platform, so a worker reaches production through a paved road rather than a bespoke pipeline.
API engineering and governance A managed gateway fronting enterprise services, enforcing authentication, throttling, and policy at the edge, so an agent's trigger surface and tool access are a governed product surface, not a sprawl of open endpoints.
Quality, SRE, and observability Continuous OpenTelemetry tracing, scheduled and continuous evaluation, runtime cost ceilings, and resume-after-crash tested rather than assumed, the AgentOps disciplines this paper names, engineered in from the first production run.

The delivery lifecycle

The embedded engineer runs each engagement through a staged lifecycle that holds autonomy behind engineering readiness, in the same cadence the adoption roadmap of chapter four recommends. The build of the state layer precedes the grant of autonomy at every stage.

Volge schematic

The Volge difference

Four engineering distinctions characterise the embedded model, each drawn from the failure modes this paper sets out.

Production-grade by default. A worker is delivered to a production standard, instrumented, cost-bounded, and version-controlled, from its first run rather than retrofitted after the first incident. The line a prototype crosses to become production capacity is exactly the line the practice is built to hold.

Durable-state and orchestration expertise. The practice concentrates its effort where this paper locates the binding constraint: persistent memory with defined retention, checkpointed durable orchestration that resumes from the last completed step, and the discipline of keeping ephemeral session state apart from durable knowledge.

SRE and observability as a standing function. An unattended worker produces no natural moment of inspection, so the practice manufactures one, continuous tracing, scheduled drift detection, and runtime budget, token, and frequency ceilings that halt or alert the moment a limit is breached.

Accelerators and paved roads. Golden-path templates, AI-assisted modernisation tooling, and reusable platform patterns compress the mechanical work, so engineering effort concentrates on what differentiates the workload rather than on rebuilding the plumbing each time.

Capability mapped to outcome

The map below traces each engineering capability through to the standing-capacity outcome it secures.

Volge schematic

A concrete first step is offered for enterprises that wish to test the argument against their own estate rather than in the abstract.

A first step. A focused discovery engagement selects one workload from the IT estate that clears the characteristic screen of chapter one, continuous or schedulable, rules-bound, and verifiable, and engineers it into a single audited, observable background worker on managed memory and durable orchestration. The objective is one production worker proven under full observability, not a spray of pilots; the staged roadmap of chapter four then extends it toward an event-triggered fleet as the disciplines mature. Where an outcome figure is cited in such an engagement, it is to be treated as illustrative until measured against the client's own baseline. Volge would welcome a working session to apply this framework to a specific operating context.


Prepared by Volge · June 2026. This document is a point of view intended to inform technology decision-making. It is not legal, financial, or investment advice. Several Microsoft Foundry capabilities described here, including persistent memory, routines, and hosted agents, were in public preview as of June 2026; product names, availability, and figures should be reconfirmed before they are relied upon, as the agentic-AI field is moving rapidly. Statistics are attributed to their sources and were accurate to the best of available knowledge as of June 2026.

VOLGE

Voice of Volge: the firm's point of view on the technology it delivers. Sourced, year-stamped, and built to be handed to a board.

Volge is an independent deep-tech enterprise service provider and premier Microsoft delivery partner. That interest is disclosed; the analysis in this book is independently sourced.

Voice of Volge: Our Point of View on Microsoft Service Offerings · June 2026
Figures are sourced and were accurate as of June 2026. Not investment advice.