A programação assistida por Inteligência Artificial passou por uma transformação profunda em poucos anos.

A primeira geração de ferramentas era essencialmente baseada em autocomplete. O desenvolvedor começava a escrever uma função e o modelo tentava completar o restante do código.

A geração seguinte colocou um chat dentro do ambiente de desenvolvimento. Passamos a conversar com o modelo, pedir explicações, solicitar funções inteiras e discutir erros sem abandonar o editor.

Em 2026 estamos entrando definitivamente em uma terceira fase: a Programação Agêntica.

Agora, o sistema de IA não apenas sugere código. Ele pode receber uma tarefa relativamente abstrata, analisar um repositório inteiro, procurar arquivos relevantes, elaborar um plano, modificar o código, executar comandos, rodar testes, interpretar os erros, consultar documentação, utilizar ferramentas externas, criar subagentes especializados e continuar trabalhando até atingir determinado objetivo. E quando combinado com SDD (Spec-Driven Development) conseguimos um poderoso ambiente de desenvolvimento baseado em IA e baseado em especificações.

Nesse novo cenário, escolher o modelo de linguagem deixou de ser a única decisão importante. Entre o desenvolvedor e o LLM surgiu uma nova camada de software: o Coding Agent ou Agente de Programação.

Claude Code, OpenAI Codex, Kimi Code, OpenCode, Deep Agents Code, GitHub Copilot CLI, Cursor, Hermes, Devin e Google Antigravity são alguns dos exemplos mais importantes dessa nova categoria.

Embora todos possam produzir código, as diferenças de arquitetura entre eles são significativas.

Este artigo considera o estado atual dessas tecnologias e apresenta uma visão consolidada com um mapa bem completo do novo ecossistema de Programação Agêntica.

No turbilhão de informações e opiniões hoje na internet, ter um material organizado, estruturado e profissional como o que a Data Science Academy oferece, economiza tempo, reduz o ruído e evita obter conhecimento impreciso. Aproveite.

Boa leitura.

O Que Realmente Define Um Agente de Programação?

Considere uma solicitação como esta:

> “Analise este projeto, descubra por que os testes estão falhando, corrija o problema e confirme que a aplicação continua funcionando.”

Um chatbot tradicional poderia sugerir hipóteses ou produzir trechos de código. Um agente de programação pode fazer muito mais.

Ele pode abrir os arquivos do projeto, pesquisar referências, entender a arquitetura, executar os testes, observar os erros, alterar vários arquivos, testar novamente e continuar iterando. Mostramos isso na prática em Desenvolvimento Full Stack com IA Generativa e Agentes de IA.

Essa capacidade surge da combinação entre o LLM e uma infraestrutura ao seu redor. É aqui que aparece um conceito cada vez mais importante: o Agent Harness.

Podemos imaginar o LLM como o cérebro. O harness fornece os mecanismos através dos quais esse cérebro interage com o mundo: ferramentas, filesystem, terminal, memória, contexto, políticas de segurança, permissões, execução de comandos, Skills, subagentes e integrações externas.

Claude Code, Codex e OpenCode não são simplesmente modelos. Eles são sistemas que organizam a interação entre modelos e ferramentas. Esse princípio é fundamental para entender a Programação Agêntica atual.

Modelo, Provider, Runtime, Framework, Harness e Coding Agent

Uma das confusões mais comuns atualmente é tratar todas essas tecnologias como se pertencessem à mesma categoria. Não pertencem.

Um modelo, como Claude, GPT, Gemini, Kimi ou um modelo open weight, fornece a capacidade de raciocínio e geração.

Um provider fornece acesso ao modelo através de uma API ou infraestrutura de inferência.

Um runtime de inferência, como Ollama ou LM Studio, permite executar modelos em determinado ambiente, inclusive localmente.

Um framework de agentes, como LangChain, fornece abstrações para construir sistemas baseados em modelos, ferramentas e agentes.

Um runtime de orquestração, como LangGraph, cuida de aspectos como execução persistente, estado, checkpoints, streaming e workflows.

