☕ 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 AIOps. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta AIOps. Mostrar todas as mensagens

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.

terça-feira, 11 de novembro de 2025

🔥💣 SYSREXX: O “KUBERNETES INVISÍVEL” DO z/OS QUE JÁ EXISTIA ANTES DA NUVEM 💣🔥

 

Bellacosa Mainframe SysRexx o REXX como framework

🔥💣 SYSREXX: O “KUBERNETES INVISÍVEL” DO z/OS QUE JÁ EXISTIA ANTES DA NUVEM 💣🔥

Quando o REXX deixou de ser linguagem… e virou infraestrutura operacional do Mainframe ☕🚀

“Enquanto o mundo moderno descobria automação… o z/OS já executava automações sistêmicas em paralelo dentro do próprio núcleo operacional.”

Existe um momento na história do Mainframe em que o REXX sofre uma mutação absurda.

Ele deixa de ser:

  • simples linguagem de scripts
  • ferramenta TSO
  • automação de rotina

…e se transforma em algo muito maior:

☕ Uma camada operacional inteligente do próprio z/OS.

Esse momento atende pelo nome de:

🔥 SYSREXX (System REXX)

E pouca gente percebe a profundidade arquitetural disso.

Porque o SYSREXX não é “apenas REXX fora do TSO”.

💣 O SYSREXX é praticamente:

  • um runtime operacional
  • um engine de automação
  • um orquestrador interno
  • um mini middleware sistêmico
  • um framework de operações embutido no z/OS

Décadas antes:

  • Kubernetes
  • PowerShell
  • DevOps
  • ChatOps
  • AIOps
  • Infrastructure as Code

…o Mainframe já possuía:

automação operacional orientada a eventos usando REXX.


☕ O DIA EM QUE O REXX VIROU “PARTE DO SISTEMA”

Durante anos o REXX viveu:

  • no TSO
  • em CLISTs
  • em automações ISPF
  • em SDSF
  • em jobs batch

Mas a IBM percebeu algo:

O mundo começava a exigir:

  • integração web
  • automação rápida
  • observabilidade
  • APIs operacionais
  • gerenciamento simplificado

Então nasceu o SYSREXX.

A própria IBM define o objetivo assim:

“Required an infrastructure to support web based initiatives interacting with z/OS components.”

Traduzindo para Bellacosa Mainframe:

🔥 “Precisávamos transformar o z/OS em algo programável em tempo real.”


🚀 O SYSREXX É UM SUBSYSTEM DE VERDADE

Esse é o primeiro choque.

Muita gente imagina:

“Ah… deve ser só um EXEC diferente.”

Negativo.

O SYSREXX nasce como:

AXR

Uma Started Task real.

Ela:

  • cria workers
  • controla filas
  • gerencia requests
  • dispara ambientes TSO
  • administra automações
  • integra console e APIs

💣 Isso é arquitetura enterprise raiz.


☕ O QUE O SYSREXX FAZ?

Ele permite executar EXECs:

  • fora do TSO
  • fora do Batch
  • via console
  • via APIs
  • via programas assembler
  • via automação sistêmica

Ou seja:

🔥 O REXX vira uma API operacional do z/OS.


🧠 O DETALHE QUE QUASE NINGUÉM PERCEBE

O SYSREXX introduziu no Mainframe conceitos que hoje chamamos de:

  • workers
  • queues
  • asynchronous execution
  • runtime isolation
  • service execution
  • orchestration

Observe a arquitetura lógica IBM:

  • Listener
  • Queue Control
  • Worker Tasks
  • Async Processing
  • Console Interface
  • AXREXX API

💣 Isso parece arquitetura cloud moderna.

Só que no z/OS.


🔥 TSO=NO — O MODO “TURBO”

Aqui mora uma engenharia genial.

O modo:

TSO=NO

executa EXECs:

  • em ambiente compartilhado
  • alta velocidade
  • baixo overhead
  • até 64 workers paralelos

Resultado:

performance absurda.


☕ O PREÇO DA VELOCIDADE

Mas existe um detalhe importante.

A IBM alerta:

“Recommend no Data Set Allocation here.”

Porque:

  • o ambiente é compartilhado
  • workers são reutilizados
  • problemas podem contaminar outros EXECs

🔥 Isso é extremamente importante.


🚨 O “VAZAMENTO FANTASMA”

Imagine um EXEC mal escrito:

/* REXX */

"ALLOC FI(TEST) DA('SYS1.PARMLIB') SHR"
EXIT

Sem FREE.

O dataset:

  • continua alocado
  • influencia EXECs futuros
  • causa bugs aleatórios

💣 Bem-vindo ao terror operacional invisível do SYSREXX.


🚀 TSO=YES — O MODO “ISOLADO”

Aqui o EXEC ganha:

  • Address Space própria
  • ambiente TSO dinâmico
  • acesso a datasets
  • comandos POSIX
  • SYSCALL
  • maior segurança

Mas…

☕ não é um TSO “completo”.

E aqui muitos profissionais caem.


🔥 A ARMADILHA DO TSO DINÂMICO

O SYSREXX usa:

IKJTSOEV

para criar:

Dynamic TSO Environment

Mas o TMP tradicional NÃO existe completamente.

Resultado:

  • alguns comandos falham
  • alguns control blocks inexistem
  • alguns LOADs explodem

E então aparece o famoso:

ABEND306

💣 O Mainframe lembrando:

“Você entrou numa área avançada.”


☕ AXRCMD — O SUPERPODER ABSURDO

Aqui o SYSREXX vira praticamente um operador automatizado.

Exemplo:

/* REXX */

Rc = AXRCMD("D IPLINFO",OUT.,5)

DO I = 1 TO OUT.0
SAY OUT.I
END

🔥 O EXEC:

  • envia comando MVS
  • captura resposta
  • processa output
  • toma decisões

Isso muda completamente o jogo.


🚀 O MAINFRAME COMEÇA A “SE OBSERVAR”

Com AXRCMD você pode:

  • monitorar jobs
  • verificar DASD
  • analisar JES2
  • inspecionar XCF
  • observar STORAGE
  • controlar devices
  • automatizar recovery

Tudo em REXX.


☕ EXEMPLO “OPS AI RAIZ”

Imagine isso:

/* REXX */

Signal On Failure

Rc = AXRCMD("D A,L",OUT.,5)

If Rc <> 0 Then Do
Call AXRWTO "ERRO NO DISPLAY"
Exit 8
End

Do I = 1 To OUT.0

If Pos("CICS",OUT.I) > 0 Then Do

If Pos("NOT ACTIVE",OUT.I) > 0 Then Do

Call AXRWTO "CICS FORA DO AR"

Rc2 = AXRCMD("S CICSPROD",MSG.,10)

Call AXRWTO "RESTART AUTOMATICO EXECUTADO"

End
End
End

Exit 0

Failure:
Call AXRWTO "ABEND NO MONITOR"
Exit 16

💣 Isso é praticamente:

  • observabilidade
  • detecção automática
  • autorecovery
  • AIOps

Só usando SYSREXX.


🔥 AXRMLWTO — O “PAINEL OPERACIONAL”

Essa função é maravilhosa.

