Transforme a IA em um sistema de execução independente: o mais recente Guia de Melhores Práticas de Agentes Gerenciados da Claude

Título original do artigo: Lançamento do Claude Managed Agents
Autor original: Lance Martin
Tradução: Peggy, BlockBeats

Nota do editor: Este artigo apresenta os Agentes Gerenciados lançados pela Claude. Ele oferece uma forma de software mais próxima do futuro: os agentes inteligentes não são mais interfaces que respondem a solicitações uma única vez, mas sim sistemas de execução que podem ser configurados, implantados, programados e operados a longo prazo.

Ao separar completamente a "inteligência" (modelo e estrutura de tempo de execução), a "execução" (ferramentas e sandbox) e o "processo" (sessão e registro), o Claude Managed Agents transforma o agente de uma "lógica no código" em uma unidade de infraestrutura independente. Esse projeto não só aumenta a estabilidade e a segurança do sistema em tarefas de longa duração, como também permite que os agentes se expandam continuamente à medida que as capacidades do modelo evoluem, sem as limitações impostas pelas estruturas existentes.

Nesse contexto, os padrões de uso comuns também mudaram: passando da execução acionada por eventos e programada para a execução automática do tipo “trigger-on-delivery” e para tarefas complexas que se estendem por dias ou até semanas, os agentes adquirem verdadeiramente a capacidade de “trabalhar continuamente”. Isso significa que o valor da IA não se reflete mais apenas na qualidade de uma única resposta, mas em sua capacidade de acumular e se multiplicar ao longo do tempo.

Se as APIs anteriores permitiam aos desenvolvedores “invocar inteligência”, os Agentes Gerenciados tentam agora responder a outra questão: como transformar a inteligência em um sistema que possa ser hospedado, programado e executado continuamente. Nesse sentido, os agentes não são mais apenas ferramentas, mas se aproximam de uma nova primitiva computacional.

O artigo original é o seguinte:

RESUMO

Os Claude Managed Agents são uma estrutura de execução de agentes pré-configurada e personalizável (agent harness) que é executada em uma infraestrutura gerenciada. Basta definir um agente como um modelo — incluindo ferramentas, competências, repositórios de arquivos/código etc. — e o restante da estrutura de execução e da infraestrutura é fornecido pelo sistema. Este sistema foi projetado para acompanhar o rápido crescimento dos níveis de inteligência do Claude e dar suporte a tarefas de longa duração.

Links relacionados:

·Blog do Claude: Padrões de uso e casos de clientes

·Blog de Engenharia: Concepção dos Agentes Gerenciados pelo Claude

·Documentação: Guia de Introdução, Início Rápido, Visão Geral da CLI e do SDK

Agentes gerenciados pelo Claude

Por que são necessários os Agentes Gerenciados da Claude

A API de mensagens do Claude é, essencialmente, um ponto de entrada para interagir diretamente com o modelo: insira uma mensagem e receba um bloco de conteúdo. Os agentes inteligentes desenvolvidos com base na API de mensagens precisam contar com uma "estrutura de tempo de execução" para lidar com o roteamento de chamadas de ferramentas, o gerenciamento de contexto e muito mais. No entanto, isso apresenta vários desafios:

1. A estrutura de execução precisa acompanhar a evolução das capacidades do Claude
Recentemente, escrevi uma postagem no blog sobre como criar um agente com base nos recursos subjacentes da API do Claude para lidar com a orquestração de ferramentas e o gerenciamento de contexto. No entanto, o problema é que a estrutura de execução do agente frequentemente pressupõe certas limitações sobre “o que o Claude não pode fazer”. À medida que as capacidades do Claude aumentam, essas premissas rapidamente se tornam obsoletas e podem até mesmo se tornar gargalos de desempenho. Portanto, a estrutura de execução deve ser atualizada continuamente para acompanhar o ritmo de evolução do Claude.