Um agent harness, como Deep Agents, acrescenta componentes de nível mais alto como filesystem, planejamento, gerenciamento de contexto, memória e subagentes. A própria documentação do LangChain, apresenta LangChain como framework, LangGraph como runtime de orquestração e Deep Agents como agent harness.

Finalmente, um Coding Agent é a aplicação pronta para trabalhar diretamente sobre software.

Essas camadas nem sempre aparecem separadamente. Claude Code, por exemplo, encapsula várias delas em um único produto. Mas compreender essa separação será cada vez mais importante.

Vamos explorar os principais Assistentes de Programação Agêntica (Coding Agents) hoje no mercado.

Claude Code

Claude Code continua sendo uma das implementações mais completas do conceito de agente de programação.

A ferramenta da Anthropic nasceu fortemente orientada ao terminal, mas hoje se estende a outros ambientes de desenvolvimento. Ela consegue explorar projetos, editar arquivos, executar comandos, rodar testes e trabalhar durante várias etapas sobre uma mesma tarefa.

Seu ecossistema inclui `CLAUDE.md`, Skills, Hooks, MCP, plugins, sistemas de permissões e subagentes. Os subagentes podem possuir prompts, ferramentas, permissões, Skills e Hooks próprios, permitindo criar especialistas para diferentes partes de um problema.

Os Hooks constituem um recurso particularmente poderoso. Eles permitem executar automaticamente comandos, endpoints ou outras ações em momentos específicos do ciclo do agente. Uma equipe pode, por exemplo, obrigar a execução de testes ou verificações depois de modificações no projeto.

A principal vantagem do Claude Code é a integração profunda entre harness e modelos Claude. A Anthropic controla os dois lados da arquitetura e consegue otimizar o comportamento dos modelos para programação, uso de ferramentas e execução agêntica.

A principal limitação aparece quando o objetivo é utilizar constantemente modelos de fabricantes diferentes ou montar um laboratório totalmente orientado à inferência local. Claude Code pode participar de arquiteturas mais abertas, mas não foi concebido prioritariamente como um harness universal para qualquer modelo.

Ideal para: desenvolvimento profissional, grandes bases de código, debugging, refatoração, criação de testes e workflows sofisticados com subagentes.

Para quem utiliza Claude como modelo principal, continua sendo uma das primeiras escolhas.

Aqui na Data Science Academy oferecemos um curso de bônus sobre Claude Code para alunos de todas as Formações e todos os Programas de Pós-Graduação. Também oferecemos um e-book gratuito: E-book Claude Code – O Guia Prático Completo.

Visite a documentação oficial: Claude Code

OpenAI Codex

O Codex atual é muito diferente da primeira geração do produto associada apenas à geração de código.

O Codex tornou-se uma plataforma agêntica que atravessa terminal, IDE e execução em Cloud. O Codex CLI pode ler, modificar e executar código diretamente na máquina do desenvolvedor. Um dos aspectos particularmente interessantes da evolução recente é a possibilidade de combinar desenvolvimento local com diferentes ambientes e modelos.

O Codex CLI suporta configuração de providers e possui tratamento específico para execução através de Ollama e LM Studio no modo destinado a modelos locais. Isso significa que o Codex pode funcionar não apenas como interface para modelos OpenAI, mas também como harness para determinados experimentos de inferência local.

Essa capacidade é importante porque separa, novamente, duas decisões: qual agente utilizar e qual modelo colocar por trás dele.

A principal vantagem do Codex é a combinação entre um harness sofisticado, integração com o ecossistema OpenAI, terminal, IDE, automação e possibilidades de execução remota.

A principal limitação é que substituir um modelo OpenAI por um modelo local não garante automaticamente a mesma qualidade de comportamento agêntico. Um agente depende fortemente da capacidade do modelo de raciocinar, seguir instruções, utilizar ferramentas e interpretar resultados.

