☕ 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

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.

Alan Turing, John McCarthy e o Delorean da Inteligência Artificial

 

Bellacosa Mainframe em uma homenagem a Alan Turing John McCarthy e os primordios da IA

☕ Um Café no Bellacosa Mainframe

Alan Turing, John McCarthy e o Delorean da Inteligência Artificial

Ou: o professor Brown trouxe uma Máquina de Turing de 1936, John McCarthy apareceu com Lisp de 1958, Igor tentou instalar um LLM num cartão perfurado — e o programador COBOL descobriu que a pergunta “máquinas podem pensar?” é bem mais antiga que o ChatGPT, o Wi-Fi e aquele colega que diz que IA vai substituir todo mundo na segunda-feira

DOC BROWN — ALERTA TEMPORAL!
“Vagner, se você colocar 1,21 gigawatts nesta fita perfurada, podemos voltar a 1936!”

IGOR: “Excelente, doutor! E depois a gente pede para a máquina preencher a SYSOUT!”

DOC BROWN: “Não, Igor. Primeiro precisamos definir o que a máquina sabe. Depois vemos se ela sabe que não sabe.”

PROGRAMADOR COBOL: “Professor, isso dá um S0C7?”

DOC BROWN: “Pior. Dá um problema filosófico.”

Há uma confusão muito comum quando se fala de Inteligência Artificial: parece que ela nasceu quando alguém abriu um chat, escreveu “faça um resumo deste PDF” e recebeu uma resposta tão convincente que resolveu perguntar se a máquina tinha alma, CPF ou direito a férias.

Não nasceu.

A conversa atual sobre IA — modelos de linguagem, agentes, automação, chatbots, geração de imagens, assistentes de código e previsões sobre AGI — tem raízes em perguntas feitas décadas antes de alguém sonhar com um smartphone. Duas figuras ajudam a entender o tamanho da estrada: Alan Turing e John McCarthy.

Turing ajudou a responder uma pergunta fundamental: o que uma máquina pode calcular? McCarthy pegou a próxima: como fazemos uma máquina exibir inteligência?

Não são a mesma pergunta. Mas, sem a primeira, a segunda talvez nem tivesse uma sala, uma placa na porta e um orçamento de pesquisa.

Para quem está começando em COBOL, isso importa mais do que parece. Afinal, COBOL, mainframe, IA, regras de negócio, automação e segurança pertencem ao mesmo universo: o universo em que seres humanos tentam transformar decisões, processos e conhecimento em algo que uma máquina consiga executar sem entrar em ABEND — ou, no mínimo, sem gerar um incidente que faça o gerente aparecer com a expressão de quem acabou de ver o Great Scott do professor Brown.



1. Antes de a IA existir, Turing desenhou a sala de máquinas

Em 1936, Alan Turing publicou um trabalho que se tornou uma das fundações da ciência da computação. Nele, apresentou a ideia que hoje chamamos de Máquina de Turing.

Não era um notebook. Não era um mainframe. Não tinha monitor, teclado, mouse, GPU, RGB, copiloto nem assistente perguntando se você deseja salvar alterações. Era uma máquina abstrata, matemática, quase ascética: uma fita potencialmente infinita, uma cabeça que lê e escreve símbolos e um conjunto de regras que determina o próximo passo.

Parece simples porque é simples. E justamente por isso é genial.

Imagine uma fita enorme com células. Cada célula pode conter um símbolo. A máquina lê uma célula, verifica seu estado atual e segue uma instrução do tipo:

“Se eu estiver no estado A e ler 0, escreva 1, mova uma posição à direita e vá para o estado B.”

Essa descrição não parece tão distante de um programa. Em COBOL, você escreve algo como:

IF SALDO-DISPONIVEL >= VALOR-SOLICITADO
    MOVE "APROVADO" TO STATUS-OPERACAO
ELSE
    MOVE "NEGADO" TO STATUS-OPERACAO
END-IF.

A diferença é que COBOL é uma linguagem de alto nível, feita para seres humanos descreverem regras de negócio. A Máquina de Turing é uma espécie de esqueleto teórico: uma forma de demonstrar o que significa executar uma sequência de instruções.

O ponto não é que seu programa de folha de pagamento seja literalmente uma Máquina de Turing com fita de papel. O ponto é que existe uma base conceitual por baixo de todo programa: dados, estados, instruções, memória e transições.

Turing mostrou que uma máquina suficientemente geral poderia simular qualquer outra máquina de cálculo, desde que recebesse a descrição correta do procedimento. Nascia a ideia de máquina universal.

E aqui o professor Brown derruba uma caixa de cartões no chão:

“Marty! Não precisamos construir uma máquina nova para cada problema. Precisamos construir uma máquina geral e trocar o programa!”

Esse raciocínio é a alma do computador moderno. O mesmo computador pode rodar um sistema bancário, calcular a folha, tratar uma imagem médica, executar um jogo, fazer uma planilha ou treinar um modelo de IA. O hardware é uma plataforma; o programa define o comportamento.

Para o programador COBOL iniciante, esta é a primeira lição: não pense em programação apenas como escrever comandos. Pense em descrever um processo de maneira precisa o suficiente para uma máquina executá-lo.



2. “Máquinas podem pensar?” — a pergunta que ainda não fechou o chamado

Em 1950, Turing publicou o artigo Computing Machinery and Intelligence. Em vez de tentar resolver logo a palavra “pensar” — uma palavra perigosamente grande, que arrasta consciência, linguagem, criatividade, emoção, filosofia, religião e um boteco inteiro de discussões — ele propôs uma alternativa prática.

Em vez de perguntar:

“Uma máquina pensa?”

Turing sugeriu perguntar algo próximo de:

“Uma máquina consegue conversar de tal modo que um avaliador humano não consiga distingui-la de uma pessoa?”

Essa ideia ficou conhecida como Teste de Turing.

Na versão simplificada, um humano conversa por texto com dois participantes escondidos: uma pessoa e uma máquina. Se não conseguir identificar de modo confiável quem é quem, a máquina demonstrou um tipo importante de comportamento inteligente.

Agora vem a parte que Igor costuma estragar quando lê apenas a manchete:

Passar ou não passar no Teste de Turing não resolve definitivamente a questão da inteligência.

Um sistema pode escrever de forma fluida, imitar emoções, reproduzir estilos e manter uma conversa impressionante. Isso prova que ele se comporta, naquele contexto, de maneira parecida com um humano? Talvez. Prova que ele entende o mundo do mesmo modo que você entende? Não necessariamente.

Um papagaio pode repetir uma frase sem entender economia. Um sistema pode produzir um parágrafo excelente sobre Db2 e, duas linhas depois, inventar uma opção de JCL que nunca existiu com a confiança de um gerente apresentando slide em reunião de diretoria.

Os modelos atuais são fantásticos em linguagem. Eles resumem, traduzem, escrevem código, classificam informações, explicam conceitos e ajudam a explorar ideias. Mas fluência não é garantia de verdade; texto bonito não é auditoria; resposta segura não é evidência.

Este é um ensinamento valioso para quem trabalha com sistemas corporativos:

  • valide regras;

  • valide fontes;

  • mantenha trilha de auditoria;

  • não deixe um modelo decidir sozinho algo sensível sem controles;

  • trate a IA como um componente de software, não como um oráculo.

Em outras palavras: se uma IA disser que o lote terminou bem, ainda abra o SDSF.



3. Bletchley Park: inteligência não é só resolver charadas, é construir método

Durante a Segunda Guerra Mundial, Turing trabalhou em Bletchley Park, no esforço britânico de criptoanálise contra comunicações alemãs codificadas, incluindo mensagens protegidas pela Enigma. Ele não foi um “gênio solitário que venceu a guerra com uma máquina”, como alguns filmes e manchetes resumem. Fez parte de uma rede enorme de matemáticos, linguistas, operadores, engenheiros e criptanalistas.

Mas sua contribuição foi decisiva. O trabalho envolvia lógica, probabilidade, máquinas eletromecânicas, hipóteses, busca de padrões e disciplina operacional. Nada muito diferente, em espírito, do que hoje se chama de análise de dados, engenharia de sistemas e segurança cibernética.

Há uma ponte direta aqui para o analista de segurança e para o programador de sistemas críticos: inteligência útil não é adivinhação. É método para reduzir incerteza.

Quando você recebe um log, por exemplo, não basta olhar uma linha e concluir que houve ataque. Você precisa de contexto:

  • qual usuário executou a ação?

  • de onde veio a conexão?

  • qual era o horário esperado?

  • houve falhas de autenticação antes?

  • o volume de operações fugiu do padrão?

  • qual ativo foi acessado?

  • existe impacto real?

A máquina pode ajudar a encontrar padrões. O humano precisa formular hipóteses, validar evidências e tomar decisões responsáveis.

Turing também nos lembra de algo trágico: genialidade técnica não protege ninguém da crueldade social. Ele foi perseguido pelo Estado britânico por ser homossexual e morreu em 1954, aos 41 anos. Quando celebramos sua obra, não devemos transformar sua vida em uma curiosidade decorativa de biografia. Devemos lembrar que ciência, tecnologia e instituições são feitas por pessoas — e podem falhar moralmente mesmo quando avançam tecnicamente.

