TeamCity

What’s Next for TeamCity – CI/CD by JetBrains

What we’re building toward

As the share of code written by AI agents grows rapidly, two questions are central to effective AI adoption: How can teams turn AI usage into real productivity gains, and how can they maintain quality, security, and control while doing so? CI/CD is critical to both.

Every contribution, whether written by a human or an AI agent, still needs to be built, tested, verified, and delivered through a trusted process. With the volume of AI-generated code ever increasing and the need to verify its quality and security, CI/CD has to support this process at a new scale.

The context and tools that CI/CD provides to AI agents will determine how effectively they can work with verification results, react to failures, and iterate on changes. This will help teams improve velocity with AI while controlling quality, security, and delivery.

For many years, TeamCity has served as a CI/CD platform for reliable building, testing, and delivery in human-driven software development. We are now developing TeamCity for a new reality where software is created through the collaboration between humans and AI coding agents.

This evolution builds on TeamCity’s existing strengths: a powerful, flexible product foundation that enables scale from individual use to enterprise-level systems. We are investing in strengthening these foundations so TeamCity can reliably support higher code change volumes from developers and AI agents.

We’re also building new end-user scenarios that help teams maintain a smooth experience as software development processes evolve.

TeamCity today

TeamCity currently has four key strengths as a CI/CD platform:

• Low-friction build configuration for any use case. UI, CLI, and AI-based configuration; pipelines in familiar YAML or the more flexible Kotlin DSL; multi-repository projects; build chains and dependencies; reusable templates; project hierarchy; and granular permissions.
  
• Faster investigation and resolution of build failures. Automatic build problem detection; test history; structured build logs; visual pipeline overview; AI Assistant with build failure analysis; build agent terminal access for debugging failed builds directly on a remote machine; and working with builds from JetBrains IDEs without switching context.
  
• Reduced build time and more efficient resource usage. Build reuse; caching; unlimited build chains; build agent pools and requirements; cloud profiles; and on-demand build agents to reduce repeated work, scale build capacity, and keep infrastructure usage under control.
  
• Clear visibility across builds, tests, and the entire CI/CD system. Advanced test insights and history; build, change, and build queue overviews; investigation capabilities; custom report tabs; and deep build tool integrations for better build process observability.

We believe TeamCity is well-positioned for the evolution of CI/CD in a world with more code changes, more verification loops, more interaction between AI agents and CI/CD systems, and a stronger need for scale, reliability, and control.

• TeamCity already supports scalability, optimization, and flexibility for complex pipelines. This helps you handle larger workloads and cover a wide variety of use cases. With AI agents, you can get your first builds up and running faster and navigate complex scenarios more easily.
  
• TeamCity will also provide AI agents with relevant CI/CD context – such as test history, build results, and automatically detected build problems – so they can reason more quickly and accurately about failures and configuration changes. Tools such as pipeline debugging and terminal access can further help AI agents investigate issues and produce higher-quality fixes.

How we see CI/CD changing

AI adoption in development processes is growing. While many developers already use AI agents to write code, companies are still struggling to achieve large productivity gains at an organizational scale. JetBrains is committed to helping customers with this.

Part of the challenge is AI governance: security, cost control, and transparency around the use of AI agents in an organization. JetBrains addresses these problems with JetBrains Central – a new control plane for AI adoption in organizations.

As the use of AI agents in development increases, the requirements for CI/CD also evolve. In development processes where a lot of code is generated by AI agents, deterministic, reliable, and secure building, testing, and delivery become critical.

We see several key directions in which CI/CD tooling will evolve.

1. Scalability, performance, and flexibility. The load on CI/CD systems will grow as teams generate more code changes and run more verification checks for AI-generated code. Scalability and performance will play an important role, along with the flexibility of the systems to adapt to fast-changing use cases and rapid scaling inside organizations.
   
2. Interaction between AI agents and CI/CD tools. Both humans and AI agents will work with CI/CD systems through AI interfaces, such as CLI, MCP, and agent skills. They will use them for everyday CI/CD tasks like configuring and updating pipelines, running builds, checking results, investigating failures, and fixing build problems. The more context and tools a CI/CD platform can provide to AI agents, the faster, cheaper, and more accurately those agents can work.
   
