Introducing TeamCity 2026.1: AI, Pipelines, and Enterprise CI/CD
In a Nutshell
TeamCity 2026.1 delivers AI-native CI/CD with built-in MCP server, CLI tool, and agent skills that let AI tools like Claude diagnose and fix builds through direct server access. The release advances pipelines from early access toward GA with YAML/Kotlin support, drag-and-drop UI, and bidirectional dependencies with existing build configurations. Key enterprise improvements include bundled SAML, Java 21 requirement, performance monitoring enabled by default, and GitLab webhooks for faster build triggering.
These notes were generated by AI and may contain inaccuracies.
The session is presented live from the JetBrains Munich office. Daniel serves as the solutions engineering lead on the TeamCity team at JetBrains, regularly working with both new and existing customers to advise on TeamCity incorporation into organizations. Ernst is based out of the Munich office on the product team, working on various features to improve TeamCity.
The presentation covers the overall direction of TeamCity, a recap of what's new in 2026.1, demonstrations of new capabilities including the TeamCity CLI, working between TeamCity and AI agents, and the latest advances in pipelines capabilities. Additional topics include overlooked features of TeamCity, the roadmap for the rest of 2026, additional services offered, and a questions segment.
The long-term vision focuses on building TeamCity to work with users and their AI agents. AI is bringing new challenges, greatly improving the load on CI systems, and massively changing how teams work. AI enables many new capabilities, and TeamCity is designed to work with users to help them accomplish tasks. As development moves at AI speed, TeamCity serves as a deterministic gate that helps control the non-deterministic behavior of AI on its way to production.
To balance AI integration with reliability, several focus areas are being developed. Usability improvements target both human users and AI agents, with interfaces added to ensure agent interaction remains under user control. Pragmatic AI features are being introduced, such as the analyze button that analyzes builds for users. Scalability is a priority as AI speed leads to increased build volumes in organizations. Enterprise customer needs are being addressed through direct engagement, with Daniel frequently consulting customers to understand requirements.
The key focus areas include ensuring TeamCity works well with AI agents both inside and outside TeamCity, advancing pipelines functionality from early access to generally available status, and enhancing enterprise scale capabilities for both performance and security expectations.
The version number format changed in 2026, with 2026.1 just released and two additional major releases planned for 2026.2 and 2026.3. Monthly bug fix updates follow the .1 .2 .3 syntax, aligning TeamCity versioning with other JetBrains tools.
TeamCity 2026.1 resolves an important security vulnerability with a post-authentication privilege escalation vulnerability impacting all on-premises versions. Cloud is not affected. A security patch plugin is available for versions from 2017.1 onwards. The fix is included in 2026.1, with all customers notified through email and social media. Additional details are available in the blog post.
The release spans multiple categories: user experience improvements including UI enhancements, pipelines with YAML and Kotlin support, developer productivity features including CLI and AI assistant, AI integrations with MCP and skills, and enterprise features including built-in SAML and security integrations.
Victor developed the TeamCity CLI originally for personal use after years of TeamCity usage while working in other JetBrains teams. The tool addresses the inefficiency of having to open browsers, perform multiple clicks, and scroll through logs to check failed builds, investigations, or fixed tasks. The CLI is now used by many JetBrains teammates and external customers.
The CLI enables checking CI status on specific branches using commands like TC run list branch this, showing build results including failures and successes. Users can explore specific builds to identify test failures, infrastructure issues, agent problems, toolchain issues, or disk space problems. The tool allows checking agent configurations including Go versions and available disk space.
A key feature enables running personal builds with uncommitted changes by sending Git patches to the TeamCity server without committing or pushing code. This addresses the common pain point of having to push commits and pull Git history just to test fixes, which the speaker describes as "the worst."
The CLI supports AI agent usage with clear contracts, JSON output everywhere, stable error codes, and documented compatibility. Installation requires running TeamCity skill install once, after which it works with tools including Genie, Cursor, CodeX, and CloudCode. A special agent skill helps these tools run the CLI effectively.
Tab completion is available and can be installed with the TeamCity completion command. Commands can be executed on remote build agents. JSON output is available throughout for piping to tools like jq and for scripting purposes. A direct API call escape hatch is built in for unsupported commands.
Planned improvements include an agent-assisted AI migration skill to help migrate from GitHub Actions or Bamboo to TeamCity pipelines, ongoing enhancement of agent skills for better integration with Cursor, Juni, and Cloud Code, and an MCP server shipping with TeamCity 2026.1. The repository is public with open issues and pull requests, and the tool is free and open source, installable via brew, npm, or winget.
TeamCity includes a built-in AI analyzer that examines failed builds to identify issues, though it cannot access codebases for fixes. For full AI integration, MCP (Model Context Protocol) setup is required. The process involves accessing AI assistant settings in the IDE, enabling MCP, and defining a new HTTP MCP server with the TeamCity instance URL ending in /app/mcp.
Authentication requires creating access tokens through the user profile, with new support for read-only permission scopes added following customer feedback from New York City. The token is configured as a bearer token in the authorization header, with automatic MCP service enabling upon configuration.
With MCP configured, AI agents like Claude can access TeamCity data to diagnose and fix build issues. The integration allows moving from broken builds to fixes through AI assistance, though AI behavior varies between attempts due to its stochastic nature. Controls like read-only tokens help manage AI access appropriately.
Pipelines provide a new visualization interface showing pipeline structure immediately upon entering builds. The settings view allows adding jobs and creating dependencies through drag-and-drop operations rather than navigating multiple screens. Job configuration including renaming, steps, build features, and agent requirements occurs in a side panel without tab switching.
YAML is supported for pipelines, enabling team members who prefer YAML to work with TeamCity. Kotlin DSL support allows defining pipelines through the pipeline object and individual jobs through the job object, using familiar syntax similar to traditional build configuration Kotlin DSL.
New dependency capabilities allow pipelines to link to existing build configurations within projects, and build configurations can add dependencies on pipelines. This bidirectional dependency support enables gradual adoption of pipelines for new project areas while maintaining connections to established build configurations.
Build feature support includes build cache, free disk space management, and test report processing, with additional features planned toward GA status. Step addition uses a new interface with drill-down options for specific commands, such as .NET publish with dedicated parameter options.
The custom run dialog enables overriding dependency reuse, customizing included changes, and overriding parameters. Input and output parameters can be defined for pipelines.
Dynamic build step credentials support GitHub app tokens for secure repository interactions. SSH known host pinning for VCS enables host key verification at the root project level, with immediate flagging of host key changes. HashiCorp Vault integration adds Google Cloud Platform authentication support. Jira self-hosted now supports token authentication alongside username and password authentication.
SAML authentication is now bundled and JetBrains-supported rather than relying on third-party plugins. GitLab integration improvements are in development for enhanced version control capabilities.
TeamCity now supports GitLab webhooks in addition to the existing ability to pull for changes. With GitLab, users can configure webhooks to trigger builds immediately after pushing new commits, providing faster response times than polling. This behavior aligns with existing GitHub webhook support. Timing settings in TeamCity triggers still apply to these webhook events.
For Perforce users, a more sophisticated approach to building shelved changelists has been introduced. The system now runs p4 resolve after unshelving to detect and resolve conflicting changes. Additionally, users can now specify multiple shelved changelist IDs when triggering custom builds.
Kubernetes integration now allows proxy settings to be defined as part of the connection configuration. A new concurrent build limit feature has been added for build configurations. This prevents repositories with frequent commits from consuming all available agents. Previously, builds would queue up when limits were exceeded. The new behavior allows the oldest running builds to be dropped when the limit is reached.
A new syntax called override.dep provides a simpler upstream way to override parameters. This syntax improves parameter resolution and build reuse behavior. Because it only bases on existing parameters, it prevents unintended builds when parameters are not populated on build configurations. This serves as a better alternative to the reverse.dep syntax.
TeamCity 2026.1 updates to Java 21. On-premises installations require both server and build agent processes to use Java 21 as a minimum. For cloud users with self-hosted agents on older Java versions, updates are required during the rollout period, which will take an additional two weeks for full cloud deployment. On-premises users have flexibility in their rollout timing. The server requires exactly Java 21, while agents can use Java 20 or any newer version.
The performance monitor, previously requiring manual addition, is now enabled by default in 2026.1. This feature provides charts showing disk IO, CPU, and memory consumption during builds. Users can identify whether agents are over or under spec, helping optimize cloud agent spending. A useful capability allows selecting portions of the chart to view corresponding log snippets, showing exact processes and timestamps where resource spikes occurred.
Build chains enable chaining build configurations together, providing reusability that single configurations cannot achieve. When builds are split across multiple configurations, failures in specific areas don't require rerunning entire chains. If no new commits exist when rerunning a build chain, TeamCity reuses dependencies, reducing build times.
Build chains are defined through snapshot dependencies in the dependencies view. Checkout rules allow skipping portions of build chains when changes don't affect specific parts, such as excluding a backend folder when only frontend files are modified.
TeamCity offers three build configuration types: regular, composite, and deployment. Converting to deployment type provides a deploy button in the upper right corner and creates a deployments list for previous builds. The redeploy button enables rolling back to earlier application versions by pushing older states and artifacts through the deployment process.
The failure conditions tab allows defining maximum build times and additional conditions based on metric values or specific text in build logs. Metrics can check artifact sizes against specified thresholds, such as ensuring artifacts exceed 10,000 bytes. Text-based conditions can search for specific warnings or regular expressions, immediately stopping builds when found to prevent unnecessary cloud agent usage. Friendly failure messages can be configured for spurious errors, and conditions can be tested against finished builds.
Future development focuses on end-to-end AI agent experiences with TeamCity, including CLI and MCP integration. Existing agent skills through CLI will be improved, and AI configuration assistance within TeamCity itself will be expanded. Migration functionality is currently available as beta on the TeamCity CLI GitHub repository.
Developer experience improvements will enable working with TeamCity without leaving existing environments, including CLI, IDE, and air.dev integration. The agentic development environment by JetBrains allows creating tasks for AI processing, running them in IDE or creating work trees for each task.
AI agents within TeamCity will support tasks like verifying documentation updates and generating release notes. Configuration writing assistance will be provided, with examples including Terraform and Ansible setup. Self-healing pipelines will handle network errors directly within TeamCity.
JetBrains Central provides AI governance across organizations, setting budgets and monitoring usage. This works across JetBrains IDEs, VS Code, CLI, and multiple AI vendors. TeamCity will primarily use Central for AI governance, with bring-your-own-key functionality available when Central cannot be used.
Pipelines will reach general availability this year, offering modern pipeline configuration with fully branchable configuration as code for YAML and Kotlin. Visual drag-and-drop configuration and rich UI options are included. Existing build configurations and build chains continue to evolve, with fully dynamic build chains planned for later this year. Pipelines can integrate into build chains, and Kotlin is supported in both pipelines and build configurations.
Upcoming features include real-time pipeline debugging, full support for all TeamCity build steps, runners, and build features, plus support for protected branches and partial repository checkouts.
Planned improvements include dynamic build chains, performance and scalability enhancements, minimum running cloud agent pools for pre-warmed agents, retry failed builds immediately within build chains without restarting entire chains, and architectural changes enabling native horizontal scalability for high availability setups.
Maven 4 support will be added when available. SARIF static analysis report standard support will be implemented. Perforce and GitHub integration improvements will continue. Cloud integration enhancements include AWS improvements and a full Azure overhaul.
Unity and Unreal game engine support through first-party plugins will see Unity improvements, with Unity build profiles planned for later this year.
Proactive CI/CD development will use AI to suggest improvements, efficiency changes, investigations, possible fixes, and build time optimization. Merge trains support and additional continuous deployment options within pipelines are planned. Deeper single sign-on capabilities including OIDC, improved Unity and Unreal workflow support, parameter reordering for custom builds, and the ability to split single on-premises instances into isolated environments are scheduled. Additional UI customization, contextual views, and improved notifications are also planned.
Paid customers receive standard support with next business day responses through a ticketing system. Business and enterprise support plans offer varying SLAs and additional communication methods including Slack channels and quarterly on-call sessions of 10 hours. Professional services include deployment and migration assistance, custom plugin development, and help with projects stuck in other CI tools like Jenkins.
Feedback channels include chat comments and dedicated feedback links, with all comments reviewed to shape future TeamCity direction.
Keep JetBrains in your library
Save the videos and channels worth coming back to, and find them again in one place.