Uma IA poderosa construída por uma organização sem ética não vira sábia. Vira apenas uma máquina mais eficiente para escalar decisões ruins.


4. John McCarthy: o homem que deu nome ao monstro

Se Turing ajudou a estabelecer os fundamentos da computação e colocou a pergunta na mesa, John McCarthy ajudou a dar nome ao campo que tentaria respondê-la.

Em 1955, ao escrever a proposta para o Dartmouth Summer Research Project on Artificial Intelligence — realizado no verão de 1956 — McCarthy usou a expressão Artificial Intelligence. O termo pegou, embora “inteligência de máquina” talvez fosse menos carregado de ficção científica.

A proposta era ousada: reunir pesquisadores para investigar a hipótese de que aspectos da aprendizagem e da inteligência poderiam ser descritos com precisão suficiente para serem simulados por uma máquina.

Repare na ambição. Não era “vamos fazer uma calculadora mais rápida”. Era:

“Vamos entender partes da inteligência de forma suficientemente clara para construí-las.”

Isso inclui aprendizado, linguagem, abstração, raciocínio, percepção, planejamento e senso comum. Sessenta e tantos anos depois, boa parte dessas palavras continua na pauta. Algumas avançaram absurdamente; outras continuam com aquele status clássico de projeto: “dependência externa aguardando definição”.

McCarthy apostava muito em IA simbólica: usar fatos, regras e relações explícitas para o computador raciocinar. Algo parecido com:

SE cliente possui limite
E valor solicitado é menor que limite
E não há bloqueio de fraude
ENTÃO aprovar operação.

Para um programador COBOL, isso soa familiar. Sistemas empresariais vivem de regras: alçadas, cálculos, validações, exceções, status, processos de aprovação e rastreabilidade.

A diferença é que a IA simbólica queria ir além de um conjunto fixo de IFs. Ela queria representar conhecimento sobre o mundo e tirar conclusões novas a partir dele.

O sonho era elegante. O mundo, porém, é cheio de exceções.

Você pode escrever uma regra simples:

Pássaros voam.

Mas pinguins não voam. Aves feridas podem não voar. Um pássaro dentro de uma gaiola pode saber voar e não estar voando. E se Igor colocar um frango congelado na mesa e perguntar se ele é um pássaro, o sistema precisa de mais café e menos certeza.

Esse tipo de problema — lidar com conhecimento incompleto, exceções e contexto — foi um dos grandes desafios da IA clássica. McCarthy trabalhou com raciocínio não monotônico, isto é, formas de raciocínio em que uma conclusão pode precisar ser revista quando surge uma informação nova.

Parece abstrato, mas você faz isso todo dia.

“A transação parece legítima.”
“Espere: o IP é novo, o valor é atípico e houve quinze tentativas de senha.”
“Atualize a conclusão.”

Em segurança, em auditoria e em operações, mudar de opinião diante de evidências novas não é fraqueza. É inteligência.



5. Lisp: a linguagem que ensinou a IA a mexer em ideias

Em 1958, McCarthy criou Lisp, abreviação de List Processing. A linguagem ganhou forma pública em seu famoso artigo de 1960 e se tornou uma das linguagens mais influentes da história da IA.

Lisp tratava listas e expressões simbólicas como elementos naturais do programa. Isso era muito poderoso para manipular estruturas de conhecimento, árvores, regras, fórmulas e linguagem.

Um exemplo muito simplificado de Lisp pode parecer assim:

(if (fraude-suspeita transacao)
    (bloquear transacao)
    (aprovar transacao))

Não é COBOL, claro. Mas a intenção deve lhe soar familiar: testar uma condição e tomar um caminho.

A diferença cultural é interessante. COBOL foi desenhado para tornar regras de negócio legíveis e duráveis. Lisp nasceu em um ambiente que queria representar símbolos, relações e transformações conceituais. Um é o funcionário experiente que conhece todas as contas do fechamento mensal; o outro é o professor maluco do laboratório que pergunta se uma expressão pode modificar outra expressão e se isso nos aproxima da mente.

Os dois têm lugar no mundo.

Aliás, Lisp não está morto. Ideias que ele popularizou — funções como valores, recursão, coleta automática de memória, manipulação de listas e metaprogramação — influenciaram muitas linguagens posteriores. A história da computação é cheia de “tecnologias antigas” que, na verdade, eram ideias adiantadas demais para o hardware e o mercado de sua época.

Mainframe também conhece essa piada. Quando alguém diz que COBOL é velho, o programador experiente responde:

“Velho é o sistema que ainda movimenta dinheiro, processa seguro, paga salário e não cai quando o hype troca de nome.”



6. A aposta de 2039: previsão, palpite ou bilhete para o Delorean?

Em uma entrevista de 1989, McCarthy falou sobre o tempo necessário para programas se tornarem tão inteligentes quanto seres humanos. Ele reconheceu que poderia levar duzentos ou quinhentos anos, dependendo dos avanços conceituais necessários. Mas disse que se inclinaria a apostar em algo como cinquenta anos — acrescentando, com humor seco, que era extremamente improvável que estivesse vivo para ver.

1989 + 50 nos leva aproximadamente a 2039.

McCarthy morreu em 2011. Ele acertou, de forma triste e literal, que não viveria para testemunhar a resposta. Mas é importante não transformar isso em profecia com data marcada no calendário.

2039 não é uma garantia de “AGI em produção”. Não haverá necessariamente um painel no Data Center dizendo:

AGI-2039 — STATUS: DISPONÍVEL
PRESS <ENTER> PARA ATIVAR CONSCIÊNCIA

A própria expressão “inteligência humana” é difícil de medir. Um sistema pode ser melhor que uma pessoa em xadrez, tradução, cálculo, reconhecimento de imagens e geração de código, mas falhar em tarefas banais que exigem contexto, bom senso, memória confiável ou compreensão física do mundo.

Foi isso que aconteceu no xadrez. Em 1968, o mestre internacional escocês David Levy apostou que nenhum computador o venceria em dez anos. Em 1978, o programa CHESS 4.7 perdeu por 2 a 1 — uma derrota humana, mas uma aproximação notável.

Décadas depois, computadores venceriam campeões mundiais. Isso não significou que eles haviam resolvido a inteligência geral. Significou que resolveram — brilhantemente — um domínio formal, com regras claras e objetivo definido.

A lição é ouro:

Ser excelente em uma tarefa não torna automaticamente um sistema inteligente em tudo.

Um modelo que escreve COBOL pode ajudar muito. Ainda assim, ele pode não conhecer as regras específicas do seu banco, não saber que um campo contém informação sensível, não entender uma convenção interna, não ter acesso ao contexto de produção e não perceber que aquela “melhoria” quebra um processo regulatório.

Por isso, IA corporativa madura precisa de humano no circuito, testes, limites de acesso, logs, aprovação e recuperação.

Igor, naturalmente, acha que basta dar UPDATE na tabela de pagamentos e perguntar para o robô “faz um PIX aí”. Não seja Igor.



7. LLMs, IA simbólica e o grande encontro no bar

A IA que domina a conversa atual é fortemente baseada em aprendizado de máquina: grandes modelos neurais treinados com enormes volumes de texto, código, imagens e outros dados. Eles aprendem padrões estatísticos e conseguem gerar respostas surpreendentemente úteis.

Esse caminho é diferente da visão mais simbólica de McCarthy. Em vez de alguém escrever explicitamente todas as regras, o modelo aprende regularidades a partir de exemplos.

Há vantagens enormes:

  • adaptação a linguagem natural;

  • capacidade de lidar com variedade de textos;

  • geração de rascunhos e código;

  • sumarização;

  • classificação;

  • tradução;

  • apoio ao atendimento;

  • descoberta de padrões.

Mas há riscos igualmente reais:

  • alucinação: inventar fatos ou referências;

  • vieses presentes nos dados;

  • falta de explicabilidade;

  • vazamento de informações;

  • prompt injection;

  • automação de decisões sem revisão;

  • confiança excessiva do usuário.

A tendência mais interessante não é escolher uma religião — “só redes neurais” ou “só regras simbólicas”. É combinar abordagens.

Um sistema empresarial pode usar um LLM para entender a solicitação em português, uma base de conhecimento validada para buscar políticas corretas, regras explícitas para decisões obrigatórias e um humano para aprovar ações de alto impacto.

Pense assim:

Pessoa faz pergunta
        ↓
LLM entende a linguagem
        ↓
RAG busca documentos autorizados
        ↓
Regras de negócio validam condições
        ↓
Humano aprova decisão sensível
        ↓
Log registra tudo

Isso está muito mais perto de uma arquitetura responsável do que soltar um modelo numa rede corporativa e torcer para ele ter juízo.

Máquinas não têm juízo moral por padrão. Elas têm permissões, dados, instruções, limitações e consequências.



8. Um roteiro para o programador COBOL entrar na conversa da IA sem virar passageiro do tempo

Você não precisa abandonar COBOL, virar cientista de dados em uma semana ou comprar uma camiseta escrito “AGI IS COMING” para participar desse futuro.

