Features News

Power Up Your Pipelines with New Agent Types Available in TeamCity Cloud

We’re introducing new types of JetBrains build agents to TeamCity Cloud. These new, more powerful agents can handle more intense builds, helping your team to build projects of any complexity.

The new agent types include new ARM Linux machines and the latest versions of the Ubuntu and Windows operating systems.

What are build agents in TeamCity?

In TeamCity, build agents are distributed agents responsible for executing the actual build and deployment processes defined in your build configurations. These agents perform tasks such as compiling code, running tests, packaging applications, and deploying artifacts.

Build agents in TeamCity enable parallel and distributed builds, which are essential for large and complex projects.

In TeamCity Cloud, you can use self-hosted build agents or take advantage of JetBrains-hosted agents. The latter are maintained and configured by JetBrains. They are started on-demand as soon as each new build needs to run.

Thanks to JetBrains-hosted agents, you can start building quickly, as you don’t need to spend time on initial agent setup and maintenance. We are now extending this fleet of agents to ensure more user scenarios are covered.

New operating systems

Previously, TeamCity Cloud offered JetBrains-hosted agents on Ubuntu 20.04 and Windows 2019. In the next two years, these OS versions will come to the end of their standard support timeline (January 2024 for Windows Server 2019 and April 2025 for Ubuntu 20.04).

In order to prepare for the end of this support and meet the growing demand for the latest long-term support versions, we’re now introducing agents on: Ubuntu 22.04 and Windows 2022. The complete list is as follows:

  • Windows: Windows-Server-2022-Small (2 vCPU), Windows-Server-2022-Medium (4 vCPU), Windows-Server-2022-Large (8 vCPU), Windows-Server-2022-XLarge (16 vCPU).
  • Linux: Ubuntu-22.04-Small (2 vCPU), Ubuntu-22.04-Medium (4 vCPU), Ubuntu-22.04-Large (8 vCPU), Ubuntu-22.04-XLarge (16 vCPU).

The set of preinstalled software and hardware specifications remain the same as for previous versions. See the documentation for further details.


There are two pricing options available for JetBrains agents:

  1. You can pay for the exact number of build minutes that an agent is occupied.
  2. You can reserve an agent for a month and pay in advance.

Both per-minute and per-month prices haven’t changed and are the same as for the older versions of agents of the same size.

For instance, the price for Windows-Server-2022-Small is the same as for Windows-Small – 20 credits per minute or 150,000 TeamCity Cloud build credits monthly.

The recommended way to set up a build

To define whether a build configuration can run on a particular build agent, you need to configure agent requirements. The most straightforward way is to set a requirement for an agent name:

teamcity.agent.name equals Ubuntu-22.04-Small

There are dedicated parameters for the OS version and CPU count, which can be combined in the following manner:

teamcity.agent.os.name equals Windows-Server-2019
teamcity.agent.hardware.cpuCount is more than 2

Finally, we provide a parameter to stick to the latest version. When a newer version of the OS is released in the future, you won’t have to change the requirements manually.

teamcity.agent.os.family equals Windows
teamcity.agent.os.latest equals true

Any other requirements are also valid. For instance, you can set a requirement for specific software that needs to be installed on the agent:

docker.version equals 20.10.9

Larger Windows agents

TeamCity Cloud already provides Windows build agents featuring 2 and 4 vCPU. However, when it comes to games, simulators, physics engines, and other projects that demand huge bandwidth, much more is needed.

On the other hand, developers continue to say that waiting for feedback from their CI tool is one of the most time-consuming parts of their job.

To handle the intensive computations and tests, Large and XLarge Windows agents are now available. Compared to the Medium machines, vCPU count, RAM size, and fast SSD storage are double for Large agents, and XLarge ones have four times more resources.

Here’s the full list of the new Windows agents with specifications:

Agent NamevCPURAMStorage
816 GB200 GB SSD for running builds
100 GB root EBS volume
1632 GB400 GB SSD for running builds
100 GB root EBS volume


The prices for large Windows agents are as follows:

  • 8 vCPU Windows (both Windows 2019 and 2022): 80 build credits per minute or 600,000 TeamCity Cloud build credits monthly
  • 16 vCPU Windows (both Windows 2019 and 2022): 160 build credits per minute or 1,200,000 TeamCity Cloud build credits monthly

The recommended way to set up a build

