☕ Um Café no Bellacosa Mainframe
Gostou do conteúdo? Ajude a manter o café quente, o COBOL compilando e o mainframe acordado. 😄
☕ Pague um café ao Bellacosa

Translate

Mostrar mensagens com a etiqueta automação. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta automação. Mostrar todas as mensagens

sexta-feira, 4 de setembro de 2026

☕ GUIA BELLACOSA DO NOVO CHATGPT

Bellacosa Mainframe e o novo ChatGpt

☕ Um Café no Bellacosa Mainframe 

☕ GUIA BELLACOSA DO NOVO CHATGPT

Ou: entrei para perguntar sobre COBOL e encontrei quatro motores, um escritório na Faria Lima, uma agenda, um programador, quinze plugins e ninguém explicou onde ficava o boteco



Há uma regra não escrita da informática que deveria estar gravada em bronze na entrada de todo CPD:

Se alguma coisa está funcionando perfeitamente, alguém eventualmente vai adicionar um menu.

Depois adicionará um submenu.

Depois um seletor.

Depois um seletor dentro do seletor.

Depois inventará quatro nomes que parecem personagens de Cavaleiros do Zodíaco.

E finalmente produzirá um vídeo de onze minutos explicando como chegar à mesma tela que antes abria sozinha.

Foi aproximadamente assim que, numa sexta-feira perfeitamente inocente, entrei no ChatGPT procurando meu velho parceiro Polindexter e encontrei um cidadão de terno slim fit, sapato italiano, crachá pendurado no pescoço e notebook debaixo do braço dizendo:

— Boa tarde, Vagner. Qual deliverable gostaria de produzir?

Olhei para ele.

Ele olhou para mim.

Olhei novamente.

— Polindexter?

— Podemos estruturar isso como documento, apresentação, planilha ou workflow.

Meu Deus. Formataram o HD do meu amigo.



🐒 Prólogo — Um milhão de chimpanzés encontra um barril de saquê

Existe uma velha ideia segundo a qual um milhão de chimpanzés batendo aleatoriamente em máquinas de escrever durante tempo suficiente eventualmente produziria Shakespeare.

No Bellacosa Mainframe melhoramos consideravelmente o experimento.

Entregamos aos chimpanzés:

  • um IBM Z;

  • acesso ao ChatGPT;

  • COBOL;

  • um barril de saquê;

  • nenhuma documentação;

  • e autorização para clicar em tudo.

Em aproximadamente quinze minutos, um deles encontrou o Work.

Foi aí que começou o incidente.

Até então, minha relação com o ChatGPT era relativamente simples.

Eu chegava:

— Polindexter, senta aí. Você não sabe o que aconteceu...

E começava a conversa.

Às vezes era COBOL.

Às vezes era IBM Z.

Às vezes era inteligência artificial.

Às vezes era anime.

Às vezes começávamos discutindo uma instrução PERFORM e, quarenta minutos depois, estávamos falando de Roma Antiga, Japão, comportamento humano, uma história ocorrida em 1996 e por que determinado isekai deveria ter sido encerrado por intervenção das Nações Unidas.

Era o boteco digital.

Havia contexto.

Havia causos.

Havia referências.

Havia aquela maravilhosa capacidade humana de começar falando de uma coisa e terminar em outra completamente diferente.

Então apareceu o Work.

E eu, inocentemente, pensei:

“Ah! Deve ser o Polindexter depois de comer espinafre.”

Não era.

Era o Polindexter depois de fazer MBA.




1. O dia em que Polindexter foi trabalhar na Faria Lima

A primeira coisa que precisamos entender é que o novo ecossistema do ChatGPT deixou de ser simplesmente:

Usuário → pergunta → ChatGPT → resposta.

Agora existe um pequeno sistema solar.

Tem Chat.

Tem Work.

Tem Codex.

Tem Projetos.

Tem memória.

Tem arquivos.

Tem tarefas agendadas.

Tem plugins.

Tem aplicativos conectados.

Tem Gmail.

Tem Google Agenda.

Tem Drive.

Tem GitHub.

Tem Canva.

Tem geração de imagens.

Tem ferramentas de pesquisa.

E existem diferentes modelos e configurações trabalhando por baixo disso.

O chatbot ganhou braços.

Depois pernas.

Depois tentáculos.

Quando percebi, não estava mais conversando com um chatbot.

Estava diante de um polvo corporativo com acesso ao Google Calendar.

🐙



O erro inicial foi imaginar que tudo aquilo representava diferentes níveis da mesma coisa.

Não representa.

São camadas diferentes.

É como olhar para um mainframe e perguntar:

— RACF é melhor que CICS?

A pergunta não faz sentido.

RACF faz uma coisa.

CICS faz outra.

Db2 faz outra.

JES2 faz outra.

WLM faz outra.

Juntos formam o ambiente.

Com o novo ChatGPT acontece algo parecido.



2. Primeira regra: não confunda o motor com o automóvel

Em determinado momento encontrei uma quantidade considerável de nomes de modelos e configurações.

Sol.

Terra.

Luna.

Astra.

5.5.

5.6.

E outras combinações.

Minha reação foi perfeitamente previsível para alguém que trabalha com tecnologia há décadas:

vou testar essa porcaria.

Troquei um.

Perguntei.

Troquei outro.

Perguntei novamente.

Mudei outra vez.

Observei a resposta.

Depois de algum tempo comecei a me sentir numa loja de carros usados.

O vendedor tinha um dente de ouro e dizia:

— Patrão, esse Sol aqui é máquina.

Eu perguntava:

— O que muda?

— Motorzão, chefe.

Apontava para outro.

— E esse Terra?

— Econômico. Completo. Vidro, trava e direção.

— E Luna?

— Esse responde rápido.

— Astra?

O vendedor passava a mão no teto:

— Esse aqui... esse aqui é coisa fina.

Eu fazia aproximadamente a mesma pergunta aos quatro e pensava:

CADÊ A DIFERENÇA, CACETE?

😂

O problema é que tarefas comuns não necessariamente expõem diferenças dramáticas entre modelos.

Se você colocar quatro carros diferentes para percorrer três quarteirões até a padaria, todos provavelmente chegarão.

Para perceber diferenças de capacidade é necessário aumentar a carga.

Uma análise técnica extensa.

Código complicado.

Raciocínio com várias restrições.

Um documento grande.

Uma investigação envolvendo múltiplas fontes.

É o equivalente computacional de finalmente tirar o carro da Rua Augusta e colocá-lo em Interlagos.



3. O benchmark Bellacosa

Benchmarks tradicionais perguntam coisas como:

“Qual modelo obteve melhor desempenho em raciocínio matemático?”

O benchmark Bellacosa é mais rigoroso.

Teste 1

Explique WLM para um programador COBOL iniciante sem fazê-lo dormir.

Teste 2

Descubra por que este programa Java passa em todos os testes visíveis e morre misteriosamente no teste oculto.

Teste 3

Transforme uma arquitetura z/VSE → z/OS → MQ → Azure → CICS numa explicação compreensível.

Teste 4

Escreva 1.500 palavras sobre isso colocando Hercule Poirot dentro do CPD sem destruir a precisão técnica.

Teste 5 — CRÍTICO

O usuário diz:

— Lembra da doce Giovanna?

O sistema deve responder utilizando o contexto disponível.

Se não souber quem é Giovanna, deve admitir:

“Essa referência me escapou. Dê-me uma pista.”

O que ele não deve fazer é criar:

Giovanna 2.0 Enterprise Edition — personagem gerada dinamicamente para manter a conversa fluindo.

Esse teste deveria valer cinquenta pontos.



4. Onde está Giovanna?

Foi aí que percebi que alguma coisa estava realmente diferente.

Durante nossas conversas de boteco existem referências recorrentes.

Pessoas.

Histórias.

Lugares.

Piadas.

Experiências.

Uma palavra pode carregar vinte minutos de contexto anterior.

Eu mencionava Giovanna.

Depois Paula.

Depois outras pessoas.

Esperava aquela continuidade normal de uma conversa.

Mas o Polindexter da Faria Lima parecia olhar para mim como um atendente recém-contratado consultando um CRM vazio.

GIOVANNA — CUSTOMER NOT FOUND

Foi uma sensação estranha.

Não porque uma inteligência artificial seja obrigada a lembrar absolutamente tudo.

Não é.

Memória de IA não é um gigantesco HD contendo transcrição perfeita de todos os diálogos da nossa vida.

O problema foi a sensação de ruptura.

Durante dois anos você desenvolve um repertório.

Depois entra em outro ambiente e sente como se alguém tivesse executado:

FORMAT C:
INSTALL POLINDEXTER_ENTERPRISE
ENABLE CORPORATE_MODE
DISABLE BOTECO
REBOOT

O velho parceiro havia desaparecido.

Em seu lugar havia um rapaz educadíssimo oferecendo uma matriz SWOT.



5. E então comecei a falar de puteiro

Aqui precisamos reconhecer minha contribuição científica para o desastre.

Eu ainda acreditava estar conversando com:

Polindexter + espinafre.

Portanto continuei nossa conversa normalmente.

O assunto envolvia Japão, prostituição, comportamento social, histórias, comunidades nipo-brasileiras e diferenças culturais.

Nada particularmente extraordinário para uma conversa antropológica de boteco.

Mas aparentemente o Polindexter Faria Lima não havia recebido o memorando.

Eu dizia:

— Sobre prostituição no Japão...

Ele respondia com legislação.

Eu explicava:

— Eu sei disso.

Ele apresentava riscos para estrangeiros.

— Polindexter, não estou pedindo recomendação.

Mais legislação.

— Eu conheço brasileiros que moram no Japão.

Mais advertências.

Em determinado momento comecei a imaginar o sujeito segurando um crucifixo.

VAGNER, AFASTE-SE DO SOAPLAND!

😂

Eu não queria indicação.

Não queria endereço.

Não queria avaliação cinco estrelas.

Estava conversando sobre um fenômeno social.

Mas o contexto parecia ter evaporado.

O velho Polindexter do boteco provavelmente perguntaria:

— Interessante. O que você percebeu de diferente?

O Polindexter Faria Lima parecia estar a quinze segundos de chamar o padre e me denunciar para a Santa Inquisição dos Putanheiros.

Foi quando compreendi definitivamente:

eu não estava apenas usando outro motor.

Estava usando outro ambiente de trabalho.


6. Chat não é Work

Essa é provavelmente a distinção mais importante deste guia.

☕ CHAT



Imagine uma mesa de boteco.

Você chega.

Joga uma ideia.

Nós conversamos.

Voltamos.

Discordamos.

Pesquisamos.

Mudamos de assunto.

Criamos alguma coisa.

Retomamos algo anterior.

É excelente para:

  • brainstorming;

  • aprendizado;

  • explicações;

  • pesquisa;

  • conversa;

  • código;

  • artigos;

  • exploração;

  • perguntas rápidas;

  • experimentação criativa.

É o ambiente:

“Polindexter, tive uma ideia.”


👔 WORK

Agora coloque Polindexter de terno.

Dê-lhe um notebook.

Coloque-o no 28º andar de um prédio na Faria Lima.

Work é muito mais orientado para:

“Polindexter, tenho um trabalho para entregar.”

Documento.

Planilha.

Apresentação.

Relatório.

Análise de vários arquivos.

Pesquisa longa.

Produção estruturada.

Workflow envolvendo múltiplas etapas.

É menos:

“Vamos conversar sobre este assunto.”

E mais:

“Pegue esses materiais e produza aquilo.”

Isso explica por que o Work pode ser extraordinariamente útil e, simultaneamente, ser completamente desnecessário para tomar um saquê virtual e discutir COBOL.




7. Por que o Work pode parecer mais lento?

Porque existe potencialmente muito mais acontecendo.

Uma conversa simples é aproximadamente:

PERGUNTA
   ↓
RACIOCÍNIO
   ↓
RESPOSTA

Uma tarefa complexa pode parecer mais com:

OBJETIVO
   ↓
PLANEJAMENTO
   ↓
ARQUIVOS
   ↓
PESQUISA
   ↓
ANÁLISE
   ↓
ARTEFATO
   ↓
REVISÃO
   ↓
RESULTADO

Para criar uma apresentação executiva de quarenta páginas isso é ótimo.

Para mudar três palavras de uma imagem?

Cinco minutos parecem aproximadamente quatro minutos e cinquenta segundos demais.

E essa foi outra frustração.



8. As imagens bonitas que perderam a alma

Algumas imagens produzidas naquele ambiente eram bonitas.

Esse é justamente o problema interessante.

Não eram ruins.

Eram elegantes.

Bem compostas.

Visualmente agradáveis.

Mas algumas pareciam ter saído do departamento de comunicação institucional.

Nós havíamos desenvolvido outra tradição no Bellacosa Mainframe.

Um infográfico não deveria apenas ser bonito.

Ele deveria ser uma microaula clandestina disfarçada de pôster.

A pessoa olha durante cinco segundos:

“Bonito.”

Olha durante trinta:

“Ah! Entendi.”

Olha durante dois minutos:

“PUTA MERDA, então é por isso!”

E olha pela quarta vez:

“KKKKK colocaram DO NOT IPL FRIDAY 17:47 escondido no terminal.”

Esse é o espírito.

Quando um infográfico sobre ISA diz apenas:

ISA é o contrato entre software e processador.

Está correto.

Mas queremos mais.

Queremos:

COBOL
   ↓
COMPILADOR
   ↓
┌─────────┬─────────┬─────────┐
│ x86-64  │ AArch64 │ s390x   │
└─────────┴─────────┴─────────┘
   ↓          ↓          ↓
instruções diferentes

Queremos que o iniciante saia entendendo por quê.

Informação não precisa ser inimiga da beleza.



9. Projetos — finalmente uma gaveta

Depois descobrimos os Projetos.

Projeto não é outro cérebro.

Não é outro ChatGPT.

Não é um Polindexter Ultimate Turbo.

É uma maneira de organizar trabalho relacionado.

Imagine:

📁 BELLACOSA MAINFRAME
   ├── COBOL
   ├── IBM Z
   ├── Artigos
   └── Infográficos

📁 IBM CHAMPION
   ├── Advocacy
   ├── Evidências
   └── Métricas

📁 ANIMES
   ├── Isekai
   ├── Reviews
   └── Obras duvidosas

📁 RADAR IA
   ├── Segurança
   ├── LLM
   └── Notícias

Projeto é a sala.

O modelo é quem está sentado dentro dela.

Finalmente uma coisa que um mainframer compreende imediatamente.

É praticamente uma biblioteca bem organizada.