Comece de modo prático.

Passo 1 — Entenda o processo antes de automatizá-lo

Escolha uma rotina de negócio conhecida: validação de cadastro, classificação de chamados, triagem de documentos, explicação de mensagens de erro ou consulta de procedimento.

Pergunte:

  • qual é a entrada?

  • qual é a saída?

  • quais regras são obrigatórias?

  • quais exceções existem?

  • que dados são sensíveis?

  • quem é responsável pela decisão?

  • como registrar auditoria?

Se você não consegue explicar o processo, não está pronto para entregar o processo a uma IA.

Passo 2 — Separe linguagem de decisão

Um LLM pode ser ótimo para receber uma pergunta como:

“Por que meu pagamento foi bloqueado?”

Mas a decisão real de bloqueio deve continuar apoiada por regras, dados transacionais e controles.

A IA pode traduzir o tecnês. O motor de regras decide. O analista responde pelo caso. Essa separação evita que um texto bonito vire uma decisão perigosa.

Passo 3 — Use a IA como par de programação, não como piloto automático

Peça para ela:

  • explicar um programa COBOL;

  • sugerir casos de teste;

  • comentar uma PROCEDURE DIVISION;

  • gerar documentação inicial;

  • converter uma regra de negócio em pseudocódigo;

  • ajudar a encontrar campos usados em uma rotina;

  • produzir uma primeira versão de teste unitário.

Mas revise tudo. Principalmente nomes de campos, arquivos VSAM, commits, SQL, regras de arredondamento, formatos de data e operações financeiras.

A IA pode ser um ótimo estagiário que trabalha rápido. Você continua sendo o responsável pela mudança em produção.

Passo 4 — Segurança não é rodapé

Nunca envie código proprietário, dados de clientes, credenciais, dumps, arquivos de produção ou detalhes operacionais para ferramentas públicas sem autorização.

Pergunte sempre:

  • onde o dado será processado?

  • ele será retido?

  • quem pode acessá-lo?

  • há contrato e política corporativa?

  • o conteúdo pode virar treinamento?

  • existe mascaramento?

  • há trilhas de auditoria?

Turing trabalhou com segredo criptográfico. McCarthy pensava em representação de conhecimento. Em 2026, os dois provavelmente olhariam para um CSV de clientes colado num chatbot público e pediriam para desligar o Delorean.


Epílogo — A pergunta ainda está na fita

Alan Turing nos deu a linguagem conceitual para pensar máquinas que executam procedimentos gerais. Ele nos deixou uma pergunta que resiste a cada nova geração tecnológica: “máquinas podem pensar?”

John McCarthy pegou essa inquietação e deu a ela um nome, um campo de pesquisa, uma agenda e ferramentas para tentar respondê-la. Criou Lisp, ajudou a moldar a IA simbólica e, em 1989, arriscou um palpite que nos aponta para 2039 — não como destino garantido, mas como um marcador fascinante no mapa.

Hoje, temos sistemas capazes de conversar, programar, traduzir, enxergar, resumir e sugerir. Alguns parecem mágicos até o momento em que erram algo óbvio. Isso não diminui sua importância; apenas nos obriga a sair do hype e entrar na engenharia.

Talvez a pergunta não seja mais apenas “a máquina pensa?”.

Talvez seja:

“Ela entende? Ela pode agir? Ela pode errar? Quem confere? Quem responde pelo dano? E por que Igor recebeu acesso de administrador?”

O programador COBOL tem uma vantagem preciosa nesta era. Já conhece sistemas longos, críticos, regulados, cheios de exceções e onde um pequeno erro pode fazer uma conta muito grande deixar de fechar. Esse olhar vale ouro quando a IA sai do laboratório e entra no banco, no governo, na saúde, na segurança e no mainframe.

No fim, Turing construiu a estrada. McCarthy colocou a placa: Inteligência Artificial. E nós, passageiros do Delorean de 2026, estamos dirigindo rumo a 2039 com uma mão no volante, outra no manual de segurança e o professor Brown gritando do banco de trás:

“Para onde vamos, não precisamos de estradas… mas vamos precisar de logs, testes, backup e um plano de rollback!”



 

terça-feira, 25 de agosto de 2026

Do Z3R0 ao HERO — Quando o T-800 Auditou o Datacenter, Desconfiou de Igor e Descobriu que Red Team Não É Só Uma Caveira no Terminal

 

Bellacosa Mainframe e a auditoria do T800

☕ Um Café no Bellacosa Mainframe

Do Z3R0 ao HERO — Quando o T-800 Auditou o Datacenter, Desconfiou de Igor e Descobriu que Red Team Não É Só Uma Caveira no Terminal

Ou: o programador COBOL queria saber se era Blue ou Red, o Exterminador respondeu que primeiro ele precisava descobrir quem tinha UPDATE na tabela de pagamentos — e Igor, naturalmente, sugeriu colocar a senha no nome do dataset para não esquecê-la.

MODELO T-800 — STATUS: OPERACIONAL
MISSÃO ORIGINAL: localizar Sarah Connor.
MISSÃO ATUALIZADA: localizar o proprietário da conta técnica com privilégio excessivo.
AVISO: “HASTA LA VISTA, SEGREGAÇÃO DE FUNÇÕES INEXISTENTE.”

O universo da segurança da informação adora cores. Há o Red Team, que pensa como um adversário; o Blue Team, que protege, monitora e responde; e o Purple Team, que tenta impedir que os dois passem a reunião inteira discutindo quem ganhou a bandeirinha do CTF.

Mas, antes que alguém instale uma distribuição cheia de ferramentas, abra três terminais pretos e declare-se “hacker ético” no LinkedIn, convém uma pequena verdade digna de uma sala de máquinas: segurança não começa pelo ataque. Começa por compreender o sistema que se pretende proteger ou avaliar.

Para o programador COBOL iniciante, isso é quase uma boa notícia. Você já está entrando por uma porta que muita gente só encontra depois de anos: a porta dos processos críticos, dos dados que realmente importam, dos controles de acesso, dos jobs que não podem falhar e das mudanças que precisam deixar rastro. No mundo em que uma API moderna conversa com uma fila, que conversa com CICS, que conversa com Db2, que conversa com um batch de quarenta anos ainda pagando salário, ninguém pode tratar segurança como detalhe de rodapé.



1. O primeiro diagnóstico do T-800: Pentest, Red Team e Blue Team não são a mesma coisa

Um pentest é uma avaliação autorizada, normalmente com escopo definido, para encontrar e validar vulnerabilidades. Pode ser um portal, uma API, uma rede, um aplicativo móvel ou um ambiente cloud. A pergunta é direta: “que falhas existem aqui, qual o impacto e como corrigir?”

O Red Team vai além: simula, de forma controlada, um adversário tentando atingir um objetivo relevante para o negócio. Não está interessado em colecionar cinquenta alertas coloridos. Está interessado em testar uma hipótese: seria possível alguém alcançar um ativo crítico? Os controles perceberiam? A organização conteria a atividade a tempo?

Já o Blue Team vive no mundo real. Ele administra ou acompanha controles, investiga alertas, endurece configurações, gerencia vulnerabilidades, melhora logs, responde a incidentes e tenta impedir que o mês da empresa acabe em reunião de crise com jurídico, diretoria e café frio.

TimePergunta principalEntrega útil
Pentest“Que vulnerabilidades existem no escopo?”Achados priorizados, evidências e recomendações
Red Team“Um adversário plausível atingiria o objetivo?”Cadeia de risco simulada e avaliação de controles
Blue Team“Como prevenimos, detectamos e respondemos?”Controles, telemetria, investigação e recuperação
Purple Team“O que aprendemos juntos?”Correções testadas e detecções melhores

O Red não existe para humilhar o Blue. Se a operação termina com “entramos e vocês não viram”, mas ninguém melhora log, regra, privilégio ou processo, a empresa acabou de pagar por um trailer de filme, não por segurança.



2. O erro que termina em ABEND: ferramenta antes de fundamento

Ferramenta é multiplicador. Multiplica velocidade quando há conhecimento; multiplica confusão quando não há.

Um scanner pode apontar uma versão vulnerável. Isso ainda não responde se o serviço está exposto, se a função vulnerável está ativa, se há rota de rede, se o controle compensatório existe ou se o impacto é relevante. O profissional precisa validar a hipótese sem provocar dano.

É igual ao COBOL. Decorar READ, WRITE e PERFORM não torna ninguém dono do processamento. É preciso entender arquivo, chave, status, commit, lock, dados de entrada, regra de negócio e consequência de uma atualização. Segurança é a mesma conversa, apenas com o T-800 olhando por cima do ombro.

Os fundamentos indispensáveis são:

  • Redes: DNS, TCP/IP, HTTP/S, TLS, proxy, VPN, roteamento, portas e segmentação.

  • Sistemas operacionais: usuários, grupos, permissões, processos, serviços, logs, atualizações e administração.

  • Programação: lógica, variáveis, validação, tratamento de erro, bibliotecas, APIs e leitura de código.

  • Dados: modelagem, autenticação no banco, permissões, cópias, backups, trilhas de auditoria e mascaramento.

  • Identidade: autenticação não é autorização; saber quem entrou não responde ao que essa pessoa pode fazer.

  • Negócio: um ativo crítico não é necessariamente o servidor mais caro; pode ser uma tabela, uma interface, uma conta técnica ou uma etapa invisível do processo.

