
Ela decide o que permanece na janela de contexto, o que é resumido, o que é executado em um sandbox e nunca entra no contexto, quando delegar uma subtarefa ruidosa para um subagente e quando parar para perguntar a um humano. Não é um framework: você ainda escreve suas próprias ferramentas. Não é um gateway: ele não retém suas credenciais ou sua política. É o que mantém um agente vivo da primeira à quinquagésima iteração.
O loop em si tem cerca de duzentas linhas de código. Qualquer um pode escrevê-lo, e a maioria das equipes faz isso em uma tarde. A estrutura de suporte é tudo o que você constrói nos seis meses seguintes, assim que esse loop encontra uma carga de trabalho real e começa a enfrentar obstáculos no meio do caminho.
Nossa tese é que os modelos se tornarão intercambiáveis, que as ferramentas se tornarão o diferencial da empresa em vez do fornecedor, e que a governança pertence abaixo do agente, e não dentro dele. O que havíamos subestimado era a estrutura de suporte. A equipe de Engenharia de Plataforma de Desenvolvedores da NetApp executou uma carga de trabalho genuinamente difícil contra essa tese, com profundidade, à frente do mercado, e nos mostrou exatamente onde ela cedeu.
Em junho de 2025, Rob Rubin, agora Diretor Sênior de Engenharia de Plataforma de Desenvolvedores na NetApp, já havia superado a questão que a maioria das empresas ainda debatia. Sua equipe gerencia os ambientes Kubernetes nos quais o restante da empresa constrói, e o provisionamento self-service já era totalmente automatizado. A limitação era a interface à frente disso: um formulário de solicitação só pode oferecer o que alguém modelou com antecedência.
A ideia dele era colocar a intenção ali. Descreva a stack que você deseja; deixe que um agente a monte a partir da automação que já existe.
Isso significou duas coisas para nós.
Sem framework de agentes. Sem estrutura de suporte. Ainda não era sobre isso que a conversa tratava. O motivo pelo qual ele padronizou o MCP é o motivo pelo qual esta história termina onde termina:
Em meados de 2025, essa era uma posição minoritária. É uma grande parte do motivo pelo qual o TrueForge é distribuído como código aberto em vez de um runtime gerenciado fechado.
A primeira fase foi a identidade, e é a parte que a maioria das equipes subestima.
Não uma identidade do tipo "o agente possui uma chave de API". Identidade real, onde a pessoa que faz a pergunta determina o que as ferramentas podem fazer. Um usuário se autentica por meio do provedor de identidade da NetApp. Essa identidade é levada através do Gateway MCP para o servidor MCP, que a resolve em relação à conta de cluster do próprio usuário e emite credenciais de curta duração e escopo de usuário. Cada chamada kubectl e cada comando de shell são executados como aquela pessoa. Pergunte sobre algo a que você não tem acesso e você receberá exatamente o que um terminal lhe daria: nada.
Quatro palavras, e elas são a razão pela qual isso chegou à produção. Um agente rodando como uma conta de serviço com cluster-admin é uma demonstração. Um agente rodando como você é infraestrutura.
Todo o resto reside no gateway, e não em qualquer agente individual: credenciais de provedor, RBAC em nível de modelo, permissões em nível de ferramenta, orçamentos, limites de taxa, proteções e logs. Os agentes fazem referência a nomes de modelos e nomes de servidores; as credenciais nunca trafegam. É isso que permite que uma equipe de plataforma aprove o quadragésimo agente com a mesma facilidade do primeiro, porque um novo agente não é uma nova cópia do modelo de segurança.
No início de 2026, o agente Kubernetes estava ativo com os usuários, e o formato da carga de trabalho explica tudo o que se segue.
Um engenheiro pergunta "por que meu pod está em CrashLoopBackOff?". A plataforma abrange oito clusters Kubernetes que atendem a toda a empresa, então a primeira tarefa do agente geralmente é localizar a carga de trabalho antes de poder diagnosticar qualquer coisa. Em seguida, a investigação propriamente dita: descrever o namespace, listar pods, extrair eventos, filtrar logs, inspecionar a camada de ingresso, consultar métricas históricas. O servidor MCP expõe kubectl, um shell, Prometheus e uma ferramenta de inventário de cluster. Nada da sequência é roteirizado; o modelo a compõe de acordo com o problema.
De quinze a trinta rodadas de saída de comando real, por pergunta. Guarde esse número, porque ele resume toda a história da engenharia.
Sendo a NetApp como é, Igor Feoktistov construiu um segundo servidor MCP que alcança abaixo do cluster, na infraestrutura física. Em uma sessão de laboratório, ele digitou "solucionar problema de cluster", sem nome de cluster e sem dicas.
O agente localizou o nó que não respondia, trabalhou através da camada do Kubernetes, não encontrou nada conclusivo lá, moveu-se para diagnósticos de hardware e identificou a causa raiz como uma falha de memória no hardware subjacente. Em seguida, identificou um sobressalente e realizou a migração da carga de trabalho, com uma janela de recuperação esperada de cinco a dez minutos.
A parte tecnicamente interessante é o caminho, não o resultado. Nenhum manual de procedimentos codifica "falha de pod para falha de memória para migração de carga de trabalho." Essa cadeia cruzou dois servidores MCP construídos de forma independente e se manteve unida porque ambos expuseram ferramentas honestas sob a mesma identidade de usuário, permitindo que o modelo continuasse descendo camadas até que as evidências fossem resolvidas. A capacidade veio da camada de ferramentas, que a NetApp projetou e escreveu. Nosso trabalho foi tornar seguro expô-las e dar ao loop um lugar durável para rodar.
Trinta iterações de kubectl bruto e saída de log fazem algo previsível com uma janela de contexto. As investigações começaram a morrer no meio da execução.
O que recebemos de volta não foi uma solicitação de funcionalidade. Foi um relatório de bug, e muito bem fundamentado:
Ele descartou os suspeitos óbvios e caros, o que é a metade difícil de qualquer diagnóstico: não era o modelo, não era o prompt, não eram as ferramentas. A camada para a qual ele apontava ficava logo abaixo da interface, aquela que decide o que permanece no contexto, o que é resumido e o que é executado em outro lugar e nunca entra no contexto.
Nós não tínhamos essa camada. Tínhamos assumido silenciosamente que o loop intermediário era um problema do cliente para resolver. Essa suposição foi o que a NetApp quebrou, e é a suposição que acreditamos que a maior parte do mercado ainda está fazendo.
O que construímos a seguir foi nosso, e ninguém pediu pela maior parte disso. A NetApp encontrou a barreira; o design do que a superou foi nosso trabalho, testado sob pressão contra a carga de trabalho real deles todas as semanas.
Execução isolada para código, arquivos e comandos de shell. Em vez de carregar megabytes de logs para o contexto do modelo, o agente executa código sobre esses dados e retorna apenas a resposta. Segredos nunca entram no sandbox.
Quando um agente pode migrar uma carga de trabalho de um hardware com falha, alguém precisa ter a capacidade de dizer "pause e me pergunte primeiro". A execução é interrompida para aprovação em pontos definidos.
Agentes tornam-se serviços chamáveis, integráveis em qualquer front-end em vez de ficarem presos ao nosso. Um pedido da NetApp, e o que mais transformou o formato do produto.
Compactação automática conforme a janela é preenchida; resultados extensos de ferramentas são enviados para armazenamento em vez de serem incluídos diretamente; carregamento adiado de ferramentas, para que mais de cem definições não consumam a janela antes do início do trabalho.
Uma interface de criação e teste para pessoas que nunca escreverão Python e que não deveriam precisar fazer isso.
Permite que o modelo encadeie várias chamadas de ferramentas em um script isolado, em vez de pagar por uma ida e volta do modelo a cada chamada. Ideal para tarefas de distribuição, como varrer oito clusters.
Parecia trivial, mas era fundamental. O limite da NetApp subiu de 30 para 40 e depois para 50 conforme as ferramentas evoluíram. Qualquer limite que tivéssemos definido manualmente teria se mostrado incorreto em cada ponto dessa curva.
Permite que uma investigação longa delegue uma subtarefa ruidosa e receba uma conclusão em vez de uma transcrição. O contexto principal permanece limpo ao longo de mais de 30 iterações.
Uma segunda equipe da NetApp chegou de forma independente. Vimal Kannan, Diretor de TI para Dados Corporativos e Analytics, gerencia o NetAI Chat, o assistente interno da NetApp. O problema dele era a abrangência, não a profundidade: muitas equipes, muitas ferramentas, muitos modelos, todos precisando de governança centralizada.
Hoje, cerca de 150 ferramentas podem ser acessadas por meio de um único Servidor MCP Virtual — um endpoint que centraliza vários servidores MCP, para que o cliente se conecte uma única vez em vez de ser configurado para cada um. O controle de acesso por usuário define o que cada indivíduo pode invocar, e as Habilidades (instruções empacotadas para uma tarefa recorrente) são delimitadas para que uma equipe veja apenas o que lhe pertence. Milhares de funcionários da NetApp acessam essas ferramentas pelo gateway sem nunca abrir um console da TrueFoundry. A governança é invisível para eles, e esse é o objetivo.
Como a Engenharia de Plataforma de Desenvolvedores nos pressionou a expor agentes como um SDK e uma API, a equipe NetAI Chat pôde chamar esses agentes diretamente de seu próprio front-end. Dois esforços independentes tornaram-se uma única plataforma, agora sob uma diretriz única liderada por Rob Rubin, abrangendo modelos, ferramentas, agentes e um Registro de Agentes que rastreia o que existe e quem é o responsável.
Um agente Kubernetes tornou-se vários em produção, com mais em desenvolvimento e um construtor de agentes interno no roadmap. Nesse ponto, o problema muda de figura:
Esse é o problema que surge quando a adoção funciona. Ela acontece mais rápido do que a maioria das equipes planeja.
Um runtime aberto e auto-hospedado elimina a fatura por usuário de uma plataforma gerenciada. Essa não é a parte interessante, e não é por isso que a NetApp está aqui.
Além da atribuição, há o problema da disciplina: as pessoas recorrem ao maior modelo disponível quando um menor seria suficiente. Ambos são resolvidos no mesmo lugar. Cada chamada de modelo e de ferramenta é vinculada a uma pessoa e a uma equipe, com orçamentos e limites de taxa que realmente funcionam, e um roteamento que envia o trabalho para o modelo apropriado, não para o maior disponível.
Não terminamos. Rob quer a aplicação de orçamento por execução, em vez de por semana, e ele tem razão: um limite semanal é impreciso quando um agente de longa duração pode consumi-lo em uma única investigação.
É também por isso que o harness e o gateway pertencem ao mesmo sistema. Um harness isolado oferece apenas um agente. Um harness dentro de um plano de controle governado oferece um agente que tanto sua equipe de segurança quanto sua equipe financeira aprovarão.
Um cliente, por mais avançado que seja, é apenas um ponto de dados. A NetApp encontrou o limite de contexto ao executar investigações de 30 iterações em oito clusters. Uma equipe que trabalha com fluxos de documentos, processamento de sinistros ou triagem de CI encontrará um limite diferente, e preferimos aprender isso com o mercado do que com nosso próprio roadmap.
Existe também uma razão mais pragmática. Uma equipe que recusou conectores proprietários em 2025 jamais apostaria sua infraestrutura Kubernetes em um runtime que não pudesse ler, executar por conta própria ou modificar. A portabilidade foi a condição de entrada para todo este relacionamento. Tornar o harness open-source é a nossa forma de levar essa condição a sério, em vez de apenas pedir que confiem em nós.
A capacidade diferenciada da NetApp, do Kubernetes até o hardware, existe porque seus engenheiros escreveram seus próprios servidores MCP para seus próprios sistemas. Nenhum fornecedor entregaria isso. O trabalho da plataforma é hospedá-los, protegê-los e governá-los.
É na vigésima segunda iteração, quando o contexto está cheio de saídas de terminal e a investigação ainda não terminou. Quase toda a engenharia real vive nesse intervalo, e ela permanece invisível até que você execute algo por tempo suficiente para encontrá-la. Um teste rápido: se seus agentes excedem rotineiramente dez chamadas de ferramenta por tarefa, você vai encontrar essa barreira.
Todo agente que trava na revisão trava na mesma pergunta: o que essa coisa pode fazer e em nome de quem. Responda a isso na infraestrutura e a resposta valerá para todos os agentes que vierem depois.
Limites de iteração, orçamentos de contexto, contagem de ferramentas: cada um desses pontos mudou para a NetApp em poucos meses. Trate-os como configuração.
Um agente que roda apenas dentro da interface de um fornecedor não pode ser integrado a nada. O SDK e a API foram a mudança que permitiu que duas equipes da NetApp se tornassem uma única plataforma.
O TrueForge é de código aberto, licenciado sob a licença MIT, em github.com/truefoundry/trueforge. O obstáculo que a NetApp enfrentou é algo que você pode encontrar em sua própria carga de trabalho, com a camada que o superou já em suas mãos.

Isso inicia o harness e sua interface na sua máquina. Quando estiver pronto para rodar para valer, faça o self-host com Docker Compose ou Kubernetes em seu próprio ambiente. Aponte para qualquer modelo através de um endpoint compatível com OpenAI, conecte seus servidores MCP e você terá um agente funcional.
O harness funciona de forma independente; os gateways são a forma como você o gerencia. Execute o TrueForge isoladamente e você terá o ciclo completo: execução em sandbox, engenharia de contexto, subagentes, aprovações, SDK e API. Você traz e gerencia seu próprio modelo e chaves MCP. Combine-o com o AI Gateway e o MCP Gateway da TrueFoundry e cada chamada de modelo, chamada de ferramenta e interação MCP torna-se autenticada, orçada, controlada por políticas e registrada sob a identidade real do usuário, a camada com a qual a análise de segurança da NetApp realmente se preocupou.