Ideal para: desenvolvimento profissional, automação de engenharia, pipelines, ambientes OpenAI e experimentação com uma combinação de agentes locais e remotos.

Visite a documentação oficial: OpenAI Codex

OpenCode

OpenCode ocupa uma posição especialmente interessante porque foi construído com forte independência em relação ao modelo e é open-source.

Em vez de organizar todo o produto em torno de uma única família de LLMs, OpenCode tenta separar deliberadamente o agente da inferência.

Sua documentação atualmente suporta dezenas de providers e também modelos executados localmente. Ollama e LM Studio podem participar diretamente dessa arquitetura.

Essa separação permite algo muito interessante: Você pode utilizar OpenCode com determinado modelo local via Ollama, trocar para outro através de LM Studio e depois utilizar modelos comerciais através de providers externos sem necessariamente abandonar o agente.

OpenCode também possui ferramentas, sistemas de permissões e uma arquitetura cada vez mais extensível. As permissões permitem definir ações que podem ser executadas automaticamente, ações que exigem aprovação e ações proibidas.

A principal vantagem é a liberdade arquitetural.

A desvantagem é que essa liberdade transfere parte da responsabilidade para o usuário. A qualidade final passa a depender fortemente do modelo escolhido, contexto, capacidade de tool calling, configuração e permissões.

Ideal para: laboratórios de IA, pesquisa, modelos locais e ambientes em que independência de fornecedor é uma prioridade.

Visite a documentação oficial: OpenCode

Deep Agents e Deep Agents Code

Deep Agents merece uma posição própria porque ajuda a compreender uma distinção arquitetural fundamental. Deep Agents não é simplesmente um coding agent.

Desenvolvido pela LangChain sobre LangGraph, Deep Agents é um “agent harness open-source”. Ele fornece recursos como filesystem para gerenciamento de contexto, memória, subagentes e outras capacidades destinadas a agentes que precisam executar tarefas complexas durante várias etapas.

Isso significa que Deep Agents pode ser utilizado para construir muito mais do que ferramentas de programação. Uma empresa pode utilizá-lo para criar agentes de pesquisa, automação, análise ou sistemas especializados internos.

Mas existe também o Deep Agents Code ou “dcode”.

Deep Agents Code é um coding agent open-source construído sobre o Deep Agents SDK. Ele funciona no terminal, oferece memória persistente, Skills, controles de aprovação e permite trocar providers e modelos.

A arquitetura fica bastante clara:

LangChain → LangGraph → Deep Agents → Deep Agents Code

  • LangChain fornece abstrações e integrações.
  • LangGraph fornece a orquestração.
  • Deep Agents fornece o harness.
  • Deep Agents Code fornece a aplicação de programação pronta para o desenvolvedor.

Outro diferencial importante é a independência de modelo. Deep Agents Code suporta modelos compatíveis com LangChain e serviços que exponham APIs compatíveis com OpenAI ou Anthropic. OpenAI, Anthropic e Google possuem integração direta e outros providers podem ser adicionados.

A grande vantagem é a capacidade de customização.

Se Claude Code representa um produto pronto e profundamente integrado ao ecossistema Anthropic, Deep Agents representa uma abordagem muito interessante para organizações que desejam construir sua própria infraestrutura agêntica.

A desvantagem é justamente a complexidade adicional. Para simplesmente instalar uma ferramenta e começar a programar, existem alternativas mais diretas.

Ideal para: Engenheiros de IA, pesquisa, criação de coding agents internos, plataformas corporativas e estudo da arquitetura de sistemas agênticos.

Deep Agents é uma das tecnologias que vale observar com mais atenção nos próximos anos. Visite a documentação oficial: Deep Agents Code.

Kimi Code

Kimi Code, desenvolvido pela Moonshot AI, tornou-se outro representante importante da nova geração de coding agents.

A ferramenta trabalha principalmente a partir do terminal e oferece Skills, MCP, Hooks, plugins e uma arquitetura de subagentes especializados. Os agentes `coder`, `explore` e `plan`, por exemplo, podem trabalhar em contextos isolados, evitando que toda informação intermediária contamine o contexto principal.