Curiosidade de sala de máquinas

O mainframe ensinou há décadas uma lição que a nuvem redescobre quase todo ano: controle de acesso é uma política, não uma tela de login. Um ID autenticado pode continuar perigosíssimo se tiver autoridade excessiva, grupos herdados, permissões antigas ou uso compartilhado. RACF não lê pensamentos, mas obriga a fazer a pergunta certa: quem tem acesso a quê, por qual motivo, e com qual registro?



3. A tríade CIA: não é agência secreta, embora Igor tivesse gostado da ideia

Segurança protege, no mínimo, três propriedades:

  • Confidencialidade: somente pessoas e processos autorizados veem a informação.

  • Integridade: dados e transações não são alterados indevidamente.

  • Disponibilidade: serviços e informações permanecem acessíveis quando necessários.

Pense num pagamento. Se alguém vê o dado de outro cliente, há quebra de confidencialidade. Se consegue alterar a conta favorecida, há quebra de integridade. Se o sistema de pagamentos fica indisponível no fechamento, há quebra de disponibilidade.

E o caso real quase sempre mistura tudo. Uma credencial comprometida pode permitir leitura indevida; a mesma conta, com privilégio demais, pode alterar uma regra; a tentativa de conter o problema pode derrubar um serviço. Segurança não é uma caixinha isolada. É o conjunto inteiro do processo sob pressão.



4. Red Team profissional: o atacante autorizado que sabe a hora de parar

O Red Team avalia caminhos, não apenas máquinas. Dependendo do escopo formal, pode testar exposição externa, aplicações, APIs, configurações, identidade, segmentação, processos, fornecedores e aspectos físicos. A palavra que mantém tudo do lado certo é autorização.

Antes de qualquer exercício sério devem existir regras de engajamento: objetivo, período, ativos permitidos, sistemas proibidos, limites de impacto, contatos de emergência, tratamento de evidências, dados que não podem ser acessados e critério de parada.

“Try harder” é excelente para o laboratório. Em produção, a tradução profissional é: pare quando a evidência já prova o risco. Não se demonstra que um backup está vulnerável apagando-o. Não se demonstra que dados pessoais podem ser acessados copiando uma base inteira. Não se demonstra indisponibilidade derrubando a folha de pagamento.

O objetivo é obter evidência mínima, confiável e reproduzível. O T-800 chama isso de eficiência. O jurídico chama de sobrevivência.

5. Blue Team: o turno da madrugada, os logs e a pergunta que ninguém queria receber

Blue Team não é um analista hipnotizado por um painel cheio de alertas. É uma combinação de capacidades: monitoramento, engenharia de detecção, resposta a incidentes, gestão de vulnerabilidades, hardening, segurança de endpoints, cloud, aplicações, identidade, backups e continuidade.

Uma defesa madura distingue quatro coisas:

  1. Evento: algo aconteceu; um login, uma alteração, uma conexão.

  2. Alerta: uma regra considerou o evento suspeito.

  3. Incidente: a investigação confirmou atividade indevida ou dano.

  4. Crise: o impacto ultrapassou a capacidade normal de resposta e exige coordenação executiva, legal ou operacional.

Confundir tudo gera dois desastres clássicos: pânico por qualquer alerta ou silêncio até a manchete chegar. Logs são fundamentais porque sem eles a organização fica discutindo memória e impressão. Com registros adequados, ela reconstrói fatos.

Para quem trabalha em z/OS, isso tem sabor familiar. SMF, RACF, logs de CICS, Db2 e auditorias não são burocracia arqueológica: são peças da história que você precisará contar quando algo parecer estranho.



6. Purple Team: quando o treinamento deixa de ser guerra civil

Purple Team é colaboração deliberada. O Red apresenta uma simulação autorizada ou um comportamento relevante; o Blue observa a telemetria, avalia se houve alerta, investiga e propõe melhoria. Depois ocorre reteste.

Exemplo: um exercício mostra que uma alteração sensível em uma conta técnica não gerou alerta útil. A correção pode envolver revisão de privilégio, registro adicional, regra de correlação, aprovação de mudança e um playbook para investigação. O reteste comprova se a defesa agora enxerga o comportamento.

Não importa qual ferramenta foi usada. Importa se a empresa consegue detectar o comportamento. É por isso que o MITRE ATT&CK é tão útil: ele fornece uma linguagem para falar de objetivos e técnicas adversárias sem reduzir a discussão a uma marca de ferramenta ou a um comando da moda.


7. O mapa de carreira: do Z3R0 ao profissional confiável

Não existe atalho, mas há sequência melhor que sair colecionando cursos.

Passo 1 — Aprenda o caminho dos dados

Entenda uma transação de ponta a ponta. Um navegador chama uma API; a API autentica o usuário, consulta uma base ou um serviço corporativo, grava um log e devolve uma resposta. Pergunte em cada etapa: onde há identidade? Onde há autorização? Onde há dado sensível? O que é registrado? Quem administra?

Passo 2 — Construa um laboratório isolado

Use apenas ambientes feitos para estudo ou sistemas próprios. Não precisa de um datacenter da Skynet. Uma máquina virtual, uma aplicação de treinamento, um serviço de logs e controles simples já permitem exercitar observação, documentação, correção e reteste.

Monte sempre os dois lados: uma aplicação ou serviço intencionalmente frágil e a visibilidade defensiva correspondente. A grande lição não é “como entrar”; é “que evidência isso deixou e como eu deveria ter percebido?”

Passo 3 — Aprenda aplicações e APIs

Aplicações modernas concentram falhas que scanners podem não compreender: autorização inadequada, regra de negócio frágil, exposição excessiva de dados, integração confusa e validação só no navegador.

Exemplo seguro: se uma pessoa autenticada consegue acessar uma fatura que não lhe pertence trocando apenas um identificador, o defeito é de autorização. O sistema confirmou “quem é você?”, mas esqueceu de confirmar “você pode ver isto?”. O remédio não é apenas esconder o campo na tela; é validar a permissão no servidor, registrar tentativas e revisar o modelo de acesso.

Passo 4 — Estude identidade, cloud e DevSecOps

Hoje o perímetro é móvel. Usuários acessam SaaS, APIs usam tokens, pipelines implantam infraestrutura e contas de serviço conversam com múltiplos sistemas. Um segredo exposto, uma permissão IAM excessiva ou uma conta técnica sem dono podem ser mais graves que uma porta aberta.

O bom profissional pergunta: qual identidade executa isso? Qual privilégio ela possui? O que aconteceria se fosse usada indevidamente? Onde está o log? Há rotação de segredo? Existe menor privilégio?

Passo 5 — Escolha uma profundidade, mantenha a largura

Você pode especializar-se em segurança ofensiva, SOC, resposta a incidentes, AppSec, GRC, cloud ou mainframe. O formato ideal é o “T”: profundidade em uma área, entendimento amplo das demais.

Um programador COBOL pode construir uma especialidade particularmente rara: segurança de aplicações e integrações híbridas. Quando a frente moderna conversa com CICS, Db2, MQ, IMS, batch e arquivos críticos, entender os dois lados é uma vantagem enorme. A porta de entrada pode ser uma API; o cofre pode estar no backend legado.



8. CVE não é automaticamente risco — e scanner não é oráculo

Uma CVE é identificação pública de uma vulnerabilidade. Ela pode ser importante, mas não substitui análise. Para priorizar, considere exposição, pré-requisitos, valor do ativo, controles existentes e impacto.

Uma falha moderada em um portal público que expõe dados pessoais pode ser mais urgente que uma falha crítica em ambiente isolado, sem rota de rede e sem uso da função vulnerável. Risco é a combinação de probabilidade e impacto, não um número piscando em vermelho.

O relatório útil traduz isso. Em vez de “corrigir vulnerabilidade”, ele diz que ativo foi afetado, por que importa, como o controle falhou, qual equipe pode corrigir, que medida temporária reduz risco e como retestar.



9. O artefato mais subestimado: o relatório

Um relatório ruim é uma coleção de prints com caveira. Um relatório bom é uma ponte entre segurança e mudança real.

Ele deve explicar o cenário, evidência, impacto plausível, controles esperados, lacuna observada, recomendação prática e prioridade. Deve falar para executivos sem esconder a parte técnica e falar para técnicos sem transformar a conclusão em poesia corporativa.

Por exemplo: “Revisar a autorização de alterações de favorecido, separar criação de aprovação, limitar privilégios da conta técnica, registrar mudanças críticas e retestar o fluxo.” Isso dá à empresa um caminho. “Melhorar a segurança” só dá vontade de pedir mais café.



Epílogo — O T-800 fecha o ISPF

Ao final da auditoria, Igor pergunta se Red Team significa usar vermelho no terminal. O T-800 olha para a tela, identifica uma conta compartilhada, três permissões herdadas e um backup nunca restaurado em teste. Depois responde, com a ternura de uma prensa hidráulica:

