DEV Community: Dati Labs

Quanto custa executar uma tarefa com Agentes de IA

Juan Felipe Voltolini — Thu, 05 Nov 2026 19:46:06 +0000

No primeiro post, contei como levei ao Startup Summit, em agosto, a palestra “Preço por token não é preço”, criada pelo Bruno Vilardi Bueno. Ao estudar o material e rodar as demos na minha conta, encontrei uma diferença de consumo entre versões da mesma família que ainda não estava no deck.

Em outubro, apresentei a palestra novamente no Oktobertech, em Blumenau. Entre as duas apresentações, o catálogo mudou de novo. O Sonnet 5.5 ainda não estava disponível em agosto e já estava em outubro. A pergunta da palestra continuava a mesma, mas a comparação tinha mais um modelo para considerar.

Ficou faltando abrir essa conta técnica por aqui. Parto de duas demos para discutir o consumo no Amazon Bedrock, a execução no Bedrock AgentCore e as decisões de arquitetura que uma tabela de preços não resolve sozinha.

A primeira demo compara uma chamada simples por modelo, usando a mesma frase em português. O consumo reportado foi de 32 tokens de entrada no Claude Sonnet 4.6, 40 no Sonnet 5 e 42 no Sonnet 5.5. Nos modelos OpenAI comparados, do GPT-5.4 ao GPT-6.1 Sol, a mesma frase ficou em 26 tokens.

Uma chamada isolada, porém, conta só parte da história. Na segunda demo, um agente recebeu uma tarefa de FinOps, consultou ferramentas e usou os resultados para continuar a execução. O que começou como um único pedido gerou cinco chamadas ao modelo e acumulou 16.223 tokens de entrada.

A partir desses dois exemplos, podemos olhar para o custo de uma tarefa considerando tanto o consumo de cada chamada quanto o contexto que se acumula ao longo da execução.

Trocar de versão também muda o consumo

A primeira demo usa chamadas simples ao Bedrock, sem ferramentas nem loop de agente, com o seguinte pedido.

Explique em 3 bullets curtos o que é RAG (Retrieval-Augmented Generation).

Fluxo de uma chamada simples ao Amazon Bedrock pela API Converse.

No primeiro texto, contei que, ao preparar a apresentação de agosto, encontrei 32 tokens de entrada no Sonnet 4.6 e 40 no Sonnet 5 para a mesma frase. Os registros reunidos aqui incluem também o Sonnet 5.5, com 42 tokens. É mais uma versão para conferir antes de reaproveitar os números da apresentação anterior. A frase continuou igual, mas a entrada reportada não.

Modelos exibidos na demo	Tokens de entrada para a mesma frase
Claude Sonnet 4.6	32
Claude Sonnet 5	40
Claude Sonnet 5.5	42
GPT-5.4, GPT-5.6 Luna, GPT-6 Luna e GPT-6.1 Sol	26 em cada um

Essas diferenças importam porque, mesmo que a tarifa de entrada fosse mantida, uma quantidade maior de tokens elevaria o custo dessa parte da chamada. A pergunta continuou igual, sem ferramentas novas nem aumento no volume de requisições. O que mudou no registro foi a quantidade reportada por chamada.

Nos modelos OpenAI desse recorte, as chamadas via Converse mantiveram 26 tokens de entrada. Essa estabilidade vale para a frase e para as versões observadas. Ela não permite concluir que qualquer texto terá o mesmo consumo, assim como as diferenças entre os modelos Claude não dizem, sozinhas, quanto custou a resposta completa.

Também é preciso cuidado ao atribuir uma causa à variação. A documentação do Sonnet 5.5 informa que ele usa o mesmo tokenizer do Sonnet 5. Portanto, a diferença de 40 para 42 tokens nos registros não demonstra uma mudança de tokenizer. O registro mostra o uso reportado pela chamada, sem isolar toda a representação interna do prompt. A causa dessa diferença permanece sem explicação neste recorte.

A API CountTokens ajuda a estimar a entrada nos modelos e formatos suportados. As fichas do GPT-5.4 e do GPT-6.1 Sol indicam que o recurso não está disponível para esses modelos. Por isso, a API não oferece um caminho para reproduzir integralmente a tabela.

Em uma nova avaliação, eu verificaria primeiro o suporte de cada modelo à API escolhida, manteria o payload e a configuração comparáveis e registraria os IDs, o endpoint, a entrada, a saída e as tarifas aplicáveis. Também verificaria o roteamento. A configuração exibida como us-east-1 não comprova a região efetiva de execução da inferência quando há roteamento cross-region, como nos perfis descritos na documentação do GPT-6.1 Sol. Esse cuidado precisa acompanhar as atualizações do modelo. No agente, ele também precisa acompanhar cada etapa da execução.

Como uma tarefa vira um loop de agente

Na chamada simples, envio uma pergunta e recebo uma resposta. No agente, dou um objetivo e disponibilizo ferramentas. O modelo avalia o contexto e escolhe o próximo passo, o código executa a ferramenta escolhida e o resultado volta como contexto para uma nova chamada. O ciclo continua até a resposta final ou até um limite de execução.

Na tarefa de FinOps, o objetivo era encontrar o serviço AWS mais caro do mês anterior, detalhar seu custo diário nas duas semanas anteriores, analisar a tendência, gerar um forecast desse serviço, consultar budgets e concluir em até cinco linhas.

Para fazer isso, o agente primeiro precisa descobrir qual serviço lidera o gasto. A ferramenta consulta os dados e devolve o resultado. Com essa informação, o modelo pode escolher o serviço e montar a consulta diária. O código executa a consulta, seu resultado volta ao contexto e uma nova chamada ao modelo define como continuar. A resposta final depende do que essas etapas conseguem apurar.

Aqui usamos o Strands Agents, SDK open source lançado pela AWS. Nesse framework, o Agent organiza o loop, funções expostas como tools executam operações e o BedrockModel permite configurar o acesso aos modelos do Bedrock. Na demo, o Bedrock AgentCore Runtime hospeda a aplicação. Strands coordena a execução, Bedrock fornece a inferência e Runtime mantém o código rodando.

Fluxo BYOA com o agente de referência do repositório. O AgentCore Runtime hospeda a aplicação, o Strands coordena o loop e o Amazon Bedrock fornece a inferência. Os eventos retornam à interface por SSE. As ferramentas desse agente de referência usam dados simulados.

O registro expandido da demo, identificado como GPT-6.1 Sol, com ID us.openai.gpt-6.1-sol, permite acompanhar esse percurso.

Ciclo	Operação visível	Entrada	Saída
1	Consulta de custo agregado por serviço	1.332	53
2	Consulta de custo diário	2.284	163
3	Consulta de forecast	3.745	441
4	Consulta de budgets	4.309	178
5	Resposta final	4.553	255
Tarefa completa	Cinco chamadas ao modelo	16.223	1.090

O primeiro ciclo recebeu 1.332 tokens de entrada. O último recebeu 4.553. Entre eles, entraram respostas do modelo, chamadas de ferramentas e seus resultados. O contexto cresceu ao longo da execução, e a entrada reportada acumulada chegou a 16.223 tokens, embora o usuário tivesse feito um único pedido.

Contar só o primeiro prompt deixaria de fora boa parte desse consumo. Multiplicar o total por cinco cometeria o erro contrário, porque os ciclos já estão somados na última linha. Para transformar os números em custo, ainda é preciso entender como a API e a interface apresentam o uso de cache.

A saída também não se resume à conclusão entregue ao usuário. O agente produz conteúdo para operar as ferramentas antes de escrever a resposta final. Pedir uma conclusão curta não limita, por si só, tudo que acontece até chegar nela.

O retorno da ferramenta merece uma revisão

Ao acompanhar o crescimento da entrada, o retorno das ferramentas se torna um ponto concreto de revisão. Campos enviados em uma etapa podem continuar no contexto das chamadas seguintes. Antes de trocar de modelo, eu olharia para esse conteúdo.

Depois da consulta agregada, quais campos são necessários para decidir a próxima chamada? Depois do detalhamento diário, quais informações precisam continuar no contexto? Se a ferramenta devolve uma estrutura inteira e o agente a carrega pelas próximas etapas, esse desenho aparece no consumo acumulado.

As próprias definições das ferramentas ocupam espaço, incluindo descrições e schemas. A documentação de tool use para Claude no Bedrock descreve esses componentes da entrada. O overhead depende da família de modelos, então não convém transportar uma estimativa de uma para outra sem conferir.