Essa arquitetura representa uma tendência importante. Em vez de fazer um único agente realizar todas as tarefas, o sistema começa a distribuir responsabilidades entre agentes especializados.

A principal vantagem do Kimi Code é combinar uma arquitetura moderna com relativa flexibilidade em relação a modelos e integrações.

Sua principal desvantagem é a velocidade de evolução. Ferramentas desse tipo mudam rapidamente, exigindo acompanhamento frequente da documentação.

Ideal para: experimentação, pesquisa, usuários da família Kimi e estudo de arquiteturas com subagentes.

Visite a documentação oficial: Kimi Code

Hermes Agent

Hermes, da Nous Research, ocupa uma categoria um pouco diferente.

Ele não tenta ser apenas um coding agent. É um agente pessoal generalista que também possui capacidades importantes para programação.

Hermes trabalha com memória persistente, histórico, ferramentas e Skills, incluindo um mecanismo particularmente interessante no qual o próprio agente pode consolidar procedimentos aprendidos e reutilizá-los posteriormente. A Nous Research descreve o produto como um agente capaz de criar e melhorar Skills a partir da experiência.

Sua arquitetura também é bastante aberta em relação aos modelos. Há suporte documentado para providers em Cloud, como OpenRouter e Anthropic, e para endpoints auto hospedados, como Ollama e vLLM.

Conversas, memória e Skills podem permanecer armazenadas localmente, dependendo da configuração utilizada. Isso aproxima Hermes de um conceito mais amplo: o “agente persistente”. Em vez de pensar apenas em uma sessão de programação, você pode imaginar um agente que permanece associado ao seu ambiente, acumula procedimentos e trabalha sobre diferentes atividades.

Essa é sua principal vantagem e também sua principal desvantagem.

Para quem quer apenas corrigir rapidamente uma função, Claude Code, Codex ou Cursor provavelmente serão mais diretos.

Ideal para: usuários avançados, home labs, pesquisa, automações persistentes e agentes pessoais auto hospedados.

Visite a documentação oficial: Hermes Agent

GitHub Copilot CLI

GitHub Copilot também evoluiu muito além de seu papel original como autocomplete.

Copilot CLI consegue trabalhar diretamente no terminal e possui mecanismos de customização como agentes especializados, Skills, Hooks e MCP.

Seu maior diferencial continua sendo o ecossistema GitHub.

Issues, pull requests, repositórios, revisão de código e agentes em Cloud podem participar do mesmo fluxo de engenharia. Isso torna Copilot particularmente atraente para empresas que já possuem grande parte de seus processos de desenvolvimento concentrados no GitHub.

Sua arquitetura, entretanto, não possui como objetivo principal servir de harness universal para qualquer servidor local.

A principal vantagem é a integração com o ciclo de desenvolvimento baseado no GitHub.

A principal limitação é a maior dependência do ecossistema e do catálogo disponibilizado pela plataforma.

Ideal para: organizações fortemente baseadas em GitHub, pull requests, issues, revisão de código e CI/CD.

Visite a documentação oficial: GitHub Copilot CLI

Cursor

Cursor começou sendo associado principalmente à ideia de um editor com IA, mas evoluiu claramente na direção dos coding agents.

A documentação atual descreve Cursor como um agente capaz de compreender codebases, planejar funcionalidades, corrigir bugs, revisar alterações e trabalhar com ferramentas externas. O ecossistema inclui Agent, Rules, Skills, MCP, CLI e outros mecanismos de customização.

Além da execução local, Cursor possui “Cloud Agents”, que podem trabalhar sobre repositórios em ambientes remotos e utilizar servidores MCP configurados para a equipe. A experiência integrada ao editor continua sendo seu maior diferencial.

Enquanto Claude Code, Codex e OpenCode possuem forte identidade ligada ao terminal, Cursor mantém o agente profundamente integrado ao ambiente visual de desenvolvimento.