“A COR É IRRELEVANTE. A AUSÊNCIA DE EVIDÊNCIA, NÃO.”

Ser Blue, Red ou Purple não é escolher uma fantasia. É escolher uma responsabilidade. O Red testa se a defesa resiste; o Blue constrói e opera essa defesa; o Purple garante que o aprendizado não morra no relatório. E o profissional que começa em COBOL traz algo precioso para todos eles: a noção de que sistemas importam porque processos e pessoas dependem deles.

Estude fundamentos. Pratique somente em ambientes autorizados. Aprenda a ler código, logs, permissões e fluxos de negócio. Respeite escopo. Documente bem. E desconfie de toda conta técnica cujo responsável seja descrito como “sempre foi assim”.

Porque, como o T-800 aprendeu naquele turno no datacenter, o futuro não é uma guerra entre máquinas e humanos. É uma planilha de acessos sem dono, uma API sem autorização e Igor dizendo: “Doutor, eu deixei a senha em comentários para facilitar a manutenção.”





segunda-feira, 24 de agosto de 2026

Prenda-me se For Capaz — Quando o IBM z17 Colocou uma IA na Alfândega da Transação e Mandou a Fraude Mostrar o Passaporte

 
Bellacosa Mainframe e o prenda-me se for capaz ia e ibm z17 contra fraudes

☕ Um Café no Bellacosa Mainframe

Prenda-me se For Capaz — Quando o IBM z17 Colocou uma IA na Alfândega da Transação e Mandou a Fraude Mostrar o Passaporte

Ou: Frank Abagnale entrou no banco vestido de piloto, o programa COBOL consultou o histórico, o Telum II calculou um score em menos de um milissegundo — e o Spyre ficou no andar de cima investigando por que o cheque tinha sido emitido por uma companhia aérea que não existia

Há uma cena clássica em qualquer bom filme de vigaristas.

O sujeito entra pela porta principal usando um uniforme impecável. Caminha como se conhecesse o prédio, cumprimenta o segurança pelo nome, segura uma pasta de couro e parece tão legítimo que ninguém se lembra de fazer a pergunta fundamental:

— Quem é você?

Frank Abagnale Jr., personagem central de Catch Me If You Can, construiu sua carreira cinematográfica exatamente nesse intervalo entre parecer legítimo e alguém conferir os dados.

Ele não precisava derrubar o sistema bancário. Não precisava explodir o datacenter, quebrar a criptografia ou fazer engenharia reversa no CICS.

Precisava apenas parecer verdadeiro durante tempo suficiente.

Fraude funciona assim.

Ela raramente entra pela janela usando máscara preta e carregando um saco com cifrão. Normalmente chega pela porta da frente com:

  • nome aparentemente correto;

  • cartão válido;

  • senha correta;

  • documento convincente;

  • dispositivo conhecido;

  • comportamento quase normal;

  • história razoavelmente plausível.

O problema da segurança moderna não é encontrar aquilo que parece completamente falso. Isso costuma ser fácil.

O problema é identificar aquilo que possui 97% de verdade e esconde a fraude nos 3% restantes.

E o banco precisa perceber isso antes que a autorização seja concluída.

Não amanhã.

Não depois do fechamento do movimento.

Não quando o cliente ligar informando que nunca comprou vinte televisores em Vladivostok.

A decisão precisa acontecer enquanto a transação ainda está atravessando o corredor.

É nesse ponto que entra o IBM z17, seu processador Telum II, o acelerador Spyre e uma ideia aparentemente simples, mas arquiteturalmente poderosa:

Em vez de mandar os dados até a inteligência artificial, colocamos a inteligência artificial perto dos dados.

Puxe uma cadeira, abra o ISPF e peça mais um café. Hoje acompanharemos uma transação bancária como se ela fosse Frank Abagnale tentando atravessar a alfândega vestido de piloto.



1. A fraude não começa com um crime: começa com uma história

Imagine que um cliente normalmente faça compras assim:

  • supermercados em Itatiba;

  • combustível duas vezes por mês;

  • serviços digitais recorrentes;

  • pequenas compras durante o dia;

  • um restaurante aos sábados;

  • nenhuma transação internacional recente.

Subitamente aparece uma tentativa de compra:

  • três notebooks;

  • às 3h17 da madrugada;

  • em outro país;

  • utilizando um dispositivo nunca visto;

  • depois de quatro tentativas recusadas;

  • com endereço de entrega diferente;

  • poucos minutos depois de uma alteração cadastral.

Nenhuma dessas características, sozinha, prova uma fraude.

Pessoas viajam.

Pessoas compram notebooks.

Pessoas trocam de celular.

Pessoas esquecem senhas.

Pessoas compram presentes de madrugada porque a insônia também participa da economia mundial.

Entretanto, quando combinamos todos os sinais, surge uma história estranha.

É exatamente esse tipo de relação que um modelo de machine learning procura aprender.

Ele não está buscando apenas uma regra rígida como:

SE VALOR > 10000
    ENTÃO RECUSAR

Ele tenta responder uma pergunta mais sofisticada:

Considerando dezenas ou centenas de características, o quanto esta transação se parece com as fraudes que observamos anteriormente?

A resposta geralmente não é “sim” ou “não”.

É um score.

Por exemplo:

RISCO-DE-FRAUDE = 0,91

Isso significa que o modelo encontrou uma combinação fortemente associada a comportamento fraudulento. Não significa que ele tenha presenciado o crime, interrogado o suspeito e recuperado o dinheiro numa mala escondida no aeroporto.

A IA não produz uma sentença judicial.

Ela produz evidência probabilística para ajudar o sistema a tomar uma decisão.

Esse será nosso primeiro ensinamento para o programador COBOL iniciante:

Machine learning não elimina a lógica de negócio. Ele acrescenta uma nova informação à lógica de negócio.



2. Treinamento e inferência: a escola e a prova oral

Antes de entender o Telum II, precisamos separar duas fases frequentemente misturadas.

Treinamento

Durante o treinamento, apresentamos ao modelo dados históricos:

  • compras legítimas;

  • fraudes confirmadas;

  • contestações;

  • chargebacks;

  • dispositivos comprometidos;

  • contas invadidas;

  • identidades roubadas;

  • comportamentos considerados normais;

  • comportamentos considerados suspeitos.

O modelo tenta encontrar relações matemáticas entre as características e os resultados conhecidos.

É como mostrar milhares de cheques a um investigador e dizer:

— Estes eram legítimos. Estes eram falsificados. Descubra os padrões.

O treinamento pode ser computacionalmente pesado. Pode utilizar GPUs, plataformas de ciência de dados, clusters, ambientes cloud ou infraestrutura especializada.

Esse trabalho não precisa acontecer dentro da transação bancária.

Nenhum cliente aceitará esperar três semanas diante da maquininha enquanto o modelo reaprende a história do sistema financeiro.

Inferência

Depois de treinado, o modelo pode receber uma nova transação e aplicar aquilo que aprendeu.

Essa aplicação é chamada de inferência.

O modelo recebe informações como:

VALOR
HORARIO
LOCALIZACAO
TIPO-DE-ESTABELECIMENTO
IDADE-DA-CONTA
DISPOSITIVO
QUANTIDADE-DE-TENTATIVAS
MEDIA-DE-GASTOS
DISTANCIA-DA-ULTIMA-COMPRA

E devolve algo como:

SCORE-DE-RISCO = 0,8734

Treinamento é a escola de investigadores.

Inferência é o momento em que o inspetor olha para o passaporte, compara os sinais e decide se chamará o supervisor.

O IBM z17 é especialmente interessante nessa segunda fase: executar a inferência rapidamente, em grande escala e suficientemente perto da aplicação transacional para que o resultado ainda possa influenciar a autorização.



3. O que acontece quando o cartão encosta na maquininha?

Vamos acompanhar nossa transação passo a passo.

A implementação real varia entre instituições, bandeiras, adquirentes e sistemas, mas o fluxo conceitual pode ser representado assim:

MAQUININHA
    ↓
ADQUIRENTE
    ↓
REDE OU BANDEIRA
    ↓
BANCO EMISSOR
    ↓
SISTEMA DE AUTORIZAÇÃO
    ↓
ANÁLISE DE RISCO
    ↓
APROVAR, NEGAR OU DESAFIAR

Dentro do banco, o sistema pode consultar:

  • situação do cartão;

  • senha ou credencial;

  • saldo;

  • limite;

  • bloqueios;

  • restrições geográficas;

  • quantidade de operações recentes;

  • perfil do cliente;

  • regras antifraude;

  • resultado de modelos de IA.

Em um ambiente mainframe, partes desse processamento podem envolver:

  • CICS;

  • IMS;

  • Db2;

  • VSAM;

  • IBM MQ;

  • programas COBOL;

  • serviços Java;

  • APIs;

  • z/OS Connect;

  • componentes Linux executando no IBM Z;

  • rotinas de segurança;

  • mecanismos de criptografia;

  • serviços de inferência.

O programa COBOL não precisa “virar uma IA”.