Minha primeira hipótese de otimização seria fazer a ferramenta retornar só o necessário para a próxima decisão, mantendo o resultado completo disponível fora do prompt para auditoria. Outra seria calcular agregações determinísticas em código, em vez de pedir ao modelo que reconstrua tudo a cada ciclo.

Essas são hipóteses para outra rodada, não economias já demonstradas. Remover campos pode tirar a informação que permitiria detectar um problema. Eu compararia o fluxo completo antes e depois, com os mesmos critérios de acerto. E, para interpretar a diferença de custo, verificaria também quanto do contexto repetido foi efetivamente reaproveitado pelo cache.

Cache precisa aparecer na conta sem entrar duas vezes

Parte do contexto se repete entre as chamadas, o que pode permitir reaproveitamento. A repetição, porém, não garante que aquele conteúdo seja elegível para cache nem que tenha ocorrido um cache hit.

No Bedrock, o suporte e as condições de prompt caching variam por modelo e API. Leituras têm tarifa própria, gravações podem custar mais que a entrada comum e o reaproveitamento depende das condições do cache. Os campos de uso permitem conferir se ele aconteceu e como foi contabilizado. Habilitar o recurso, por si só, não confirma o desconto.

Antes de aplicar as tarifas, é preciso conferir como a interface apresenta esses campos. Se o valor mostrado como “do cache” já estiver incluído na entrada exibida, somá-lo novamente inflará o consumo. Sem confirmar esse mapeamento nos dados da API e no código da interface, não dá para assumir a convenção usada pela demo.

Na inferência textual, eu separaria a entrada sem cache, a leitura de cache, a escrita de cache e a saída, usando categorias mutuamente exclusivas e compatíveis com a API. Cada quantidade recebe sua tarifa, na unidade indicada pela tabela de preços. Depois, somo os custos de todas as chamadas da tarefa.

Essa separação evita cobrar duas vezes o mesmo consumo na estimativa. Ainda assim, ela cobre apenas a inferência. O código que organiza o agente e executa suas ferramentas também precisa rodar em algum lugar.

O que o AgentCore Runtime acrescenta

Para acompanhar esse loop no AgentCore Runtime, a aplicação emite eventos de ciclo, ferramentas, tokens e recursos, repassados por SSE até a interface. O Runtime não precisa interpretar o significado desses eventos. A instrumentação permite enxergar o que aconteceu dentro da invocação, em vez de medir só o pedido e a resposta final.

Hospedar o agente no Runtime não substitui a cobrança de inferência no Bedrock. A aplicação continua fazendo chamadas ao modelo e, ao mesmo tempo, consome recursos para executar seu código.

Na modalidade microVM v1 considerada na demo, CPU e memória precisam ser tratadas separadamente. A documentação de custos e observabilidade explica que CPU é consumo efetivo, enquanto memória é contabilizada ao longo do tempo. Esperar a resposta do modelo ou de uma ferramenta não implica consumir CPU durante toda a espera, se nenhum processo estiver usando CPU. A memória ocupada pode continuar faturável.

Por isso, a duração de uma invocação não equivale automaticamente ao mesmo tempo de uma vCPU consumida. E terminar a resposta não significa necessariamente encerrar a sessão naquele instante.

Na calculadora da demo, a estimativa de Runtime combinava os recursos reportados com premissas sobre a sessão. Entre elas estavam 900 segundos de tempo ocioso, footprint aproximado de 1 GB e CPU em idle estimada em 1% de vCPU. Eram premissas da estimativa, não uma medição reconciliada com a fatura. A tabela de preços do AgentCore precisa ser consultada para a modalidade e a região aplicáveis antes de transformar esse uso em custo.

O tempo ocioso chama atenção porque a sessão continuava entrando na estimativa depois de a resposta estar pronta. Reduzir o timeout pode diminuir a memória acumulada nesse intervalo, mas aumenta a chance de precisar iniciar outra sessão. Se várias interações reutilizam a mesma sessão, a atribuição do custo por tarefa também muda.

Serviços adicionais, como AgentCore Gateway e Memory, entram na conta se forem usados. O loop com ferramentas e histórico, por si só, não depende de incluir esses componentes. Para comparar arquiteturas, precisamos identificar os recursos que cada uma realmente usa e verificar se elas chegam a resultados equivalentes.

A comparação que eu faria antes de escolher

A comparação começa por uma definição de sucesso. No registro de FinOps, o forecast retornou uma janela diferente da solicitada e a consulta de budgets veio vazia. A resposta final reconheceu essas limitações. Esse comportamento precisa entrar na avaliação. Detectar a diferença de período e informar a ausência de dados pode ser mais importante que economizar tokens na conclusão.

Não houve uma nova execução para este texto nem uma avaliação de qualidade equivalente entre os modelos. Uma execução por modelo não sustenta um ranking de qualidade. Para decidir, eu montaria um conjunto representativo de tarefas, incluindo dados vazios, períodos divergentes, falhas de ferramenta e retries. Avaliaria as respostas contra critérios explícitos e mediria o tempo do fluxo inteiro.

Com esses critérios, compararia alternativas mudando uma coisa por vez. As mudanças poderiam envolver o contrato das ferramentas, o contexto carregado, a divisão entre modelo e código determinístico, o modelo escolhido ou os limites de execução. Assim consigo separar o efeito de cada decisão sobre custo, qualidade e latência.

A modalidade de inferência também precisa combinar com o trabalho. Batch pode servir a análises offline que aceitam espera, mas não substitui diretamente cada etapa dependente de resposta desse fluxo interativo. Os service tiers oferecem outros compromissos entre processamento e preço, conforme o modelo.

Depois de definir o que conta como sucesso, posso reunir as inferências de todos os ciclos, a execução no Runtime, os serviços chamados pelas ferramentas, a observabilidade e os demais recursos usados. Esse é o custo do fluxo que será comparado, não apenas o valor da última resposta.

O custo por tarefa resolvida

Para comparar alternativas, eu dividiria o custo total da avaliação pela quantidade de tarefas resolvidas segundo o critério definido. O custo total precisa incluir também as tentativas que falharam. Excluir os erros faria a solução parecer mais barata sem melhorar sua capacidade de resolver o trabalho.

Junto desse resultado, eu mostraria a taxa de resolução e a latência, porque o mesmo custo pode esconder comportamentos muito diferentes. A telemetria ajuda a explicar as chamadas, enquanto o Cost Explorer e o relatório de custos ajudam a reconciliar a cobrança. Um contador de tokens ou uma estimativa de Runtime não substitui essa conferência.

A comparação entre modelos começa pela tarifa, mas precisa acompanhar o que a aplicação faz com cada um deles. Na chamada simples, a mesma frase teve contagens diferentes nos registros. No agente, os resultados das ferramentas passaram a compor as chamadas seguintes. No Runtime, a sessão continuava entrando na estimativa depois de a resposta estar pronta. Cada parte aponta para uma decisão que vale examinar antes de atribuir todo o custo ao modelo escolhido.

Isso também muda a forma de procurar economia. Um retorno menor de uma ferramenta pode reduzir a entrada das chamadas seguintes, desde que preserve a informação necessária. Um tempo ocioso menor pode reduzir o custo da sessão, dependendo de como ela será reutilizada. Para saber se o ajuste compensa, precisamos olhar para o fluxo completo, incluindo a qualidade da resposta e o tempo até a conclusão.

A palestra nasceu com o Bruno, ganhou uma nova comparação quando a preparei para o Summit e voltou ao público em outubro, no Oktobertech. A cada retomada, os números precisam ser conferidos outra vez. Novos modelos entram no catálogo, as ferramentas podem devolver outros dados e a tarefa pode exigir mais etapas do que o primeiro teste mostrou. É a relação entre consumo, execução e resultado que dá sentido ao preço por token.

Ganhos e limites do RAG com Amazon Bedrock e S3 Vectors

Juan Felipe Voltolini — Wed, 28 Oct 2026 16:56:50 +0000

O rerank colocou mais fontes confirmadas no topo da busca. A limpeza reduziu o volume de texto enviado ao modelo. Se a gente parasse nessas duas medidas, deixaria de olhar para o que saiu das conversas e para a forma como a resposta usou o que ficou.

Em um dos pilotos, por exemplo, a conversa chegou inteira ao modelo. A resposta trouxe o procedimento final e a confirmação do cliente, com citações corretas, mas confundiu falas do cliente com uma orientação do atendente. Também deixou de mostrar que uma orientação anterior havia sido corrigida. O trecho necessário estava ali, só que a resposta não preservou o sentido da conversa.