3. Agentic steps in CI/CD. Some tasks within CI/CD workflows will be handled with AI tooling. CI/CD systems will need to support launching AI agents from builds and make it possible to configure these steps conveniently and securely.
   
4. AI governance. Both in-product AI features and AI agents launched from CI/CD steps will need to integrate with AI governance capabilities, giving organizations the control, visibility, and policy enforcement required to adopt AI safely.

How we’re developing TeamCity

We continue to develop TeamCity for this future, investing both in core CI/CD capabilities and in integration with AI workflows. 

We’re taking a pragmatic approach to AI capabilities:

• Investment in core CI/CD capabilities to ensure each customer’s desired level of determinism, scale, security, and human control.
• Full support for development workflows across the whole spectrum of AI adoption – from fully human to autonomous AI processes.
• Optional, governed, in-product AI features that solve end-user problems.

We are also deepening TeamCity’s role in the JetBrains ecosystem, which supports customers across the entire software development life cycle. JetBrains IDEs and Air help improve individual and team productivity, TeamCity builds and delivers code, Qodana helps ensure its quality, and JetBrains Central helps govern AI usage.

In line with this, the TeamCity roadmap is shaped around the following streams. 

Enterprise-grade scalability, performance, and flexibility

We are investing in:

• Performance and scalability. We are improving platform responsiveness and increasing throughput for code changes and code verifications.
• Dynamic build chains. We aim to enable a more flexible approach to generating configurations during execution.
• A faster and more familiar way to configure and work with builds. We are moving Pipelines – a new way to configure builds – from EAP to general availability, and we will continue developing them further. Pipelines bring native branch support, YAML alongside the Kotlin DSL, a visual drag-and-drop editor, easier access to powerful TeamCity features, and pipeline debugging, all while preserving the power and flexibility of TeamCity.
• New and improved CI/CD integrations. We’re expanding support for popular tooling, including GitHub, build tools, SARIF, AWS, Azure, and more.

Developer experience and interfaces for AI agents

Our goal is to make it possible for developers to work with TeamCity end to end, both directly and through AI agents, without leaving their context, whether that’s the IDE, terminal, or an agentic development environment (ADE) like Air.

To do this, we are developing the CLI, MCP server, agent skills, and plugin for JetBrains IDEs. We are investing in support for working with TeamCity through these interfaces, including:

• Pipeline configuration and migration from other CI/CD tools.
• Build management, including working with statuses, investigations, and fixing failing builds.
• Running builds, including runs without the commit-push cycle through remote runs from the IDE plugin.
• Providing AI agents with data (build problems, test history, and more) that can help them work more cost-effectively and produce higher-quality results.

Support for AI build steps and AI governance

TeamCity can already launch AI agents as part of pipelines. We are expanding these capabilities and improving the user experience by:

• Simplifying the setup of AI agent builds through easier configuration and ready-made recipes.
• Bringing BYOK (Bring Your Own Key) to TeamCity, making it possible to use local LLMs or approved providers in TeamCity’s in-product AI features and AI workflows launched from TeamCity.
• Integrating with JetBrains Central, a product that provides AI governance capabilities to help with AI adoption, including token quotas, analytics on token usage problems, and policies for LLM usage.

Longer-term plans

We continue to develop TeamCity in line with our vision of the future, while listening closely to our customers. We have set the main areas we are investing in while keeping the details flexible so we can adapt to customer needs, technology shifts, and broader market changes.

We want to highlight a few focus areas in our long-term plans:

• Moving TeamCity toward proactive CI/CD, where it is an active participant in the development process, suggesting pipeline configurations and optimizations and using AI to help customers get more value with less friction.
• Supporting merge trains and new VCS-related processes and tools that become relevant for AI-led development.
• Strengthening continuous delivery capabilities to help teams ship AI-generated code faster while maintaining control.
• Deepening integration with other JetBrains products, including JetBrains IDEs, JetBrains Central, and Air.

As AI changes how software is created, reliable and controlled building, testing, and delivery become even more important. That is the future we are building TeamCity for.