About Air Teams
JetBrains Air Teams is a JetBrains Agentic Development Environment built for teams: a shared place where a team runs coding agents in the cloud and reuses what works.
Most agentic work happens on individual laptops, and what one developer figures out there doesn't spread. The environment that makes an agent effective, the instructions that keep it on track, the tools it can reach, and the workflows worth repeating all stay in one person's setup. JetBrains Air Teams moves them off the laptop: you configure them once, and the whole team reuses them.
You describe a task, an agent works on it in a cloud environment, and its work lands on a task branch that reaches your main branch through a pull request. Nothing runs on your machine, so a task keeps going when you close your laptop, and several tasks can run at once.
You work with it in the browser at https://air.jetbrains.cloud, and you can reach the same tasks from a JetBrains IDE or the Air app – see Ways to reach Air Teams.
What you get
Cloud tasks – give an agent a goal and the context it needs, watch it work, steer it, and review the diff. Tasks run in parallel without tying up anyone's machine, and they aren't tied to the device you started them on. You pick the agent and model per task.
Shared cloud environments – the image, resources, variables, secrets, and network access an agent needs to build and test your code. An agent is only as good as its environment allows, and setting one up once is enough: every task and every teammate reuses it, and the setup script is versioned in the repository.
Automations – recurring work that runs on its own, started by an event or a schedule instead of by a person. Code review, issue fixes, dependency updates. You configure the instructions, environment, tools, and trigger once, and the result is a team asset rather than someone's personal script.
Projects – the shared home that ties the rest together: members and roles, shared environments, and connectors and secrets providers the whole team uses, so nobody has to connect the same service twice. A project's automations can run on the project's own credits, under its own service account, so they keep running after the person who wrote them moves on.
What stays with you
Agents do the work; the team keeps the decisions. An agent's changes go to its own task branch, never to your main branch, and a person opens and merges the pull request – see Run a task.
You can also see how a result came about, not just what changed. A task keeps its chat history, and an automation run unfolds the agent's reasoning and every tool call it made – see View run details.
What an automation does is your instructions, so how much it produces is up to you. An automation that leaves comments nobody reads is an instruction problem you can fix – see Create automations.
What a cloud environment is
A cloud environment is a Docker container on a virtual machine in the JetBrains cloud service. JetBrains Air Teams creates one for each task, clones the repository into it, and runs the agent there. It doesn't last forever: JetBrains Air Teams suspends it after a period of inactivity and releases it when the task is archived – see Cloud environment lifecycle.
The container is built from an environment configuration, so two people running the same task get the same toolchain, the same variables, and the same network rules. The agent never sees your local files, processes, or credentials.
The agent commits to its own task branch and pushes it, so the work is on the server before you look at it – see Run a task.
Where to start
Run your first task – if your organization already has JetBrains Air Teams, go to Quickstart with cloud tasks. It takes you from signing in to a pull request.
Set it up for an organization – enable JetBrains Air Teams, give it access to your repositories, and manage AI access. See Set up Air Teams.
Understand the surfaces – what the browser can do on the new task page, and what you get once a task is running. See Work with a task in the browser.
Work on your own machine instead – the Air app runs agents against your local project, in a Git worktree, or in a Docker container. See Air app.