Esses resultados vêm de um estudo que fizemos no Dati Labs entre setembro e outubro de 2026, com uma base de atendimento. Comparamos o preparo dos documentos, a divisão em trechos, os modelos de embeddings e a reordenação da busca. Aqui, vamos passar pelas escolhas que tiveram efeito na recuperação e pelas que exigiram uma revisão mais cuidadosa do conteúdo.

Em uma conversa de suporte, uma sugestão pode ser descartada algumas mensagens depois, e uma resposta curta pode confirmar que o problema foi resolvido. São detalhes que precisam sobreviver ao preparo e chegar à resposta com o mesmo significado. Foi olhando para eles que conseguimos entender melhor os limites de cada ajuste.

A arquitetura usada na avaliação

Usamos o Amazon Bedrock para acessar os modelos de IA e o Amazon Bedrock Knowledge Bases para organizar a ingestão dos documentos e recuperar os trechos relacionados a cada pergunta. O Amazon S3 Vectors foi o armazenamento vetorial principal do estudo.

Nesse desenho, os modelos de embeddings representam os textos numericamente para permitir buscas por significado, mesmo quando a pergunta usa palavras diferentes das que estão no documento. O S3 Vectors armazena e permite consultar essas representações. As Knowledge Bases integram esse índice à recuperação do conteúdo que vai apoiar a resposta. A documentação da integração entre S3 Vectors e Knowledge Bases detalha esse fluxo.

Na análise, precisamos considerar separadamente o armazenamento, a ordem dos resultados e a geração da resposta. Um ganho em uma dessas partes não pode ser atribuído automaticamente às outras.

O estudo de setembro usou principalmente S3 Vectors e incluiu comparações com OpenSearch Serverless. Já os pilotos de outubro ficaram em um laboratório com S3 Vectors, concentrados em um atendimento. A recuperação integral desse documento permitiu examinar a resposta sabendo que o desfecho estava no contexto, sem atribuir sua omissão à busca.

Reordenação e critérios de aceitação

O ganho mais consistente de recuperação veio do rerank. Nessa etapa, um modelo avalia novamente a relação entre os trechos encontrados e a pergunta, para reordenar os candidatos antes de entregá-los à geração. Esse é o papel descrito na documentação de reordenação do Bedrock.

Para comparar as duas buscas, a chamada pode ser feita diretamente pelo retrieve, sem gerar uma resposta ainda. Este primeiro exemplo pede até 25 trechos e mostra os dez primeiros, com a fonte e a pontuação. A estrutura está na referência do Boto3 para retrieve.

Os exemplos usam uma pergunta fictícia e uma Knowledge Base textual com S3 Vectors em us-west-2. Para executá-los, substitua o ID e use uma base já ingerida, com credenciais e permissões para consultar a base e usar o modelo de rerank. As chamadas podem gerar cobrança. São exemplos ilustrativos, não uma nova execução do estudo.

import boto3

client = boto3.client("bedrock-agent-runtime", region_name="us-west-2")
kb_id = "KBID123456"  # Substitua pelo ID da sua Knowledge Base.
pergunta = "Por que meu relatório está vazio?"

sem_rerank = client.retrieve(
    knowledgeBaseId=kb_id,
    retrievalQuery={"text": pergunta},
    retrievalConfiguration={
        "vectorSearchConfiguration": {
            "numberOfResults": 25,
            "overrideSearchType": "SEMANTIC",
        }
    },
)

for posicao, trecho in enumerate(sem_rerank["retrievalResults"][:10], 1):
    print(posicao, trecho["location"], trecho["score"])

A segunda chamada mantém a mesma base, pergunta e busca semântica. Acrescenta a reordenação dos candidatos para devolver até dez resultados. O campo é numberOfRerankedResults, dentro de bedrockRerankingConfiguration, conforme a configuração de rerank no Retrieve. O ARN abaixo usa o Cohere Rerank 3.5, disponível em us-west-2.

com_rerank = client.retrieve(
    knowledgeBaseId=kb_id,
    retrievalQuery={"text": pergunta},
    retrievalConfiguration={
        "vectorSearchConfiguration": {
            "numberOfResults": 25,
            "overrideSearchType": "SEMANTIC",
            "rerankingConfiguration": {
                "type": "BEDROCK_RERANKING_MODEL",
                "bedrockRerankingConfiguration": {
                    "modelConfiguration": {
                        "modelArn": "arn:aws:bedrock:us-west-2::foundation-model/cohere.rerank-v3-5:0"
                    },
                    "numberOfRerankedResults": 10,
                },
            },
        }
    },
)

for posicao, trecho in enumerate(com_rerank["retrievalResults"], 1):
    print(posicao, trecho["location"], trecho["score"])

Para comparar as buscas, precisamos observar se a fonte que sustenta a resposta subiu de posição, caiu ou deixou de aparecer. As pontuações vêm de avaliações diferentes, então não basta comparar seus valores. Os números a seguir são do estudo histórico, não da pergunta fictícia usada no código.

Na configuração que reproduzia a base de produção, usamos busca por significado, sem filtros, com S3 Vectors. O Cohere Rerank 3.5 reordenava 25 candidatos e devolvia 10 resultados. A fonte confirmada apareceu em primeiro lugar em 10 de 14 perguntas reais, contra 7 sem reordenação. Houve também uma pergunta que piorou de posição.

Esse resultado sustenta um ganho na ordenação para a configuração medida. Não mostra quantas perguntas receberam respostas corretas nem demonstra uma vantagem causada pela troca de armazenamento. A revisão também encontrou um limite na própria lista de fontes de referência, que incluía um atendimento confirmado sem orientação útil.

Também avaliamos um conjunto separado de 32 perguntas sintéticas, criadas a partir do próprio acervo e sem validação humana prévia. Uma configuração que foi melhor nessas perguntas ficou pior nas reais. Por isso, o resultado sintético serviu como apoio à investigação, sem substituir a comparação com dúvidas reais.

O rerank também mudou a escala da pontuação usada pelo agente para aceitar um resultado. Ao reaplicar o corte antigo aos registros, o agente descartaria fontes confirmadas. A adoção da reordenação precisa, portanto, incluir uma revisão desse corte com exemplos que devem ser aceitos e perguntas que a base não consegue responder. Manter o mesmo valor só porque a busca continua devolvendo uma pontuação pode anular parte do ganho.

Preservar a mudança de orientação

Uma conversa de suporte registra hipóteses e correções junto da solução. Essa sequência precisa fazer parte da avaliação da resposta.

Considere um exemplo fictício, criado apenas para ilustrar o problema. Uma pessoa abre um chamado porque um relatório veio vazio. O atendente sugere atualizar o aplicativo. Depois de examinar as informações, percebe que a versão está correta e retira essa orientação. O problema era o filtro de período. A pessoa ajusta o filtro, gera o relatório novamente e confirma que os dados apareceram.

Uma resposta que recomenda atualizar o aplicativo pode citar uma frase real desse atendimento. O erro está em apresentar a tentativa inicial como solução, ignorando a correção que veio depois.

Também faltaria um passo se a resposta dissesse apenas para ajustar o filtro, sem mencionar que é preciso gerar o relatório novamente. E a confirmação de que funcionou naquele chamado não basta para dizer que o procedimento resolve qualquer relatório vazio.

Para avaliar fidelidade, precisamos conferir quem fez cada afirmação, se ela foi mantida ou revista e a que resultado a confirmação se refere. Verificar apenas a existência da citação deixa essas relações de fora.

Divisão em trechos conforme o conteúdo

A divisão dos documentos em trechos, ou chunking, afeta o que a busca consegue localizar e quanto contexto chega ao modelo. Além do tamanho, interessa onde fica o corte. Uma orientação e sua correção podem acabar em trechos diferentes. No piloto da abertura, porém, o desfecho já estava no contexto; a falha ocorreu na interpretação.

Comparamos o corte padrão, blocos por turno de conversa e a divisão hierárquica. Nesta última, a busca procura em trechos menores e pode devolver uma parte maior do documento para ampliar o contexto, como descreve a documentação de chunking do Bedrock.

Também comparamos Titan V2 e Cohere v3, modelos que criam as representações numéricas usadas na busca. Nem a troca entre eles nem a mudança na divisão do texto mostrou uma vantagem consistente nas perguntas reais. O estudo não sustenta escolher uma dessas alternativas como padrão superior para toda base.

Os critérios de preparo precisam levar em conta o tipo de conteúdo. Nas conversas em TXT, precisamos preservar quem falou, a ordem das mensagens e a ligação entre pergunta, orientação e confirmação. A correção de uma tentativa anterior precisa continuar acessível.