Também existem mecanismos de controle sobre execução de comandos, MCP e outras ferramentas, incluindo modos com sandbox e aprovação.

A principal vantagem é a experiência de desenvolvimento.

A principal limitação aparece para quem deseja máxima independência de provider ou pretende construir um laboratório centrado em inferência local.

Ideal para: desenvolvedores que passam grande parte do dia em um editor visual e desejam combinar IDE e agente no mesmo produto.

Visite a documentação oficial: Cursor

Devin e Devin Desktop

Devin representa outra filosofia.

Em vez de pensar apenas em um assistente trabalhando ao lado do desenvolvedor, sua proposta enfatiza a delegação de trabalho para agentes de engenharia.

O ecossistema atual inclui Devin Cloud, Devin Desktop, Devin CLI e Devin Review.

Uma mudança importante ocorreu em junho de 2026: Windsurf passou a se chamar Devin Desktop, consolidando o IDE e a estratégia de agentes da Cognition sob a mesma marca.

Devin Desktop mantém a experiência do antigo Windsurf, mas coloca gerenciamento de agentes em posição muito mais central. O Agent Command Center inclui recursos destinados à coordenação de vários agentes.

Devin também pode executar tarefas autonomamente na Cloud, enquanto o trabalho pode ser delegado e revisado diretamente pelo ambiente desktop.

Isso aproxima a experiência de algo semelhante a gerenciar uma pequena equipe virtual de engenharia.

A principal vantagem é a delegação.

A principal limitação é que essa plataforma pode ser excessiva para tarefas pequenas e possui uma arquitetura mais proprietária do que alternativas como OpenCode ou Deep Agents.

Ideal para: organizações interessadas em delegar tickets e tarefas completas para agentes locais e remotos.

Visite a documentação oficial: Devin

Google Antigravity

A estratégia do Google para desenvolvimento agêntico mudou significativamente em 2026.

Em maio, o Google anunciou a transição dos usuários individuais do Gemini CLI para Antigravity CLI. O novo produto preservou elementos importantes como Agent Skills, Hooks, subagentes e extensões, agora organizadas como plugins do Antigravity.

Antigravity possui uma proposta mais ampla do que simplesmente oferecer um chat para programação.

Seu ecossistema inclui CLI, Skills, plugins e um SDK que permite construir agentes sobre o próprio Antigravity Harness. O SDK oferece ferramentas customizadas, políticas de segurança, lifecycle hooks e criação programática de subagentes.

Isso coloca o Google diretamente na disputa não apenas pelos modelos, mas pela camada de harness e infraestrutura agêntica.

A principal vantagem é a integração com Gemini e o ecossistema Google.

A principal limitação, para laboratórios totalmente orientados a modelos locais, é que OpenCode, Hermes e Deep Agents oferecem caminhos mais naturais para esse tipo de experimentação.

Ideal para: usuários de Gemini, Google Cloud e organizações interessadas na plataforma agêntica do Google.

Visite a documentação oficial: Google Antigravity

Grok Build

Grok Build é o Coding Agent da xAI voltado especificamente para programação agêntica e uso direto no terminal.

A ferramenta utiliza os modelos Grok como base de raciocínio, mas acrescenta a camada necessária para transformar o LLM em um agente capaz de trabalhar sobre projetos reais de software. Isso inclui analisar repositórios, localizar arquivos relevantes, modificar código, executar comandos, rodar testes, interpretar erros e continuar iterando sobre uma tarefa.

O Grok Build oferece uma CLI oficial e uma interface interativa no terminal. O desenvolvedor pode entrar no diretório de um projeto, executar o comando `grok` e começar a trabalhar de maneira semelhante ao que acontece com Claude Code, Codex CLI e Gemini CLI.

A ferramenta também oferece recursos importantes para Programação Agêntica, incluindo planejamento de tarefas, execução autônoma, gerenciamento de permissões, suporte a MCP, Skills, plugins, hooks, Git worktrees e subagentes. O modo baseado em objetivos permite fornecer uma tarefa mais ampla e deixar o agente decompor o problema, executar as etapas necessárias e verificar o resultado.