2. Os ciclos de vida das tarefas do Claude estão ficando mais longos
A variedade de tarefas que o Claude é capaz de realizar está crescendo exponencialmente, ultrapassando 10 horas de trabalho humano nos testes de benchmark do METR. Isso impõe exigências mais rigorosas à infraestrutura subjacente do agente: ela deve oferecer segurança, estabilidade em cenários de execução prolongada (sendo capaz de lidar com diversas falhas de infraestrutura) e escalabilidade (por exemplo, suportando várias equipes de agentes em execução simultânea).

Por que esses desafios são importantes

É fundamental enfrentar os desafios mencionados acima, pois prevemos que as futuras versões do Claude serão capazes de operar continuamente por períodos de dias, semanas ou até meses, lidando com os problemas mais complexos da humanidade.

O Claude Agent SDK é o primeiro passo nessa direção, oferecendo uma estrutura de execução de agentes inteligentes de uso geral e fácil de usar. Por sua vez, os Claude Managed Agents vão um passo além: com base nessa estrutura, eles oferecem uma estrutura de tempo de execução completa + infraestrutura gerenciada, projetada especificamente para garantir a execução segura e confiável de tarefas por longos períodos.

Introdução

Uma maneira simples de começar é usando nossa skill de código aberto claude-api, que pode ser utilizada imediatamente no Claude Code. Basta instalar a versão mais recente do Claude Code e, em seguida, executar o subcomando a seguir para concluir a configuração de inicialização do Claude Managed Agents.

Pessoalmente, tenho uma forte preferência pela abordagem baseada em “habilidades” para integrar novas funcionalidades e utilizo amplamente essa abordagem na prática.

Além disso, você pode consultar nossa documentação para começar rapidamente a usar o SDK ou a CLI e criar protótipos de seus agentes no Claude Console.

Casos de uso

Você pode encontrar muitos casos de uso interessantes no blog oficial do Claude. Combinando esses casos com minha própria experiência prática, observei alguns padrões de uso comuns:

1. Acionado por evento
Execução de tarefa por um Agente Gerenciado acionada por um serviço.
Por exemplo, quando um bug é detectado no sistema, é feita uma chamada automática a um agente designado para que ele crie um patch e envie um PR. Não é necessária nenhuma intervenção humana entre as etapas de "identificação do problema" e "aplicação do patch".

2. Execução programada
Agendamento de tarefas para execução por um Agente Gerenciado.
Por exemplo, muitas pessoas, inclusive eu, utilizam esse método para gerar resumos diários (como um resumo das atividades na Plataforma X ou no GitHub, ou um relatório de progresso da equipe gerado por um agente). Abaixo está um exemplo do meu resumo diário de atividades na Plataforma X.

3. Disparar e esquecer
Execução de tarefa por um agente gerenciado, acionada por um usuário, mas que não requer acompanhamento contínuo. Por exemplo, atribuir tarefas a um agente gerenciado por meio do Slack ou do Teams, que então conclui a tarefa de forma autônoma e entrega os resultados (como tabelas, slides ou até mesmo aplicativos).

4. Tarefas de longo prazo
Uma tarefa de longa duração, que considero um dos cenários mais valiosos para os Agentes Gerenciados.
Realizei algumas experiências com base no repositório de pesquisa automática de Andrej Karpathy, explorando diferentes formas de aplicação. Por exemplo, recentemente usei a biblioteca de pretextos do _chenglou como base e pedi a um Agente Gerenciado que pesquisasse como aplicá-la ao conteúdo do nosso blog de engenharia.

Conceitos fundamentais

Há três conceitos fundamentais a serem compreendidos no processo de integração:

1. Agente
Uma configuração sob controle de versão que define a "identidade" do agente: incluindo o modelo, o prompt do sistema, as ferramentas, as habilidades, o servidor MCP, etc. Depois de criado, ele pode ser chamado repetidamente por meio do ID.