Nos manuais em PDF, HTML ou Markdown, a revisão deve conferir o texto extraído e manter títulos, condições e exceções junto do procedimento. Nas tabelas, cada valor precisa continuar ligado ao cabeçalho certo.

Em FAQs e fichas resumidas, precisamos conferir a fonte de cada passo. Um atendimento sem solução não pode virar uma orientação pronta depois do resumo.

Esses critérios orientam a preparação e a revisão. Não representam uma comparação por formato já realizada pelo estudo nem um tamanho de trecho recomendado para qualquer arquivo.

Redução de volume e perdas no preparo

A limpeza retirou cabeçalhos repetidos, avisos automáticos e outros elementos das conversas. Reduziu a quantidade média de texto enviada ao modelo, mas não melhorou a recuperação nas perguntas reais. Em algumas perguntas, a entrada aumentou.

A revisão identificou respostas curtas do cliente removidas logo depois de perguntas do atendente. Uma mensagem de uma palavra pode confirmar que o procedimento funcionou. Quando a regra trata esse conteúdo como dispensável, a redução de volume pode vir acompanhada da perda do desfecho.

As fichas de FAQ geradas por modelo reduziram ainda mais a entrada. Porém, a leitura integral de quatro casos encontrou passos que não existiam nas conversas de origem. Eram atendimentos sem orientação suficiente, transformados em fichas que pareciam prontas para responder. Esses casos demonstraram uma falha, sem permitir calcular uma taxa de erro para todas as fichas.

A decisão de adotar um preparo mais compacto precisa considerar o conteúdo preservado. Comparar a conversa original com a versão preparada permite verificar se a orientação final, as correções e a confirmação continuam presentes. A contagem de texto, sozinha, não responde a essa questão.

Anonimização e conferência independente

O preparo combinou regras, dicionários e detectores de dados pessoais. Na revisão, outros detectores encontraram resíduos que a conferência baseada nas mesmas regras da anonimização não havia acusado.

Esse resultado reforça a necessidade de uma conferência independente sobre o texto preparado e sobre o conteúdo efetivamente devolvido pela busca. O cuidado se estende às fichas e planilhas derivadas. Uma cópia recriada com outra versão do preparo pode perder proteções que já existiam no material revisado.

A substituição de nomes por marcadores também precisa preservar quem disse o quê. Na revisão, interessa tanto o que ficou exposto quanto o que foi removido sem necessidade. Apagar a identificação não deve apagar a sequência que permite interpretar o atendimento.

Critérios para avaliar a resposta final

Nesse caso, comparamos mudanças nas instruções, respostas organizadas em campos e uma troca de modelo. O procedimento final passou a aparecer, o formato melhorou e as citações passaram a apontar para os trechos certos. Ainda assim, nenhuma saída atendeu a todos os critérios. Faltavam limites importantes, e a interpretação da mudança de orientação continuava errada. As extrações reprovadas foram bloqueadas, em vez de virar uma orientação para o usuário.

Antes de julgar a saída, precisamos definir o que a resposta deve preservar, incluindo o procedimento completo, as orientações que foram revistas, a confirmação relatada e os limites do caso. A leitura das fontes completas e o registro de todo o contexto enviado ao modelo permitem investigar onde a falha aconteceu. Comparar uma mudança por vez ajuda a separar o efeito de cada escolha.

O que aprendemos com o estudo

O estudo mostrou onde cada ajuste contribuiu e onde ainda precisamos ter cuidado. O rerank trouxe uma melhora concreta na posição das fontes confirmadas. Já a redução do volume de texto exigiu uma revisão do que estava sendo removido, porque mensagens curtas e correções podiam ser essenciais para entender o atendimento. Nos pilotos de geração, mesmo com a informação disponível e as citações corretas, ainda encontramos respostas que mudavam o sentido da conversa.

Esses resultados ajudaram a definir uma forma mais cuidadosa de avaliar o RAG. Precisamos acompanhar o conteúdo desde a conversa original, conferir o que foi preservado no preparo, observar o que a busca recuperou e revisar como isso apareceu na resposta. Essa comparação permite identificar onde uma falha aconteceu e escolher o próximo ajuste com base no problema observado.

Os testes tiveram um recorte específico e não definem uma configuração ideal para toda base de atendimento. Ainda assim, deixam um aprendizado que orienta esse trabalho. Para transformar conversas em uma fonte útil de orientação, precisamos preservar o que elas contam, incluindo as tentativas, as correções e os limites da solução encontrada. É essa continuidade entre a fonte e a resposta que dá sentido aos ganhos de recuperação e aproxima o sistema da ajuda que a pessoa espera receber.

Minha primeira palestra não era minha

Juan Felipe Voltolini — Thu, 17 Sep 2026 16:47:39 +0000

No fim de agosto falei em público pela primeira vez. Foi no estande da Dati no Startup Summit 2026, em Florianópolis: duas rodadas, uma na quarta e outra na quinta, com um telão ao lado mostrando o Amazon Bedrock rodando ao vivo e a plateia de fone, como é o formato de palestra em estande.

E a palestra não era minha.

"Preço por token não é preço" nasceu com o Bruno Vilardi Bueno, meu colega no Dati Labs, que a apresentou pela primeira vez no webinar da Dati, em junho. Deck, duas demos, roteiro e um apêndice com as perguntas que sempre aparecem. Eu peguei esse material, estudei até entender cada número, rodei as demos na minha própria conta e levei para o público.

Este texto é sobre o que acontece nesse meio do caminho.

Uma palestra que só uma pessoa dá

Se o Bruno estivesse de férias ou em outro cliente na semana do Summit, aquele conteúdo simplesmente não teria ido para o estande. Um ativo que depende de uma pessoa específica para ser entregue é um gargalo com slide bonito.

O Palla, que lidera o Dati Labs, escreveu sobre o detalhe que decide se um radar de tecnologia vive ou morre. O radar morre quando ninguém alimenta. Uma palestra morre pelo mesmo mecanismo por outro caminho, quando ninguém além do autor consegue entregá-la. Nos dois casos o artefato continua lá, bonito, e mesmo assim não sobrevive ao primeiro conflito de agenda.

Levar a palestra do Bruno ao Summit foi, na prática, o primeiro teste disso no Dati Labs.

O que o Bruno me entregou

O pacote tinha quatro peças: o deck, duas demos, o roteiro e um apêndice com as perguntas que sempre aparecem.

O apêndice é a peça rara. A maioria dos repasses entrega o deck e para por aí. Ter escrito "quanto tempo leva medir isso", "provisionado sai mais barato?" e "e se eu trocar de modelo depois?" com a resposta pronta foi o que me deu confiança para abrir espaço para perguntas nas duas rodadas.

Externalizar é metade do movimento

O Palla também escreveu sobre por que a IA removeu a obrigatoriedade da colaboração e sobre o risco de cada pessoa virar herói de um pedaço do trabalho. Ele usa a espiral do conhecimento de Nonaka e Takeuchi para explicar por que escrever um documento não basta. Externalizar é metade do movimento. A outra metade é alguém internalizar aquilo, transformar de volta em repertório próprio, e a espiral só gira se as duas acontecerem.

Foi exatamente isso que aconteceu aqui, e eu só percebi depois.

O que internalizar custou

Internalizar é mais chato do que parece. No meu caso foi rodar as duas demos na minha conta até os números serem meus, refazer a conta do agente no papel para entender de onde vinha, e ler a documentação de service tiers e de batch inference para saber responder por que batch não serve para agente antes de alguém perguntar.

Nada disso é decorar o deck. Na hora de apresentar eu não estava repetindo o Bruno, estava explicando uma coisa que eu entendia, com o mapa que ele desenhou.

E foi durante essa parte que apareceu o número que não estava no material.

O número que não estava no deck

Antes de qualquer slide, uma demo: a mesma frase em português enviada para oito modelos no Bedrock. O prompt é idêntico em todas as chamadas e o que muda é só o identificador do modelo. Onze palavras viram 22 tokens em um modelo e 36 em outro, 64% de diferença para a mesma entrada, e nenhum preço entrou nessa conta ainda.

Quando rodei essa demo na minha conta, em agosto, o catálogo já não era o mesmo de junho. Rodei de novo incluindo a família nova da Anthropic e o número mudou: a mesma frase que dava 32 tokens na família 4.6 deu 40 na família 5.

Mesmo fornecedor, mesma tabela de preço por token, 25% a mais de tokens de entrada.

Isso não estava no deck do Bruno. O número apareceu porque alguém pegou o material, rodou de novo e olhou o resultado.