Outro aspecto interessante é a compatibilidade com elementos já utilizados por outros Coding Agents. Grok Build pode trabalhar com arquivos como `AGENTS.md` e possui compatibilidade com diversas convenções do ecossistema Claude Code, incluindo `CLAUDE.md`, Skills, MCPs, agentes e hooks. Isso reduz o custo de experimentar a ferramenta em projetos que já utilizam outras soluções de Programação Agêntica.

Diferentemente de ferramentas independentes de modelo como OpenCode, Grok Build está fortemente integrado ao ecossistema da xAI e aos modelos Grok. Essa integração pode permitir melhor alinhamento entre modelo e Agent Harness, mas também cria maior dependência de um único fornecedor.

A principal vantagem é oferecer uma experiência integrada de Programação Agêntica usando os modelos Grok, com uma CLI moderna e recursos avançados de autonomia, ferramentas e subagentes.

A desvantagem é justamente a menor independência arquitetural em relação ao modelo e ao provider quando comparado a ferramentas como OpenCode, Cline ou outros agentes que permitem alternar livremente entre diferentes famílias de LLMs.

Ideal para: desenvolvedores que desejam experimentar os modelos Grok em workflows de Programação Agêntica, usuários do ecossistema xAI e ambientes em que tarefas autônomas executadas diretamente pelo terminal são uma prioridade.

Visite a documentação oficial: Grok Build

Aider

Aider merece permanecer neste panorama mesmo que sua filosofia seja mais próxima de “pair programming avançado” do que das grandes plataformas multiagente atuais.

Ele trabalha diretamente com repositórios Git a partir do terminal e permite solicitar alterações, executar verificações e manter as modificações organizadas dentro do fluxo do Git.

Uma de suas maiores vantagens sempre foi a flexibilidade em relação aos modelos.

A documentação permite conectar Aider a diferentes LLMs, incluindo modelos através de OpenRouter e modelos executados localmente.

Aider também ficou conhecido pelos benchmarks voltados especificamente para edição de código, tornando o projeto interessante para comparar modelos.

Sua principal vantagem é a simplicidade.

Sua principal limitação é justamente não possuir (ainda) toda a infraestrutura de subagentes, execução remota, memória, Skills e orquestração encontrada nas plataformas mais novas.

Ideal para: desenvolvedores que desejam um parceiro de programação simples, transparente, baseado em terminal e Git.

Visite a documentação oficial: Aider

Onde Entram Ollama, LM Studio e OpenRouter?

Ollama, LM Studio e OpenRouter são extremamente importantes neste ecossistema, mas não devem ser confundidos com coding agents.

Ollama fornece uma maneira prática de executar e servir modelos, especialmente modelos open weight, localmente. A própria plataforma atualmente destaca integrações com ferramentas como OpenCode e Hermes.

LM Studio também permite baixar, executar e servir modelos localmente, inclusive através de APIs consumidas por coding agents.

Eles funcionam, portanto, principalmente como parte da camada de inferência. Ollama e LM Studio são estudados em diversos cursos aqui na DSA, em especial na Formação Agentic AI Engineer 4.0.

Já OpenRouter ocupa outra posição. Ele fornece uma interface unificada para centenas de modelos e diversos providers, permitindo que uma aplicação troque de modelo sem precisar implementar integração individual com cada fornecedor.

Podemos ter, por exemplo:

“OpenCode → Ollama → modelo local”

ou

“Hermes → OpenRouter → modelo em Cloud”

ou

“Deep Agents Code → provider compatível → modelo escolhido”.

Esse desacoplamento é uma das mudanças mais importantes da Programação Agêntica.

Então, Qual Ferramenta Escolher?

Se o objetivo principal for “desenvolvimento profissional utilizando Claude”, a primeira escolha seria o Claude Code.

Se quiser “integração forte com OpenAI, desenvolvimento local e possibilidades de execução remota”, avalie o Codex.