2. Meio ambiente
Um modelo utilizado para descrever o ambiente de teste fornecido para a execução da ferramenta do agente (por exemplo, tipo de ambiente de execução, política de rede, configuração de pacotes de dependência, etc.).

3. Sessão
Uma instância em execução com estado, iniciada com base em um agente e um ambiente pré-configurados. Isso criará uma sandbox totalmente nova a partir do modelo de ambiente, montará os recursos necessários para esta execução (como arquivos e repositórios do GitHub) e armazenará com segurança as informações de autenticação em um keystore (como as credenciais do MCP).

Você pode pensar da seguinte maneira:

· Agente = A própria configuração

· Ambiente = O modelo de sandbox necessário para o funcionamento do agente

· Sessão = Um processo de execução específico

Um agente pode corresponder a várias sessões.

Utilização

Consulte a documentação para obter mais detalhes. O uso geral é dividido em duas categorias:

1. SDK (orientado a código)
Integre o SDK ao seu aplicativo para gerenciar sessões em tempo de execução. Atualmente, o Managed Agents oferece suporte a 6 idiomas: Python, TypeScript, Java, Go, Ruby, PHP.

2. CLI (Interface de Linha de Comando)
Interaja com todos os recursos da API por meio da linha de comando, incluindo agentes, ambientes, sessões, cofres, habilidades, arquivos, etc. Cada tipo de recurso possui subcomandos correspondentes.

Prática comum:
Normalmente, a CLI é usada para configuração e inicialização, enquanto o SDK é usado para a lógica de execução.
Um modelo de agente é persistente — você pode criar um modelo (por exemplo, definindo o modelo, o prompt do sistema, as ferramentas, o servidor MCP e as habilidades em YAML), armazená-lo no Git e aplicá-lo durante o processo de implantação por meio da CLI.

Fluxo de trabalho

Fui coautor de uma publicação no blog de engenharia da Anthropic, juntamente com @mc_anthropic, @gcemaj e @jkeatn, que apresentou uma explicação detalhada sobre a construção dos Claude Managed Agents. Uma conclusão fundamental do artigo foi que permitir que os agentes evoluam em sintonia com o nível de inteligência do Claude é, essencialmente, um “problema de infraestrutura”, e não apenas uma questão de design da estrutura de execução.

Isso significa que o verdadeiro desafio não está em “como criar um agente mais inteligente”, mas em como construir um sistema capaz de funcionar de forma estável a longo prazo, ser escalável e evoluir, permitindo que o agente execute tarefas cada vez mais complexas e de longo prazo.

Com base nessa filosofia, não criamos uma estrutura de tempo de execução fixa para os agentes, pois prevíamos sua evolução contínua. Em vez disso, "desacoplamos" várias partes essenciais do sistema:

“Brain” (o Claude e sua estrutura de execução)

“Mãos” (área de testes e ferramenta para realizar ações concretas)

“Sessão” (registra os logs de eventos da execução)

Essas três foram projetadas como interfaces independentes, com o mínimo de pressupostos umas sobre as outras. Cada peça pode apresentar falha ou ser substituída de forma independente, sem afetar o sistema como um todo.

No artigo, também explicamos como essa arquitetura oferece maior confiabilidade, segurança e flexibilidade — ao mesmo tempo em que abre espaço para a integração futura de novas estruturas de tempo de execução, sandboxes ou infraestruturas de hospedagem de sessões.

Conclusão

Estou muito entusiasmado com projetos que exploram a orquestração multiagente ou tarefas de longo prazo. Uma coisa que sempre me frustrou no passado é o fato de a estrutura de execução do agente ter dificuldade em acompanhar a evolução das capacidades do modelo.

A importância dos Agentes Gerenciados do Claude reside no fato de que eles cuidam da estrutura de execução e da camada de infraestrutura para você, permitindo que se concentre em um nível mais elevado — tratando o próprio “agente” como um novo elemento fundamental da API do Claude, possibilitando uma maior exploração e desenvolvimento a partir dele.

[Link da publicação original]