Ela permite gerar:

  • WTOs multiline
  • outputs organizados
  • blocos formatados
  • relatórios operacionais

Exemplo:

Connect='IPLCHK'

Call AXRMLWTO '=== STATUS IPL ===','Connect','L'

Do I = 1 To OUT.0
Call AXRMLWTO OUT.I,'Connect','D'
End

Call AXRMLWTO '=== FIM ===','Connect','DE'

O console vira praticamente:

uma dashboard textual enterprise.


☕ O SYSREXX É O “POWERSHELL DO MAINFRAME”

Mas com diferenças importantes:

  • mais integrado
  • mais seguro
  • mais próximo do kernel
  • mais operacional
  • absurdamente eficiente

🔥 O EASTER EGG MAIS INSANO

Pouca gente percebe…

Mas o SYSREXX já fazia:

ChatOps operacional

Muito antes do Slack existir.

Observe:

@1STATUS
@1CICSCHK
@1JES2INFO
@1DASDMON

💣 Isso é praticamente:

  • slash commands
  • bots operacionais
  • automação conversacional

No console do z/OS.

Décadas atrás.


☕ O MAINFRAME JÁ FAZIA “SERVERLESS”

Pense nisso.

Você:

  • dispara EXEC
  • runtime nasce
  • executa lógica
  • devolve resultado
  • encerra worker

🔥 Isso lembra o quê?

Lambda.
Functions.
Serverless.

Só que:

no Mainframe.


🚀 O SYSREXX COMO “DEVOPS INVISÍVEL”

Hoje falam:

  • DevOps
  • GitOps
  • AIOps
  • Platform Engineering

Mas o z/OS já possuía:

  • automação sistêmica
  • workers paralelos
  • filas
  • eventos
  • execução assíncrona
  • automação declarativa

O SYSREXX era isso.


☕ O DETALHE MAIS BONITO DO SYSREXX

A IBM poderia ter criado:

  • linguagem nova
  • engine nova
  • framework novo

Mas ela escolheu:

REXX.

Porque:

  • simples
  • legível
  • humana
  • rápida
  • poderosa

🔥 CONCLUSÃO

O SYSREXX é uma das tecnologias mais subestimadas do z/OS.

Ele transformou o REXX em:

  • infraestrutura
  • automação enterprise
  • motor operacional
  • plataforma sistêmica
  • interface programável do Mainframe

E talvez o mais impressionante:

☕ O mundo moderno reinventou muitos conceitos que o Mainframe já dominava há décadas.

Enquanto muita gente ainda estava aprendendo a automatizar servidores distribuídos…

🔥 o z/OS já executava automações inteligentes dentro do próprio coração do sistema operacional. 🔥

quarta-feira, 27 de agosto de 2025

O Paciente Loop: Patrick Jane, COBOL e o Mistério dos Agentes de IA que Nunca Conferem se Fizeram a Coisa Certa

 

Bellacosa Mainframe e os loops agentes de ia e o cobol na confusao

☕ Um Café no Bellacosa Mainframe

O Paciente Loop: Patrick Jane, COBOL e o Mistério dos Agentes de IA que Nunca Conferem se Fizeram a Coisa Certa

Existe uma cena imaginária que poderia perfeitamente abrir um episódio de The Mentalist.

Uma grande empresa acaba de colocar em produção seu novíssimo sistema de Inteligência Artificial. Há telas gigantes na sala de operações, dashboards coloridos, gráficos, APIs, modelos generativos, agentes, bancos vetoriais, cloud, Kubernetes e uma quantidade respeitável de palavras em inglês sendo pronunciadas por minuto.

O diretor anuncia orgulhoso:

— Nosso agente agora trabalha sozinho.

Patrick Jane, sentado no canto da sala, mexe distraidamente em uma xícara de chá.

Ele olha para o monitor.

Olha para o diretor.

Olha novamente para o monitor.

E pergunta:

— Como vocês sabem que ele fez a coisa certa?

Silêncio.

O arquiteto responde:

— Porque a execução terminou com sucesso.

Jane sorri.

— Eu não perguntei se terminou. Perguntei se estava certo.

Nesse momento começa o episódio.

E talvez comece também uma das discussões mais importantes da atual engenharia de Inteligência Artificial.

Porque estamos descobrindo que o maior problema dos agentes de IA não é necessariamente a inteligência.

É o loop.

Ou, mais precisamente, a ausência dele.

Bem-vindo ao café.

Pegue uma cadeira, abra uma sessão TSO imaginária, coloque ===> diante de você e venha investigar comigo um dos crimes arquiteturais mais interessantes da era da Inteligência Artificial.


A primeira pista: durante muito tempo nós confundimos resposta com solução

Quem está começando em COBOL aprende cedo uma coisa aparentemente simples.

Um programa recebe dados.

Processa.

Produz uma saída.

Algo semelhante a:

ENTRADA
   ↓
PROGRAMA COBOL
   ↓
SAÍDA

Imagine nosso programa clássico.

IDENTIFICATION DIVISION.
PROGRAM-ID. CALCSAL.

DATA DIVISION.
WORKING-STORAGE SECTION.

01 WS-SALARIO      PIC 9(7)V99.
01 WS-BONUS        PIC 9(7)V99.
01 WS-TOTAL        PIC 9(8)V99.

PROCEDURE DIVISION.

    COMPUTE WS-TOTAL = WS-SALARIO + WS-BONUS

    DISPLAY 'TOTAL: ' WS-TOTAL

    STOP RUN.

Entrou salário.

Entrou bônus.

Calculamos.

Terminamos.

Durante décadas esse modelo mental funcionou muito bem.

Depois chegaram os grandes modelos de linguagem.

E começamos praticamente da mesma forma.

PROMPT
   ↓
LLM
   ↓
RESPOSTA

Escrevemos:

Explique um programa COBOL que lê um arquivo VSAM.

O modelo responde.

Nós lemos.

Se estiver errado, corrigimos o prompt.

Ele responde novamente.

Nós verificamos outra vez.

E assim sucessivamente.

Pare por alguns segundos e observe o que aconteceu.

Existe um loop:

PROMPT
   ↓
MODELO
   ↓
RESPOSTA
   ↓
VOCÊ VERIFICA
   ↓
VOCÊ CORRIGE
   ↓
NOVO PROMPT

Quem está executando o loop?

Você.

A Inteligência Artificial não possui necessariamente um processo próprio de verificação nesse cenário.

Ela gera.

Você avalia.

Ela tenta.

Você confere.

Ela erra.

Você corrige.

O ser humano é o scheduler, o monitor, o operador e o mecanismo de recovery.

Patrick Jane provavelmente observaria:

— Interessante. Vocês chamaram a máquina de agente autônomo, mas existe um humano escondido atrás dela fazendo todo o trabalho de controle.

Touché.


Prompt Engineering não morreu. Apenas deixou de ser toda a história

Por alguns anos houve quase uma obsessão com Prompt Engineering.

Qual o melhor prompt?

Quantas instruções?

Qual temperatura?

Devemos dizer "pense passo a passo"?

Devemos fornecer exemplos?

Devemos criar personas?

Tudo isso continua importante.

Mas existe uma mudança arquitetural maior acontecendo.