You may use a requirement on an agent name or OS version and CPU count, in the same way as described in the previous section.

How can I find the most suitable agent for my builds?

TeamCity Cloud automatically collects CPU and memory usage during a build, which can help you analyze if a build requires hardware adjustment.

Let’s try to test the Kotlin Compiler (Gradle jvmCompilerTest task)  on Windows-Server-2019-Medium to see how it works on Windows. As you can see, the CPU and memory usage remains high during almost the entire execution process. This makes it a solid candidate for tweaking the hardware requirements.

Here’s how the performance improves once we switch to the brand-new Windows-Server-2019-Large agent:

The build duration was roughly halved. Given that Windows-Server-2019-Large is twice as expensive as Windows-Server-2019-Medium, the result was a faster build for the same price.

However, the CPU load is still rather high. We can further decrease the build time by adopting an XLarge agent.


The popularity of ARM processors has skyrocketed recently. More and more vendors are porting their software products to this platform. While it’s technically possible to produce ARM-specific distributions on x86 architecture with the help of emulators, native builds are a higher performing and more resilient method.

New Ubuntu ARM agents complement the platforms that JetBrains agents facilitate builds for. Powered by the latest AWS Graviton3 processors, they also boast better performance compared to the x86 versions.

ARM agents will be available with both supported Ubuntu versions and all hardware tiers:

  • Ubuntu-20.04-Small-Arm64 (2 vCPU)
  • Ubuntu-20.04-Medium-Arm64 (4 vCPU)
  • Ubuntu-20.04-Large-Arm64 (8 vCPU)
  • Ubuntu-20.04-XLarge-Arm64 (16 vCPU)
  • Ubuntu-22.04-Small-Arm64 (2 vCPU)
  • Ubuntu-22.04-Medium-Arm64 (4 vCPU)
  • Ubuntu-22.04-Large-Arm64 (8 vCPU)
  • Ubuntu-22.04-XLarge-Arm64 (16 vCPU)


For the new ARM Ubuntu agents, both the per-minute and per-month prices are the same as our current pricing for the x86 versions of agents of the same size.

For instance, the price for Ubuntu-20.04-Small-Arm64 is the same as for Ubuntu-20.04-Small – 10 credits per minute or 75,000 TeamCity Cloud build credits monthly.

Recommended way to set up a build

Here’s the requirement that you can use for the new agent names:

teamcity.agent.name equals Ubuntu-20.04-Large-Arm64

There is also a dedicated parameter for the architecture type:

teamcity.agent.cpuArchitecture equals aarch64

How can TeamCity help adapt my builds for ARM?

It would be wonderful if starting building for ARM was as simple as copying an existing x86-specific configuration and just changing a required agent. However, the ARM environment is different, and your software and build configurations might need adjustment.

Debugging such configurations gets even more complicated if your local machine has a different architecture. The good news is that TeamCity improves the user experience when undertaking this task.

When a build is running, you can access an agent in a single click through an agent terminal.

This feature is extremely beneficial to quickly see how your commands perform in a specific environment.

TeamCity goes beyond just that. You can run a build with your local changes on a CI agent right from IntelliJ IDEA, harnessing the Remote Run feature. It even allows you to debug your tests using the built-in debugger!

New default build agents

Currently, the default OS versions are Ubuntu 20.04 and Windows 2019. This means that TeamCity will prefer these versions when it picks up an agent for a build in case another version is not selected with explicit agent requirements.

Due to the end of standard support approaching for the aforementioned versions, we want to shift our focus to the latest versions. Starting from February 1, 2024, the new default build agents will be Ubuntu 22.04 and Windows 2022, respectively.

The older versions will be deprecated in the future. To ensure a smooth transition, we encourage you to gradually start adopting new agents using the recommended methods above.

New naming conventions

Previously, an agent name consisted of an OS name and size, but our new agents don’t fit this model. The new format will include a specific OS name, version, size, and, optionally, architecture.

All of the agents mentioned above follow the new convention.

The old name format will be preserved as an easy and short alias to a default OS version. This will help us to preserve backward compatibility with the existing requirements.

For existing customers, the old agents will list the the old versions until February 1, 2024:

Linux-Small => Ubuntu-20.04-Small
Windows-Medium => Windows-Server-2019-Medium

Over to you

Do you have any questions regarding the new agent types in TeamCity? Feel free to reach out to us in the comments section below or via the forum. We’ll be happy to help!

image description