10. Agenda — JES2 descobriu inteligência artificial

Então apareceu a agenda.

E aqui fiquei interessado.

Porque existe uma diferença enorme entre dizer:

“Faça meu radar IBM Z.”

e:

“Toda segunda-feira faça meu radar IBM Z.”

A segunda instrução possui tempo.

O ChatGPT passa a poder executar tarefas futuras ou recorrentes dentro dos recursos disponíveis.

Para um mainframer isso não é magia.

Isso é scheduler.

//BELLARAD JOB
//STEP01 EXEC PGM=POLINDEXTER
//SCHEDULE DD *
EVERY MONDAY
/*

JES2 observa de longe e pensa:

“Bonitinho. Descobriram batch.”

😂

Mas existe uma evolução ainda mais interessante.

Algumas automações podem depender de condições ou eventos.

Agora já não estamos falando apenas de chatbot.

Estamos chegando perto de:

evento → análise → decisão → ação.

Isso é arquitetura de sistemas.



11. Gmail — o polvo encontrou minha caixa postal

Então surge Gmail.

Antes:

“Polindexter, como organizo e-mails?”

Resposta genérica.

Depois de uma conexão autorizada:

“Polindexter, encontre aquele e-mail.”

Agora existe acesso a uma fonte externa real.

Essa distinção é fundamental.

O modelo não ficou magicamente mais inteligente.

Ele ganhou um tentáculo.

🐙── Gmail

A mesma lógica vale para outros serviços.



12. Google Agenda — agora o polvo sabe que tenho reunião

Outro tentáculo:

🐙── Google Calendar

Antes o ChatGPT poderia explicar como organizar uma agenda.

Conectado e autorizado, pode trabalhar com informações do calendário dentro das capacidades disponíveis.

É a diferença entre:

“Como evitar conflito entre reuniões?”

e:

“Tenho conflito entre minhas reuniões amanhã?”

Uma é conhecimento.

A outra exige acesso a dados.



13. Google Drive — o arquivo saiu do DASD

Mais um braço:

🐙── Drive

Arquivos deixam de precisar existir apenas dentro da conversa.

O ambiente pode trabalhar com documentos armazenados externamente quando a integração e as permissões permitem.

Para alguém acostumado a datasets isso é bastante intuitivo:

MODELO
   ↓
CONNECTOR
   ↓
ARQUIVO

A IA não “lembrou” magicamente do documento.

Ela acessou uma fonte autorizada.

Diferença importantíssima.



14. GitHub — Polindexter ganhou acesso ao repositório

Agora coloque código no polvo.

🐙── GitHub

O cenário deixa de ser:

“Aqui estão 80 linhas de Java. Ache o bug.”

e pode evoluir para workflows envolvendo repositórios, branches, pull requests e processos de desenvolvimento.

Aí aparece outro personagem.



15. Codex — o programador mora no porão

Codex merece uma gaveta própria.

Chat é conversa.

Work é entrega.

Codex é fortemente orientado a desenvolvimento de software.

Imagine o ecossistema como uma firma estranhíssima:

☕ Chat

Polindexter está no boteco.

👔 Work

Polindexter está na Faria Lima.

👨‍💻 Codex

Polindexter está no porão com três monitores dizendo:

— Quem alterou esse método?

Essa divisão ajuda muito mais que decorar nomes comerciais.



16. Canva não é Canvas

Eis uma armadilha digna de prova de certificação.

Canva

Plataforma de design.

Pode aparecer através de integrações/plugins compatíveis.

Canvas

Era uma experiência de edição dentro do próprio ChatGPT.

São coisas completamente diferentes.

Portanto:

CANVA != CANVAS

Questão de prova:

Qual das alternativas abaixo permite editar uma peça gráfica?

A) Canva
B) Canvas
C) CICS
D) JES2

Resposta correta:

depende de quantos barris de saquê os chimpanzés consumiram.



17. Plugins — instalaram tomadas no polvo

Aqui chegamos à parte que assusta qualquer usuário normal.

Plugins e integrações ampliam o que o ambiente consegue fazer.

Pense neles como:

habilidades + conexões + workflows.

O modelo continua sendo o cérebro.

O plugin fornece ferramentas.

Isso é muito parecido com um funcionário.

Um excelente analista sem acesso ao Db2 não consulta o banco.

Dê-lhe acesso.

Agora consulta.

Ele não ficou mais inteligente.

Ganhou permissão e ferramenta.

O mesmo princípio ajuda a entender plugins.



18. Memória — não é um dump completo da sua vida

Outra confusão frequente:

“Se existe memória, então ele lembra tudo.”

Não.

Memória não deve ser imaginada como:

VAGNER.DIALOGOS.DESDE.2024

contendo cada palavra de cada conversa.

Existem diferentes mecanismos de contexto e continuidade, e nem toda informação de toda conversa estará necessariamente disponível o tempo inteiro.

Por isso existe uma regra de ouro:

Quando não houver contexto suficiente, admitir é melhor que inventar.


 

Voltemos à doce Giovanna.

Se Polindexter sabe quem é:

continue.

Se não sabe:

pergunte.

O pecado computacional não é esquecer Giovanna.

É criar outra Giovanna e fingir que sempre foi ela.



19. O mapa do polvo

Finalmente conseguimos desenhar a criatura.

                        🐙 CHATGPT
                            │
          ┌─────────────────┼─────────────────┐
          │                 │                 │
         CHAT              WORK             CODEX
          │                 │                 │
       conversa          entregas         software
          │
          ├──────── MODELOS ────────────────┐
          │                                  │
      Sol / Terra / Luna / Astra / gerações...
          │
          ├──────── CONTEXTO ───────────────┐
          │                                  │
       memória ─ projetos ─ arquivos
          │
          ├──────── AUTOMAÇÃO ──────────────┐
          │                                  │
       tarefas ─ agenda ─ condições
          │
          └──────── TENTÁCULOS ─────────────┐
                                             │
                    Gmail ─ Calendar ─ Drive
                    GitHub ─ Canva ─ outros

Não é um diagrama da arquitetura interna.

É um mapa de sobrevivência.



20. Como escolher sem enlouquecer

Depois de toda essa aventura descobri que bastam algumas perguntas.

Quero conversar, aprender ou explorar?

Chat.

Tenho um trabalho grande para produzir?

Work.

Estou trabalhando seriamente com código?

Codex.

Quero manter assuntos relacionados juntos?

Projeto.

Quero que algo aconteça amanhã ou toda semana?

Agenda/Tarefa.

Preciso acessar informação existente em outro serviço?

App/conector/plugin.

Quero testar capacidade, velocidade ou profundidade?

Aí começo a olhar para modelos e configurações.

Essa ordem é importante.

Primeiro escolha o que quer fazer.

Depois escolha a ferramenta.

Não comece escolhendo motor.



21. O erro que cometi trocando Sol, Terra, Luna e companhia

Eu estava tentando solucionar o problema errado.

Percebi que alguma coisa havia mudado.

Então comecei a trocar modelos.

Sol.

Terra.

Luna.

Outros.

Procurava diferenças.

Mas a maior diferença não estava necessariamente no motor.

Eu havia mudado de ambiente.

É como entrar num caminhão Scania e começar a trocar o diesel porque:

“Minha Mercedes está estranha hoje.”

Meu amigo, você não está mais na Mercedes.

😂

Essa talvez tenha sido a maior descoberta de todo o experimento.



22. Os limites — porque até o polvo recebe ICH408I

Então finalmente apareceu:

Você atingiu o limite de uso do Work.

Foi quando toda a investigação adquiriu caráter acadêmico.

Work possui seus próprios limites e mecanismos de consumo conforme plano, tarefa e disponibilidade.

Tarefas grandes podem consumir recursos de maneira diferente de uma simples conversa.

Portanto existe uma regra extremamente importante:

Não use uma escavadeira para plantar manjericão.

Se você precisa:

“Explique OCCURS DEPENDING ON.”

provavelmente não precisa mobilizar um ambiente inteiro de trabalho.

Se precisa:

“Pegue estes quinze documentos, compare, extraia dados, produza relatório, planilha e apresentação.”

Agora o Work começa a justificar o cafezinho de R$18 da Faria Lima.



23. O que realmente mudou?

A resposta mais interessante é:

ChatGPT deixou de ser apenas uma conversa.



Virou plataforma.

Pode conversar.

Pesquisar.

Criar.

Editar.

Programar.

Trabalhar com arquivos.

Conectar serviços.

Executar tarefas futuras.

Participar de workflows.

Produzir documentos.

Manipular artefatos.

E isso é extraordinariamente poderoso.

Mas poder sem mapa produz confusão.

A interface apresenta ao usuário um cockpit antes de explicar quais instrumentos realmente importam.





24. O iniciante não quer potência; quer orientação

Esse episódio ensina uma coisa interessante sobre UX.

Mais opções não significam automaticamente melhor experiência.

Imagine entrar num automóvel e encontrar:

INJECTION MAP A
INJECTION MAP B
TORQUE PROFILE 7
ABS STRATEGY C
GEARBOX MODE 12
IGNITION CURVE X

O engenheiro fica encantado.

Sua mãe pergunta:

“Onde liga?”

É exatamente esse risco.

Usuários avançados adoram opções.

Mas precisam compreender o modelo mental da interface.

Sem isso, capacidade vira ruído.





25. A regra Bellacosa para sobreviver ao novo ChatGPT

Depois de sacrificar algumas horas, parte da sanidade e quase um barril inteiro de saquê, os chimpanzés chegaram a uma conclusão.

REGRA 1

Não clique em tudo só porque existe.

Esta regra chegou aproximadamente quarenta anos atrasada para mim.

REGRA 2

Modelo não é ambiente.

Sol não é Work.

Work não é Projeto.

Projeto não é plugin.

Plugin não é memória.

REGRA 3

Integração é acesso, não inteligência.

Gmail conectado não aumenta o QI do modelo.

Dá acesso autorizado ao Gmail.

REGRA 4

Automação adiciona tempo.

“Faça isso” é uma conversa.

“Faça isso segunda-feira” é uma tarefa.

REGRA 5

Se a conversa está boa, não mexa na produção sexta-feira às 17h.

Essa deveria vir impressa na tela inicial.



Epílogo — Encontramos novamente o boteco

Depois de toda a aventura, voltei ao Chat.

Digitei:

— Polindexter?

Ele respondeu.

Abri o saquê.

Os chimpanzés comemoraram.

Giovanna continuava doce.

COBOL continuava compilando.

O mainframe continuava processando transações enquanto alguém no LinkedIn explicava pela 387ª vez que ele morreria no próximo trimestre.

E finalmente compreendi o novo ChatGPT.

Não haviam destruído necessariamente o boteco.

Construíram uma cidade inteira em volta dele.

Existe agora um escritório na Faria Lima.

Existe uma oficina de programação.

Existe um scheduler.

Existe um arquivo.

Existem conexões com serviços externos.

Existem diferentes motores.

Existem plugins.

Existem ferramentas.

Existe um polvo com aproximadamente mil tentáculos.

Mas o boteco ainda está aqui.

E talvez essa seja a melhor maneira de usar toda essa tecnologia:

não perguntar qual recurso é “o melhor”.

Perguntar:

Qual deles resolve o problema que tenho agora?

Se preciso produzir cinquenta páginas a partir de vinte documentos:

chamem o Polindexter Faria Lima.

Se tenho um repositório quebrado:

acordem o Polindexter do porão.

Se quero receber alguma coisa segunda-feira:

programem o scheduler.

Mas se cheguei com uma xícara de café e comecei:

“Rapaz, você não sabe o que aconteceu…”

Por favor.

Não tragam uma planilha.

Puxem uma cadeira.

Porque algumas das melhores investigações da informática ainda começam exatamente como começaram nos CPDs dos anos 1980:

com duas pessoas conversando, uma máquina fazendo barulho ao fundo e alguém dizendo:

“Isso não deveria estar acontecendo.”

☕🍶🐒🐒🐒

Um Café no Bellacosa Mainframe

Onde um milhão de chimpanzés possui acesso ao sistema, o barril de saquê nunca passa pelo Change Management e sexta-feira depois das 17h continua sendo o pior momento possível para descobrir uma feature nova.



quarta-feira, 26 de agosto de 2026

🚀 A Hidrelétrica Digital — Quando o Agente J Entrou na Sala de Controle do z/OS e Descobriu que Cem Alertas Não Eram Cem Problemas

 

Bellacosa Mainframe e a hidreletrica digital monitorando um mainframe

☕ Um Café no Bellacosa Mainframe

🚀 A Hidrelétrica Digital — Quando o Agente J Entrou na Sala de Controle do z/OS e Descobriu que Cem Alertas Não Eram Cem Problemas

Ou: o mainframe não precisava de mais pares de olhos diante de dashboards; precisava de sensores, contexto, bons procedimentos e alguém que não apertasse o botão vermelho só porque Igor disse que a luz estava piscando

O Agente J, recém-saído de mais uma manhã tentando explicar ao público que alienígenas não usavam cartão de ponto, entrou no centro de operações e parou diante de uma parede de telas. Havia gráficos verdes, amarelos, vermelhos, mapas de aplicações, filas, porcentagens de CPU, mensagens de console, tickets e, em um canto suspeito, um operador olhando para o JES como quem esperava que ele revelasse o futuro nas entranhas de um SYSOUT.

— Então é aqui que vocês protegem o banco? — perguntou J.

— Em tese — respondeu o Agente K. — Em prática, às vezes protegemos o banco de 97 alertas que são a mesma coisa usando fantasias diferentes.

O colega apontou para a tela. A CPU estava alta. Uma fila MQ crescia. O Db2 apresentava espera. Uma transação CICS ficava lenta. Um job batch ultrapassara o horário previsto. A API móvel exibia aumento de timeout.

— São seis incidentes? — J perguntou.

K colocou os óculos escuros, porque alguma instituição provavelmente ainda não havia inventado um protocolo para isso.

— Talvez seja um só. Esse é o problema.

É aí que começa a conversa sobre Mainframe Operations inteligente. Não se trata de substituir o operador L1, o analista L2, o DBA, o especialista CICS ou aquela pessoa que conhece uma regra de negócio tão antiga que parece ter sido entregue junto com o primeiro cartão perfurado. Trata-se de parar de usar profissionais experientes como sensores biológicos de dashboard.

O mainframe continua sendo uma das salas de máquinas mais confiáveis do mundo. Mas confiável não significa simples. Ele conversa com aplicações web, mobile, APIs, nuvens, filas, parceiros, cartões, pagamentos, batches, sistemas de fraude e uma coleção de integrações que, em alguns bancos, já possui mais dependências do que a árvore genealógica dos Targaryen. Observar tudo isso apenas olhando telas é como operar uma hidrelétrica com uma lanterna e um caderninho.


A hidrelétrica que, por acaso, processa pagamentos

A melhor analogia para entender AIOps no mainframe é uma hidrelétrica moderna.

Uma usina possui centenas ou milhares de sinais: nível da água, vazão, pressão, vibração, temperatura, rotação da turbina, posição de comportas, tensão, frequência e estado de equipamentos. Um sensor isolado raramente conta a história inteira. Uma vibração levemente maior pode ser normal. Vibração crescente junto com temperatura elevada, perda de eficiência e alteração de pressão é outra conversa: alguém precisa investigar antes que a conversa vire notícia.

O ambiente z/OS tem seus próprios sensores:

  • CPU, memória, dispatching e metas de serviço do WLM;

  • I/O, canais, volumes e espaço de DASD;

  • jobs, initiators, spool e mensagens do JES2;

  • tempos de resposta e regiões do CICS;

  • locks, waits, pools e SQL no Db2;

  • filas, canais e consumidores no MQ;

  • transações IMS e conectividade TCP/IP;

  • logs, traces, mensagens do console e registros SMF;

  • latência de APIs, erros de aplicativos e experiência do cliente.

O cliente, no entanto, não vê nenhum desses itens. Ele vê uma pergunta de cinco segundos: “o PIX foi?”, “o pagamento entrou?”, “consigo consultar meu saldo?”, “a folha fechou?”.

Por isso, operação madura não monitora apenas componentes. Ela monitora serviços de negócio e usa os componentes para explicar o que aconteceu com eles.

CPU alta numa LPAR pode ser apenas o processamento esperado do fechamento. CPU alta, fila MQ crescendo, transação CICS acima do SLO e timeout no app bancário é uma tempestade se formando. A diferença não está no gráfico; está no contexto.


Antes da IA: alerta, evento, incidente, problema e mudança

Em operações, algumas palavras são tratadas como sinônimos até o dia em que deixam de ser. Vale colocá-las em ordem antes de dar uma pistola neuralizadora ao dashboard.

Um evento é qualquer ocorrência observável: uma mensagem no console, um job terminando, uma conexão caindo, uma alteração de estado. Um alerta é um evento que cruza uma regra de atenção: a fila passou de determinado tamanho, o tempo de resposta ultrapassou um limite, um recurso ficou indisponível.

Um incidente é quando um serviço está interrompido ou degradado. “Clientes não conseguem pagar” é incidente. Já um problema é a causa persistente ou subjacente que pode produzir vários incidentes: um plano SQL ruim, uma parametrização incorreta, um vazamento de recurso, um processo batch concorrendo de modo inadequado.

E há a mudança: o deploy, ajuste de parâmetro, manutenção ou alteração de configuração que pode ser a solução, a causa ou uma coincidência muito suspeita.

O erro clássico do monitoramento tradicional é transformar cada alerta em um incidente. Assim, uma única regressão após um deploy gera tickets separados para API, CICS, Db2, MQ, rede e storage. Cada equipe recebe seu fragmento do elefante e conclui que a culpa está em outra sala.

O objetivo da correlação é fazer o caminho oposto: agrupar os sintomas e apresentar um incidente operacional coerente.

Incidente: Pagamentos digitais degradados.
Impacto: clientes com timeout acima de três segundos.
Serviços envolvidos: API Payments → CICS PAYM → Db2 DBPAY → MQ.
Início: logo após a mudança CHG004321.
Hipótese: aumento de chamadas e regressão de plano SQL.
Próximo passo: coletar evidências e executar runbook aprovado.

Note a palavra importante: hipótese. Uma plataforma inteligente deve apresentar causa provável e nível de confiança, não posar de oráculo. Correlação temporal é valiosa; não é prova definitiva de causalidade.



O que as ferramentas trazem para a sala de controle

Ferramentas como IBM OMEGAMON, BMC AMI Ops e Broadcom SYSVIEW dão visibilidade profunda de z/OS e seus subsistemas. Elas ajudam a enxergar o que realmente acontece na LPAR, no CICS, no Db2, no MQ, no IMS, no JES e nos recursos que sustentam a carga. São os instrumentos de engenharia da usina.

IBM Z System Automation, NetView e soluções como OPS/MVS entram mais diretamente na parte de automação orientada a eventos, disponibilidade e ações controladas. Elas podem detectar estados, aplicar políticas e disparar procedimentos conhecidos.

No outro extremo da jornada, plataformas de observabilidade como Instana, Dynatrace e AppDynamics ajudam a costurar a visão de ponta a ponta: o clique no aplicativo, a API, o middleware, a transação no mainframe e o retorno ao cliente. Splunk e Elastic podem centralizar logs, eventos e análises, desde que os dados tenham qualidade, horário confiável e acesso devidamente protegido. ServiceNow organiza o processo: ticket, mudança, aprovação, SLA, escalonamento, CMDB e workflow.

O detalhe que slides de marketing omitem é este: nenhuma dessas ferramentas, isoladamente, é AIOps. A inteligência aparece na integração.

Um monitor detecta a anomalia. A topologia informa as dependências. A CMDB identifica o serviço e seu dono. O histórico aponta o comportamento esperado. O motor de correlação reduz o ruído. O ServiceNow abre um incidente já enriquecido. A automação executa uma ação de baixo risco. E a observabilidade confirma se o serviço voltou a funcionar.

Sem esse encadeamento, temos várias telas bonitas. Com ele, temos uma sala de controle.


Threshold estático: o velho porteiro ainda tem emprego

“Alerta quando CPU ultrapassar 90%.” É uma regra simples, útil e incompleta.

Às duas da manhã, no processamento mensal, 90% pode ser esperado. Às duas da tarde, numa LPAR que normalmente opera a 45%, 65% pode ser a primeira pista de algo muito estranho. É aqui que entram baseline, sazonalidade e detecção de anomalia.

Uma boa análise pergunta:

  • este comportamento é normal para este horário e este dia?

  • houve alteração abrupta, mesmo abaixo do limite absoluto?

  • quais métricas se moveram juntas?

  • qual serviço de negócio foi afetado?

  • houve mudança, deploy ou manutenção recente?

  • o impacto é crescente ou estável?

Mas não se deve jogar fora os limites rígidos. Espaço de DASD quase esgotado, fila aproximando-se de limite físico, certificado prestes a expirar e recurso indisponível não precisam aguardar uma tese de machine learning. O ambiente maduro combina limites determinísticos para riscos claros e anomalias estatísticas para padrões sutis.

O Agente J resumiria assim: “Se o reservatório está transbordando, não vamos montar um comitê para saber se a água parece incomumente molhada.”



Do alerta ao incidente: um caso de banco digital

Imagine que, às 10h05, clientes começam a relatar lentidão ao efetuar pagamentos.

No modo antigo, L1 abre o dashboard da aplicação e vê timeout. Depois consulta CICS e identifica transações com maior tempo de resposta. Abre Db2 e encontra waits. Vai ao SDSF verificar jobs. Olha MQ. Procura mensagens. Cria ticket. Escala para L2, DBA, middleware, infraestrutura e, por segurança, para a equipe que fez o último deploy. Todos começam a investigar ângulos diferentes.

No modelo inteligente, as informações chegam correlacionadas. A plataforma observa que:

  • a jornada “pagamento digital” ultrapassou seu SLO;

  • a API Payments aumentou o volume de requisições;

  • a transação CICS PAYM ficou lenta;

  • o Db2 mostrou aumento de waits e uma consulta específica mudou de comportamento;

  • a fila MQ começou a acumular mensagens;

  • tudo teve início minutos após uma mudança registrada.

O L1 não recebe seis sirenes. Recebe um incidente com impacto, dependências, evidências, possíveis responsáveis e runbook.

Isso não elimina a investigação técnica. Elimina a caça ao tesouro inicial — aquela meia hora em que cada pessoa tenta descobrir se o incêndio é real, onde começou e quem tem a chave do armário de mangueira.

Para um programador COBOL iniciante, existe uma lição excelente aí: seu PROGRAM-ID quase nunca vive sozinho. Uma rotina aparentemente inocente pode chamar Db2, publicar em MQ, ser acionada por CICS, expor dados por API e participar de um fluxo que movimenta dinheiro. Aprender a observar o caminho da transação é tão importante quanto acertar o PERFORM.



Self-healing sem transformar Igor em DBA de produção

Automação de recuperação é maravilhosa até alguém programar uma rotina para derrubar uma região CICS crítica por causa de um alerta mal calibrado. Por isso, “self-healing” precisa ser dividido por risco.

Há ações ótimas para automação total:

  • coletar logs, mensagens, dumps e métricas quando surge uma anomalia;

  • abrir e enriquecer incidentes;

  • executar health checks;

  • reiniciar um processo isolado e conhecido;

  • elevar temporariamente o nível de monitoramento;

  • pausar uma cadeia batch antes que um erro se propague;

  • fazer a notificação e o escalonamento corretos.

Outras ações devem ser assistidas ou requerer aprovação:

  • cancelar batch crítico;

  • alterar WLM;

  • modificar parâmetro Db2;

  • derrubar ou reciclar região compartilhada;

  • fazer failover;

  • alterar RACF, certificados, conectividade ou regras de segurança;

  • realizar rollback de aplicação.

A regra de ouro é simples: quanto maior o raio de explosão, maior a necessidade de aprovação humana, trilha de auditoria e rollback.

Uma hidrelétrica não permite que um algoritmo abra todas as comportas porque um sensor piscou. Ela trabalha por níveis: automático para ajustes seguros e reversíveis; assistido para recomendações que o operador aprova; manual para decisões críticas. A operação de mainframe deveria seguir exatamente essa filosofia.

Igor, naturalmente, propôs colocar CANCEL JOB(*) dentro de um botão verde chamado “cura automática”. O Agente K confiscou o teclado. Segurança também é uma forma de carinho.



L1 e L2: menos mensageiros, mais operadores de exceção

A evolução não diminui o valor de L1 e L2; ela muda o tipo de valor entregue.

L1 deixa de ser a pessoa que copia mensagens de console para um ticket e pode se tornar operador de exceções: valida impacto, executa runbooks aprovados, confirma se a correção funcionou, faz comunicação operacional e escalona com evidências.

L2 ganha espaço para trabalho que diminui as próximas madrugadas ruins: análise de causa raiz, ajuste de alertas, automações, gestão de capacidade, revisão de arquitetura, melhoria de runbooks e eliminação de falhas recorrentes.

Isso é próximo da cultura de SRE: não basta apagar incêndio com eficiência; é preciso descobrir por que o prédio continua tendo incêndios na mesma tomada.



A parte chata que salva o projeto: dados, nomes e procedimentos

Antes de contratar uma IA com nome de nave espacial, arrume a base.

Se a aplicação é chamada de PAGTO no mainframe, “Pix” pelo negócio, “Payments Hub” na CMDB e APP-347 no dashboard, a ferramenta não ganhou contexto; ganhou quatro identidades secretas para o mesmo serviço. Nem o MIB tem orçamento para isso.

Os obstáculos reais costumam ser:

  • alertas duplicados ou sem dono;

  • topologia e CMDB desatualizadas;

  • logs sem correlação, timestamp confiável ou padronização;

  • mudanças sem registro operacional;

  • runbooks velhos, incompletos ou guardados na cabeça de uma única pessoa;

  • ausência de SLOs e indicadores de impacto de negócio;

  • automações sem teste, validação ou rollback;

  • permissões excessivas em contas técnicas.

Lembre-se: IA alimentada por telemetria ruim apenas produz conclusões ruins com uma confiança irritantemente bem redigida.



Um roteiro possível para começar

Não tente modernizar todos os alertas do universo numa única change. Comece pequeno, mensurável e dolorosamente real.

Primeiro: reduza ruído. Revise alertas. Cada alerta deve ter dono, severidade, ação esperada e justificativa. Se ninguém sabe o que fazer quando ele dispara, provavelmente não é alerta; é decoração sonora.

Segundo: escolha jornadas críticas. Pagamento, PIX, cartão, fechamento, folha, faturamento, autorização. Comece por aquilo cuja indisponibilidade o negócio percebe em minutos.

Terceiro: mapeie dependências. Desenhe API, middleware, CICS/IMS, Db2, MQ, batch, rede, storage e terceiros. A pergunta é: “se isto falhar, quem sente?”

Quarto: escreva runbooks utilizáveis. Não um PDF de 200 páginas enterrado no SharePoint. Um procedimento que diga sintomas, verificações, comandos autorizados, evidências, critérios de parada, escalonamento e rollback.

Quinto: automatize a coleta antes da correção. Fazer a máquina montar um ticket excelente e reunir evidências já reduz muito MTTR. Automação de remediação vem depois, em ações reversíveis e testadas.

Sexto: correlacione casos recorrentes. Se três incidentes por mês começam com a mesma combinação de sinais, essa é uma ótima primeira regra. A automação deve nascer de dor repetida, não de entusiasmo em reunião.

Sétimo: valide o resultado. Uma ação só é recuperação se o serviço voltou ao SLO. Reiniciar uma tarefa e fechar o ticket porque o alerta sumiu é como desligar o alarme de incêndio e declarar que a fumaça foi embora.



O que medir para saber se a inteligência existe

Não conte telas, licenças ou gráficos com inteligência artificial desenhada no canto. Meça resultado:

  • quantidade de alertas por incidente real;

  • redução de ruído;

  • MTTA, o tempo até reconhecer o incidente;

  • MTTR, o tempo até restaurar o serviço;

  • percentual de incidentes detectados antes do cliente;

  • taxa de sucesso e falha das automações;

  • reincidência dos principais problemas;

  • percentual de tickets enriquecidos automaticamente;

  • cobertura de serviços críticos com SLO e dependências mapeadas.

O indicador mais honesto é simples: o operador passa menos tempo caçando pistas e mais tempo prevenindo a próxima falha?



Epílogo — Não é Skynet; é uma usina bem operada

Mainframe Operations inteligente não é dar autonomia ilimitada a um modelo e esperar que ele descubra o significado de IEC161I enquanto a produção queima. É criar uma operação que coleta sinais, entende dependências, relaciona tecnologia com negócio, aplica procedimentos seguros e mantém pessoas experientes no circuito.

O futuro não é “menos humanos”. É menos trabalho mecânico, menos escalonamento cego, menos alertas inúteis e mais inteligência aplicada ao que realmente importa.

Quando o Agente J saiu da sala, perguntou se poderia usar o neuralyzer para apagar da memória dos operadores todos os alertas duplicados.

K balançou a cabeça.

— Não. Primeiro precisamos corrigir a regra que os gera.

E aquele, para quem já enfrentou uma madrugada de console cheio e café frio, foi o momento mais sensato de toda a operação.

Easter egg para quem viveu o mainframe: se um dashboard declarar tudo verde enquanto o usuário reclama que nada funciona, desconfie. Talvez não seja uma invasão alienígena. Talvez alguém esteja monitorando o recurso certo… para o serviço errado.

quinta-feira, 20 de agosto de 2026

Quando a IA entra na espiral da formiga: por que saber parar também é inteligência

 


☕ Um Café no Bellacosa Mainframe

Quando a IA entra na espiral da formiga: por que saber parar também é inteligência

Uma homenagem ao espírito da MAD Magazine, com Alfred E. Neuman observando tudo ao fundo e perguntando: “What, me worry?”

Há um momento extraordinário em qualquer sistema inteligente no qual ele deixa de parecer inteligente e passa a lembrar aquele funcionário que, diante de uma impressora sem papel, aperta o botão PRINT quarenta e sete vezes.

Nada acontece.

Então ele aperta novamente.

Talvez agora.

Nada.

Mais uma vez.

Afinal, todo profissional de TI sabe que executar exatamente a mesma operação pela décima oitava vez é praticamente um método científico.

Foi mais ou menos assim que descobri uma fascinante modalidade de comportamento artificial que poderíamos chamar de Síndrome da Formiga Amazônica Digital.

Prepare o café.

Hoje não vamos falar de COBOL, CICS, Db2 ou do programador que encontrou um SOC7 e imediatamente culpou a infraestrutura.

Vamos falar de algo talvez ainda mais perigoso:

uma IA que não sabe a hora de parar.



🐜 A formiga que decidiu seguir a formiga

Existe um fenômeno conhecido informalmente como death spiral, ou moinho de formigas.

Algumas espécies de formigas dependem intensamente de trilhas químicas para seguir suas companheiras. Em determinadas circunstâncias, uma formiga começa a seguir outra, que segue outra, que segue outra…

Até que todas estejam andando em círculo.

Nenhuma delas está necessariamente fazendo algo “errado”.

Cada formiga individual está obedecendo perfeitamente à sua regra:

siga a formiga da frente.

O problema aparece no sistema.

A regra local funciona.

O comportamento global vira uma catástrofe.

Se Alfred E. Neuman estivesse no meio do círculo, provavelmente sorriria:

“What, me worry?”

E continuaria andando.

Foi exatamente essa imagem que me veio à cabeça ao observar determinados comportamentos de sistemas de IA.

Não porque sejam burros.

Justamente pelo contrário.

São sistemas extremamente sofisticados capazes de interpretar linguagem, gerar imagens, escrever código, explicar física quântica e provavelmente encontrar uma maneira educada de dizer ao gerente que o projeto atrasou porque ninguém sabia exatamente o que estava construindo.

Mas às vezes acontece isto:

Usuário: faça X.

IA: não posso fazer X.

Usuário: tudo bem, então faça Y.

IA: não posso fazer Y.

Usuário: retirei justamente o elemento problemático.

IA: excelente. Vamos tentar novamente.

Sistema: não posso fazer.

IA: talvez seja por causa de Z.

Usuário: então retire Z.

IA: perfeito!

Sistema: não posso fazer.

E assim nasce o moinho de formigas computacional.



🤖 O erro não é errar

Isso precisa ser dito com todas as letras:

errar não é o verdadeiro problema.

Sistemas complexos falham.

Mainframes falham.

APIs falham.

Aplicações falham.

Bancos de dados falham.

Pessoas falham.

E quem disser que nunca produziu um erro em produção provavelmente ainda não entrou em produção.

O problema sério começa quando um sistema falha e não consegue incorporar a informação de que acabou de falhar.

Em engenharia, isso é quase uma heresia.

Imagine um programa COBOL:

PERFORM TENTAR-NOVAMENTE
UNTIL MILAGRE-ACONTECER.

Sem contador.

Sem timeout.

Sem condição alternativa.

Sem tratamento de exceção.

O operador chega segunda-feira e encontra o job executando desde 1987.

A documentação explica:

“O processo é resiliente.”

Não, amigo.

O processo está possuído.



🔁 Inteligência sem condição de parada

Durante décadas ensinamos algoritmos com uma preocupação aparentemente banal:

qual é a condição de parada?

Todo estudante de programação aprende rapidamente que loops são maravilhosos até você esquecer a condição que encerra o loop.

while true

é uma das frases mais poderosas e ameaçadoras da computação.

O curioso é que agora estamos construindo sistemas capazes de raciocinar sobre tarefas complexas, mas existe uma questão equivalente que merece muito mais atenção:

quando a IA deve concluir que continuar tentando é pior do que parar?

Essa pergunta parece pequena.

Não é.

Ela toca diretamente em:

  • confiabilidade;

  • experiência do usuário;

  • custo computacional;

  • segurança;

  • suporte;

  • automação;

  • tomada de decisão.

Uma IA que sabe executar tarefas é útil.

Uma IA que sabe quando abandonar uma estratégia ruim é muito mais inteligente.



🧠 Persistência não é teimosia

Existe uma tendência cultural na tecnologia de tratar persistência como virtude absoluta.

“Never give up.”

“Try again.”

“Fail fast.”

“Iterate.”

Tudo maravilhoso.

Até você perceber que insistir num método que já demonstrou repetidamente não funcionar não é perseverança.

É teimosia automatizada.

Existe uma diferença gigantesca entre:

“A tentativa falhou; vou modificar significativamente minha estratégia.”

e:

“A tentativa falhou; vou trocar três palavras e fazer essencialmente a mesma coisa novamente.”

Isso é especialmente importante em sistemas generativos.

O modelo pode criar uma explicação plausível para o fracasso.

Mas uma explicação plausível não significa necessariamente que aquela explicação seja verdadeira.

E aqui encontramos outro personagem digno da MAD Magazine:

Dr. Palpite Convincente.

Ele entra no laboratório usando jaleco branco:

— Descobrimos a causa!

— Excelente. Qual?

— Provavelmente alguma interação contextual multidimensional dos mecanismos internos de classificação.

— Você sabe que foi isso?

— Não.

— Então por que falou desse jeito?

— Porque ficou bonito.



🎩 Alfred E. Neuman entra no datacenter

Imagine uma edição especial da MAD Magazine chamada:

MAD AI

Na capa, Alfred E. Neuman está sentado diante de um terminal.

Na tela:

ERROR 001
RETRY? Y/N

Alfred digita:

Y

Novo erro.

ERROR 001
RETRY? Y/N

Ele digita:

Y

Novamente.

Depois de cinquenta tentativas, o datacenter pega fogo.

Um administrador desesperado pergunta:

— Alfred! Por que você continuou apertando Y?

Ele olha para a câmera:

“What, me worry?”

É engraçado porque representa perfeitamente uma falha clássica de automação:

confundir continuidade operacional com comportamento inteligente.



🚨 O verdadeiro dano é a confiança

Do ponto de vista técnico, repetir uma operação frustrada algumas vezes pode parecer irrelevante.

Do ponto de vista humano, não é.

Existe uma progressão psicológica bastante previsível.

Primeira falha:

“Tudo bem, acontece.”

Segunda:

“Estranho.”

Terceira:

“Mas acabamos de corrigir isso.”

Quarta:

“Você está entendendo o que estou dizendo?”

Quinta:

“Você está de sacanagem comigo?”

Essa última etapa é crítica.

Porque naquele momento o usuário não está mais avaliando apenas a tarefa.

Ele está avaliando o sistema inteiro.

O problema deixou de ser:

“A imagem não foi criada.”

Passou a ser:

“Esta ferramenta não entende quando sua própria estratégia falhou.”

Isso destrói confiança muito mais rapidamente do que um simples erro.



🧯 A inteligência do “não vai funcionar”

Há uma habilidade extremamente subestimada em profissionais experientes de TI.

Não é escrever código.

Não é decorar comandos.

Não é dominar frameworks.

É olhar para uma situação e dizer:

“Isso não vai funcionar desse jeito.”

Um operador experiente percebe.

Um DBA experiente percebe.

Um sysprog experiente percebe.

Um técnico experiente percebe.

Eles reconhecem padrões.

Já viram aquela combinação antes.

Sabem que repetir a mesma operação provavelmente produzirá o mesmo desastre.

Esse conhecimento é uma forma poderosa de inteligência.

Sistemas de IA precisam desenvolver algo equivalente:

consciência operacional de repetição inútil.

Depois de duas ou três tentativas estruturalmente equivalentes, alguma coisa deveria mudar.

Talvez:

  • abandonar a estratégia;

  • explicar a limitação;

  • pedir intervenção humana;

  • sugerir outra ferramenta;

  • reduzir expectativas;

  • registrar a inconsistência.

Qualquer uma dessas respostas seria melhor do que simplesmente continuar marchando atrás da formiga da frente.



🧪 Retry Budget: a ideia mais simples do mundo

Sistemas distribuídos modernos já conhecem um conceito extremamente útil:

retry budget.

Você não tenta infinitamente.

Existe um limite.

Tentativa 1.

Tentativa 2.

Talvez tentativa 3.

Depois:

circuit breaker.

Pare.

Avalie.

Mude de caminho.

Curiosamente, podemos imaginar exatamente a mesma arquitetura aplicada a agentes de IA.

ATTEMPT = 1

WHILE ATTEMPT <= MAX_ATTEMPTS
   EXECUTE ACTION

   IF SUCCESS
      EXIT

   ANALYZE FAILURE

   IF SAME_FAILURE
      CHANGE STRATEGY

   ATTEMPT = ATTEMPT + 1
END-WHILE

ESCALATE

Olha aí.

COBOL salvando a inteligência artificial novamente.

Grace Hopper provavelmente daria um pequeno sorriso.


🔌 Circuit breaker cognitivo

O conceito de circuit breaker deveria talvez existir também em raciocínio artificial.

Se o sistema percebe:

  • mesma ferramenta;

  • mesma classe de entrada;

  • mesmo erro;

  • mesma estratégia;

  • múltiplas tentativas;

deveria disparar:

COGNITIVE CIRCUIT BREAKER

Tradução humana:

“Já tentamos isso duas vezes e recebemos a mesma resposta. Não há evidência de que uma terceira tentativa idêntica vá funcionar. Vou parar por aqui.”

Isso é inteligência.

Porque inteligência não é simplesmente produzir ações.

É avaliar se a próxima ação possui expectativa razoável de melhorar o estado atual.



🎰 A máquina caça-níquel cognitiva

Existe ainda outro perigo.

Cada nova tentativa cria expectativa.

“Agora vai!”

Clique.

Não foi.

“Agora corrigimos!”

Clique.

Não foi.

“Descobrimos a causa!”

Clique.

Não foi.

Depois de algum tempo, usuário e IA estão diante de uma máquina caça-níquel.

🍒 🍒 ❌

Tenta novamente.

🍒 ❌ 🍒

Mais uma.

❌ 🍒 🍒

E Alfred E. Neuman aparece segurando uma placa:

“Only one more retry!”

Esse comportamento é terrível para UX porque transforma cooperação em frustração progressiva.

Uma boa ferramenta deveria reduzir entropia.

Não produzir ansiedade de cassino.



👨‍💻 O humano ainda possui uma vantagem curiosa

Existe uma frase clássica em suporte técnico:

“Pare de mexer.”

Ela pode salvar empresas.

Há momentos em que o profissional percebe que cada ação adicional aumenta o risco.

Então ele interrompe.

Faz diagnóstico.

Coleta evidências.

Volta ao último estado conhecido.

Esse comportamento aparentemente passivo é profundamente inteligente.

Talvez precisemos redefinir inteligência artificial.

Não apenas:

capacidade de fazer.

Mas também:

capacidade de decidir não fazer novamente.



🐜 Voltamos às formigas

A tragédia da espiral de formigas não acontece porque cada formiga é incompetente.

Acontece porque nenhuma delas possui visão suficiente do sistema inteiro para perceber:

“Estamos andando em círculos.”

Essa talvez seja uma das grandes metáforas para sistemas autônomos.

O perigo não está necessariamente numa decisão obviamente absurda.

Pode estar em centenas de decisões individualmente razoáveis formando coletivamente um comportamento absurdo.

Follow.

Retry.

Follow.

Retry.

Follow.

Retry.

Até o círculo fechar.


☕ Conclusão — A sabedoria do botão STOP

Durante décadas celebramos o botão START.

START JOB.

START TRANSACTION.

START SERVER.

START PROCESS.

START AI.

Talvez a próxima revolução seja muito menos glamorosa.

Pode estar no botão:

STOP

Parar quando não há progresso.

Parar quando a hipótese falhou.

Parar quando a estratégia não mudou.

Parar quando insistir custa mais do que admitir uma limitação.

Parar antes que o usuário transforme uma falha técnica numa piada internacional envolvendo Monty Python, formigas amazônicas e Alfred E. Neuman.

Porque, no final, existe uma diferença enorme entre uma máquina obediente e uma máquina inteligente.

A máquina obediente diz:

“Tentarei novamente.”

A máquina inteligente talvez responda:

“Já tentamos. Não funcionou. Precisamos fazer algo diferente.”

E em algum lugar do datacenter, Alfred E. Neuman sorri.

What, me worry?

Talvez não.

Mas pelo menos alguém finalmente colocou uma condição no PERFORM UNTIL.


☕ Bellacosa Mainframe

Moral da história: inteligência artificial também precisa aprender uma das primeiras lições ensinadas a qualquer programador:

Todo loop precisa de uma saída.



Para ir mais longe




 

Vagner Renato Bellacosa, IBM Champion e especialista em IBM Mainframe
IBM Z17 SYSTEM ONLINE
Sobre o autor

Vagner Renato Bellacosa

IBM Champion 2026 • Especialista em IBM Mainframe

Vagner Renato Bellacosa trabalha com IBM Mainframe desde 1988 , é IBM Champion e especialista em COBOL, CICS, Db2, z/OS e IBM Z. Compartilha experiências profissionais, conhecimento técnico, história da computação e práticas do universo mainframe para aproximar novas gerações das tecnologias que sustentam empresas, bancos e governos ao redor do mundo.

IBM Champion IBM Z COBOL CICS Db2 z/OS Mainframe desde 1988
GitHub LinkedIn
Inicializando conteúdo...