A pergunta deixou de ser apenas:

Como consigo uma boa resposta?

E passou a ser:

Como construo um sistema capaz de alcançar um objetivo, verificar se o alcançou e corrigir a própria trajetória quando necessário?

Essa diferença parece pequena.

Não é.

É aproximadamente a diferença entre escrever um programa COBOL isolado e administrar uma cadeia inteira de processamento bancário.


Conheça o suspeito principal: o Execution Loop

Podemos representar um agente moderno de maneira simplificada assim:

OBJETIVO
   ↓
DESCOBRIR
   ↓
PLANEJAR
   ↓
EXECUTAR
   ↓
VERIFICAR
   ↓
MELHORAR
   └──────────→ NOVO CICLO

A postagem original fala em cinco grandes estágios.

Dependendo da literatura ou framework, os nomes mudam. Você encontrará variações como:

Plan
Execute
Observe
Evaluate
Improve

ou:

Discover
Plan
Execute
Verify
Iterate

Não se prenda aos nomes.

Observe o princípio.

O sistema não considera a geração de uma resposta como o final do trabalho.

Ele pergunta:

Funcionou?

Essa simples pergunta transforma tudo.


Primeiro estágio: descobrir

Imagine um gerente chegando para nosso agente e dizendo:

Corrija os clientes com problema.

Um agente ingênuo poderia imediatamente começar a alterar registros.

Um agente bem projetado deveria primeiro investigar.

Que clientes?

Qual problema?

Qual sistema?

Produção ou homologação?

Qual janela de processamento?

Existe autorização?

Quais tabelas podem ser modificadas?

Qual política regulatória se aplica?

Qual é a definição de sucesso?

Isso é Discover.

Antes de agir, compreender.

Um programador COBOL conhece isso melhor do que imagina.

Quando recebemos uma manutenção dizendo:

O batch está errado.

Não abrimos imediatamente o editor e começamos a trocar IF por EVALUATE.

Investigamos.

Consultamos o SYSOUT.

Verificamos o RC.

Lemos o dump.

Observamos os datasets.

Procuramos alterações recentes.

Consultamos o log.

Descobrimos o contexto.

Em outras palavras:

fazemos investigação antes de execução.

Patrick Jane aprovaria.


Segundo estágio: planejar

Depois de compreender o problema, o agente precisa decidir o que fazer.

Suponha que a tarefa seja:

Localize transações duplicadas e gere um relatório.

Um plano poderia ser:

1. Identificar fonte dos dados.
2. Consultar transações.
3. Determinar chave de duplicidade.
4. Agrupar ocorrências.
5. Validar os resultados.
6. Gerar relatório.
7. Conferir totais.
8. Entregar.

Observe algo importantíssimo.

Planejamento não é execução.

Parece óbvio, mas muitos sistemas agentic misturam os dois.

O agente começa chamando APIs enquanto ainda está tentando descobrir o problema.

Isso é como um programador entrar em produção com UPDATE antes de executar o SELECT.

Quem trabalha em ambiente corporativo sentiu um pequeno arrepio lendo essa frase.

Exatamente.


Terceiro estágio: executar

Agora o agente começa a trabalhar.

Pode consultar banco.

Pode chamar uma API.

Pode executar código.

Pode buscar documentos.

Pode criar arquivos.

Pode usar ferramentas.

Pode disparar outros agentes.

Nesse momento deixamos de falar apenas sobre LLM.

Passamos a falar sobre sistema agentic.

Isso é crucial.

Um Large Language Model sozinho é um mecanismo probabilístico de geração.

Um agente normalmente combina modelo com alguma estrutura de execução:

LLM
+
TOOLS
+
MEMÓRIA
+
REGRAS
+
CONTEXTO
+
ORQUESTRAÇÃO

Agora começamos a chegar a algo muito mais interessante.


Quarto estágio: verificar

Aqui está a pista que resolve boa parte do caso.

Imagine que pedimos:

Gere um programa COBOL que calcule juros.

A IA escreve 150 linhas perfeitamente formatadas.

Pode até ficar bonito.

Isso significa que está certo?

Não.

Precisamos compilar.

Código gerado
      ↓
Compilador
      ↓
RC?

Suponhamos:

MAXCC = 12

Fim do mistério.

O programa estava errado.

Mas imagine algo ainda mais perigoso.

Ele compila.

MAXCC = 0

Está correto?

Também não necessariamente.

Compilação comprova principalmente que o código respeitou regras sintáticas e semânticas esperadas pelo compilador.

Ainda precisamos testar.

COMPILAÇÃO
    ↓
UNIT TEST
    ↓
TESTES FUNCIONAIS
    ↓
VALIDAÇÃO DE REGRA
    ↓
SEGURANÇA
    ↓
PERFORMANCE

Somente então podemos aumentar nossa confiança.

Aqui está uma lição gigantesca:

Um resultado tecnicamente executável não é necessariamente um resultado correto.

Isso vale para COBOL.

Vale para SQL.

Vale para IA.

Vale para praticamente toda engenharia.


Evaluation Gap: o buraco entre "fiz" e "está certo"

Esse problema recebe um nome interessante:

Evaluation Gap.

O agente executa a tarefa.

Mas ninguém mede o resultado.

Imagine:

AGENTE
  ↓
EXECUTA
  ↓
SUCESSO

Qual é a definição de sucesso?

"Não deu erro"?

Perigoso.

Imagine um agente responsável por classificar dez mil documentos.

Ele processa todos.

Nenhuma exceção.

Nenhum timeout.

Nenhuma API falhou.

Operacionalmente:

100% de sucesso.

Mas depois descobrimos que 17% dos documentos foram classificados incorretamente.

Tecnicamente funcionou.

Business-wise fracassou.

Esse é o Evaluation Gap.


Um programador mainframe já conhece isso pelo Return Code

Aqui temos uma deliciosa ironia histórica.

O mundo da IA está redescobrindo conceitos que profissionais de processamento empresarial utilizam há décadas.

Considere:

//STEP01 EXEC PGM=PROGA
//STEP02 EXEC PGM=PROGB,COND=(4,LT)

Ou estruturas modernas de scheduler baseadas no resultado de etapas anteriores.

A lógica fundamental é:

EXECUTA
   ↓
VERIFICA RESULTADO
   ↓
DECIDE O PRÓXIMO PASSO

É exatamente a essência do loop agentic.

Naturalmente, IA adiciona uma dimensão probabilística e interpretativa muito maior.

Mas arquiteturalmente existe parentesco.

Não estamos inventando o conceito de controle.

Estamos aplicando controle a sistemas capazes de raciocínio probabilístico.


Single-Agent Loop: nosso investigador solitário

Agora chegamos a uma decisão arquitetural importante.

Usamos um agente?

Ou vários?

Comecemos pelo agente único.

        AGENTE
          │
     ┌────┴────┐
     ↓         ↓
  Planeja    Executa
     ↓
  Verifica
     ↓
  Corrige

Ele controla todo o ciclo.

Para muitas tarefas isso é excelente.

Imagine um agente encarregado de analisar JCL.

Ele recebe:

JOB
 ↓
PROC
 ↓
DD statements
 ↓