Ele pode continuar fazendo aquilo que sempre fez muito bem: orquestrar regras de negócio, validar campos, controlar estados, registrar decisões e preservar a integridade da transação.

A diferença é que agora ele pode receber um score calculado por um modelo.

Conceitualmente, nossa lógica poderia se parecer com isto:

       EVALUATE TRUE
           WHEN CARTAO-BLOQUEADO
               MOVE '05' TO CODIGO-RESPOSTA

           WHEN SCORE-FRAUDE > 900
               MOVE 'N' TO AUTORIZAR
               MOVE 'FRAUDE ALTA' TO MOTIVO-DECISAO

           WHEN SCORE-FRAUDE > 650
               MOVE 'S' TO EXIGIR-AUTENTICACAO
               MOVE 'VALIDACAO ADICIONAL'
                 TO MOTIVO-DECISAO

           WHEN LIMITE-DISPONIVEL < VALOR-COMPRA
               MOVE 'N' TO AUTORIZAR
               MOVE 'LIMITE INSUFICIENTE'
                 TO MOTIVO-DECISAO

           WHEN OTHER
               MOVE 'S' TO AUTORIZAR
               MOVE 'APROVADA' TO MOTIVO-DECISAO
       END-EVALUATE.

Naturalmente, um sistema bancário real será muito mais sofisticado. A ordem das verificações, os limites, as exceções e as regras serão governados por políticas específicas.

Mas o princípio é este:

IA calcula o risco.
A aplicação toma a decisão.

Essa separação é saudável.

O modelo não deve possuir autoridade ilimitada simplesmente porque tem “inteligência artificial” no nome.



4. O orçamento de tempo da transação

Quando alguém lê que o z17 pode executar inferências com tempo de resposta inferior a 1 milissegundo, pode imaginar que toda a compra será concluída nesse intervalo.

Não é isso.

Um milissegundo é:

[
1\text{ ms} = 0{,}001\text{ segundo}
]

O número divulgado refere-se ao processamento da inferência no cenário medido, não ao tempo total da transação desde a maquininha até a resposta final.

A operação completa ainda pode incluir:

  • transmissão pelas redes;

  • validação criptográfica;

  • leitura de bancos de dados;

  • execução de regras;

  • verificação de limite;

  • gravação de logs;

  • atualização de saldos;

  • journaling;

  • construção da resposta;

  • retorno à maquininha.

Pense na transação como um filme de duas horas e na inferência como uma cena importante dentro dele.

O Telum II não precisa filmar o longa-metragem inteiro em um milissegundo. Ele precisa executar sua cena sem estourar o cronograma da produção.

Isso é fundamental porque toda aplicação crítica possui um orçamento de latência.

Se a autorização inteira precisa responder em determinado intervalo, não podemos entregar quase todo esse orçamento a um modelo remoto.

Uma chamada externa pode exigir:

  1. montar uma requisição;

  2. serializar os dados;

  3. criptografar;

  4. atravessar a rede;

  5. autenticar no serviço;

  6. entrar numa fila;

  7. executar a inferência;

  8. montar a resposta;

  9. retornar pela rede;

  10. tratar timeouts e erros.

Mesmo que a média seja boa, há uma pergunta mais importante:

O comportamento continuará previsível durante os picos?

Em ambiente crítico, não basta dizer que a resposta média foi de 5 ms.

Precisamos conhecer:

  • percentil 95;

  • percentil 99;

  • percentil 99,9;

  • comportamento em saturação;

  • impacto sobre outros workloads;

  • tempo máximo aceitável;

  • estratégia de fallback;

  • resultado quando o serviço não responder.

Uma média bonita pode esconder um pequeno grupo de respostas terrivelmente lentas.

E o sistema bancário não pode dizer ao comerciante:

— Tivemos um excelente tempo médio hoje. Infelizmente, sua venda caiu no percentil azarado.



5. Telum II: o investigador sentado dentro do banco

O Telum II é o processador que equipa o IBM z17 e inclui a segunda geração do acelerador integrado de IA.

A palavra mais importante é “integrado”.

A inferência pode acontecer muito perto da carga transacional, sem depender de um acelerador remoto pendurado do outro lado de uma rede.

Segundo a IBM, o acelerador do Telum II oferece quatro vezes a capacidade computacional da geração anterior, chegando a 24 TOPS, além de suporte a INT8 e melhorias destinadas a ampliar a variedade de modelos executáveis. O processador também trabalha com caches maiores, melhorias de roteamento e uma DPU destinada a auxiliar operações de entrada e saída. IBM Telum II.

O que são TOPS?

TOPS significa trillions of operations per second, ou trilhões de operações por segundo.

É uma medida da capacidade computacional do acelerador.

Entretanto, TOPS não contam toda a história.

Dois aceleradores com números semelhantes podem produzir resultados diferentes devido a:

  • arquitetura;

  • precisão numérica;

  • eficiência do compilador;

  • movimentação de dados;

  • memória;

  • cache;

  • tipo do modelo;

  • tamanho do lote;

  • utilização dos núcleos;

  • integração com a aplicação.

É como comparar dois restaurantes apenas pelo número de fogões. O resultado também depende da cozinha, dos ingredientes, dos garçons e de alguém lembrar que o cliente pediu o bife sem cebola.

Por que INT8 importa?

Modelos de IA podem trabalhar com diferentes precisões numéricas.

INT8 utiliza números inteiros de oito bits. Em muitos cenários de inferência, isso permite:

  • representar os parâmetros com menos espaço;

  • movimentar menos dados;

  • executar mais operações;

  • consumir menos energia;

  • aumentar o throughput.

Essa redução de precisão precisa ser validada para garantir que o modelo continue suficientemente acurado.

Não adianta tornar a inferência quatro vezes mais rápida se ela passar a confundir Frank Abagnale com o gerente da agência.



6. Spyre: a equipe de inteligência no andar de cima

Se o Telum II é o agente posicionado diretamente no balcão de imigração, o Spyre é uma equipe adicional de inteligência.

O IBM Spyre Accelerator é fornecido em placas PCIe e possui 32 núcleos de aceleração por chip. Várias placas podem ser combinadas para atender cargas maiores. O produto tornou-se disponível para IBM z17 e LinuxONE 5 em outubro de 2025. Anúncio oficial do Spyre.

Ele foi pensado para complementar o acelerador do Telum II em cenários como:

  • modelos maiores;

  • vários modelos trabalhando conjuntamente;

  • IA generativa;

  • modelos de linguagem;

  • aplicações multimodais;

  • assistentes;

  • agentes de IA;

  • análise de dados estruturados e textuais.

Imagine uma transação suspeita.

O Telum II pode executar rapidamente o modelo preditivo principal:

Risco calculado: 78%.

Uma arquitetura mais sofisticada pode combinar outros modelos:

  • um modelo para o comportamento do dispositivo;

  • outro para identidade;

  • outro para lavagem de dinheiro;

  • um encoder examinando descrições textuais;

  • um modelo avaliando relações entre contas;

  • um sistema generativo produzindo um resumo para o analista.

Isso é chamado de abordagem multimodelo ou, em certos contextos, ensemble.

O benchmark dos 450 bilhões de inferências antifraude não deve ser apresentado como resultado obrigatório da soma Telum II mais Spyre.

A alegação foi originalmente associada ao acelerador integrado do Telum II. O Spyre amplia a capacidade e o repertório do sistema, principalmente para modelos mais complexos e novas cargas de IA.

Em resumo:

TELUM II
Inferência transacional rápida, integrada e previsível.

SPYRE
Capacidade complementar para modelos maiores, múltiplos e generativos.

Os dois podem trabalhar dentro da mesma estratégia, mas não são peças idênticas.



7. Cinco milhões por segundo não são 450 bilhões por dia

Agora chegamos ao Easter egg matemático escondido no roteiro.

Originalmente diziamos que o z17 podia processar até 5 milhões de inferências por segundo, equivalentes a mais de 450 bilhões por dia.

Vamos convocar o programa COBOL da contabilidade:

[
5.000.000 \times 86.400 = 432.000.000.000
]

Um dia possui 86.400 segundos.

Portanto, cinco milhões de inferências por segundo equivalem a 432 bilhões por dia.

Para chegar a 450 bilhões, precisaríamos de aproximadamente:

[
450.000.000.000 \div 86.400
= 5.208.333
]

Ou cerca de 5,21 milhões de inferências por segundo.

Isso não significa necessariamente que a IBM tenha cometido um erro.

A IBM apresenta números arredondados e indicadores derivados de cenários específicos:

  • até 5 milhões de inferências por segundo;

  • até 450 bilhões de inferências por dia;

  • resposta de aproximadamente 1 ms ou inferior, dependendo da declaração.

O erro aparece quando alguém liga as duas frases com “ou seja”, transformando indicadores de benchmark em uma conversão matemática exata.

Uma formulação mais segura seria:

O IBM z17 pode alcançar até 5 milhões de inferências por segundo em determinado cenário e, segundo outro indicador divulgado pela IBM, até 450 bilhões de inferências por dia.

Curiosidade para o programador iniciante: sempre desconfie de expressões como:

  • “ou seja”;

  • “equivale a”;

  • “portanto”;

  • “isso representa”.

