Managed Agent Runs: Agentes Autônomos Que Trabalham na Sua Arquitetura Enquanto Você Dorme

Duas semanas atrás, lançamos o Agent Hub com guardrails de conformidade — regras que dizem aos agentes de IA o que eles podem e não podem fazer. Essa era a camada defensiva. Hoje estamos adicionando a ofensiva.

O Managed Agent Runs permite despachar agentes de IA autônomos diretamente do Archyl. Dê a eles uma tarefa, conecte-os às suas ferramentas, defina um agendamento e deixe-os trabalhar. Eles clonam seu repositório, leem sua arquitetura, chamam serviços externos e reportam tudo o que fizeram — cada chamada de ferramenta, cada decisão, cada token gasto.

Isso não é "conversar com sua arquitetura." Isso é um agente que faz trabalho real, de forma autônoma, no seu código.

Por Que Managed Runs?

O padrão que continuávamos vendo era este: equipes configuravam regras de conformidade, geravam seu arquivo CLAUDE.md e depois rodavam agentes manualmente no terminal. Copiar o contexto, colar no Claude Code, rodar a tarefa, verificar a saída. Toda vez.

A peça que faltava era automação. Você não deveria precisar ficar de olho em um agente fazendo uma tarefa rotineira. Verificar dependências desatualizadas toda segunda de manhã? Isso deveria ser um agendamento. Revisar PRs abertos contra regras de arquitetura após cada merge? Isso deveria ser automático. Gerar um relatório semanal de drift arquitetural? Configure e esqueça.

O Managed Runs fecha esse ciclo. Defina a tarefa, escolha um agendamento, e o Archyl cuida do resto — clonagem, injeção de contexto, execução e monitoramento.

Anatomia de uma Execução

Toda execução gerenciada segue o mesmo ciclo de vida:

  1. Clone — O agente clona o repositório do seu projeto em um workspace isolado. Cópia limpa, sem contaminação de execuções anteriores.

  2. Injeção de contexto — Antes de o agente escrever uma única linha de código, ele recebe todo o seu contexto arquitetural: modelo C4, ADRs, regras de conformidade, stack tecnológico, contratos de API. Os mesmos dados do get_agent_context que alimentam os guardrails, injetados automaticamente.

  3. Execução — O agente trabalha na sua tarefa. Ele pode ler arquivos, escrever código, chamar ferramentas externas e tomar decisões. Cada ação é registrada como um evento em um feed em tempo real.

  4. Relatório — Quando a execução é concluída (ou atinge o limite de iterações), você recebe um trace completo: cada chamada de ferramenta com sua entrada e saída, badges de status, contagem de tokens, tempo decorrido.

A página de detalhes da execução mostra tudo. Chamadas de ferramentas são cards expansíveis com JSON destacado sintaticamente. Cada card mostra de qual conector a ferramenta veio — "github" para chamadas da API do GitHub, "archyl" para consultas de arquitetura, "linear" para rastreamento de issues. Você pode rastrear exatamente o que o agente fez e por quê.

Conectores: Conecte Qualquer Serviço MCP

Aqui é onde fica interessante. Managed Runs não conversam apenas com o Archyl. Eles podem conversar com qualquer coisa que fale MCP (Model Context Protocol).

Conectores permitem que você anexe serviços externos às execuções dos seus agentes. Por padrão, oferecemos suporte a:

  • GitHub — Leia PRs, verifique status de CI, liste issues, revise código
  • GitLab — As mesmas capacidades para projetos hospedados no GitLab
  • Linear — Leia e atualize issues, acompanhe o progresso do sprint
  • Slack — Envie mensagens, leia canais, notifique equipes
  • Qualquer servidor MCP — Se ele expõe ferramentas MCP, você pode conectá-lo

Configurar um conector leva trinta segundos. Dê um nome, cole a URL do servidor, adicione headers de autenticação se necessário, e o Archyl vai consultar o servidor para descobrir as ferramentas disponíveis. Você verá todas as ferramentas que o conector expõe antes de salvar.

Quando você cria uma execução ou agendamento, você escolhe quais conectores anexar. O agente ganha acesso a todas as ferramentas de todos os conectores anexados, organizadas por namespace do nome do conector. Uma ferramenta do GitHub aparece como github__list_pull_requests. Uma ferramenta do Linear aparece como linear__get_issue. Sem colisões, sem ambiguidade.