SYSOUT

Analisa.

Identifica problemas.

Explica.

Confere novamente.

Entrega a resposta.

Não precisamos de quinze agentes discutindo DISP=(NEW,CATLG,DELETE).

Um agente bem instruído pode resolver.

Essa arquitetura oferece enorme vantagem:

simplicidade.

Menos componentes.

Menor latência.

Menor custo.

Menos pontos de falha.

Mais facilidade de debugging.

E essa última palavra deveria estar escrita em letras douradas em todo projeto de IA corporativa.


Fleet Loop: quando Red John aparece

Mas existem casos maiores.

Imagine um agente encarregado de modernizar uma aplicação bancária COBOL com 8 milhões de linhas.

Agora nossa investigação cresceu.

Precisamos compreender COBOL.

JCL.

Db2.

CICS.

VSAM.

Regras de negócio.

APIs.

Segurança.

Testes.

Arquitetura.

Documentação.

Performance.

Talvez um único agente possa tentar.

Mas surge outra possibilidade.

Uma Fleet, ou frota de agentes especializados.

                    ORQUESTRADOR
                         │
        ┌────────────────┼───────────────┐
        ↓                ↓               ↓
   COBOL Agent       DB2 Agent      CICS Agent
        │                │               │
        └────────────────┼───────────────┘
                         ↓
                   TEST AGENT
                         ↓
                   EVALUATOR

Agora cada agente possui responsabilidade específica.

É quase uma equipe virtual.


O orquestrador é o JES da festa

Para um iniciante COBOL, podemos fazer uma analogia divertida.

Imagine o orquestrador como algo entre um scheduler, JES e gerente de processamento.

Ele não necessariamente executa todo o trabalho.

Ele determina:

quem trabalha;

quando trabalha;

com quais informações;

em qual sequência;

e o que acontece depois.

ORCHESTRATOR
      ↓
  AGENT COBOL
      ↓
   AGENT DB2
      ↓
 TEST AGENT
      ↓
 EVALUATOR

Sem orquestrador, uma frota de agentes pode virar uma reunião corporativa às 16h de sexta-feira.

Todo mundo fala.

Ninguém sabe quem decide.

E misteriosamente surge outra reunião.


Role Specialization Gap

Esse é outro problema citado.

Você cria cinco agentes.

Mas todos fazem praticamente a mesma coisa.

Um analisa.

Outro também analisa.

Outro revisa a análise.

Outro "supervisiona".

Outro analisa a revisão.

Parabéns.

Você inventou burocracia digital.

Especialização precisa significar fronteiras claras.

Por exemplo:

Maker → produz
Checker → verifica
Security → procura vulnerabilidades
Performance → analisa eficiência
Orchestrator → decide fluxo

Isso é melhor.

Temos separação de responsabilidades.

Um conceito antiquíssimo da engenharia de software reaparece.

Separation of Concerns.


Maker e Checker: uma das melhores ideias para IA empresarial

Se eu tivesse que selecionar uma arquitetura simples para ensinar a um iniciante, escolheria:

MAKER
  ↓
CHECKER

O Maker faz.

O Checker confere.

Por exemplo:

Agent A:
"Gere SQL."

Agent B:
"Verifique o SQL."

Melhor ainda:

Agent A
gera SQL
   ↓
database sandbox
   ↓
execution result
   ↓
Agent B
avalia

Aqui aparece um princípio fundamental:

sempre que possível, substitua opinião por evidência.

Em vez de perguntar ao segundo LLM:

Esse código parece correto?

Execute.

Compile.

Teste.

Compare.

Meça.

Observe.

Isso aumenta enormemente a confiabilidade.


Open Loop: Patrick Jane solto na cena do crime

Loops abertos são interessantes porque permitem exploração.

Imagine:

Descubra por que nosso processamento ficou 40% mais lento.

O agente pode explorar várias hipóteses.

CPU?
 ↓
I/O?
 ↓
Db2?
 ↓
Locks?
 ↓
WLM?
 ↓
Dataset?
 ↓
Rede?
 ↓
Mudança recente?

Ele não conhece previamente o caminho.

Investiga.

Formula hipóteses.

Descarta.

Testa.

Reformula.

É uma abordagem quase investigativa.

E muito parecida com The Mentalist.

Jane entra em uma sala e começa a observar detalhes aparentemente insignificantes.

Um copo deslocado.

Uma janela aberta.

Uma pessoa olhando para o relógio.

Uma contradição.

Um perfume.

Nenhuma pista isolada fornece a resposta.

O valor aparece quando diferentes sinais são combinados.

Um agente exploratório faz algo conceitualmente semelhante.


Mas o Open Loop possui um monstro escondido: custo

Imagine o agente dizendo:

Vou investigar mais uma hipótese.

Depois:

Mais uma.

Depois:

Talvez outra.

Depois:

Encontrei algo interessante. Vou aprofundar.

Depois:

Talvez exista uma abordagem alternativa.

Duas horas depois:

TOKENS: ☠☠☠☠☠
CUSTO:  ☠☠☠☠☠
RESULTADO: "AINDA INVESTIGANDO"

Esse é o problema de loops excessivamente abertos.

Sem critério de parada, exploração vira desperdício.

Precisamos de limites.

Por exemplo:

máximo 5 hipóteses

máximo 3 tentativas

máximo 50.000 tokens

timeout 10 minutos

confidence > 95%

stop when test passes

A palavra-chave é:

budget.

Agentes precisam de orçamento.

Não apenas monetário.

Tempo.

Tokens.

Chamadas de API.

CPU.

Ferramentas.

Tentativas.


Closed Loop: o mundo confortável do batch

Agora entramos em terreno familiar ao mainframe.

Loops fechados possuem passos bem definidos.

RECEBER
 ↓
VALIDAR
 ↓
PROCESSAR
 ↓
CONFERIR
 ↓
GRAVAR
 ↓
FINALIZAR

Isso é previsível.

E previsibilidade é ouro em ambientes corporativos.

Especialmente quando estamos falando de:

pagamentos,

folha salarial,

liquidação,

contabilidade,

regulatório,

processamento financeiro.

Ninguém quer um agente criativo decidindo:

Hoje vou experimentar uma maneira diferente de calcular a folha.

Não.

Obrigado.

Volte para homologação.


Entretanto, loops fechados também possuem um problema

Rigidez.

Imagine que uma API mudou.

O fluxo continua:

Passo 1
Passo 2
Passo 3
Passo 4

Mas Passo 3 não funciona mais.

Um workflow extremamente rígido pode repetir o erro indefinidamente.

Por isso aparece uma arquitetura extremamente interessante:

exploração aberta + execução fechada.

PROBLEMA
   ↓
OPEN LOOP
investiga soluções
   ↓
DECISÃO
   ↓
CLOSED LOOP
executa solução controlada
   ↓
VALIDAÇÃO

Essa combinação provavelmente será uma das estruturas mais úteis da IA corporativa.


Memory Gap: o agente com amnésia

Imagine conversar hoje com um agente.

Você explica durante quarenta minutos seu sistema.

Ele entende.

Amanhã você retorna.

— Então, sobre aquele problema do CICS...

Agente:

— Qual problema?