Foi também o ponto que mais pegou o público nas duas rodadas. A comparação entre oito modelos diferentes as pessoas aceitam rápido, porque é intuitivo que Llama, Amazon Nova e Claude recortem texto de jeitos diferentes. Trocar de versão dentro da mesma família parece uma operação neutra para o custo, e não é. Você atualiza o identificador do modelo, não mexe em uma linha de código, e a fatura do mês seguinte vem diferente.

Nas duas rodadas essa foi a parte em que as pessoas paravam de olhar o telão e começavam a anotar.

O que isso diz sobre repasse

Se eu tivesse decorado o deck, teria apresentado os oito modelos de junho e ninguém teria percebido nada. O material teria sobrevivido intacto e teria envelhecido em silêncio.

A diferença entre as duas coisas foi uma tarde rodando as demos.

É esse o argumento da espiral, na prática. Um repasse que funciona devolve mais material do que recebeu, e o sinal de que alguém internalizou de verdade é justamente aparecer uma informação nova que o autor não tinha.

O que a próxima pessoa vai precisar

O material do Bruno era muito bom e ainda assim tinha uma lacuna que só aparece quando outra pessoa pega. Essa lacuna virou item de checklist, e o checklist é o que eu entrego para quem for dar essa palestra depois de mim:

Deck e roteiro. O óbvio, e o único que a maioria dos repasses cobre.
Demos que rodam numa conta que não é a do autor, com model access, região e profile documentados. Demo que só roda na máquina de quem escreveu não é repassável.
Apêndice das perguntas recorrentes, com a resposta pronta. É o que permite abrir para perguntas sem medo.
Data de validade nos números. "Medido em junho de 2026, com estes model IDs." Todo número de demo de IA tem prazo e nenhum deck avisa qual é.
Tempo por bloco e o que cortar quando o horário aperta. Em estande o horário sempre aperta.
Meia hora de conversa com o autor. Nenhum documento substitui, e é a parte mais barata do pacote.

O item da data de validade é o meu. Os outros cinco eu aprendi recebendo.

E tem uma instrução que vale mais que o checklist inteiro: a demo precisa ser rodada de novo, não relida. É rodando que você descobre o que mudou desde que o material foi escrito, e é isso que separa apresentar de repetir.

O teste passou

Hoje a palestra mora em duas cabeças e o material está pronto para uma terceira. Era esse o teste. Se um ativo do Dati Labs troca de mão sem perder qualidade, e ainda volta com um número a mais do que tinha, ele pode ir para os outros times da Dati. É para lá que ele vai agora.

O conteúdo técnico da palestra, a conta inteira com os números, merece um texto próprio, e é o próximo que eu escrevo.

Créditos

"Preço por token não é preço" é do Bruno Vilardi Bueno.

O Dati Labs é a área de AI & Modernization da Dati, liderada pelo Marcelo Palladino.

O Startup Summit 2026 aconteceu de 26 a 28 de agosto, em Florianópolis. Obrigado a quem parou no estande para ouvir.

Seu time trocou o refinamento pelo plan mode, e ninguém mais precisa se falar

Marcelo Palladino "Palla" — Mon, 10 Aug 2026 01:28:57 +0000

A BruLethy era gerente sênior de dados numa das maiores empresas de tecnologia do mundo, e pediu demissão depois de oito anos lá dentro. Ela gravou um vídeo contando por quê, e faz questão de dizer, no meio da própria história, que não foi culpa da inteligência artificial.

"Eu não quero ser hipócrita em dizer que a minha vida foi destruída pelas inteligências artificiais. Eu vi como o meu trabalho foi potencializado, mas a forma com que isso foi implementado e a cobrança em cima disso foi o que transbordou o meu copo."

BruLethy, aos 10:21

Guarde essa ressalva, porque ela é dela e vai na direção contrária deste texto, que passa daqui em diante falando do que a IA mudou. Eu acho que as duas coisas cabem. A ferramenta é a mesma para todo mundo. O que mudou foi o que ela tornou possível uma gestão fazer.

O que aconteceu com ela foi uma reestruturação. Tiraram os analistas do time e, no lugar de gente, entregaram agentes.

"Ao invés deles me darem pessoas para me ajudar, um time para me ajudar, eles me deram algumas inteligências artificiais que eu podia agora colocar para trabalhar para mim 24 horas por dia, sete dias por semana. Então os limites do que era humanamente possível de ser feito não existiam mais."

BruLethy, aos 09:00

E ela era boa nisso. Como sênior, batia o olho na saída do modelo e via o erro rápido. A recompensa por render bem foi mais área, mais projeto e mais agente, até chegar no ponto que ela descreve como cinco projetos planejados sozinha, com cinco modelos diferentes, para entregar tudo no mesmo dia.

Isso tem nome, e eu venho usando ele há três anos. Só que o nome vem depois. Primeiro a frase.

A IA não destruiu a colaboração. Ela removeu a obrigatoriedade dela.

Colaborar era necessidade estrutural de quem não conseguia segurar o problema inteiro sozinho. Hoje uma pessoa com um agente segura, e entrega. E o que vira opcional deixa de acontecer.

O que dava mais medo era depender de uma pessoa só

Em 2023 eu subi no palco do TDC com uma frase que tinha acabado de escrever para um artigo sobre o que faz o deploy dar menos medo, publicado em inglês no Builder Center da AWS. Nada corrompe mais a cultura DevOps do que o heroísmo. Repeti a sessão várias vezes desde então, e a última gravada é do DevOpsDays Campinas de 2025.

A frase nasceu de um exercício simples. Eu queria entender o que exatamente me dava medo na hora de colocar alguma coisa em produção, depois de descontar ferramenta, automação e testes. Sobrava uma coisa só. Me dava medo subir código sabendo que, se desse problema, existia uma única pessoa capaz de resolver.

O ponto que eu defendo nessa sessão é que herói não é falha da pessoa. É falha de liderança. Ninguém acorda querendo ser o único que sabe mexer em uma parte específica do sistema. A pessoa vai acumulando contexto, os outros vão saindo, a organização não cria mecanismo nenhum para espalhar aquilo, e um dia ela olha em volta e está sozinha segurando um pedaço da empresa. Os dois lados dessa moeda são ruins. Eu já estive nos dois.

O que mudou de 2023 para cá é o tempo que leva para produzir um herói.

Antes o herói se formava por acidente

Reparem na ordem dos acontecimentos no relato dela. Uma decisão de reestruturação, tomada de uma vez, removeu o time e colocou capacidade de máquina no lugar. O desgaste de anos que costuma produzir esse tipo de dependência foi pulado inteiro. E foi apresentada como melhoria de cargo. A frase dela é "voltei a ser uma super analista, super super sênior".

É o herói sendo fabricado e comemorado dentro do mesmo processo.

Ela também viveu os dois lados da moeda ao mesmo tempo, o que eu nunca tinha visto acontecer com a mesma pessoa. Era a única capaz de revisar aquele volume, e dependia inteiramente de um sistema que precisava conferir sozinha. Os dois papéis colapsaram em uma cadeira só.

E o exercício que eu proponho na palestra para justificar tudo isso para a gestão, que é perguntar quanto custa se essa pessoa sair do time, acabou de rodar em público. Ela saiu. Passou por burnout, terapia e medicação antes de sair, e conta no vídeo que, ao conversar com os colegas, descobriu que não era só ela.

As cerimônias não eram amadas, eram obrigatórias

Tem um trecho no vídeo dela que é a descrição mais precisa de mob programming que eu já vi, escrita por alguém que não usa esse nome e que está falando no passado.

"Quando a gente tinha um problema que não conseguia resolver sozinho, o que a gente fazia? A gente chamava pessoas que a gente confiava, que a gente admirava intelectualmente. A gente sentava numa sala, mostrava o problema, todo mundo ali interagia colaborativamente para resolver esse problema e a gente chegava numa solução. E aquilo ali não existia mais, porque agora você só precisava escrever um prompt bem bonito e jogar para a inteligência artificial."

BruLethy, aos 11:41

O Mano Deyvin assistiu e comentou esse vídeo ao vivo no canal dele, e ataca pelo outro lado, o do processo. Ele desenha a esteira antiga inteira no quadro, discovery, kickoff, priorização, planning, pré-refinamento, refinamento, e diz que com IA isso morreu. E aí o Henrique Breim, no chat, fecha o assunto melhor do que os dois.

"Refinamento hj é plan mode do claude"

@HenriqueBreim, no chat do Mano Deyvin, aos 11:26

