AI Watch · Tools & ecosystem
The coding-agent map in late 2026: who's winning, and the three protocols that make agents swappable
Nine in ten professional developers now use a coding agent every week. The market has a clear leader, a fast challenger and a fading incumbent. But the more durable story is underneath: three open standards (MCP, ACP and Agent Skills) are turning agents into interchangeable parts. Here's the map, what the numbers really say, and how to pick a setup that doesn't lock you in.
1. Adoption: from "nice to have" to default
JetBrains' Developer Ecosystem Survey 2026 (15,000+ professional developers, fielded May–July 2026, reweighted to be globally representative) is the largest independent snapshot of how people actually code right now. Headline numbers:
Key figures
- 90% of professional developers use AI coding agents at work at least weekly (local or cloud agents).
- 68% use them daily.
- An "agent" here means more than autocomplete: a tool that reads the codebase, edits multiple files, runs commands and iterates, the loop covered in the AI Watch on agents (Aug 24).
Put simply, not using an agent is now the unusual choice. The interesting questions have moved: which agent, how much you delegate, and how it plugs into the rest of your tools.
2. The players, by the numbers
"Adoption" below means share of professional developers using the tool at work (JetBrains survey, Jan 2026 vs. May–July 2026). "Awareness" means share who have heard of it.
| Tool | Adoption at work | Trend | What stands out |
|---|
| Claude Code (Anthropic) | 18% → 39% | ▲ more than doubled | 47% in the US. The main tool for 31% of developers, meaning ~80% of its users make it their primary tool. |
| GitHub Copilot | 29% (a year ago) → 21% | ▼ lost the lead | Still the best known (79% awareness). Broadest ecosystem; issue-to-PR cloud agent inside GitHub. |
| Codex (OpenAI) | 3% → 16% | ▲ ~5× | Awareness jumped from 27% to 65%. Its users are the most "agent-heavy" (see next section). |
| Cursor | 18% → 12% | ▼ small decline | Awareness still rising (69% → 75%). Biggest drop in China (28% → 16%). |
| JetBrains AI / Junie | ~9% | — | Also hosts other agents inside its IDEs (more on ACP below). |
| OpenCode (open source) | 7% | ▲ new | 42% awareness with no big company behind it. |
| Google Antigravity | 6% | → stable | Awareness 29% → 47%; tied for 3rd place in India (15%). |
Read this with care: the survey is run by JetBrains, which sells its own AI tools, though it's reweighted to reduce bias toward JetBrains users. Shares add up to more than 100% because many developers use several tools. And adoption isn't quality: benchmark leaderboards shift with every model release (Codex holds a top Terminal-Bench 4.0 entry; Claude Code with Opus 5.5 scores 66 on Artificial Analysis's Coding Agent Index), so "most used" and "best on a benchmark" are separate questions.
Why the shift happened (the plausible reasons)
- Terminal-first agents beat editor-first assistants for multi-step work. Tools that run commands, execute tests and retry on their own fit the "delegate the task" workflow better than inline suggestion.
- The model and the tool improved together. Each frontier model release (Opus 5.5 on Sep 22, Sonnet 5.5 on Sep 28) lands in the vendor's own agent first.
- Price and quotas matter. JetBrains suggests Codex's heavy users may be chasing value, since it has historically offered higher usage quotas.
3. How much code do agents really write?
You've heard "100% of my code is written by AI". A follow-up JetBrains analysis asked developers what share of last month's work code was fully agent-written, AI-assisted or fully manual.
| Metric | Value |
|---|
| Average share fully written by agents | ~47% |
| Written with some AI assistance | ~38% |
| Written fully by hand | ~27% |
| Developers with >80% agent-generated code | ~22% (a minority) |
| Developers who write zero code without AI | 1 in 5 |
(Averages exceed 100% because answers were in buckets and the midpoints were averaged.)
Three profiles emerged from clustering the answers:
- Agentic coders (~31%): ~84% of their code is agent-generated.
- AI-assisted coders (~47%): ~40% agent-generated, but still steer most of it with AI help and write some by hand.
- Manual coders (~23%): ~75% hand-written, AI used occasionally.
Other patterns worth knowing:
- Seniors delegate more, not less. About a quarter of senior developers generate over 80% of their code with agents; juniors lean toward AI-assisted rather than fully agentic. Delegation needs judgment: knowing what to ask for and how to review it.
- Stack matters. Go, JavaScript and TypeScript developers are the most agentic (~54–55% agent-written); C/C++ the least (~38%). Web front-end and back-end work sits at the high end.
- Region matters. In China, Japan and South Korea, 32–35% of developers generate over 80% of their code with agents, about double Europe/UK (~16%).
- Tool audience matters. 42% of heavy Codex users are above 80% agent-generated, versus 32% for Claude Code. JetBrains' reading: Claude Code has gone mainstream, so its audience is no longer mostly power users.
4. The protocol stack: MCP, ACP, Skills
Market share will keep moving. What makes it less risky to pick a tool is that the industry has converged on open standards at three different layers. Think of a coding agent as a worker: it needs a desk (where it lives), tools (what it can touch) and know-how (procedures it follows).
| Layer | Standard | Question it answers | Origin |
|---|
| Desk | ACP (Agent Client Protocol) | "Where does the agent live in my editor?" | Zed, Aug 2025; JetBrains co-develops since Oct 2025 |
| Tools | MCP (Model Context Protocol) | "What data and actions can the agent reach?" | Anthropic, Nov 2024; now under the Agentic AI Foundation |
| Know-how | Agent Skills (SKILL.md) | "How should the agent do this specific task?" | Anthropic, open standard since Dec 2025; 40+ adopting clients |
MCP and Skills were covered in earlier AI Watch editions (Aug 20 and Sep 1). ACP is the piece most people haven't met yet, so let's zoom in.
5. ACP up close: the "LSP for agents"
Before the Language Server Protocol, every editor had to build its own TypeScript support, its own Python linter integration, and so on. LSP made one language server work in every editor. ACP applies the same idea to agents: any ACP-compatible agent runs in any ACP-compatible editor, no custom plugin per pair.
How it works
- Subprocess model: the editor launches the agent as a child process and they talk JSON-RPC 2.0 over stdin/stdout, the same transport LSP uses.
- Sessions: the editor creates a session with history, sends prompts, and the agent streams updates back token by token.
- Permissions: before running a terminal command or writing a file, the agent sends a
session/request_permission message; the editor (you) approves or denies.
- MCP hand-off: at session start the editor passes its configured MCP servers to the agent. So you configure tools once, in the editor, and any agent you plug in can use them.
The five core messages
session/initialize (capabilities) → session/new (open a conversation) → session/prompt (user asks) → session/update (agent streams) → session/cancel (stop mid-response)
Who supports it
- Editors: Zed (native, most complete), JetBrains IDEs (native, where Claude Agent, Codex, Copilot and OpenCode are built into the AI chat and others like Cursor can be added via ACP), Neovim and Emacs (stable community plugins). VS Code has no native support; Microsoft standardized its agent mode on MCP instead (status as of March 2026).
- Agents: 25+ as of March 2026. Gemini CLI, GitHub Copilot CLI, Goose, Cline and OpenHands natively; Claude Code and Codex CLI through adapters.
Pros and cons
| Pros | Cons |
|---|
| Switch agents without switching editors (or relearning your workflow). | Adapters for the biggest agents mean features can lag behind the vendor's own app. |
| Configure MCP tools once, reuse with every agent. | No native VS Code support, and VS Code is the most used editor. |
| Uniform permission prompts across agents. | Another moving standard to track; still version 1. |
6. Choosing a setup without getting locked in
A practical way to think about it, whatever tool you use today:
- Pick the agent for the model and the loop, not the brand. Run it on 3–5 real tasks from your own work (a bug fix, a small feature, a refactor with tests) and compare finished results and cost per task.
- Put your tools in MCP. Database access, docs search, issue tracker: if they're MCP servers, they move with you to any agent.
- Put your procedures in Skills and plain files. Repo conventions in a project instructions file, repeatable workflows (e.g. "how we write a migration") as
SKILL.md. Both are portable text, not vendor settings.
- If you live in Zed, JetBrains, Neovim or Emacs, try ACP so you can swap agents from the same panel.
- Keep the review muscle. The data shows seniors delegate most because they can judge the output. Delegate more as your ability to review grows, not before.
Generic example: a portable setup
A small team building a web app with a Postgres database:
- Tools (MCP): a Postgres MCP server (read-only in dev), a docs-search server, a browser server for UI checks.
- Know-how (Skills):
skills/write-migration/SKILL.md, skills/add-api-endpoint/SKILL.md.
- Rules: a project instructions file with stack, test command and "never touch
.env".
- Agent: whichever one wins their own 5-task trial this quarter. If a better one appears next quarter, they switch the agent and keep everything above.
The takeaway: the leaderboard will look different in six months. Your tools, procedures and review habits don't have to. Invest in the layers that are standardized, and treat the agent itself as the swappable part.
IA Watch · Ferramentas e ecossistema
O mapa dos agentes de código no fim de 2026: quem está ganhando, e os três protocolos que tornam os agentes intercambiáveis
Nove em cada dez devs profissionais já usam um agente de código toda semana. O mercado tem um líder claro, um desafiante acelerado e um ex-líder perdendo terreno. Mas a história mais duradoura está por baixo: três padrões abertos (MCP, ACP e Agent Skills) estão transformando agentes em peças trocáveis. Aqui vai o mapa, o que os números dizem de verdade, e como montar um setup que não te prende a ninguém.
1. Adoção: de "diferencial" a padrão
A Developer Ecosystem Survey 2026 da JetBrains (mais de 15 mil devs profissionais, aplicada entre maio e julho de 2026, com pesos para representar a população global) é o maior retrato independente de como as pessoas programam hoje. Os números principais:
Números-chave
- 90% dos devs profissionais usam agentes de código no trabalho pelo menos uma vez por semana (locais ou na nuvem).
- 68% usam todo dia.
- "Agente" aqui é mais que autocomplete: uma ferramenta que lê o código, edita vários arquivos, roda comandos e itera, o loop que vimos no IA Watch sobre agentes (24/08).
Resumindo: não usar agente virou a exceção. As perguntas interessantes mudaram de lugar: qual agente, quanto você delega e como ele se conecta ao resto das suas ferramentas.
2. Os players, em números
"Adoção" abaixo é a fatia de devs profissionais que usam a ferramenta no trabalho (pesquisa da JetBrains, jan/2026 vs. mai–jul/2026). "Conhecimento" é a fatia que já ouviu falar dela.
| Ferramenta | Adoção no trabalho | Tendência | Destaque |
|---|
| Claude Code (Anthropic) | 18% → 39% | ▲ mais que dobrou | 47% nos EUA. É a ferramenta principal de 31% dos devs, ou seja, ~80% de quem usa acaba fazendo dela a número um. |
| GitHub Copilot | 29% (há um ano) → 21% | ▼ perdeu a liderança | Continua o mais conhecido (79%). Ecossistema mais amplo; agente na nuvem que vai da issue ao PR dentro do GitHub. |
| Codex (OpenAI) | 3% → 16% | ▲ ~5× | Conhecimento saltou de 27% para 65%. Seus usuários são os que mais delegam (ver próxima seção). |
| Cursor | 18% → 12% | ▼ leve queda | Conhecimento ainda subindo (69% → 75%). Maior queda na China (28% → 16%). |
| JetBrains AI / Junie | ~9% | — | Também hospeda outros agentes dentro das IDEs (mais sobre ACP abaixo). |
| OpenCode (open source) | 7% | ▲ novo | 42% de conhecimento sem nenhuma big tech por trás. |
| Google Antigravity | 6% | → estável | Conhecimento 29% → 47%; empatado em 3º na Índia (15%). |
Leia com cuidado: a pesquisa é da JetBrains, que vende ferramentas de IA próprias, embora os dados sejam reponderados para reduzir o viés a favor de usuários JetBrains. As fatias somam mais de 100% porque muita gente usa várias ferramentas. E adoção não é qualidade: os rankings de benchmark mudam a cada lançamento de modelo (o Codex tem uma das primeiras posições no Terminal-Bench 4.0; o Claude Code com Opus 5.5 marca 66 no Coding Agent Index da Artificial Analysis). "Mais usado" e "melhor no benchmark" são perguntas diferentes.
Por que a virada aconteceu (as explicações mais plausíveis)
- Agentes de terminal superam assistentes de editor em trabalho de várias etapas. Ferramentas que rodam comandos, executam testes e tentam de novo sozinhas combinam melhor com o fluxo "delega a tarefa inteira" do que sugestões inline.
- Modelo e ferramenta evoluíram juntos. Cada modelo de ponta novo (Opus 5.5 em 22/09, Sonnet 5.5 em 28/09) chega primeiro no agente do próprio fabricante.
- Preço e cota pesam. A JetBrains sugere que os usuários mais intensos do Codex podem estar buscando custo-benefício, já que ele historicamente oferece cotas maiores.
3. Quanto código os agentes escrevem de fato?
Você já ouviu "100% do meu código é escrito por IA". Uma análise complementar da JetBrains perguntou aos devs qual fatia do código de trabalho do último mês foi escrita inteiramente por agentes, com ajuda de IA, ou totalmente à mão.
| Métrica | Valor |
|---|
| Média escrita inteiramente por agentes | ~47% |
| Escrita com alguma ajuda de IA | ~38% |
| Escrita totalmente à mão | ~27% |
| Devs com mais de 80% do código gerado por agentes | ~22% (minoria) |
| Devs que não escrevem nenhuma linha sem IA | 1 em cada 5 |
(As médias passam de 100% porque as respostas eram por faixas e a conta usou o ponto médio de cada faixa.)
Agrupando as respostas, surgiram três perfis:
- Agentic coders (~31%): ~84% do código vem de agentes.
- AI-assisted coders (~47%): ~40% vem de agentes, mas a maior parte ainda é conduzida com ajuda de IA e uma parte escrita à mão.
- Manual coders (~23%): ~75% escrito à mão, IA usada de vez em quando.
Outros padrões que valem saber:
- Seniores delegam mais, não menos. Cerca de um quarto dos seniores gera mais de 80% do código com agentes; juniores tendem ao modo assistido. Delegar exige critério: saber o que pedir e como revisar.
- A stack importa. Devs de Go, JavaScript e TypeScript são os mais "agênticos" (~54–55% do código por agentes); C/C++ os menos (~38%). Front-end e back-end web ficam no topo.
- A região importa. Na China, Japão e Coreia do Sul, 32–35% dos devs geram mais de 80% do código com agentes, cerca do dobro da Europa/Reino Unido (~16%).
- O público da ferramenta importa. 42% dos usuários intensos do Codex passam de 80% de código gerado, contra 32% no Claude Code. A leitura da JetBrains: o Claude Code virou mainstream, então seu público já não é só de power users.
4. A pilha de protocolos: MCP, ACP, Skills
A fatia de mercado vai continuar mudando. O que diminui o risco de escolher uma ferramenta é que a indústria convergiu para padrões abertos em três camadas diferentes. Pense num agente de código como um profissional: ele precisa de uma mesa (onde trabalha), de ferramentas (o que pode tocar) e de know-how (procedimentos que segue).
| Camada | Padrão | Pergunta que responde | Origem |
|---|
| Mesa | ACP (Agent Client Protocol) | "Onde o agente mora dentro do meu editor?" | Zed, ago/2025; JetBrains co-desenvolve desde out/2025 |
| Ferramentas | MCP (Model Context Protocol) | "Que dados e ações o agente alcança?" | Anthropic, nov/2024; hoje sob a Agentic AI Foundation |
| Know-how | Agent Skills (SKILL.md) | "Como o agente deve fazer esta tarefa específica?" | Anthropic, padrão aberto desde dez/2025; 40+ clientes adotaram |
MCP e Skills já apareceram em edições anteriores do IA Watch (20/08 e 01/09). O ACP é a peça que pouca gente conhece ainda, então vamos dar zoom nele.
5. ACP de perto: o "LSP dos agentes"
Antes do Language Server Protocol, cada editor precisava construir seu próprio suporte a TypeScript, sua própria integração com linter de Python, e assim por diante. O LSP fez um único servidor de linguagem funcionar em qualquer editor. O ACP aplica a mesma ideia aos agentes: qualquer agente compatível roda em qualquer editor compatível, sem plugin específico para cada par.
Como funciona
- Modelo de subprocesso: o editor inicia o agente como processo filho e os dois conversam via JSON-RPC 2.0 por stdin/stdout, o mesmo transporte do LSP.
- Sessões: o editor cria uma sessão com histórico, envia prompts, e o agente devolve atualizações em streaming, token a token.
- Permissões: antes de rodar um comando no terminal ou gravar um arquivo, o agente manda uma mensagem
session/request_permission; o editor (você) aprova ou nega.
- Repasse de MCP: no início da sessão, o editor entrega ao agente os servidores MCP que você configurou. Você configura as ferramentas uma vez, no editor, e qualquer agente plugado pode usá-las.
As cinco mensagens básicas
session/initialize (capacidades) → session/new (abre conversa) → session/prompt (usuário pede) → session/update (agente responde em streaming) → session/cancel (interrompe no meio)
Quem suporta
- Editores: Zed (nativo, o mais completo), IDEs JetBrains (nativo; Claude Agent, Codex, Copilot e OpenCode vêm embutidos no chat de IA, e outros como o Cursor entram via ACP), Neovim e Emacs (plugins da comunidade, estáveis). O VS Code não tem suporte nativo; a Microsoft padronizou o modo agente dele em MCP (situação em março de 2026).
- Agentes: mais de 25 em março de 2026. Gemini CLI, GitHub Copilot CLI, Goose, Cline e OpenHands nativamente; Claude Code e Codex CLI via adaptadores.
Prós e contras
| Prós | Contras |
|---|
| Troca de agente sem trocar de editor (nem reaprender o fluxo). | Os maiores agentes rodam via adaptador, então recursos podem chegar depois do app oficial. |
| Configura as ferramentas MCP uma vez e reaproveita em qualquer agente. | Sem suporte nativo no VS Code, que é o editor mais usado. |
| Pedidos de permissão uniformes entre agentes. | Mais um padrão em movimento para acompanhar; ainda na versão 1. |
6. Como escolher sem ficar preso
Um jeito prático de pensar, seja qual for a ferramenta que você usa hoje:
- Escolha o agente pelo modelo e pelo loop, não pela marca. Rode em 3 a 5 tarefas reais do seu trabalho (um bug, uma feature pequena, um refactor com testes) e compare resultado final e custo por tarefa.
- Coloque suas ferramentas em MCP. Banco de dados, busca em docs, gerenciador de issues: se forem servidores MCP, vão junto com você para qualquer agente.
- Coloque seus procedimentos em Skills e em arquivos simples. Convenções do repositório num arquivo de instruções do projeto, fluxos repetíveis (ex.: "como escrevemos uma migration") como
SKILL.md. Os dois são texto portátil, não configuração de fornecedor.
- Se você vive no Zed, JetBrains, Neovim ou Emacs, teste o ACP para trocar de agente no mesmo painel.
- Mantenha o músculo da revisão. Os dados mostram que seniores delegam mais porque conseguem julgar o resultado. Aumente a delegação conforme sua capacidade de revisar cresce, não antes.
Exemplo genérico: um setup portátil
Um time pequeno construindo um web app com banco Postgres:
- Ferramentas (MCP): um servidor MCP de Postgres (só leitura em dev), um de busca em documentação, um de navegador para checar a UI.
- Know-how (Skills):
skills/write-migration/SKILL.md, skills/add-api-endpoint/SKILL.md.
- Regras: um arquivo de instruções do projeto com a stack, o comando de teste e "nunca mexa no
.env".
- Agente: o que vencer o teste de 5 tarefas do próprio time neste trimestre. Se aparecer um melhor no próximo, eles trocam o agente e mantêm todo o resto.
A lição: o ranking vai estar diferente daqui a seis meses. Suas ferramentas, procedimentos e hábitos de revisão não precisam mudar junto. Invista nas camadas que são padronizadas e trate o agente em si como a peça trocável.