Pronto.

Temos um consultor que sofre amnésia todas as manhãs.

Não escala.

Por isso sistemas agentic precisam de memória.

Mas "memória" não significa simplesmente jogar todas as conversas anteriores dentro do prompt.

Isso seria caro, lento e eventualmente impossível.

Precisamos de camadas.

MEMÓRIA DE CURTO PRAZO
contexto da execução

MEMÓRIA DE TRABALHO
informações relevantes da tarefa

MEMÓRIA PERSISTENTE
dados entre sessões

BASE DE CONHECIMENTO
documentação externa

Um mainframer pode imaginar algo como:

WORKING-STORAGE
+
VSAM
+
DB2
+
LOG

Não é uma equivalência técnica perfeita, evidentemente.

Mas ajuda a compreender a ideia.


Context não é Memory

Aqui existe uma sutileza importante.

Contexto é aquilo que o modelo consegue considerar na execução atual.

Memória é um mecanismo capaz de preservar e recuperar informações úteis através das execuções.

Imagine uma biblioteca.

Contexto é a pilha de livros atualmente sobre sua mesa.

Memória é a biblioteca inteira e o catálogo que permite encontrar novamente os livros relevantes.

Essa distinção será cada vez mais importante.


Connectors: as mãos do agente

Um modelo sem ferramentas sabe falar.

Um agente equipado com conectores consegue agir.

Imagine:

LLM
 │
 ├── Gmail
 ├── Calendar
 ├── Git
 ├── Database
 ├── Mainframe
 ├── API
 ├── Files
 └── Monitoring

Isso muda completamente sua natureza.

Perguntar:

Qual é o saldo do cliente?

é uma tarefa linguística + acesso a dados.

Perguntar:

Transfira R$ 500.

é uma ação.

E ação exige controles muito mais fortes.

Autorização.

Auditoria.

Identidade.

Permissão.

Limites.

Confirmação.

Rollback.

É aí que Agentic AI deixa de ser brinquedo e entra no território da engenharia empresarial séria.


Automations: o agente começa a trabalhar sem ser chamado

Outro building block fundamental são automações.

Podemos ter:

EVENTO
  ↓
TRIGGER
  ↓
AGENTE
  ↓
LOOP

Exemplo:

Um job termina com RC=12.

O monitor detecta.

Um agente recebe SYSOUT.

Analisa.

Compara com incidentes anteriores.

Sugere causa.

Consulta documentação.

Cria resumo.

Encaminha para operador.

Agora temos algo muito próximo de AIOps agentic.


A regra de ouro: autonomia não significa ausência de controle

Talvez este seja um dos maiores equívocos atuais.

Algumas pessoas imaginam uma escala assim:

MAIS AUTONOMIA = MAIS EVOLUÇÃO

Nem sempre.

Em aplicações empresariais, talvez a melhor equação seja:

AUTONOMIA
+
OBSERVABILIDADE
+
LIMITES
+
VALIDAÇÃO
+
AUDITORIA
=
CONFIANÇA

Um agente completamente autônomo, porém impossível de auditar, pode ser menos útil que um agente limitado e extremamente previsível.


Human-in-the-Loop continua vivo

Existe também um ponto onde o humano deve permanecer.

Imagine:

Agente detecta
fraude provável
      ↓
Confidence 62%
      ↓
AÇÃO IRREVERSÍVEL?
      ↓
SIM
      ↓
HUMAN REVIEW

Isso não significa fracasso da automação.

Significa arquitetura responsável.

Um sistema maduro sabe quando continuar sozinho.

E sabe quando chamar alguém.


Curiosidade: Agentic AI está redescobrindo sistemas de controle

Existe algo fascinante em toda essa discussão.

Muito antes de LLMs, engenharia já estudava sistemas baseados em feedback.

Termostato.

Piloto automático.

Controladores industriais.

Sistemas de navegação.

Automação fabril.

Todos trabalham aproximadamente com:

ESTADO DESEJADO
      ↓
AÇÃO
      ↓
MEDIÇÃO
      ↓
ERRO
      ↓
CORREÇÃO

Agentic AI adiciona capacidades linguísticas e cognitivas poderosas ao princípio.

Mas o DNA do loop é antigo.


Easter Egg nº 1 — PROC LOOP

Imagine um agente COBOL escrito como se fosse um episódio de The Mentalist:

       PROCEDURE DIVISION.

       1000-INVESTIGATE.
           PERFORM 2000-DISCOVER
           PERFORM 3000-PLAN
           PERFORM 4000-EXECUTE
           PERFORM 5000-VERIFY

           IF WS-RESULTADO = 'OK'
               PERFORM 9000-SHIP
           ELSE
               PERFORM 6000-IMPROVE
               GO TO 1000-INVESTIGATE
           END-IF.

           STOP RUN.

Alguns veteranos COBOL acabaram de franzir a testa por causa daquele GO TO.

Sim.

Foi proposital.

O easter egg era fazer um mainframer sentir uma pequena perturbação na Força.


Easter Egg nº 2 — Red John era um Open Loop

Patrick Jane passou anos investigando Red John.

Hipótese.

Pista.

Nova hipótese.

Suspeito.

Erro.

Nova pista.

Outro suspeito.

Mais investigação.

Tecnicamente poderíamos dizer que a série inteira possui um gigantesco:

OPEN INVESTIGATION LOOP

com um critério final:

RED JOHN IDENTIFIED = TRUE

Talvez Bruno Heller tenha criado Agentic Television antes de isso virar buzzword.


Uma arquitetura agentic para analisar um Abend

Agora vamos juntar tudo em um exemplo muito próximo do universo mainframe.

Recebemos:

JOB ABC123
ABEND S0C7

Nosso agente entra em ação.

Primeiro ele descobre contexto.

Qual STEP?

Qual programa?

Qual offset?

Qual dump?

Houve mudança recente?

Depois planeja.

1 localizar mensagem
2 identificar programa
3 mapear offset
4 localizar campo
5 verificar dados
6 buscar histórico

Executa.

Consulta SYSOUT.

Obtém dump.

Lê listing.

Verifica copybook.

Cruza layout.

Então avalia.

A hipótese realmente explica o S0C7?

Se não explicar:

ITERATE

Formula outra hipótese.

Por exemplo:

Campo numericamente inválido.

Ou redefinição incorreta.

Ou arquivo com layout inesperado.

Ou COMP-3 corrompido.

Quando encontra evidência suficiente:

VERIFY = PASS

Entrega diagnóstico.

Veja como isso é muito superior a simplesmente perguntar a um chatbot:

O que é S0C7?

Uma coisa é explicar o conceito.

Outra coisa é investigar o incidente.

Essa diferença resume boa parte da passagem de Generative AI para Agentic AI.


Passo a passo para construir seu primeiro loop mental

Se você é iniciante, não tente começar criando quinze agentes, quatro bancos vetoriais, Kubernetes, três modelos e um nome grego para o orquestrador.

Comece pequeno.