Ninguém nunca acordou feliz para o pré-refinamento. Aquilo funcionava porque estava no calendário e não dependia de alguém querer, e o efeito colateral de estar no calendário é que uma vez por semana o time inteiro era empurrado para dentro da mesma sala, olhando para o mesmo problema, com as mesmas dúvidas.

O que removeram do processo foi justamente o que mantinha a colaboração de pé sem depender de vontade. E o que sobra quando a sala para de acontecer é o que ela conta no vídeo, semanas seguidas sem falar com ninguém sobre nada que não fosse uma entrega.

60% preferem trabalhar sozinhos, e não estão errados

O Mano Deyvin rodou uma enquete ao vivo durante a transmissão. 60% do chat dele preferem trabalhar sozinhos com IA. 40% preferem trabalhar com pessoas. O chat responde coisas como "somos antissociais" e "solta o Claude Code na minha mão".

É enquete de chat ao vivo, autosselecionada, e sem número de respondentes divulgado. Serve como sintoma, e é assim que eu vou usar.

O sintoma é a outra metade do mecanismo. A preferência por trabalhar sozinho sempre existiu. O que sustentava a sala de pé, mesmo contra ela, era a obrigatoriedade. Some a obrigatoriedade, some a sala. E isso também significa que qualquer proposta que dependa das pessoas passarem a gostar de sentar juntas já nasce morta.

Ele mesmo, que passou o vídeo inteiro defendendo o lado humano, fecha com uma fronteira que eu acho mais precisa do que qualquer coisa que eu tinha formulado antes.

"Quando você tá numa empresa muito grande, tomar decisão sozinho com uma IA é ruim, é bom ter mais gente. Mas agora como um programador entregando task, solta o Claude Code na minha mão."

Mano Deyvin, aos 24:37

Grupo na decisão. Sozinho com o agente na execução.

Isso resolve a tensão inteira, e é exatamente a ordem que a gente acabou seguindo sem ter formulado assim.

A revisão virou o trabalho, e ninguém está formando sênior

A parte mais forte dele é quando desenha o fluxo e mostra onde a IA ajuda e onde não ajuda. Discovery e mão na massa, resolvido. Revisão, não. A frase dele é que você tem muito mais trabalho validando do que criando.

Eu falei uma coisa parecida no DevOpsDays de 2025, e falei de forma absoluta demais. Disse que não faz o menor sentido gerar código com IA e depois botar IA para revisar. A parte que se sustenta é a da responsabilidade, e eu mantenho cada palavra dela. Se eu subo código para produção, eu respondo por aquele código, tendo usado assistente ou não. A parte que envelheceu mal é o absoluto. Revisão assistida como primeira passada, com uma pessoa assinando embaixo do merge, funciona e vai acontecer.

Só que isso parte a revisão em duas, e as duas metades têm destinos diferentes. Ler o diff e apontar o que está estranho é delegável, e cada vez mais. Decidir quando desconfiar do resultado, e em que ponto parar, não é. A máquina assume a primeira. A segunda fica inteira com a pessoa, e é ela que exige repertório.

Só que o Mano Deyvin faz uma observação que fecha a armadilha. Escalar o time não resolve o gargalo de revisão, porque revisão exige alguém sênior. E aí volta o trecho mais grave do vídeo dela.

"Agora era mais fácil pedir para escrever um código SQL do que ensinar o cara que acabou de chegar a escrever e corrigir os erros dele."

BruLethy, aos 12:28

Quem toma essa decisão todo dia fica sem sênior em poucos anos. E sem sênior não existe a revisão que acabamos de estabelecer como o gargalo. Sai barato hoje e cobra caro depois, porque formar sênior leva anos e a conta só chega quando já não dá tempo de formar ninguém.

Mob programming é a resposta que eu tenho aqui, e a primeira versão dela está errada. A primeira versão é colocar quem sabe menos vendo quem sabe mais decidir, o que pressupõe alguém na sala com o repertório pronto.

Não tem. Saber quando desconfiar de um agente é conhecimento novo, e os sêniores de hoje não adquiriram isso em lugar nenhum, porque não havia onde. Eu inclusive.

Então não é transmissão, é construção. E a diferença importa mais do que parece. Quando o grupo constrói o julgamento junto, em cima de um problema de verdade, ele nasce distribuído. Quando uma pessoa constrói sozinha, ele nasce concentrado, e a gente já sabe onde isso termina.

E aqui eu preciso separar duas senioridades que eu vinha tratando como uma. A antiga é repertório de domínio e de código, leva anos, e é ela que a decisão de pedir o SQL ao modelo em vez de ensinar quem chegou está destruindo. A nova é saber desconfiar do agente, e essa se constrói em meses, porque nem existia até outro dia.

Só que a nova depende inteiramente da antiga. Ninguém desconfia de um resultado sem ter repertório para achar estranho o que está ali. E é por isso que destruir a formação da primeira inviabiliza a segunda, mesmo a segunda sendo rápida de construir.

Escrever skill é externalização, e a espiral não fecha

Nonaka e Takeuchi já descreveram isso, e melhor do que eu. Eles descrevem quatro movimentos possíveis entre conhecimento tácito e explícito, formando uma espiral que gira porque o explícito volta a virar tácito no fim, e só um dos quatro dispensa documento.

Tem um detalhe nesse quadro que eu só enxerguei há pouco tempo. Quando a gente escreve uma skill para um agente, que é um documento de instruções que ele carrega e executa sozinho, está fazendo externalização, exatamente como quem escreve um playbook. A diferença aparece depois, em quem lê. Playbook uma pessoa lê, aplica, e aquilo vira reflexo, então a espiral gira. Skill o agente executa, e a volta para o tácito simplesmente não acontece.

Dá para entregar cada vez mais assim, indefinidamente, sem que ninguém tenha aprendido no caminho. É a mesma conta do parágrafo anterior, vista pelo outro lado.

O que a gente fez no Dati Labs, e por que o resultado não foi código

O Dati Labs é a área de IA e modernização da Dati, e o que nos ocupa é entender o que muda no jeito de trabalhar quando agentes entram no trabalho para valer.

Em julho o time inteiro passou um dia em cima de um problema de cliente que ninguém tinha resolvido antes, com voz em tempo real e avatar apresentando ao vivo em palco. Nada parecido com o dia a dia de ninguém ali.

Estamos construindo um time, e eu queria fazer isso com problema real em vez de exercício, porque exercício todo mundo sabe que é exercício e ninguém se compromete de verdade com o resultado. E queria que a gente exercitasse programar com IA em grupo, e não cada um na sua máquina descobrindo sozinho o que funciona.

O formato foi uma sessão longa de sabatina com o agente de IA no meio e com a condução mudando de mão o tempo todo ao longo do dia. A pessoa da vez assume o problema e leva as perguntas da sala inteira até a decisão ficar de pé, e então passa adiante. Todo mundo passou pela cadeira.

A troca de mão tinha um artefato. Virava um documento escrito na hora, endereçado a quem assumia a cadeira, com o estado da discussão e a regra de como continuar. E a regra é a parte que interessa aqui. Se algo já decidido parecer errado, desafie uma vez, em voz alta, e deixe o time decidir, que é antiheroísmo escrito dentro do processo.

Em algum ponto do dia o quadro branco entrou. Não estava planejado e não durou muito, uns cinco minutos, o tempo de desenhar o orquestrador no meio, as peças em volta, e colocar o time todo na mesma página.

No fim do dia não havia código de produção. Havia uma especificação escrita e mais de sessenta tarefas especificadas e prontas para desenvolvimento.

Isso me obrigou a atualizar a minha própria palestra. Nas duas gravações eu descrevo mob programming como gente revezando no teclado, quinze ou vinte minutos cada, resolvendo um problema de código de forma colaborativa. Foi assim que eu aprendi programação funcional nos meus primeiros dias no Nubank, todo torto, sem saber as teclas de atalho direito, e foi o período em que eu mais aprendi lá.

Mob programming já estava na lista de antídotos contra o heroísmo que eu publiquei naquele artigo de 2023, junto com pair programming, game days e sessões de whiteboard. E o quadro branco está naquela lista por um motivo específico, que é impedir que a arquitetura desça pronta da cabeça de uma pessoa só.

O teclado hoje é onde o agente trabalha. Então o que o time produz junto deixou de ser apenas o código e passou a ser aquilo que o agente vai consumir depois. O mecanismo continua o mesmo. Mudou o artefato que sai da sala no fim do dia.

Toda sexta o time inteiro junto

Hoje esse projeto está na mão de um desenvolvedor. Uma pessoa sozinha com um agente é, ponto por ponto, a configuração que quebrou a gerente do vídeo, e é o arranjo que produz herói mais rápido que qualquer outro que eu já tenha visto.