Elas parecem conectores inocentes, mas frequentemente escondem o exato lugar onde marketing, arredondamento e matemática decidiram falsificar um cheque juntos.



8. O que o benchmark realmente mediu?

O número de 450 bilhões por dia não caiu do céu diretamente na capa de uma revista.

Segundo a metodologia publicada pela IBM, o resultado foi extrapolado de testes internos com:

  • hardware IBM tipo 9175;

  • modelo LSTM sintético para detecção de fraude em cartões;

  • batch size de 160;

  • ambientes Red Hat Enterprise Linux e z/OS;

  • z/OS Container Extensions;

  • configuração específica de CPUs, IFLs, zIIPs e memória.

A IBM também informa claramente que os resultados podem variar. Metodologia do benchmark do z17.

O que é LSTM?

LSTM significa Long Short-Term Memory.

É um tipo de rede neural recorrente desenvolvido para trabalhar com sequências e dependências temporais.

Em fraude, isso pode ser útil porque o significado de uma transação depende frequentemente daquilo que aconteceu antes.

Exemplo:

10:01 — compra de R$ 25 em Itatiba
10:04 — compra de R$ 19 em Itatiba
10:07 — compra de R$ 12.000 em Tóquio

A última transação não é suspeita apenas pelo valor. Ela é suspeita pela relação temporal e geográfica com as anteriores.

Modelos atuais podem empregar outras arquiteturas, mas a LSTM continua sendo uma referência útil para determinados problemas sequenciais.

O que é batch size?

Batch size é a quantidade de amostras processadas conjuntamente.

No teste divulgado, o lote era de 160 inferências.

Isso ajuda o acelerador a utilizar melhor seus recursos, assim como uma transportadora consegue mover caixas com mais eficiência quando carrega um caminhão inteiro em vez de enviar um veículo para cada pacote.

Entretanto, batching cria uma consideração importante:

  • throughput mede quanto trabalho total é concluído;

  • latência mede quanto tempo cada solicitação espera e leva para ser respondida.

Grandes lotes podem aumentar o throughput, mas, dependendo da implementação, também podem fazer uma solicitação aguardar o lote ser formado.

Por isso, nunca analise apenas um número.

Pergunte:

  • Qual era o modelo?

  • Qual era o tamanho do lote?

  • Quantas threads foram usadas?

  • Qual era a configuração?

  • A latência apresentada é média ou percentil?

  • O resultado foi medido ou extrapolado?

  • Havia carga transacional concorrente?

  • O modelo era real ou sintético?

Essa é uma dica de ouro para qualquer benchmark, não apenas de mainframe.



9. Inferência não é sinônimo de transação

Outra armadilha está na palavra “operação”.

Quando ouvimos “450 bilhões de operações de inferência”, é tentador imaginar 450 bilhões de compras analisadas.

Mas uma transação pode executar vários modelos:

MODELO 1 — fraude do cartão
MODELO 2 — risco do dispositivo
MODELO 3 — identidade comprometida
MODELO 4 — localização anômala
MODELO 5 — lavagem de dinheiro
MODELO 6 — conta-laranja

Uma única compra poderia gerar seis inferências.

Logo:

1 transação ≠ obrigatoriamente 1 inferência

Também é possível processar inferências em lotes ou utilizar modelos diferentes conforme o tipo de operação.

O número demonstra capacidade de execução de modelos. Não deve ser convertido automaticamente em quantidade de cartões, clientes ou compras.

É como olhar o contador de instruções executadas pelo processador e concluir que cada instrução representa um cliente atendido.

O COBOLzeiro olha para isso, toma um gole de café e pergunta:

— Onde está o copybook com a definição dessa unidade?

Pergunta correta.



10. “Levar a IA até os dados” não significa eliminar toda movimentação

Uma das frases mais fortes da apresentação do z17 é a ideia de executar IA onde os dados residem.

Mas precisamos interpretá-la corretamente.

Não significa que nenhum byte jamais se mova.

Dentro do sistema ainda haverá:

  • leitura de registros;

  • acesso a memória;

  • comunicação entre componentes;

  • preparação das variáveis;

  • busca de características;

  • passagem de parâmetros;

  • gravação do resultado.

O que pode ser evitado é a necessidade de enviar a transação para um serviço remoto de inferência, fora do ambiente em que a aplicação crítica está sendo executada.

Isso reduz:

  • dependência da rede;

  • latência externa;

  • serialização;

  • pontos adicionais de falha;

  • exposição de dados sensíveis;

  • fronteiras operacionais;

  • complexidade de auditoria.

Compare os dois caminhos.

Inferência remota

COBOL/CICS
    ↓
API
    ↓
GATEWAY
    ↓
REDE
    ↓
SERVIÇO EXTERNO
    ↓
MODELO
    ↓
REDE
    ↓
RESPOSTA
    ↓
DECISÃO

Inferência local

COBOL/CICS
    ↓
SERVIÇO DE INFERÊNCIA NO AMBIENTE IBM Z
    ↓
TELUM II
    ↓
SCORE
    ↓
DECISÃO

O segundo caminho não é magicamente gratuito, mas reduz fronteiras.

E cada fronteira removida significa menos um lugar para:

  • perder tempo;

  • falhar;

  • expirar;

  • autenticar;

  • converter dados;

  • abrir uma porta de ataque;

  • explicar para a auditoria.



11. O cloud não é o vilão do filme

Seria confortável transformar esta história num duelo:

MAINFRAME = HERÓI
CLOUD = VIGARISTA

Mas arquitetura séria não funciona como desenho animado.

Cloud pode ser excelente para:

  • treinamento de modelos;

  • experimentação;

  • notebooks;

  • ciência de dados;

  • armazenamento histórico;

  • elasticidade;

  • processamento assíncrono;

  • comparação de versões;

  • grandes modelos;

  • investigação posterior.

O IBM Z pode ser particularmente apropriado para:

  • inferência na transação;

  • dados regulados;

  • baixa latência previsível;

  • enorme volume;

  • integração com sistemas existentes;

  • disponibilidade;

  • segurança e auditoria;

  • continuidade operacional.

Uma arquitetura híbrida madura pode funcionar assim:

PLATAFORMA DE DADOS OU CLOUD
    ↓
TREINAMENTO
    ↓
VALIDAÇÃO
    ↓
APROVAÇÃO DO MODELO
    ↓
EMPACOTAMENTO
    ↓
IMPLANTAÇÃO NO IBM Z
    ↓
INFERÊNCIA TRANSACIONAL
    ↓
MONITORAMENTO E FEEDBACK

O modelo aprende em um ambiente e trabalha em outro.

Isso também cria responsabilidades importantes:

  • versionar o modelo;

  • registrar quem o aprovou;

  • controlar sua implantação;

  • medir drift;

  • comparar versões;

  • permitir rollback;

  • manter explicabilidade;

  • preservar evidências.

O modelo é um componente de produção. Deve receber disciplina semelhante à de qualquer outro artefato crítico.

Se você jamais colocaria um load module não testado diretamente em produção, também não deveria instalar um modelo treinado na sexta-feira por alguém que escreveu no change:

“Melhorias diversas. Baixo risco.”



12. Falso positivo: quando o FBI prende o piloto verdadeiro

Um sistema antifraude pode errar de duas maneiras principais.

Falso negativo

A transação era fraudulenta, mas foi considerada legítima.

Consequências possíveis:

  • perda financeira;

  • chargeback;

  • investigação;

  • desgaste com o cliente;

  • impacto regulatório.

Falso positivo

A transação era legítima, mas foi considerada fraudulenta.

Consequências:

  • compra recusada;

  • cliente constrangido;

  • perda da venda;

  • chamada ao atendimento;

  • cancelamento do cartão;

  • deterioração da confiança.

Imagine o cliente viajando pela Europa depois de meses comprando apenas em São Paulo.

O comportamento mudou bruscamente, mas existe uma explicação legítima.

Um modelo ruim pode confundir “fora do padrão” com “fraude”.

Essa é uma distinção essencial:

Anomalia não é prova de crime. É motivo para investigar ou aplicar controles proporcionais.

Por isso, uma instituição pode criar diferentes respostas:

  • risco baixo: aprovar;

  • risco moderado: solicitar biometria;

  • risco alto: enviar notificação;

  • risco muito alto: bloquear;

  • caso complexo: análise humana.

Quanto mais rápido o score estiver disponível, mais opções o banco terá.

Em vez de escolher apenas entre aprovar e negar, pode inserir autenticação adaptativa sem destruir a experiência do cliente.


13. Segurança local não é segurança automática

Colocar a IA no mainframe não elimina:

  • credenciais roubadas;

  • engenharia social;

  • fraude interna;

  • dados de treinamento contaminados;

  • modelos enviesados;

  • configuração incorreta;

  • permissões excessivas;

  • falhas de aplicação;

  • ataques adversariais;

  • decisões de negócio ruins.

O ambiente local pode ajudar a proteger:

  • confidencialidade dos dados;

  • propriedade intelectual do modelo;

  • tráfego sensível;

  • disponibilidade;

  • cadeia de auditoria;

  • previsibilidade operacional.

