Azure Pipelines has traditionally used a concurrency-based model for Microsoft-hosted agents. You purchase or receive parallel-job capacity, and that capacity determines how many hosted jobs can run at the same time.
Azure DevOps now also provides GitHub-hosted agents for Azure Pipelines with a different pricing model: pay as you go.
With this model, pipeline execution is charged per minute based on the selected agent size. GitHub-hosted agents provide access to larger machine configurations, including Apple Silicon macOS options and larger Linux and Windows machines. The GitHub-hosted Agents pool is separate from the existing Azure Pipelines pool.
For DevOps teams, the important change is not simply the price calculation. It changes how teams should think about pipeline capacity, machine size, cost control, and workload placement.
What Are Hosted Agents?
A hosted agent is a virtual machine provided by the CI/CD platform to execute a pipeline job.
A simplified Azure Pipelines workflow looks like this:
Developer Push
|
v
Azure Pipeline
|
v
Hosted Agent
|
+-- Checkout
+-- Restore
+-- Build
+-- Test
+-- PublishWith Microsoft-hosted agents, Azure Pipelines traditionally uses a parallelism-based model.
The newer GitHub-hosted agent model works differently:
Pipeline Job
|
v
GitHub-hosted Agent
|
v
Pay for Execution MinutesThe agent size determines the per-minute rate.
This allows teams to select more powerful machines when a workload actually needs additional CPU, memory, storage, or Apple Silicon.
What Changed With Pay-as-You-Go?
The main difference is the billing model.
Microsoft-hosted agents:
Capacity
|
v
Parallel Jobs
|
v
Concurrency-Based BillingGitHub-hosted agents:
Pipeline Execution
|
v
Agent SKU
|
v
Minutes Used
|
v
Pay-as-You-GoGitHub-hosted agents do not use the existing parallel-job concurrency model. Jobs using this pool are metered by execution time instead.
There is also no free tier or free minutes for GitHub-hosted agents under the pay-as-you-go model.
Existing Pipelines Do Not Automatically Change
This is an important point for teams worried about unexpected billing.
Enabling GitHub-hosted agent billing does not automatically move existing pipelines to the new pool.
Existing pipelines continue using the Microsoft-hosted Azure Pipelines pool unless their configuration is changed to target the GitHub-hosted Agents pool.
The architecture therefore looks like:
Azure DevOps
|
+-----------+-----------+
| |
v v
Azure Pipelines Pool GitHub-hosted Agents
| |
v v
Parallelism Model PAYG MinutesThis gives organizations the option to migrate individual workloads rather than changing everything at once.
How to Use a GitHub-Hosted Agent
After the GitHub-hosted Agents pool is available, a YAML pipeline can explicitly select it.
For example:
pool:
name: 'GitHub-hosted Agents'
vmImage: 'macos-26-arm64'
steps:
- checkout: self
- script: |
uname -a
sw_versThe important part is the combination of:
name: 'GitHub-hosted Agents'and the required VM image.
Microsoft's current documentation includes Apple Silicon macOS images such as macos-26-arm64 and macos-26-arm64-xl.
Why Larger Agents Matter
Not every pipeline needs a large machine.
A small application might run perfectly well on a standard hosted agent.
A large build can be different.
For example:
Large Repository
|
+-- Restore dependencies
+-- Compile many projects
+-- Run tests
+-- Build containers
+-- Package artifactsSuch a pipeline may benefit from additional CPU, memory, or disk capacity.
The pay-as-you-go model allows the team to select a larger machine for that workload instead of treating every pipeline as if it needs the same hardware.
The goal should be to match compute capacity to workload requirements.
Pay-As-You-Go Does Not Automatically Mean Cheaper
This is one of the most important considerations.
A per-minute model can be attractive when workloads are short or when a team needs specialized hardware only occasionally.
But a pipeline that runs frequently and consumes a large number of minutes can generate significant usage costs.
Consider two simplified workloads:
Pipeline A
10 minutes × 20 runs
= 200 execution minutes
Pipeline B
45 minutes × 200 runs
= 9,000 execution minutesThe second workload needs much more careful cost analysis.
These numbers are only examples, not pricing estimates.
The actual cost depends on the agent SKU and current pricing.
Cost Depends on Agent Size
The pay-as-you-go model ties the rate to the selected agent SKU.
That means your YAML configuration becomes an important cost decision.
For example:
pool:
name: 'GitHub-hosted Agents'
vmImage: 'macos-26-arm64'and:
pool:
name: 'GitHub-hosted Agents'
vmImage: 'macos-26-arm64-xl'represent different compute configurations and therefore different billing characteristics.
Do not select the largest machine simply because it makes builds faster.
First determine whether the performance improvement justifies the additional per-minute cost.
A Simple Cost Model
You can estimate pipeline spending with a simple formula:
Estimated Cost =
Pipeline Minutes × Agent RateFor multiple workloads:
Total Cost =
(Build Minutes × Build Rate)
+
(Test Minutes × Test Rate)
+
(Release Minutes × Release Rate)For example:
Build:
1,000 minutes × build rate
Tests:
2,000 minutes × test rate
Total:
3,000 billed minutes across the selected SKUsThe exact rates should come from the current Azure DevOps pricing information rather than being hard-coded into internal documentation.
Monitoring Usage
Cost management becomes especially important when teams move from a capacity-oriented model to usage-based billing.
Azure DevOps provides usage information for the GitHub-hosted Agents pool, and usage can also be monitored through Azure Cost Management. Microsoft's current documentation notes that pool analytics can show minutes by project, image, agent SKU, and pipeline.
A useful monitoring structure is:
Total Minutes
|
+-- Project A
| |
| +-- Pipeline 1
| +-- Pipeline 2
|
+-- Project B
|
+-- Pipeline 3
+-- Pipeline 4This makes it easier to identify expensive workloads.
Finding Expensive Pipelines
Suppose a team notices that its monthly CI usage has increased.
Do not immediately reduce the runner size.
First find out what is consuming the minutes.
Look for:
Pipelines with unusually long builds
Frequently triggered workflows
Large test suites
Repeated dependency installation
Jobs running on oversized machines
Pipelines that run when no artifact is produced
Duplicate CI work
For example:
Pipeline
|
+-- Restore: 8 min
+-- Build: 5 min
+-- Test: 35 min
+-- Package: 3 minIf tests consume most of the time, changing the build machine may not solve the cost problem.
Optimize the expensive stage first.
Join the conversation! Your thoughts help the community grow.