Se a prioridade for “independência de modelo”, OpenCode faria bastante sentido.

Se quiser “construir o próprio agente ou a própria plataforma agêntica”, considere LangGraph e Deep Agents. Se deseja utilizar essa arquitetura pronta diretamente no terminal, experimentaria Deep Agents Code.

Para um “laboratório com Ollama, LM Studio e diversos modelos locais”, provavelmente o ideal seria começar com OpenCode e comparar seu comportamento com Codex, Hermes, Deep Agents Code e Aider.

Para um “agente persistente e generalista”, Hermes é particularmente interessante.

Para um ambiente centrado no “GitHub”, Copilot CLI oferece uma integração difícil de ignorar.

Para uma experiência profundamente integrada ao “editor”, Cursor continua entre as principais alternativas.

Para “delegação de tarefas para equipes de agentes”, Devin merece atenção.

Para usuários do ecossistema “Google e Gemini”, Antigravity tornou-se a plataforma que precisa ser observada.

E para quem deseja algo relativamente simples, transparente e fortemente baseado em terminal e Git, Aider continua sendo uma excelente alternativa.

A Nova Arquitetura da Programação Agêntica

Talvez a conclusão mais importante seja perceber que a disputa deixou de ser apenas:

Claude contra GPT contra Gemini contra Kimi

A arquitetura está ficando muito mais modular. Agora existem diferentes camadas:

Modelo → Provider → Runtime de Inferência → Framework → Runtime de Orquestração → Agent Harness → Coding Agent → Ferramentas

Nem todo produto separa essas camadas explicitamente.

  • Claude Code reúne várias delas.
  • OpenCode procura separar agente e modelo.
  • LangChain fornece abstrações para construção.
  • LangGraph fornece orquestração.
  • Deep Agents fornece o harness.
  • Deep Agents Code fornece o coding agent.
  • Ollama e LM Studio fornecem infraestrutura de inferência local.
  • OpenRouter fornece acesso e roteamento entre modelos e providers.
  • MCP padroniza parte da comunicação entre agentes e ferramentas externas.
  • Skills começam a funcionar como unidades reutilizáveis de conhecimento e procedimentos.
  • Hooks permitem aplicar comportamentos determinísticos em diferentes pontos do ciclo do agente.
  • Subagentes distribuem problemas entre especialistas com contextos próprios.

E sistemas de permissões e sandboxes começam a definir até onde esses agentes podem agir autonomamente.

De Coding Agents Para Engenharia de Sistemas de Agentes

Essa modularidade abre possibilidades muito interessantes.

Um desenvolvedor pode utilizar OpenCode como coding agent, Ollama como runtime de inferência e um modelo open weight executado em sua própria workstation.

Depois pode manter OpenCode e substituir apenas a inferência por OpenRouter.

Pode trocar OpenCode por Deep Agents Code e continuar experimentando os mesmos modelos.

Uma empresa pode ir ainda mais longe e utilizar LangGraph e Deep Agents para construir um agente de programação próprio, integrado aos seus repositórios, documentação, sistemas internos, políticas de segurança e infraestrutura.

Portanto, a pergunta relevante deixa gradualmente de ser:

“Qual é o melhor modelo para programação?”

E passa a ser:

“Qual combinação de modelo, provider, runtime, harness, agentes, ferramentas, memória, protocolos e infraestrutura produz o melhor sistema de engenharia de software?”

Essa mudança é muito mais profunda do que simplesmente adicionar Inteligência Artificial ao editor de código.

Estamos passando da programação com um chatbot para ambientes nos quais agentes planejam, executam, verificam, colaboram e aprendem procedimentos.

É exatamente nesse ponto que a Programação Agêntica começa a se transformar em Engenharia de Sistemas de Agentes de IA. E se quiser desenvolver essas habilidades na prática e de forma profissional, oferecemos duas Formações com esse perfil:

Formação AI Software Engineer 4.0

Formação Forward Deployed Engineer 4.0

Equipe DSA