Por isso o time inteiro para trinta minutos toda sexta-feira. E o combinado é explícito quanto ao que aquilo não é. Não é reunião de status de tarefa. Quem está no projeto conta o avanço e, principalmente, o método. O combinado até aqui é escolher um projeto por vez e tornar isso um hábito. Estamos só no começo disso.

A palavra que carrega peso ali é método. Status qualquer um extrai do repositório, de uma ferramenta de tarefas, e um agente extrai melhor e mais rápido do que a gente. Por que a pessoa desconfiou do agente naquele ponto específico, o que ela tentou antes, e o que fez ela mudar de ideia, isso não está em commit nenhum.

Nas minhas sessões eu compartilho uma prática parecida chamada rotação do bombeiro. A ideia original é rodar quem fica de plantão, semana a semana, para que o time inteiro aprenda a apagar incêndio e ninguém acabe sendo o único que sabe. Esta sexta-feira que estamos colocando no Dati Labs é a mesma mecânica aplicada a conhecimento em vez de incidente, e ela entrou na agenda antes de existir um herói para dissolver.

Naquele artigo de 2023 eu escrevi que a organização pronta para fazer deploy na sexta é a que entende que cultura de time vale mais que talento individual. Ironicamente, nossa reunião é às sextas-feiras. Só que agora deployment não é o assunto.

O que ainda não sabemos

Isso foi um dia, num projeto. É anedota, não evidência, e eu não vou fingir o contrário.

O que a anedota ilustra, porém, não é anedota. O relatório da DORA de 2025, com quase cinco mil profissionais ouvidos, achou três coisas que conversam direto com este texto. A adoção de IA passou a ter relação positiva com throughput, o que é uma virada em relação a 2024. Ela continua tendo relação negativa com estabilidade de entrega. E 30% relatam pouca ou nenhuma confiança no código que a IA gera, o que o relatório lê como necessidade de capacidade crítica de validação.

Aceleração expondo fraqueza mais adiante no fluxo, e validação virando a habilidade escassa. É o mesmo mecanismo que eu descrevi aqui, medido em escala que eu não tenho.

Falta dizer o que me faria mudar de ideia, porque admitir que é anedota é honestidade sobre a evidência e não sobre a tese. Em seis meses de sexta-feira eu vou olhar duas coisas. Se alguém de fora do projeto conseguir contar o método em voz alta, funcionou. Se a pauta começar a escorregar para status sem ninguém ter decidido isso, virou mais uma reunião no calendário e eu conto aqui.

Também não vou fingir que é uma prática confortável. Na minha sessão eu conto que já trabalhei com gente que simplesmente não entrava no mob, e a parte irônica é que costumavam ser justamente as pessoas com quem eu mais teria aprendido. Expor o que você não sabe na frente do time é desconfortável, e é legítimo que seja. Sem cultura de confiança construída antes, isso não funciona, vira constrangimento e o time abandona na segunda tentativa.

Créditos

A ideia de que heroísmo é anti-padrão não é minha. Ela está em The Phoenix Project, no personagem do Brent, está no Effective DevOps, de Jennifer Davis e Ryn Daniels, que trata heroísmo entre os anti-padrões culturais.

E está na DORA. O State of AI-assisted Software Development de 2025 achou sete perfis de time por análise de cluster, e um deles é o hero team, que entrega com qualidade e impacto sobre uma fundação instável apoiada em heroísmo individual em vez de processo. Eu escrevi uma frase com superlativo em cima de um problema que a comunidade já tinha nomeado, e a frase é o que eu reivindico, não o diagnóstico.

O quadro dos quatro movimentos tem duas datas, e vale separar. Os quatro padrões de conversão entre tácito e explícito já estão no artigo que o Nonaka publicou sozinho na Harvard Business Review em 1991, onde o tácito para explícito se chama articulação. Os nomes que eu uso aqui, externalização inclusive, vêm do livro de 1995, com o Takeuchi. Vale uma correção que eu preciso fazer em mim mesmo. No artigo de 2023 eu escrevi que revisão de código transfere conhecimento tácito por socialização, com essa palavra. No palco, eu apresento três dos quatro movimentos e deixo a socialização de fora. Escrevi certo e falei errado por dois anos.

Mob programming também não é invenção nossa, e eu usei o termo o texto inteiro sem dizer de onde ele vem. A prática foi nomeada pelo Woody Zuill e pelo time dele, e o desenho original é o time inteiro no mesmo problema, ao mesmo tempo, no mesmo espaço e no mesmo computador. O que eu descrevo aqui, com a sessão terminando em especificação em vez de código, é um desvio desse desenho. O desvio é meu, e a crítica sobre ele também deve vir para mim. Vale dizer que parte da comunidade hoje prefere chamar a prática de ensemble programming.

E o vídeo que abre este texto é da BruLethy, com o comentário ao vivo do Mano Deyvin por cima. Os dois merecem ser assistidos inteiros, e a discordância entre eles é mais interessante do que a concordância.

O detalhe que decide se o seu radar de tecnologia vive ou morre

Marcelo Palladino "Palla" — Mon, 20 Jul 2026 13:26:17 +0000

Em 2022, eu e o Francisco Edilton (Chico, AWS Community Hero) nos encontrávamos todas as terças-feiras, sete da noite no horário do Brasil, para escrever a HeroBuzz. Ele em Lisboa, eu em São Paulo. A newsletter era a desculpa. O que a gente realmente fazia era jogar conversa fora.

A maioria das pessoas olha para uma hora marcada no calendário e pergunta quanto tempo aquilo vai durar. Comigo e com o Chico a pergunta sempre é como aproveitar melhor esse tempo. E era nessa "perda de tempo" que apareciam as histórias que compartilhamos na HeroBuzz. Coisas que a gente tinha visto dar errado, times que quebraram do mesmo jeito em organizações que não tinham nada a ver uma com a outra, decisões óbvias em retrospecto que ninguém tomou na hora. De vez em quando uma delas era boa demais para morrer ali, e um de nós dizia "e se a gente escrevesse sobre isso?".

Foi assim que nasceu a edição #33, em abril daquele ano. Na semana anterior tínhamos falado sobre o Technology Radar da ThoughtWorks e como ele é organizado. Naquela, pegamos o gancho para falar sobre por que uma organização poderia querer criar um radar próprio. Escrevemos sobre conhecimento concentrado em poucas cabeças, sobre o efeito copia e cola entre times, sobre stack que cresce sem gestão até virar problema de segurança. E terminamos com uma pergunta ao leitor:

Nós conhecemos algumas organizações que se beneficiariam muito de um radar próprio. E você, acha que faz sentido para a sua realidade? Quais seriam os anéis e quadrantes do radar para sua organização?

Era muito fácil escrever aquilo. A gente estava olhando de fora.

Há 45 dias assumi a direção de AI & Modernization na Dati e estou liderando as iniciativas do Dati Labs. A pergunta voltou endereçada a mim.

Boas ideias param na máquina de quem as teve

Essa cena eu já tinha visto se repetir em lugares que não tinham nada em comum, e levei tempo para entender que era sempre a mesma cena.

Alguém chega numa conversa e diz que a tecnologia "X" está muito melhor que as outras tecnologias que usamos na empresa. Qual é a prova? Não existe. É uma impressão legítima, formada por alguém competente, que não vira decisão de ninguém porque não tem lastro nem lugar para morar. Ou alguém inicia uma iniciativa que outro time já estava tocando havia semanas. Repare que aí ninguém errou. Os dois times fizeram exatamente o que se esperava deles, com autonomia e velocidade. O desperdício aconteceu do mesmo jeito.

Velocidade individual produz desperdício coletivo quando não existe um canal para as pessoas saberem umas das outras. E o problema é difícil de combater porque nunca se apresenta como falha. Ele se apresenta como movimento. Todo mundo ocupado, todo mundo entregando, e a organização andando menos do que se espera. É um dos sintomas clássicos de falta de coordenação.

Duas formas de escalar engenharia

Para simplificar a discussão aqui, podemos dizer que existem dois jeitos de organizar isso.

O primeiro é o time opinativo. A stack está decidida e o desenvolvedor não gasta julgamento escolhendo ferramenta. Ele gasta julgamento no negócio. Isso escala muito bem e entrega rápido, e quem despreza esse modelo normalmente nunca precisou sustentar cinquenta times ao mesmo tempo.

O segundo é o time onde experimentar é normal e até esperado. Você compra capacidade de descobrir coisas e paga em dispersão. No caso do Dati Labs, é o modelo certo. Nosso trabalho é justamente descobrir, e a gente não descobre nada sem experimentar.