Mas o sistema ainda precisa de:

  • RACF bem administrado;

  • princípio do menor privilégio;

  • criptografia;

  • segregação de funções;

  • logging;

  • monitoramento;

  • revisão de modelos;

  • gestão de vulnerabilidades;

  • resposta a incidentes;

  • governança de IA.

A IA é apenas uma camada.

A arquitetura completa se parece mais com isto:

IDENTIDADE
    +
DADOS CONFIÁVEIS
    +
MODELO VALIDADO
    +
APLICAÇÃO CORRETA
    +
REGRAS DE NEGÓCIO
    +
AUDITORIA
    +
RESPOSTA OPERACIONAL

Se qualquer camada estiver comprometida, o vigarista poderá atravessar o sistema usando um belo uniforme e um crachá perfeitamente impresso.


14. Passo a passo para o COBOLzeiro entender uma integração com IA

Você não precisa se transformar imediatamente em cientista de dados. Comece fazendo as perguntas corretas.

Passo 1 — Entenda o evento de negócio

Defina exatamente o que será avaliado:

  • compra?

  • PIX?

  • abertura de conta?

  • alteração cadastral?

  • saque?

  • pedido de empréstimo?

Passo 2 — Identifique as entradas

Descubra quais informações alimentam o modelo:

VALOR
HORARIO
PAIS
DISPOSITIVO
HISTORICO
TENTATIVAS
IDADE-DA-CONTA
TIPO-DE-CANAL

Passo 3 — Conheça o contrato

O serviço deve possuir um contrato claro:

ENTRADA:
    DADOS-DA-TRANSACAO

SAIDA:
    SCORE-DE-RISCO
    VERSAO-DO-MODELO
    CODIGO-DE-STATUS
    MOTIVO
    TEMPO-DE-INFERENCIA

A versão do modelo é fundamental para auditoria.

Passo 4 — Defina o timeout

O que acontecerá se a inferência não responder?

  • negar tudo;

  • aprovar tudo;

  • usar regras tradicionais;

  • chamar um modelo alternativo;

  • encaminhar para validação adicional?

Não responder também é um resultado operacional, e precisa de regra.

Passo 5 — Separe score de decisão

Evite permitir que o modelo controle diretamente a transação.

MODELO → SCORE
REGRA → DECISÃO

Passo 6 — Registre evidências

Grave pelo menos:

  • identificador da transação;

  • horário;

  • score;

  • versão do modelo;

  • decisão;

  • regra aplicada;

  • resultado posterior conhecido.

Isso permite reconstruir a história.

Passo 7 — Monitore desempenho e qualidade

Observe:

  • latência;

  • throughput;

  • erros;

  • timeouts;

  • falsos positivos;

  • falsos negativos;

  • mudança no perfil dos dados;

  • queda de acurácia.

Passo 8 — Prepare rollback

Se o novo modelo começar a bloquear metade da população de Itatiba, você precisa retornar rapidamente à versão anterior.

MLOps sem rollback é apenas aventura.


15. Easter eggs recuperados do cheque falsificado

Easter egg número 1 — O mainframe já fazia “IA” antes da moda

Bancos utilizam modelos estatísticos, regras, scores e análise de risco há décadas.

O que mudou não foi a descoberta repentina de que padrões podem indicar fraude. Mudaram:

  • escala;

  • variedade dos modelos;

  • integração;

  • velocidade;

  • capacidade de processar mais sinais;

  • uso de aceleradores especializados.

A inteligência transacional não nasceu ontem. Ela ganhou músculos novos.

Easter egg número 2 — O COBOL não perdeu o emprego para a IA

A IA pode calcular a probabilidade de fraude, mas alguém ainda precisa:

  • validar a mensagem;

  • aplicar o limite;

  • controlar a conta;

  • atualizar o saldo;

  • produzir o registro;

  • garantir atomicidade;

  • tratar exceções;

  • responder ao canal.

O modelo pode dizer que o cheque parece suspeito.

O COBOL continua sendo o funcionário que decide se o cheque entra no movimento e garante que o livro-caixa feche no final do dia.

Easter egg número 3 — Frank Abagnale trabalhou para o FBI

A melhor ironia da história é que o fraudador pode ensinar o sistema a identificar fraudes.

Na segurança, o conhecimento ofensivo frequentemente fortalece a defesa.

Da mesma forma, fraudes confirmadas tornam-se exemplos de treinamento. O atacante, involuntariamente, deixa material para melhorar o próximo modelo.

É quase um programa de estágio não remunerado do Red Team.

Easter egg número 4 — A velocidade pode reduzir fraude sem aumentar bloqueios

Com mais capacidade de inferência, o banco pode executar vários modelos em vez de depender de uma única regra agressiva.

Isso permite distinguir melhor:

  • comportamento incomum;

  • comportamento realmente malicioso;

  • cliente viajando;

  • conta comprometida;

  • compra legítima de alto valor;

  • fraude coordenada.

Mais inteligência pode significar não apenas bloquear mais, mas bloquear melhor.

Easter egg número 5 — O mainframe não precisa aparecer na manchete

Quando uma transação é aprovada corretamente, ninguém comemora:

— Fantástico! O sistema consultou o limite, avaliou o risco, atualizou os registros e respondeu dentro do SLA!

O cliente apenas guarda o cartão.

O sucesso do sistema crítico é frequentemente invisível.

Ele só vira notícia quando para.


16. O verdadeiro “Catch Me If You Can” da fraude moderna

Frank Abagnale precisava manter sua história por alguns minutos.

A fraude digital precisa parecer legítima por milissegundos.

Ela corre entre:

  • a captura dos dados;

  • a autenticação;

  • a análise;

  • a autorização;

  • a liquidação.

O IBM z17 procura fechar esse intervalo colocando capacidade de inferência dentro do núcleo transacional.

Não é uma solução mágica.

Não elimina a necessidade de investigadores, regras, autenticação, governança, criptografia ou analistas.

O que ele faz é permitir que a aplicação pergunte, no momento decisivo:

Esta operação se parece com aquilo que afirma ser?

E receba uma resposta antes que o suspeito chegue ao portão de embarque.

A grande inovação não está apenas em fazer cinco milhões de cálculos por segundo. Está em realizar a análise cedo o bastante para mudar o destino da transação.

Antes, muitos sistemas descobriam a fraude depois:

  1. a operação era aprovada;

  2. o dinheiro seguia seu caminho;

  3. o cliente reclamava;

  4. começava a investigação;

  5. alguém tentava recuperar o prejuízo.

Era perícia.

Com a inferência transacional, a inteligência pode participar do processo antes da conclusão:

  1. a operação chega;

  2. os dados são avaliados;

  3. o modelo produz o score;

  4. as regras interpretam o risco;

  5. o sistema aprova, bloqueia ou desafia;

  6. a decisão é registrada.

É a diferença entre encontrar a falsificação no arquivo morto e pará-la no balcão.


Epílogo — O cheque, o COBOL e o homem de uniforme

No final do filme, o vigarista não é derrotado porque alguém construiu uma parede infinitamente alta.

Ele é alcançado porque o investigador aprende a reconhecer seus padrões.

O papel usado.

A forma de imprimir.

As cidades escolhidas.

O modo como ele conta a história.

Fraude é repetição disfarçada de improviso.

A inteligência artificial encontra valor justamente nessa repetição: relações pequenas demais, rápidas demais ou numerosas demais para depender exclusivamente da observação humana.

O Telum II aproxima essa análise do lugar onde a decisão acontece.

O Spyre amplia o repertório para modelos maiores e abordagens mais complexas.

O z17 fornece o ambiente para executar isso com a velocidade, a escala, o isolamento e a previsibilidade exigidos por sistemas críticos.

E o COBOL?

O COBOL continua no balcão.

Recebe a mensagem.

Valida o cartão.

Consulta o limite.

Interpreta o score.

Executa a regra.

Grava a decisão.

Libera ou recusa a transação.

Talvez ele não apareça no trailer. Talvez ninguém compre uma camiseta escrito PERFORM UNTIL FRAUD-DETECTED. Mas, quando Frank Abagnale chegar usando o uniforme de piloto, será o velho programa transacional que olhará o score calculado em menos de um milissegundo e dirá:

       IF IDENTIDADE-PARECE-PERFEITA
          AND HISTORIA-NAO-FECHA
              MOVE 'N' TO AUTORIZAR
              MOVE 'PRENDA-ME-SE-FOR-CAPAZ'
                TO MOTIVO-RECUSA
       END-IF.

No andar de cima, o Spyre cruza os dossiês.

Dentro do processador, o Telum II examina o próximo passageiro.

No CICS, outra tarefa começa.

E em algum lugar do datacenter, um COBOL escrito quando Leonardo DiCaprio ainda era criança continua protegendo uma transação que jamais saberá seu nome.

Para ir mais longe

https://eljefemidnightlunch.blogspot.com/2026/08/spy-vs-spy-no-tribunal-as-trapacas.html

https://eljefemidnightlunch.blogspot.com/2026/08/red-team-e-os-doze-trabalhos-de-asterix.html




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...