Use esta sequência como seu mapa:

  1. Defina um objetivo mensurável. "Explicar JCL" é vago; "identificar possíveis erros em um JOB e apontar evidências" é melhor. Em seguida, determine quais ferramentas o agente realmente precisa, estabeleça como ele saberá que terminou, crie uma etapa independente de validação, defina limites de custo e tentativas, registre cada decisão, teste primeiro com casos conhecidos, introduza memória apenas quando houver necessidade real, adicione novos agentes somente quando existir uma especialização justificável e mantenha ações críticas sob autorização explícita até possuir evidências suficientes de confiabilidade.

Essa ordem é menos glamourosa.

E muito mais segura.


Observabilidade: porque até Patrick Jane precisava de pistas

Se um agente falhar e você não conseguir descobrir por quê, possui um problema grave.

Precisamos observar:

INPUT

DECISION

MODEL CALL

TOOL CALL

RESULT

EVALUATION

RETRY

COST

DURATION

FINAL OUTPUT

Isso é tracing agentic.

Um sistema empresarial precisa conseguir responder:

Por que esse agente tomou essa decisão?

Talvez não consigamos reconstruir todo fenômeno interno do modelo.

Mas podemos registrar o contexto operacional disponível:

instruções;

dados recuperados;

ferramentas utilizadas;

resultados;

scores;

retries;

políticas aplicadas.

Quem vem do mainframe sabe o valor disso.

SMF existe por um motivo.

SYSLOG existe por um motivo.

JESMSGLG existe por um motivo.

Auditoria existe por um motivo.

Quando algo explode às 03:17 da madrugada, "a IA decidiu" não será uma explicação aceitável.


A arquitetura que eu escolheria para uma empresa

Não escolheria simplesmente "Single Agent" ou "Fleet".

Escolheria de acordo com risco e complexidade.

Para tarefas pequenas:

Single Agent
     ↓
Tool
     ↓
Verifier

Para tarefas grandes:

                 ORCHESTRATOR
                       │
        ┌──────────────┼──────────────┐
        ↓              ↓              ↓
     COBOL           DB2            CICS
        │              │              │
        └──────────────┼──────────────┘
                       ↓
                    MAKER
                       ↓
                    CHECKER
                       ↓
                 QUALITY GATE
                       ↓
             ┌─────────┴─────────┐
             ↓                   ↓
           PASS                 FAIL
             ↓                   ↓
           SHIP               ITERATE

Agora temos algo reconhecível para qualquer profissional de engenharia.

Pipeline.

Quality gate.

Especialização.

Auditoria.

Retry.

Observabilidade.

Controle.


O curioso encontro entre Mainframe e IA

Talvez a parte mais divertida dessa história seja perceber quanto do futuro se parece com o passado.

Estamos falando de:

jobs,

queues,

orchestration,

retries,

return codes,

logs,

resource limits,

authorization,

transaction boundaries,

checkpoint,

recovery,

audit trail.

Um mainframer poderia olhar para boa parte dessa arquitetura e perguntar:

— Vocês passaram três anos inventando nomes novos para coisas que fazemos desde 1978?

Não exatamente.

Mas...

também não estaria completamente errado.

A novidade fundamental está na possibilidade de incluir mecanismos probabilísticos capazes de interpretar linguagem, contexto, intenção e informação não estruturada dentro desses loops.

O velho mundo determinístico ganha um novo componente cognitivo.


E chegamos ao verdadeiro segredo

A discussão frequentemente fica presa a modelos.

Qual é maior?

Qual possui mais parâmetros?

Qual benchmark vence?

Qual raciocina melhor?

Essas perguntas importam.

Mas quando chegamos a produção, surgem outras muito mais difíceis.

O que acontece quando o modelo erra?

Como detectamos?

Quem corrige?

Quantas vezes pode tentar?

Quando deve desistir?

Quando chama um humano?

Como registramos?

Como recuperamos?

Como evitamos repetir o mesmo erro amanhã?

Como garantimos que dois agentes não executem ações conflitantes?

Como impedimos um loop infinito?

Como controlamos custo?

Como testamos?

É aí que começa a verdadeira Loop Engineering.


O último interrogatório

Voltemos à nossa sala.

O diretor continua orgulhoso.

— Nosso agente é extremamente inteligente.

Patrick Jane termina seu chá.

— Inteligência não é o que me preocupa.

— Então o que preocupa?

Jane aponta para o dashboard.

— Quando ele erra, quem percebe?

O diretor hesita.

— O usuário.

Jane sorri.

— Então vocês ainda não construíram um agente.

— Construímos o quê?

— Um estagiário muito rápido.

Silêncio.

Fim do episódio.


O diagnóstico final

Durante a primeira fase da IA generativa, tentamos criar respostas melhores.

Durante a segunda, demos ferramentas aos modelos.

Durante a terceira, começamos a transformar modelos em agentes.

Agora entramos numa fase mais madura.

Precisamos transformar agentes em sistemas confiáveis.

E sistemas confiáveis exigem loops.

DISCOVER
   ↓
PLAN
   ↓
EXECUTE
   ↓
OBSERVE
   ↓
EVALUATE
   ↓
IMPROVE
   ↓
REPEAT

Mas repare numa última sutileza.

O objetivo não é repetir infinitamente.

O objetivo é saber quando parar.

Um bom loop possui critérios de entrada.

Critérios de qualidade.

Limites.

Feedback.

Recovery.

Auditoria.

E condição de saída.

Isso é engenharia.


☕ A última xícara

Talvez daqui a alguns anos a palavra "agente" nem seja tão importante.

Talvez simplesmente chamemos tudo isso de software.

Afinal, microsserviços já foram novidade.

Cloud já foi novidade.

APIs já foram novidade.

DevOps já foi novidade.

Containers já foram novidade.

Com o tempo, tecnologias extraordinárias tornam-se infraestrutura.

Agentic AI provavelmente seguirá caminho semelhante.

E quando isso acontecer, os sistemas vencedores não serão necessariamente aqueles com o maior número de agentes ou com o modelo mais impressionante.

Serão aqueles que conseguirem responder consistentemente às perguntas que Patrick Jane faria logo ao entrar na sala:

O que aconteceu?

Por que aconteceu?

Como você sabe?

Quem verificou?

O que fará se estiver errado?

E existe uma sexta pergunta, aquela que talvez seja a mais importante de todas:

Quando o loop termina?

Porque gerar uma resposta é fácil.

Executar uma tarefa é mais difícil.

Verificar o resultado é ainda mais difícil.

Corrigir-se sem destruir nada é engenharia.

E fazer tudo isso repetidamente, com custo controlado, memória, segurança, rastreabilidade, qualidade e possibilidade de intervenção humana...

isso já não é apenas Inteligência Artificial.

É engenharia de sistemas empresariais com inteligência dentro do loop.

E talvez essa seja a verdadeira revolução que estava escondida diante de nós o tempo inteiro.

READY

RUN AGENT

DISCOVER...

PLAN...

EXECUTE...

VERIFY...

QUALITY GATE FAILED.

ITERATING...

Patrick Jane olha para o terminal 3270.

Sorri discretamente.

E diz:

— Agora sim. Pelo menos ele sabe que errou.

quarta-feira, 18 de setembro de 2024

AIOps : Quando um Programador Embarca no Seaview e Descobre que o Verdadeiro Monstro do Oceano Não é um Polvo Gigante.