O Dati Labs é a área de AI & Modernization da Dati, e o que nos ocupa é a transformação do trabalho com IA agêntica. A pergunta que a gente quer responder é o que muda no jeito de fazer as coisas quando agentes passam a participar do trabalho para valer, e como isso vai se refletir nas organizações, nos processos e no software.

No Dati Labs, autonomia é uma escolha deliberada. É como acreditamos que se constrói um time que precisa explorar tecnologia em constante mudança. Só que essa escolha tem uma conta, e a conta é transparência.

A conta da autonomia

Autonomia cria imediatamente dois desafios de comunicação que não existiam antes.

O primeiro é para cima. Como comunicar à liderança o que o time está explorando? Se a resposta for uma apresentação que você monta de vez em quando, com o que lembrar na véspera, então a autonomia do time está apoiada na sua memória, e isso não sobrevive a nenhum trimestre difícil. E, principalmente, não sobrevive à sua saída. Líderes vêm e vão, a organização continua. Quem está acima de você não vai retomar decisões por má-fé. Vai retomar porque ninguém consegue defender o que não enxerga.

O segundo é para os lados. Como permitir que seu time aprenda com outros times, e que outros times aprendam com o seu? Colaboração entre áreas não acontece por boa vontade. Acontece quando existe alguma coisa visível para colaborar em cima.

Foi aí que a ficha caiu sobre o que eu mesmo tinha escrito quatro anos atrás. Autonomia sem transparência produz desperdício com aparência de produtividade. E a transparência que resolve isso não é um relatório produzido por alguém, porque relatório tem a assinatura e o recorte de quem o produziu. Tem que ser um artefato que pertence ao time, que qualquer um consegue ler, e que continua existindo independente de quem está na sala.

Transparência morre quando é cara

Essa é a parte que eu subestimei em 2022, e é onde a maioria das tentativas fracassa.

Se contribuir com o artefato exigir ter uma opinião formada, ninguém contribui. A pessoa viu um lançamento interessante numa quinta-feira à noite, não tem tempo de avaliar, não quer ou não tem tempo para se posicionar sobre aquilo depois, e simplesmente não registra. A ideia volta a morrer na máquina de quem a teve, agora com um processo bonito por cima.

O que resolveu isso para o Dati Labs foi separar duas coisas que parecem uma só. Registrar e julgar.

Registrar precisa ser quase gratuito. Nome, categoria, link, data. Ninguém precisa ter opinião para colocar algo na fila, e colocar não significa endossar. Julgar é um passo separado e deliberado, que acontece depois, com calma e critério. Quando você mistura os dois, obriga cada pessoa a chegar com posição pronta, e o custo disso silencia justamente quem tem menos tempo e mais contexto de campo.

Essa separação é o que tenho de mais transferível para oferecer aqui, e ela não depende de ferramenta nenhuma.

Vale dizer o que pode dar errado do meu lado da mesa. Radar interno pode virar cemitério de blips (cada item registrado no radar) com uma facilidade impressionante, e quase sempre pelo mesmo motivo. Alguém confunde o artefato com o processo e começa a exigir campos, revisão e reunião de curadoria. O custo de entrada sobe, o mecanismo passa a servir a si mesmo, e o time volta a decidir por fora mantendo a aparência por dentro. Quando ninguém alimenta, a primeira hipótese que eu tenho que considerar é que eu tornei a entrada ou a avaliação cara demais.

Baixar esse custo de entrada e de avaliação é, por si só, um desafio e tanto. E é exatamente o tipo de coisa que IA agêntica resolve muito bem. No Dati Labs a gente já começou a usar agentes para isso. Mas esse é assunto para outro texto.

O radar começa como espelho

Cheguei imaginando que o trabalho inicial seria montar um mecanismo para decidir o que vem pela frente. Errei a ordem.

Quando você chega a uma organização que já entrega muito, não está diante de uma folha em branco. As pessoas já entregaram projetos, já resolveram problemas difíceis, já formaram opinião sólida sobre um monte de coisa. Já existe postura. Talvez ela só não seja recuperável por ninguém além de quem a formou. Fica viva no julgamento de cada pessoa e invisível para todas as outras ao mesmo tempo.

Descobrir isso não depende de epifania. É conversando com as pessoas e entendendo o contexto. Influência se constrói conhecendo as pessoas e o terreno, e eu passei as primeiras semanas aprendendo bem mais com o meu time do que o contrário. É um time talentoso e eu tenho sorte de trabalhar com eles.

Então o primeiro trabalho de um radar não é decidir nada. É dar nome ao que já é verdade. Você registra a postura que o time já tem antes de começar a triar o que chega de fora, e só depois de existir esse espelho é que faz sentido montar o filtro.

A matriz de fronteira e relevância do Dati Labs

Quando o filtro entra em cena, a tentação é ordenar tudo por novidade. Achamos que essa é a régua errada, e ela é o motivo de tanta gente boa gastar a semana correndo atrás do que está mais barulhento na timeline. O hype pelo hype.

No Dati Labs, a gente usa duas perguntas, e a segunda pesa mais que a primeira.

A primeira é sobre o potencial de mudança: isso muda o teto do que era possível, reabrindo casos que a gente considerava inviáveis, ou melhora muito alguma coisa que já dava para fazer?

A segunda é sobre relevância: isso toca os nossos clientes e/ou a nossa stack, ou é interessante para o mundo e distante do que a gente entrega e da estratégia?

Percebe? No limite, tudo é interessante. Então ter uma régua de relevância é fundamental para não desperdiçar energia.

	Perto do nosso jogo	Longe do nosso jogo
Muda o teto do que é possível	Anel 1: Mergulhar. Testar agora.	Anel 3: Observar. De longe.
Melhora o que já era possível	Anel 2: Acompanhar. De perto, sem correr.	Anel 4: Passar. Registrar e seguir.

A relevância pesar mais é o que muda o resultado, o que é um tanto contraintuitivo, se você pensar bem. Mas vem comigo, uma coisa impressionante que não toca no seu jogo, que não conversa com a estratégia de negócio, merece menos energia do que uma coisa entediante que toca. Faz sentido? Pense nisso como antídoto para o "isso aqui está muito melhor agora" solto numa conversa de corredor, porque a régua nos leva a completar a frase.

"Melhor para quê? Melhor para quem? Melhor quanto?"

Na mesma semana avaliamos duas novidades da mesma categoria, do mesmo fornecedor. As duas eram boas. Mas apenas uma reabria casos de uso que antes eram inviáveis para nós. A outra apenas melhorava uma solução que já funcionava. Pela régua do hype, elas competiriam pela mesma priorização. Pela nossa régua de fronteira x relevância, tiveram destinos diferentes. Uma foi para teste imediato, para o mergulho, enquanto a outra foi para acompanhamento. Nenhum dos dois foi ignorado. Registrar o segundo é o que impede o time de reavaliar a mesma coisa do zero daqui a três meses.

Créditos

Nada disso é invenção nossa. O Technology Radar da ThoughtWorks é a técnica original, e a ThoughtWorks mantém o build-your-own-radar aberto justamente para que qualquer empresa monte o seu.

O que mudou não foi a técnica, foi a pressão. O Technology Radar é um retrato curado e periódico. Ele não foi desenhado para a vazão diária de lançamentos que a gente vive hoje, o que não é defeito nenhum, é escopo. Na prática, quando a entrada acelera desse jeito, você precisa de um lugar separado para o que chegou e ainda não foi julgado. Se a fila de triagem se misturar com a lista de posturas, as duas perdem sentido, porque você deixa de saber o que foi decidido e o que só foi anotado. Foi por isso que acabamos com dois níveis, um para o que está chegando e outro para o que já é postura, com uma ponte entre eles para o que sobrevive ao teste.

O que ainda não sabemos

Estamos bem no começo disso. O que queremos construir é justamente uma forma de fazer com que as pessoas do time da Dati se sintam confortáveis em contribuir, mesmo sem certeza de que aquilo vale a pena. O mecanismo é o meio para que isso aconteça, não o objetivo.

Em 2022 eu e o Chico perguntamos aos leitores quais seriam os anéis e quadrantes do radar da empresa deles. A pergunta continua valendo. Só que hoje eu sei que escolher os anéis é a parte fácil. A parte difícil é alimentar e manter aquilo numa terça-feira comum, com entrega pressionando e ninguém cobrando.

Me pergunte de novo daqui a seis meses.

Se você também está pensando em como a IA agêntica transforma o trabalho e as organizações, entre em contato comigo.