Esse namespace importa. Quando você olha o feed de eventos de uma execução, cada chamada de ferramenta mostra sua origem. Você pode identificar instantaneamente se o agente estava consultando seu modelo de arquitetura, lendo um PR do GitHub ou postando no Slack. Visibilidade total sobre o que o agente acessou e onde.

Agendamentos: Automação Baseada em Cron

Algumas tarefas não deveriam esperar um humano apertar "Executar". Agendamentos permitem definir execuções recorrentes de agentes com expressões cron padrão.

Alguns exemplos do que equipes já estão fazendo:

Revisão semanal de arquitetura — Toda segunda às 9h, um agente verifica o código em busca de drift arquitetural. Ele compara a estrutura real do código com o modelo C4, sinaliza novas dependências que não estão documentadas e identifica componentes que cresceram além do escopo pretendido.

Verificação de conformidade de PRs — Após cada merge na main, um agente revisa o diff contra as regras de conformidade. Ele captura os padrões que passaram pelo CI — não erros de sintaxe, mas violações arquiteturais que só fazem sentido no contexto do sistema completo.

Auditoria de dependências — Toda quarta-feira, um agente escaneia a árvore de dependências em busca de vulnerabilidades conhecidas, pacotes descontinuados e incompatibilidades de versão entre serviços. Ele cria um resumo com classificações de severidade e atualizações sugeridas.

Sincronização de documentação — Toda sexta à tarde, um agente compara o código atual com a documentação do projeto. Endpoints ausentes, descrições desatualizadas, novos serviços sem documentação — ele sinaliza tudo.

Cada agendamento mostra sua expressão cron, próxima execução, última execução e status ativo/pausado. Você pode pausar um agendamento sem excluí-lo, dispará-lo manualmente fora da cadência normal, ou editar o texto da tarefa e o horário a qualquer momento.

A Página de Detalhes da Execução

Investimos bastante tempo na experiência de monitoramento, porque visibilidade é tudo quando você está deixando um agente trabalhar de forma autônoma.

A página de detalhes da execução oferece:

  • Status num relance — Em execução, concluído, falhou ou cancelado. Badge com código de cores, visível imediatamente.
  • Uso de tokens — Tokens de entrada e saída, para que você possa rastrear custos por execução.
  • Tempo decorrido — Quanto tempo o agente trabalhou, atualizado em tempo real durante a execução.
  • ID da execução — Para rastreabilidade e depuração.
  • Feed de eventos ao vivo — Cada ação que o agente toma aparece como um card expansível. Chamadas de ferramentas mostram a origem do conector, nome da ferramenta, parâmetros de entrada e saída. Mensagens mostram o raciocínio do agente. Erros são destacados.

O feed foi projetado para leitura rápida. Linhas recolhidas mostram o tipo de evento e um resumo de uma linha. Passe o mouse para ver o badge do conector e expanda para detalhes completos. Quando algo dá errado, você não precisa vasculhar logs — você percorre uma linha do tempo estruturada de exatamente o que aconteceu.

Consciente da Arquitetura por Padrão

Toda execução gerenciada recebe acesso automático ao servidor MCP do seu projeto Archyl. Isso significa que o agente pode:

  • Consultar o modelo C4 para entender os limites do sistema
  • Ler ADRs para entender decisões passadas
  • Verificar regras de conformidade para saber quais padrões seguir
  • Navegar contratos de API para entender interfaces de serviço
  • Consultar atribuições de tecnologia para escolher as ferramentas certas

Isso não é uma integração opcional. É a base. O agente não começa do zero — ele começa da sua arquitetura. Quando precisa criar um novo serviço, ele sabe a qual container pertence. Quando escreve código, sabe quais padrões são obrigatórios. Quando adiciona uma dependência, sabe quais tecnologias são aprovadas.

Combinado com conectores externos, isso cria agentes que são ao mesmo tempo conscientes da arquitetura e operacionalmente capazes. Eles conhecem seu sistema e podem interagir com suas ferramentas.

Primeiros Passos

O Managed Agent Runs está disponível agora no Agent Hub para os planos Business e Scale.

  1. Crie um conector — Vá em Agent Hub → Connectors. Adicione seu GitHub, Linear ou qualquer serviço compatível com MCP.
  2. Inicie uma execução — Vá em Runs → New Run. Escreva sua tarefa, anexe conectores e lance.
  3. Configure um agendamento — Vá em Schedules → New Schedule. Escolha uma expressão cron, anexe conectores e deixe rodar.

Os agentes estão prontos. Sua arquitetura é o contexto. Suas ferramentas são os conectores. Agora coloque-os para trabalhar.