Bellacosa Mainframe apresenta o aiops

☕ Um Café no Bellacosa Mainframe

AIOps sem Mistérios para Programadores COBOL

Quando um Programador Embarca no Seaview e Descobre que o Verdadeiro Monstro do Oceano Não é um Polvo Gigante... É uma Anomalia de Performance Escondida Entre Milhões de Métricas

"Profundidade: 8.000 metros."

"Pressão externa: centenas de atmosferas."

"Silêncio absoluto."

No fundo do oceano não existe espaço para improvisação.

Não existe Ctrl+C.

Não existe reboot.

Não existe "vamos tentar novamente amanhã".

Uma pequena falha...

...e toda a missão termina.

Curiosamente, é exatamente assim que funciona um IBM Z.

Enquanto milhões de pessoas compram, transferem dinheiro, usam cartões, fazem PIX, reservam passagens e movimentam bolsas de valores, o mainframe continua trabalhando silenciosamente nas profundezas da infraestrutura mundial.

É justamente aí que nasce o universo do AIOps, do Performance Management e do Capacity Planning.

Prepare seu uniforme da Marinha Nelson Institute, embarque no USS Seaview, comandado pelo Almirante Harriman Nelson e pelo Capitão Lee Crane, porque hoje faremos uma viagem ao fundo do mar... das métricas do IBM Z.


Capítulo 1 — O Oceano Invisível do Mainframe

Todo iniciante imagina que um computador executa apenas programas.

Na realidade, um IBM Z executa milhares de atividades simultaneamente.

Enquanto seu programa COBOL faz um simples:

READ CLIENTES

o sistema inteiro está trabalhando.

Nos bastidores existem:

  • Dispatcher

  • PR/SM

  • WLM

  • zIIP

  • RMF

  • SMF

  • CICS

  • Db2

  • MQ

  • JES2

  • VSAM

  • RACF

  • DFSMS

  • Coupling Facility

  • IOS

  • Channel Subsystem

Todos gerando estatísticas.

Imagine centenas de sensores espalhados pelo casco do Seaview.

Cada sensor mede:

  • pressão

  • temperatura

  • velocidade

  • combustível

  • profundidade

  • oxigênio

  • consumo elétrico

Agora multiplique isso por dezenas de milhares.

É isso que o IBM Z mede continuamente.


Easter Egg nº 1

Na série Viagem ao Fundo do Mar, o Seaview parecia navegar calmamente.

Mas na sala de máquinas havia dezenas de oficiais monitorando centenas de instrumentos.

No IBM Z acontece exatamente o mesmo.

Você vê apenas uma tela 3270.

Por trás dela existe um oceano inteiro de telemetria.


Capítulo 2 — O erro que muita gente está cometendo

Com a chegada dos LLMs surgiu uma ideia perigosa.

"Agora basta perguntar para uma IA."

Será?

Imagine entrar no Seaview e perguntar:

— IA, estamos seguros?

Resposta:

— Sim.

Fim.

Mas...

E se existir uma microfissura no casco?

E se um sonar estiver apresentando ruído?

E se uma bomba hidráulica estiver começando a vibrar?

A IA respondeu.

Mas não analisou.

Essa é exatamente a diferença entre um chatbot e uma plataforma especializada como o IBM Z IntelliMagic Vision.


Informação não é conhecimento

Uma IA pode responder:

"A CPU está em 82%."

Ótimo.

Mas isso é bom?

Ruim?

Esperado?

Anormal?

Ela não sabe.

Porque falta contexto.

O especialista pergunta:

  • qual CPC?

  • qual LPAR?

  • qual horário?

  • qual workload?

  • qual Service Class?

  • qual política WLM?

  • houve IPL?

  • mudou o firmware?

  • houve novo package Db2?

  • apareceu nova aplicação Java?

  • aumentou MQ?

  • mudou o peso PR/SM?

É outro nível de investigação.


Capítulo 3 — O verdadeiro tesouro do oceano chama-se SMF

Poucos iniciantes conhecem o SMF.

Mas ele talvez seja o recurso mais valioso do z/OS.

SMF significa:

System Management Facility

Pense nele como o diário de bordo do Seaview.

Tudo é registrado.

Tudo.

Quem usou CPU.

Quem fez I/O.

Quem abriu datasets.

Quem executou CICS.

Quem acessou Db2.

Quem consumiu zIIP.

Quem gerou paging.

Quem alterou configuração.

Décadas de história ficam registradas.

Sem SMF...

não existe análise histórica.


Curiosidade

Muitas empresas possuem anos de dados SMF armazenados.

Algumas conseguem comparar o comportamento atual com períodos de cinco ou dez anos atrás.

É como comparar uma expedição submarina atual com os registros originais do Almirante Nelson.


Capítulo 4 — Uma imagem vale mais que mil RMFs

O artigo comenta algo extremamente importante.

Uma figura vale mais que mil palavras.

Observe mentalmente a topologia apresentada.

Diversos:

CPC

↓

LPARs

↓

Sysplex

Tudo conectado.

Em segundos o especialista entende:

Quem pertence a quem.

Quem compartilha recursos.

Quem faz parte do mesmo Sysplex.

Quem utiliza determinado processador.

Nenhum texto consegue transmitir isso tão rapidamente.


Easter Egg nº 2

No Seaview existia uma enorme mesa de navegação.

Ninguém decorava o oceano.

Eles olhavam o mapa.

O IntelliMagic faz exatamente isso.

Ele desenha o mapa do seu mainframe.


Capítulo 5 — O poder do Change Detection

Imagine esta situação.

Segunda-feira:

Tudo perfeito.

Terça-feira:

Usuários reclamando.

O que mudou?

Essa pergunta pode consumir dias de investigação.

Mas o IntelliMagic compara automaticamente períodos diferentes.

Ele verifica:

  • CPU

  • zIIP

  • Dispatch Time

  • Busy

  • Eligible Work

  • Utilização

  • Tendências

  • Desvios

Não apenas mostra valores.

Mostra mudanças.

E mais importante...

Mostra mudanças relevantes.


O segredo do desvio padrão

Imagine um sonar.

O ruído normal fica entre:

10 e 15 decibéis.

Hoje apareceu:

Nada mudou.

Agora imagine:

Tem algo enorme vindo na direção do submarino.

Foi isso que o desvio padrão detectou.

Mudanças realmente fora do comportamento esperado.

Não basta aumentar.

Precisa aumentar de forma estatisticamente significativa.


Capítulo 6 — Health Rating

Talvez a funcionalidade mais fascinante.

Imagine o painel do Seaview.

Luzes verdes.

Luzes amarelas.

Luzes vermelhas.

Você não precisa ler milhares de sensores.

Basta olhar o painel.

No IntelliMagic ocorre exatamente isso.

Cada sistema recebe indicadores como:

  • Dispatch Time

  • MVS Busy

  • LPAR Busy

  • zIIP

  • IOSQ

  • Pending

  • Connect

  • Interrupt

  • Page-ins

Em poucos segundos o especialista sabe onde investigar primeiro.


Dica Bellacosa

Nunca olhe apenas um indicador.

Performance é correlação.

CPU alta pode ser consequência.

Não a causa.


Capítulo 7 — Tendência vale mais que fotografia

Uma fotografia mostra um instante.

Um gráfico mostra uma história.

É por isso que Capacity Planning utiliza séries históricas.

Não interessa apenas saber:

Hoje = 70%.

Interessa descobrir:

Janeiro:

65%

Fevereiro:

67%

Março:

69%

Abril:

72%

Maio:

75%

Junho:

78%

Agora existe uma tendência.

Sem histórico...

não existe previsão.


Capítulo 8 — Capacity Planning

Aqui muitos iniciantes cometem outro erro.

Pensam:

Capacity Planning = CPU.

Não.

CPU é apenas uma peça.

O especialista observa:

CPU

↓

Memória

↓

I/O

↓

Storage

↓

Channels

↓

Paging

↓

Network

↓

zIIP

↓

MSU

↓

Software

↓

CICS

↓

Db2

↓

MQ

↓

IMS

↓

Batch

↓

Online

↓

WLM

Tudo ao mesmo tempo.

Porque gargalos raramente aparecem isolados.


Curiosidade

Em muitos ambientes o problema nunca foi CPU.

Foi um único volume DASD saturado.

Ou uma fila MQ crescendo.

Ou uma política WLM mal definida.

Ou uma consulta SQL sem índice.


Capítulo 9 — O verdadeiro papel do especialista

O artigo fala algo maravilhoso.

O maior problema não é coletar dados.

É interpretá-los.

Hoje qualquer ferramenta coleta milhões de métricas.

Mas poucas conseguem responder:

O que realmente importa?

Imagine o Seaview.

Existem dez mil instrumentos.

Mas apenas um oficial experiente percebe que pequenas vibrações significam falha futura.

É exatamente isso que faz um especialista em performance.


Capítulo 10 — Explainability

Uma IA responde.

O especialista explica.

Existe enorme diferença.

Imagine um diretor perguntando:

"Por que precisamos comprar outro CPC?"

Você responde:

"Porque a IA sugeriu."

A reunião termina.

Agora imagine responder:

  • crescimento médio de 18% ao ano;

  • tendência confirmada em 36 meses;

  • workloads Batch crescendo;

  • consumo zIIP estabilizado;

  • pico de MSU chegando ao limite contratual;

  • risco para SLA da aplicação bancária;

  • previsão estatística de saturação em oito meses.

Agora existe evidência.


Easter Egg nº 3

No Seaview, o Almirante Nelson nunca dizia apenas:

"Vamos mergulhar."

Ele mostrava:

  • cartas náuticas;

  • sonar;

  • profundidade;

  • corrente marítima;

  • combustível;

  • pressão.

Isso é explainability.


Capítulo 11 — IA não substitui Analytics

Esse talvez seja o maior ensinamento do artigo.

A IA facilita perguntas.

O IntelliMagic produz respostas confiáveis.

Pense assim.

ChatGPT é como um excelente oficial de comunicações.

Ele conversa.

Resume.

Explica.

O IntelliMagic é o centro de controle do submarino.

Recebe milhares de sinais.

Correlaciona.

Detecta anomalias.

Calcula riscos.

Prevê problemas.

Ambos trabalham juntos.

Jamais um substitui o outro.


Passo a passo de uma investigação de performance

Imagine que um gerente liga dizendo:

"O sistema ficou lento."

Como um especialista procede?

Passo 1 — Confirmar o sintoma

Foi CPU?

I/O?

Rede?

Storage?

Aplicação?


Passo 2 — Comparar com a baseline

Como era ontem?

Semana passada?

Mesmo horário?


Passo 3 — Procurar mudanças

Novo deploy?

Novo package?

Nova política WLM?

Novo firmware?

Novo microcódigo?


Passo 4 — Correlacionar métricas

CPU alta.

Mas também houve:

  • aumento de I/O;

  • queda no cache;

  • crescimento do MQ;

  • aumento de locks Db2.

Agora aparece a verdadeira causa.


Passo 5 — Avaliar impacto

Quem sofreu?

Clientes?

PIX?

Internet Banking?

Cartão?

Folha?

Ou apenas um batch interno?


Passo 6 — Recomendar ações

Redistribuir workload.

Aumentar zIIP.

Reconfigurar WLM.

Otimizar SQL.

Criar índices.

Mover datasets.

Alterar prioridades.


O futuro

A próxima geração de ferramentas será híbrida.

Imagine conversar com a plataforma:

"Quais sistemas apresentaram crescimento anormal?"

A IA responde.

Mas por trás dela existe um motor especializado analisando:

  • milhares de métricas;

  • estatísticas;

  • tendências;

  • Health Insights;

  • correlações;

  • previsões.

É exatamente essa união que o artigo chama de:

AI + Analytics.


Curiosidades Bellacosa

✅ Um único IBM Z pode produzir milhões de registros SMF por dia.

✅ O WLM ajusta prioridades automaticamente centenas de vezes por segundo para manter os objetivos de serviço.

✅ O zIIP pode descarregar grande parte do processamento elegível de Db2, XML, Java, criptografia e workloads analíticos, reduzindo custos de software em muitos cenários.

✅ Um problema aparentemente "de CPU" pode, na verdade, ser consequência de filas de I/O, contenção em locks Db2, espera por MQ ou políticas WLM inadequadas.

✅ Ferramentas como o IBM Z IntelliMagic Vision incorporam décadas de conhecimento de especialistas em performance, automatizando análises que antes exigiam anos de experiência.


Conclusão — A Verdadeira Viagem ao Fundo do Mar

Ao final da missão, o USS Seaview emerge lentamente das profundezas. A tripulação sobreviveu não porque tinha o sonar mais bonito ou o rádio mais moderno, mas porque soube interpretar corretamente cada sinal vindo do oceano.

No IBM Z acontece exatamente o mesmo.

Os gráficos, mapas de Sysplex, indicadores de saúde, detecção automática de mudanças e análises históricas são os "sonares" do mundo corporativo. Eles transformam bilhões de amostras de desempenho em conhecimento acionável.

A IA generativa representa o novo oficial de comunicações: traduz perguntas complexas para linguagem natural, resume informações e acelera o acesso ao conhecimento. Já plataformas como o IBM Z IntelliMagic Vision são o cérebro analítico do navio, capazes de correlacionar milhares de métricas, detectar riscos antes que se tornem incidentes e justificar cada conclusão com evidências.

Para o programador COBOL iniciante, a maior lição é simples: escrever um bom programa não significa apenas fazer a lógica funcionar. Significa entender como esse programa consome CPU, acessa VSAM e Db2, utiliza CICS, aproveita zIIP, respeita as metas do WLM e influencia todo o ecossistema do mainframe.

No universo Bellacosa Mainframe, o código é apenas a ponta do iceberg.

A verdadeira aventura começa quando você aprende a enxergar o oceano invisível que existe sob cada EXEC CICS, cada SELECT no Db2, cada mensagem no MQ e cada READ em um dataset. É nesse oceano que vivem os maiores desafios da engenharia de performance — e também onde se encontram os maiores tesouros de conhecimento para quem deseja se tornar um verdadeiro Mestre Jedi do Mainframe.

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