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

segunda-feira, 28 de setembro de 2026

☕ ALAN TURING ENTRA NO CPD — O MAPA DOS AGENTES DE IA EXPLICADO POR UM MAINFRAMER

 


☕ UM CAFÉ NO BELLACOSA MAINFRAME

☕ ALAN TURING ENTRA NO CPD — O MAPA DOS AGENTES DE IA EXPLICADO POR UM MAINFRAMER

De currículo invisível, PF3 e SDSF até WLM, JES2, CICS, Db2, MQ e IMS — nove conversas sobre agentes de inteligência artificial que acabaram revelando que alguns dos problemas mais modernos da computação possuem parentes muito antigos.



🎬 PRÓLOGO — EU NÃO ESTAVA ESCREVENDO UMA SÉRIE

Existe uma coisa curiosa em escrever durante muitos anos.

Às vezes você pensa que está escrevendo artigos independentes.

Um assunto aparece.

Você investiga.

Escreve.

Publica.

Toma outro café.

Algumas semanas depois aparece outra pergunta.

Outro artigo.

Outro café.

Até que um dia você olha para trás e percebe:

Espere um pouco...

Esses textos estão conversando entre si.

Foi exatamente o que aconteceu com uma sequência de artigos que comecei a construir usando Alan Turing como nosso visitante imaginário dentro de um CPD.

No começo, a pergunta parecia relativamente simples:

Como devemos preparar pessoas para trabalhar com inteligência artificial?

Depois apareceu outra:

Como será a interface de um agente que não apenas responde, mas executa ações?

E outra:

Como descobriremos o que esse agente está fazendo?

Depois:

Quem decide qual agente é mais importante?

Quem coloca o trabalho para executar?

Como controlamos uma transação?

Onde guardamos o estado?

Como agentes conversam sem depender uns dos outros?

Como organizamos memória e contexto?

Quando percebi, Alan Turing já estava andando pelo corredor do CPD acompanhado de alguns velhos conhecidos:

ISPF
SDSF
WLM
JES2
CICS
Db2
MQ
IMS

E foi aí que apareceu a hipótese que une esta série inteira:

Talvez alguns dos problemas que estamos descobrindo agora nos agentes de IA sejam novos em implementação, escala e comportamento — mas não necessariamente novos como problemas de engenharia.

O mainframe passou décadas resolvendo problemas como:

IDENTIDADE
AUTORIZAÇÃO
EXECUÇÃO
PRIORIDADE
OBSERVABILIDADE
TRANSAÇÃO
ESTADO
MENSAGERIA
RECUPERAÇÃO
AUDITORIA
CONCORRÊNCIA
DEPENDÊNCIAS

Naturalmente:

JES2 não é um framework de agentes.

SDSF não é observabilidade de LLM.

WLM não é um scheduler de prompts.

CICS não é LangGraph.

Db2 não é memória de IA.

MQ não é protocolo mágico entre agentes.

IMS não foi inventado para armazenar a infância digital de um robô.

😂

A comparação é conceitual.

E justamente por isso ela é tão interessante.

Este artigo é o mapa dessa viagem.



🧠 CAPÍTULO 1 — O CURRÍCULO INVISÍVEL DA INTELIGÊNCIA ARTIFICIAL

Antes de construir o agente, precisamos construir quem vai trabalhar com ele

👉 ALAN TURING E O CURRÍCULO INVISÍVEL DA INTELIGÊNCIA ARTIFICIAL

Nossa viagem começa antes da arquitetura.

Começa nas pessoas.

Existe uma tentação enorme diante de qualquer revolução tecnológica:

NOVA TECNOLOGIA
      ↓
NOVO CURSO
      ↓
NOVA FERRAMENTA
      ↓
CERTIFICADO
      ↓
PRONTO

Mas nunca foi tão simples.

Quem viveu várias gerações da informática sabe disso.

Aprender COBOL não significava apenas conhecer:

MOVE
PERFORM
IF
EVALUATE

O programador acabava aprendendo silenciosamente muitas outras coisas:

  • decomposição de problemas;

  • leitura de documentação;

  • disciplina operacional;

  • análise de impacto;

  • debugging;

  • responsabilidade sobre dados;

  • relacionamento com usuários;

  • conhecimento do negócio;

  • avaliação de riscos.

Existe, portanto, um currículo formal e outro quase invisível.

Com IA acontece algo semelhante.

Prompt engineering pode ser útil.

Conhecer modelos também.

Mas trabalhar seriamente com IA começa a exigir algo muito maior:

IA
│
├── pensamento crítico
├── validação
├── segurança
├── privacidade
├── conhecimento de domínio
├── avaliação de resultados
├── automação
├── ética
├── governança
└── capacidade de perguntar

Este primeiro artigo estabelece o fundamento humano da série.

Antes de perguntar:

O que o agente pode fazer?

precisamos perguntar:

Quem saberá dizer se aquilo que ele fez está correto?

Esse detalhe acompanhará todos os capítulos seguintes.



🤖 CAPÍTULO 2 — A UX DOS AGENTES

Quando PF3 voltou para salvar a inteligência artificial

👉 ALAN TURING E A UX DOS AGENTES — QUANDO PF3, MAXCC E RACF VOLTARAM PARA SALVAR A INTELIGÊNCIA ARTIFICIAL

Então demos autonomia à máquina.

E imediatamente apareceu outro problema.

Um chatbot responde.

Um agente age.

Essa diferença parece pequena até colocarmos ferramentas nas mãos dele.

Imagine:

USUÁRIO
   ↓
OBJETIVO
   ↓
AGENTE
   ├── consulta arquivos
   ├── chama API
   ├── pesquisa banco
   ├── altera documento
   ├── envia mensagem
   └── executa processo

De repente a interface precisa responder perguntas que o velho chatbot não precisava responder:

O QUE ESTÁ FAZENDO?

POR QUE ESTÁ FAZENDO?

QUAL ETAPA ESTÁ EXECUTANDO?

POSSO PARAR?

POSSO DESFAZER?

QUEM AUTORIZOU?

O QUE JÁ FOI ALTERADO?

E eis que aparece nosso velho amigo:

PF3

O PF3 torna-se uma metáfora perfeita para interruptibilidade.

O artigo também traz RACF para a conversa por meio do princípio de menor privilégio.

Se um agente precisa ler relatórios:

READ

por que entregar:

ALTER
DELETE
CONTROL

?

Não entregue uma bazuca para matar um mosquito.

E jamais resolva problemas de autorização usando a filosofia:

DÊ ACESSO A TUDO
       ↓
DEPOIS A GENTE VÊ

Quatro décadas de segurança corporativa já ensinaram como essa história termina.

O capítulo estabelece uma nova regra:

Autonomia sem controle não é sofisticação. É risco operacional.



🔭 CAPÍTULO 3 — O SDSF DOS AGENTES

Não basta o robô trabalhar. Precisamos enxergar o que está acontecendo.

👉 ALAN TURING E O SDSF DOS AGENTES — O QUE DIABOS O ROBÔ ESTÁ FAZENDO?

Agora o agente está trabalhando.

Maravilha.

Só existe uma pequena pergunta:

O que ele está fazendo?

Quem trabalhou com batch conhece uma rotina quase instintiva:

SUBMIT
  ↓
SDSF
  ↓
ST
  ↓
JOB
  ↓
OUTPUT

Não ficamos olhando para o terminal durante quinze minutos vendo:

Working...

Queremos estado.

Queremos evidência.

Queremos saber onde o processamento está.

A documentação da IBM confirma exatamente essa função histórica do SDSF: monitorar e controlar processamento, visualizar jobs e seus outputs e permitir ações como hold, release e cancel.

Transportando o princípio para agentes:

AGENTE FINANCEIRO

OBJETIVO:
Consolidar relatório mensal

STATUS:
Executando

ETAPA 1 — localizar arquivos       OK
ETAPA 2 — validar período          OK
ETAPA 3 — consultar Db2            OK
ETAPA 4 — reconciliar valores      RUNNING
ETAPA 5 — gerar relatório          WAITING
ETAPA 6 — enviar relatório         APPROVAL

Esse talvez seja um dos conceitos mais importantes da série.

Autonomia aumenta a necessidade de observabilidade.

Quanto menos diretamente o humano controla cada passo, mais importante se torna enxergar o estado da execução.



⚖️ CAPÍTULO 4 — O WLM DOS AGENTES

Quando descobrimos que nem todo trabalho possui a mesma importância

👉 ALAN TURING E O WLM DOS AGENTES

Agora temos outro problema.

Imagine mil agentes querendo trabalhar simultaneamente.

Um está:

resumindo newsletter

Outro:

processando fraude bancária

Outro:

gerando imagem

Outro:

atendendo cliente VIP

Outro:

fechando folha de pagamento

Todos deveriam receber os mesmos recursos?

Evidentemente não.

Bem-vindo ao velho problema de workload management.

No z/OS, WLM trabalha justamente com classes de serviço, metas de desempenho e importância relativa do trabalho. Quando todos os objetivos não podem ser satisfeitos simultaneamente, essa importância participa das decisões de gerenciamento dos recursos.

Nos agentes podemos imaginar:

AGENT WORKLOAD
│
├── CRITICAL
│   └── fraude
│
├── HIGH
│   └── atendimento
│
├── NORMAL
│   └── relatórios
│
└── DISCRETIONARY
    └── indexação histórica

E aparece outra ideia fundamental:

Agentes competirão por recursos.

Tokens custam.

GPU custa.

CPU custa.

APIs possuem limites.

Bancos possuem capacidade.

Pessoas disponíveis para aprovação humana também são um recurso limitado.

O problema deixa de ser:

O agente consegue executar?

e passa a ser:

Qual trabalho merece recursos primeiro?

Alan Turing acaba de conhecer o WLM.



🏭 CAPÍTULO 5 — O JES2 DOS AGENTES

Alguém precisa receber, organizar e despachar o trabalho

👉 ALAN TURING E O JES2 DOS AGENTES

Temos prioridades.

Temos recursos.

Temos agentes.

Agora alguém precisa organizar a bagunça.

No mundo batch, JES recebe jobs, mantém trabalhos em filas, encaminha jobs para execução e administra seus outputs. É exatamente assim que a própria documentação introdutória do z/OS descreve suas funções fundamentais.

Conceitualmente:

SUBMISSÃO
    ↓
  FILA
    ↓
CLASSIFICAÇÃO
    ↓
DESPACHO
    ↓
EXECUÇÃO
    ↓
 RESULTADO

Agora substitua JOB por TASK:

TASK-8472
OBJETIVO = analisar contratos
PRIORIDADE = HIGH
AGENTE = LEGAL-07
STATUS = WAITING

Começamos a perceber que um ecossistema corporativo de agentes precisará responder:

Quem recebeu a tarefa?

Onde ela está?

Quem executará?

Está esperando?

Está rodando?

Falhou?

Pode reiniciar?

Existe dependência?

Qual resultado produziu?

Não significa transformar JES2 em orquestrador de LLM.

Significa reconhecer que gerenciamento do ciclo de vida do trabalho é um problema antigo.


⚡ CAPÍTULO 6 — O CICS DOS AGENTES

Quando inteligência encontra transação

👉 ALAN TURING E O CICS DOS AGENTES

Até aqui nossos agentes estavam realizando trabalho.

Mas empresas não vivem apenas de trabalho.

Vivem de transações.

Comprar.

Vender.

Reservar.

Cancelar.

Transferir.

Atualizar.

Consultar.

Registrar.

CICS existe justamente no universo de processamento transacional. Uma transação dispara programas associados, pode envolver diversos programas e recursos, e muitas instâncias podem executar concorrentemente.

Agora imagine um agente recebendo:

Resolva o problema deste cliente.

Ele talvez precise:

CONSULTAR PEDIDO
      ↓
CONSULTAR PAGAMENTO
      ↓
VALIDAR ENTREGA
      ↓
CALCULAR CRÉDITO
      ↓
ATUALIZAR CADASTRO

Não estamos mais falando apenas de linguagem.

Estamos mexendo no estado real do negócio.

Aqui surge uma fronteira essencial:

PENSAR
≠
AGIR

e:

GERAR UMA RESPOSTA
≠
EXECUTAR UMA TRANSAÇÃO

Quando um agente atravessa essa fronteira, entram em cena concorrência, integridade, autorização, recuperação e consistência.

O simpático chatbot acabou de entrar em produção.

Agora a brincadeira ficou séria.


🗄️ CAPÍTULO 7 — O DB2 DOS AGENTES

Quando o agente descobriu que memória também precisa de COMMIT

👉 ALAN TURING E O DB2 DOS AGENTES

Um agente sem estado vive eternamente no presente.

Para realizar trabalhos complexos ele precisa guardar coisas.

Por exemplo:

objetivos
tarefas
resultados
aprovações
clientes
documentos
eventos
checkpoints
estado do workflow

Mas guardar informação introduz um problema:

Quando uma mudança se torna definitiva?

O velho Db2 imediatamente levanta a mão.

No Db2, uma unidade de trabalho representa uma sequência recuperável de operações; COMMIT confirma as mudanças e ROLLBACK pode desfazer alterações ainda não confirmadas.

Isso produz uma analogia poderosa para agentes.

Imagine:

LER
 ↓
ANALISAR
 ↓
PROPOR ALTERAÇÃO
 ↓
VALIDAR
 ↓
APROVAÇÃO
 ↓
COMMIT

Se algo falhar:

ROLLBACK

Mas existe uma pegadinha deliciosa.

Nem tudo no mundo possui rollback.

Se o agente:

ENVIAR EMAIL

não existe:

ROLLBACK EMAIL

que retire a mensagem da cabeça de quem leu.

😂

Portanto sistemas de agentes precisam distinguir ações reversíveis de ações irreversíveis.

O Db2 nos ensina algo maior que SQL:

Estado precisa possuir fronteiras de consistência.


📨 CAPÍTULO 8 — O MQ DOS AGENTES

Mensagem enviada não significa destinatário disponível

👉 ALAN TURING E O MQ DOS AGENTES — MENSAGEM ENVIADA NÃO SIGNIFICA CONVERSA SÍNCRONA

Então nossos agentes começaram a conversar.

E imediatamente alguém inventou:

AGENTE A
   ↓
AGENTE B
   ↓
AGENTE C

Parece maravilhoso.

Até o agente B ficar indisponível.

Ou lento.

Ou ocupado.

Ou reiniciar.

Ou o agente C morar em outro ambiente.

É exatamente aqui que décadas de mensageria corporativa começam a parecer extremamente atuais.

IBM MQ permite que aplicações se comuniquem através de mensagens e filas, inclusive executando em momentos, velocidades e locais diferentes. Produtor e consumidor podem ficar desacoplados.

Portanto:

AGENTE A
   ↓
 MENSAGEM
   ↓
  FILA
   ↓
AGENTE B

A existência da fila muda completamente a arquitetura.

O produtor não precisa necessariamente ficar parado olhando para o consumidor.

Podemos construir sistemas:

ASSÍNCRONOS
RESILIENTES
DESACOPLADOS
DISTRIBUÍDOS

Mas surgem novos problemas:

ordenação
duplicidade
correlação
persistência
retry
dead letter
idempotência
timeout

A IBM também documenta que filas mantêm mensagens até que aplicações possam recuperá-las e que consumidores e produtores podem operar desacoplados.

De repente, multiagentes deixam de parecer uma reunião de robôs conversando.

Começam a parecer...

sistemas distribuídos.

Bem-vindo ao inferno.

Tem café na entrada.


🌳 CAPÍTULO 9 — O IMS DOS AGENTES

Quando Alan Turing descobriu que encontrar um filho é fácil se você souber quem é o pai

👉 ALAN TURING E O IMS DOS AGENTES — QUANDO O MUNDO VIROU UMA ÁRVORE

Finalmente chegamos ao IMS.

E aparece uma pergunta fascinante:

Toda memória precisa ser representada como tabela?

Não.

IMS trabalha historicamente com modelo hierárquico.

Temos relações:

ROOT
 │
 ├── CHILD
 │     ├── CHILD
 │     └── CHILD
 │
 └── CHILD

Na terminologia oficial do IMS, segmentos possuem relações parent/child; um segmento pode inclusive ser filho de um segmento e pai de outro.

Isso oferece uma metáfora extraordinariamente útil para determinados tipos de contexto de agentes.

Imagine:

CLIENTE
│
├── PEDIDOS
│   ├── PEDIDO 8472
│   │   ├── ITENS
│   │   ├── PAGAMENTO
│   │   └── ENTREGA
│   └── PEDIDO 9011
│
├── CONTRATOS
│
└── ATENDIMENTOS

Contexto frequentemente possui relações naturais.

A própria IBM explica uma diferença fundamental: numa base hierárquica IMS, segmentos ao longo de um caminho hierárquico já possuem relações implícitas com pais e filhos, enquanto no modelo relacional relacionamentos normalmente são construídos explicitamente por joins.

Isso não significa:

Vamos substituir vector databases por IMS!

Calma.

😂

A lição é mais interessante:

A forma como representamos conhecimento influencia profundamente a maneira como conseguimos navegar por ele.

E assim chegamos da execução à memória.


🗺️ CAPÍTULO 10 — AGORA OLHE PARA O MAPA INTEIRO

Depois dos nove artigos, podemos finalmente enxergar a arquitetura escondida.

┌───────────────────────────────────────┐
│       CURRÍCULO INVISÍVEL             │
│ Quem está preparado para trabalhar?   │
└──────────────────┬────────────────────┘
                   ↓
┌───────────────────────────────────────┐
│          UX / PF3 / RACF              │
│ Como controlar autonomia?             │
└──────────────────┬────────────────────┘
                   ↓
┌───────────────────────────────────────┐
│               SDSF                    │
│ O que está acontecendo?               │
└──────────────────┬────────────────────┘
                   ↓
┌───────────────────────────────────────┐
│                WLM                    │
│ Qual trabalho é mais importante?      │
└──────────────────┬────────────────────┘
                   ↓
┌───────────────────────────────────────┐
│               JES2                    │
│ Quem recebe e despacha o trabalho?    │
└──────────────────┬────────────────────┘
                   ↓
┌───────────────────────────────────────┐
│               CICS                    │
│ Como executar ações de negócio?       │
└──────────────────┬────────────────────┘
                   ↓
┌───────────────────────────────────────┐
│               Db2                     │
│ Como manter estado consistente?       │
└──────────────────┬────────────────────┘
                   ↓
┌───────────────────────────────────────┐
│                MQ                     │
│ Como componentes conversam?           │
└──────────────────┬────────────────────┘
                   ↓
┌───────────────────────────────────────┐
│               IMS                     │
│ Como organizar e navegar contexto?    │
└───────────────────────────────────────┘

Agora a série revela algo que talvez não estivesse completamente evidente quando escrevemos o primeiro artigo.

Não estamos mais discutindo simplesmente:

INTELIGÊNCIA ARTIFICIAL

Estamos discutindo:

SISTEMAS DE INTELIGÊNCIA ARTIFICIAL

Essa diferença é gigantesca.


🧩 CAPÍTULO 11 — O AGENTE DEIXOU DE SER O CENTRO

Durante algum tempo olhamos para IA assim:

PROMPT
  ↓
LLM
  ↓
RESPOSTA

Só que um sistema corporativo real começa a parecer muito mais com:

                    USUÁRIO
                       │
                       ↓
                   OBJETIVO
                       │
                       ↓
                 ORQUESTRADOR
                       │
        ┌──────────────┼──────────────┐
        ↓              ↓              ↓
     AGENTE A       AGENTE B       AGENTE C
        │              │              │
        └──────────────┼──────────────┘
                       ↓
                    TOOLS
        ┌──────────────┼──────────────┐
        ↓              ↓              ↓
       DB             MQ             API
        │
        ↓
      ESTADO

E ao redor disso precisamos:

IDENTIDADE
AUTORIZAÇÃO
OBSERVABILIDADE
AUDITORIA
PRIORIZAÇÃO
RECUPERAÇÃO
LIMITES
CHECKPOINTS
APROVAÇÕES
MENSAGERIA
TRANSAÇÕES

O LLM continua importante.

Mas ele passa a ser um componente da arquitetura.

Essa talvez seja a evolução mais importante de toda a série.


🧙 CAPÍTULO 12 — TURING FAZ A PERGUNTA ERRADA

Alan Turing olha para nosso jovem programador COBOL.

E pergunta:

— Então finalmente construímos uma máquina que pensa?

O programador olha para o CPD.

Olha para:

SDSF
WLM
JES2
CICS
DB2
MQ
IMS

Depois olha para o pequeno agente trabalhando no terminal.

E responde:

— Não sei.

Turing fica surpreso.

— Depois de tudo isso?

— Talvez a pergunta tenha mudado.

— Como assim?

O programador pega uma caneta.

E escreve no quadro:

CAN MACHINES THINK?

Risca.

Embaixo escreve:

CAN MACHINES WORK
SAFELY,
RELIABLY,
OBSERVABLY
AND
RESPONSIBLY?

Turing olha.

Sorri.


🦖 CAPÍTULO 13 — O MAINFRAME NÃO PREVIU A IA

E precisamos deixar uma coisa muito clara.

O mainframe não previu os LLMs.

JES2 não é ancestral tecnológico direto de agentes.

WLM não administra pensamentos.

CICS não executa raciocínio.

Db2 não possui consciência.

MQ não faz robôs fofinhos conversarem.

IMS não é cérebro artificial.

O valor da comparação está em outro lugar.

Durante décadas sistemas corporativos precisaram responder:

Quem pode executar?

O que pode executar?

Quando executará?

Com qual prioridade?

Sobre quais recursos?

Como sabemos que terminou?

O que acontece quando falha?

Como desfazemos mudanças?

Como componentes se comunicam?

Como reconstruímos o que aconteceu?

Essas perguntas reaparecem quando agentes deixam o laboratório e começam a operar sistemas reais.

Não copiamos a solução.

Reaproveitamos o conhecimento de engenharia.


🥚 EASTER EGG — O PROGRAMA QUE JÁ ESTAVA RODANDO

Turing caminha até o último terminal do CPD.

Na tela existe apenas:

READY

Ele digita:

WHO

A máquina responde:

TURING

Ele pergunta:

STATUS

Resposta:

ACTIVE

Turing sorri.

— Interessante.

O programador COBOL pergunta:

— O quê?

— Passamos nove capítulos tentando descobrir como controlar agentes inteligentes.

— Sim.

Turing aponta para o CPD.

— E vocês passaram cinquenta anos construindo sistemas para controlar humanos, programas, jobs, transações e mensagens.

Silêncio.

O operador do outro lado da sala grita:

— JOB ABENDOU!

Turing pergunta:

— S0C7?

— S0C7!

Turing pega seu café.

— Algumas coisas realmente nunca mudam.

😂


☕ EPÍLOGO — TALVEZ O FUTURO TENHA CHEIRO DE CPD

Existe uma tendência natural na tecnologia de acreditar que tudo começou ontem.

Cada nova geração cria novas palavras.

Novos frameworks.

Novos diagramas.

Novas abstrações.

E muitas delas realmente representam avanços extraordinários.

Mas engenharia também possui memória.

Quando vejo agentes de IA discutindo:

orchestration
observability
workload
state
messaging
transactions
authorization
checkpoints
recovery

é impossível para quem viveu mainframe não sentir um estranho déjà-vu.

Não porque sejam as mesmas tecnologias.

Não são.

Mas porque computadores continuam enfrentando alguns problemas fundamentais:

TRABALHO PRECISA SER ORGANIZADO.

RECURSOS SÃO FINITOS.

ESTADO PRECISA SER PROTEGIDO.

FALHAS ACONTECEM.

MENSAGENS SE PERDEM.

SISTEMAS FICAM INDISPONÍVEIS.

USUÁRIOS COMETEM ERROS.

PROGRAMAS COMETEM ERROS.

AUTOMAÇÃO AMPLIFICA ERROS.

E agora acrescentamos uma criatura nova:

AGENTES PODEM ESCOLHER A PRÓXIMA AÇÃO.

Isso muda muita coisa.

Mas não apaga setenta anos de engenharia de sistemas.

Talvez faça justamente o contrário.

Torne esse conhecimento ainda mais valioso.

Por isso esta série não é apenas sobre Alan Turing.

Não é apenas sobre mainframe.

E nem sequer é apenas sobre inteligência artificial.

É sobre algo muito mais antigo:

COMO CONSTRUÍMOS SISTEMAS NOS QUAIS PODEMOS CONFIAR?

Começamos ensinando pessoas.

Depois demos autonomia à máquina.

Criamos formas de observá-la.

Priorizamos seu trabalho.

Organizamos suas filas.

Controlamos suas transações.

Protegemos seu estado.

Permitimos que conversasse com outros sistemas.

Finalmente começamos a organizar sua memória.

E talvez este seja apenas o começo.

Porque no fundo do CPD existe uma porta.

Turing acabou de encontrá-la.

Na porta existe uma pequena placa:

AGENTS
AUTHORIZED PERSONNEL ONLY

Ele olha para nós.

— Vamos?

O programador COBOL suspira.

Salva tudo.

Confere o spool.

E responde:

— Só depois do café.

☕

Bellacosa Mainframe

☕ UM CAFÉ NO BELLACOSA MAINFRAME

🤖 Alan Turing entra no CPD

O mapa dos agentes de IA explicado por um mainframer

Esta série acompanha a evolução de uma ideia: compreender os problemas modernos dos agentes de inteligência artificial usando conceitos conhecidos por quem trabalha com mainframe, IBM Z e sistemas corporativos.

A viagem começa pelas pessoas e pela experiência de uso, passa por observabilidade, priorização e execução, chega às transações, estado e mensageria e termina na organização hierárquica do contexto.

01
FEV / 2023

🧠 O currículo invisível da inteligência artificial

Antes de construir agentes inteligentes precisamos preparar as pessoas que trabalharão com eles. Técnica, pensamento crítico, conhecimento de negócio, segurança, ética e responsabilidade formam o currículo que nem sempre aparece no certificado.

02
MAR / 2023

🤖 A UX dos agentes

Quando uma IA deixa de apenas responder e começa a executar ações, sua interface precisa mostrar objetivos, progresso, permissões e resultados. PF3, MAXCC e RACF tornam-se excelentes analogias para controle, retorno e privilégio mínimo.

04
MAI / 2023

⚖️ O WLM dos agentes

CPU, GPU, tokens, APIs e bancos de dados são recursos finitos. O Workload Manager inspira uma discussão sobre prioridades, objetivos de serviço, importância do trabalho e distribuição dinâmica de recursos entre agentes.

06
JUL / 2023

⚡ O CICS dos agentes

Uma coisa é uma IA produzir texto. Outra é permitir que ela execute operações reais de negócio. CICS introduz a conversa sobre processamento transacional, concorrência, segurança e integridade.

07
AGO / 2023

🗄️ O Db2 dos agentes

Agentes precisam manter estado, checkpoints, decisões e resultados. O Db2 fornece o ponto de partida para discutir unidade de trabalho, consistência, COMMIT, ROLLBACK e recuperação.

10
SET / 2026

☕ Alan Turing entra no CPD — O mapa completo

O artigo-âncora reúne toda a evolução da ideia: pessoas, UX, observabilidade, prioridade, orquestração, transações, estado, mensageria e contexto transformam artigos independentes em uma arquitetura conceitual para agentes de IA.

🖥️ Leitor da série

Selecione qualquer capítulo acima para abri-lo normalmente. O painel abaixo é apenas um recurso adicional de navegação.

quinta-feira, 10 de setembro de 2026

🎧 zBNA — A Conversação do Batch: Harry Caul e o Mistério do Critical Path

 

Bellacosa Mainframe apresenta o zBNA analise de processos batch

☕ Um Café no Bellacosa Mainframe

🎧 zBNA — A Conversação do Batch: Harry Caul e o Mistério do Critical Path

Sob a batuta de Harry Caul, de The Conversation: no mainframe, assim como numa gravação de vigilância, o problema raramente está simplesmente no sinal mais alto. Está naquilo que acontece entre os sinais — nas pausas, dependências, esperas e detalhes que ninguém percebeu.



Imagine uma sala silenciosa.

Na parede existem gráficos de CPU, relatórios de utilização, tempos de execução, estatísticas de I/O e algumas planilhas de capacity planning.

O batch deveria ter terminado às 03:00.

São 03:17.

Alguém olha para o gráfico e diz:

— Precisamos de um mainframe maior.

No fundo da sala, Harry Caul não responde.

Ele coloca os fones de ouvido.

Volta a fita.

Escuta novamente.

Porque Harry aprendeu uma coisa durante toda uma vida ouvindo conversas que outras pessoas não deveriam ouvir:

uma informação isolada pode dizer algo completamente diferente quando colocada no contexto correto.

E é exatamente esse o problema que encontramos quando tentamos fazer sizing de um ambiente IBM Z olhando somente para capacidade de processador.

Bem-vindo à investigação.



🎧 1. Harry Caul não começaria olhando o processador

Para quem nunca assistiu a The Conversation, Harry Caul é um especialista em vigilância e gravação de áudio.

Seu trabalho não consiste simplesmente em gravar sons.

Ele precisa separar ruído de informação.

Uma conversa aparentemente banal pode esconder algo importante.

Uma frase pode assumir outro significado quando escutada novamente.

No nosso datacenter acontece algo parecido.

Temos:

CPU utilization
MSU
MIPS
Elapsed Time
CPU Time
I/O
Wait
ENQ
Db2
VSAM
JES2
WLM
Scheduler

Tudo está falando ao mesmo tempo.

O erro seria escolher o gráfico mais chamativo e concluir:

CPU alta
   ↓
Falta capacidade
   ↓
Comprar processador

Pode ser verdade.

Mas ainda não sabemos.

Harry Caul provavelmente perguntaria:

“O que aconteceu antes disso?”


 

Essa pergunta nos leva ao IBM Z Batch Network Analyzer — zBNA.



🕸️ 2. O batch é uma conversa entre JOBs

Para um programador COBOL iniciante, uma sequência batch pode parecer algo relativamente simples.

Temos JOBs:

JOB001
JOB002
JOB003
JOB004
JOB005

Parece uma lista.

Mas operacionalmente eles podem estar relacionados:

             +--> JOB B --+
             |            |
JOB A -------+            +--> JOB D --> JOB E --> FIM
             |            |
             +--> JOB C --+

Agora a história mudou.

JOB B e JOB C dependem de A.

JOB D depende de alguma condição relacionada aos anteriores.

JOB E depende de D.

Portanto, não estamos mais observando apenas programas.

Estamos observando uma rede de dependências.

É quase uma conversação:

JOB A: terminei.

JOB B: agora posso começar.
JOB C: eu também.

JOB C: terminei.

JOB D: ainda não.

JOB B: terminei.

JOB D: agora sim.

JOB D: processando...
JOB D: processando...
JOB D: processando...

JOB E: esperando...

Harry Caul imediatamente prestaria atenção naquele silêncio.

Por que JOB E está esperando?


⏱️ 3. O silêncio também faz parte da gravação

Esse é um conceito fundamental para quem começa a estudar performance.

Um programa pode estar demorando sem estar usando CPU.

Considere:

Elapsed Time = 42 minutos
CPU Time     = 11 minutos

Onde estão os outros 31 minutos?

Essa é uma pergunta maravilhosa.

Porque começamos a procurar:

I/O WAIT
LOCK
ENQ
DATASET CONTENTION
DB2 LOCKING
QUEUE
SCHEDULING
RESOURCE WAIT
NETWORK
APPLICATION SERIALIZATION

Imagine nossa investigação encontrando:

Elapsed Time     42 min
├── CPU           11 min
├── I/O            17 min
├── Lock/ENQ        8 min
└── Outros waits    6 min

Agora tente resolver isso simplesmente colocando mais processador.

Talvez os 11 minutos de CPU melhorem.

Mas e os outros?

Essa é a primeira grande lição:

Elapsed Time não é simplesmente CPU Time usando outro relógio.


🐉 4. Encontramos JOB D

Voltemos à cadeia:

JOB A = 12 min

       +-- JOB B = 18 min --+
       |                    |
       +-- JOB C =  7 min --+
                            |
                         JOB D = 42 min
                            |
                         JOB E = 9 min

B e C podem executar simultaneamente.

Portanto não podemos simplesmente fazer:

12 + 18 + 7 + 42 + 9

Precisamos considerar a dependência.

Nesse exemplo simplificado:

12 + MAX(18,7) + 42 + 9

Temos:

12 + 18 + 42 + 9 = 81 minutos

E observe JOB D:

42 / 81 ≈ 52%

Ele ocupa mais da metade do caminho.

Harry Caul colocaria os fones novamente.

Por que exatamente são 42 minutos?

Essa pergunta vale potencialmente muito dinheiro.


🛣️ 5. Critical Path — quem realmente possui o relógio?

Chegamos ao conceito central:

Critical Path.

Imagine uma rede maior:

                 JOB B --------+
                /               \
JOB A ----------                 +---- JOB F ----+
                \               /                |
                 JOB C --> JOB D                 +--> JOB H
                                                /
                 JOB E -------------------------+

Podemos possuir diferentes caminhos:

A → B → F → H

A → C → D → F → H

E → H

Um deles determinará quando todo o processo poderá terminar.

Esse é nosso caminho crítico.

E aqui surge uma descoberta extremamente importante:

O JOB que mais consome CPU não precisa ser o JOB mais importante para reduzir a janela batch.

Suponha que JOB X consuma enorme quantidade de CPU.

Todo mundo olha para ele.

JOB X
CPU TIME = █████████████████████

Parece culpado.

Mas JOB X possui bastante folga e está fora do critical path.

Você consegue uma otimização fantástica:

JOB X
-30% elapsed

Resultado sobre o fechamento:

0 minutos

Nada.

O batch termina exatamente no mesmo horário.

Enquanto isso, um JOB pequeno pertencente ao critical path perde cinco minutos esperando determinado recurso.

Eliminar aquela espera poderia antecipar o fechamento em aproximadamente cinco minutos.

Harry Caul diria:

vocês estavam ouvindo a pessoa errada.


💻 6. Programador COBOL: não condene o programa imediatamente

Encontramos JOB D.

A primeira reação pode ser:

— COBOL velho!

Calma.

Talvez o programa esteja perfeitamente correto.

Imagine:

PERFORM PROCESSA-REGISTRO
   UNTIL EOF.

O programa está executando adequadamente.

Mas cada ciclo depende de acesso a um recurso.

Pode existir:

COBOL
  ↓
VSAM
  ↓
Dataset
  ↓
ENQ
  ↓
WAIT

Ou:

COBOL
  ↓
SQL
  ↓
Db2
  ↓
LOCK
  ↓
WAIT

Ou ainda:

JOB
 ↓
Scheduler
 ↓
Dependency
 ↓
WAIT

Nenhuma quantidade de indignação contra o COBOL resolverá automaticamente isso.

E talvez nenhuma quantidade adicional de CPU resolva.

Precisamos encontrar a causa.


⚙️ 7. Capacity não é a mesma coisa que velocidade

Aqui encontramos outra armadilha.

Imagine dois sistemas hipotéticos:

SYSTEM A
10 engines × velocidade X

SYSTEM B
6 engines × velocidade Y

Mesmo que determinada medida agregada de capacidade pareça semelhante, o comportamento do workload pode ser diferente.

Por quê?

Imagine trabalho altamente paralelo:

JOB1 ──┐
JOB2 ──┤
JOB3 ──┼──> resultado
JOB4 ──┤
JOB5 ──┘

Vários engines podem ser aproveitados.

Agora imagine:

JOB1
  ↓
JOB2
  ↓
JOB3
  ↓
JOB4

Colocar dezenas de engines disponíveis ao lado dessa sequência não faz os JOBs executarem simultaneamente por mágica.

Temos então que distinguir:

aggregate capacity

de

per-engine performance

e ambos de:

usable parallelism.


🧵 8. Usable parallelism — dez microfones não criam dez conversas

Harry Caul poderia instalar dez microfones.

Mas se existe apenas uma pessoa falando, continuamos tendo uma conversa.

No mainframe podemos possuir:

10 engines disponíveis

enquanto o workload oferece:

1 unidade relevante de trabalho executável

Visualmente:

CPU0 ████████████
CPU1 ░░░░░░░░░░░░
CPU2 ░░░░░░░░░░░░
CPU3 ░░░░░░░░░░░░
CPU4 ░░░░░░░░░░░░

Adicionar CPU5, CPU6 e CPU7 não necessariamente ajudará.

Talvez precisemos investigar:

  • dependências;

  • scheduler;

  • initiators;

  • particionamento;

  • desenho dos JOBs;

  • datasets;

  • banco;

  • I/O;

  • serialização da aplicação.

Esse é o significado prático de usable parallelism.

Não importa somente quanta capacidade existe.

Importa quanto daquele paralelismo o workload consegue realmente consumir.


🏭 9. JES2, WLM e scheduler entram na sala

Agora nossa investigação fica mais interessante.

Eu dividiria o problema em quatro níveis:

BUSINESS PROCESS
       ↓
BATCH NETWORK
       ↓
z/OS RESOURCE BEHAVIOR
       ↓
PROCESSOR

No terceiro andar dessa investigação encontramos:

JES2
WLM
Initiators
Scheduler
I/O
Db2
VSAM
ENQ
Storage
Memory
Network

Imagine comprarmos um IBM Z muito mais poderoso.

Temos:

PROCESSOR
████████████████████████

JOB
██████

WAIT
████████████████████████████████

O processador está disponível.

O JOB não está trabalhando.

Harry Caul aumenta o volume.

Nada.

Porque o problema não está onde todos estavam olhando.


🎧 10. CPU a 95%: culpada!

Não tão rápido.

Encontramos:

CPU = 95%

Parece assustador.

Mas existe trabalho útil sendo processado?

O SLA está sendo atendido?

Existe fila significativa esperando CPU?

A utilização é sustentada ou apenas um pico?

O comportamento está dentro do esperado?

Então 95% isoladamente não constitui diagnóstico.

Agora encontramos:

CPU = 40%

Maravilha!

Temos sobra.

Talvez.

Ou talvez metade do workload esteja esperando recursos.

Portanto:

CPU HIGH ≠ automaticamente ruim

CPU LOW ≠ automaticamente bom

Um gráfico é uma pista.

Não é uma sentença.


🕵️ 11. War Room Mainframe sob a batuta de Harry Caul

Agora apagamos as luzes.

Colocamos JOB D no centro da tela.

Pergunta número um:

Por que exatamente são 42 minutos?

Não:

Quanto CPU ele usa?

Ainda não.

Primeiro:

42 MINUTOS
    |
    +-- CPU?
    |
    +-- I/O?
    |
    +-- ENQ?
    |
    +-- Db2 lock?
    |
    +-- VSAM?
    |
    +-- Queue?
    |
    +-- Scheduler?
    |
    +-- Dependency?
    |
    +-- Application serialization?

Então começamos a correlacionar evidências.

Esse é o ponto em que capacity planning deixa de ser comparação de catálogo e começa a se aproximar de investigação.


🔄 12. Harry Caul volta a fita

Encontramos o gargalo.

PATH A:

81 minutos

PATH B:

75 minutos

Otimizamos PATH A:

81 → 70

Excelente!

Acabou?

Não.

Agora temos:

PATH A = 70
PATH B = 75

PATH B tornou-se o novo critical path.

O gargalo mudou de endereço.

Esse comportamento ensina uma das coisas mais importantes sobre performance:

MEASURE
   ↓
ANALYZE
   ↓
FIND CRITICAL PATH
   ↓
OPTIMIZE
   ↓
MEASURE AGAIN
   ↓
RECALCULATE
   ↺

Harry Caul volta a gravação porque uma segunda audição pode revelar algo que a primeira interpretação escondeu.

Nós fazemos a mesma coisa.

Depois de modificar o workload, medimos novamente.


💰 13. Performance também conversa com dinheiro

Existe outro microfone naquela sala.

Custo.

Sizing não deveria ser simplesmente:

Qual máquina é mais rápida?

Precisamos equilibrar:

PERFORMANCE
     +
CAPACITY
     +
SLA
     +
SOFTWARE COST
     +
OPERATIONAL RISK
     +
GROWTH

Porque uma solução tecnicamente elegante pode não ser economicamente interessante.

Da mesma maneira, economizar dinheiro sacrificando um SLA crítico pode custar muito mais ao negócio.

Sizing é um problema de engenharia.

Mas também é um problema de negócio.


🎯 14. Antes do zBNA existe uma pergunta zero

Eu acrescentaria uma etapa antes de qualquer análise:

Qual é o SLA?

Imagine que o fechamento termina às 04:30.

Caso A:

SLA = 06:00
Fim = 04:30

Temos determinada situação.

Caso B:

SLA = 03:00
Fim = 04:30

Agora temos um incidente.

Os mesmos JOBs.

A mesma CPU.

O mesmo hardware.

O mesmo elapsed.

Contextos de negócio completamente diferentes.

Performance sem objetivo é apenas uma coleção muito bonita de gráficos.


🧠 15. As seis perguntas de Harry Caul

Se eu estivesse ensinando isso para um programador COBOL iniciante, colocaria seis perguntas ao lado do terminal:

1. Quando o negócio precisa terminar?

SLA.

2. O que precisa acontecer para ele terminar?

Batch Network.

3. Qual sequência determina esse horário?

Critical Path.

4. Por que os componentes críticos estão demorando?

CPU, I/O, locks, ENQ, Db2, VSAM, scheduling, dependências.

5. O workload consegue utilizar capacidade adicional?

Usable Parallelism.

6. Qual alteração entrega maior benefício considerando custo e risco?

Sizing.

Somente então colocamos os candidatos a processador sobre a mesa.


☕ 16. A tradução para quem está começando no COBOL

Você escreveu:

PERFORM PROCESSO-A
PERFORM PROCESSO-B
PERFORM PROCESSO-C
PERFORM PROCESSO-D

Alguém aparece oferecendo um computador duas vezes mais rápido.

Parece razoável imaginar:

2 × PERFORMANCE
       =
1/2 ELAPSED TIME

Mas descobrimos:

PROCESSO-A → CPU

PROCESSO-B → espera arquivo

PROCESSO-C → espera outro JOB

PROCESSO-D → espera lock Db2

Ops.

Nosso computador duas vezes mais rápido não pode acelerar magicamente aquilo que não está usando processador.

Quando ampliamos isso para centenas ou milhares de JOBs, datasets, bancos, schedulers, dependências e recursos compartilhados, começamos a compreender por que precisamos enxergar o workload como sistema.

É aí que o zBNA se torna particularmente interessante.


🥚 Easter Egg — 03:17

O processamento deveria terminar às 03:00.

Harry está sentado no fundo da War Room.

03:00

Nada.

03:05

Nada.

03:11

Os gerentes começam a olhar para o dashboard.

03:16

Alguém diz:

— Precisamos de mais CPU.

Harry coloca os fones.

03:17

Ele volta alguns minutos da gravação operacional.

Na tela:

JOB D
STATUS: WAIT

CPU?

AVAILABLE

Ele continua seguindo a cadeia.

Predecessor.

Dataset.

ENQ.

Wait.

Silêncio.

Harry tira lentamente os fones.

Não faltava processador.

Faltava ouvir a conversa inteira.


🏁 Conclusão — o mainframe também deixa pistas

O ensinamento mais importante do zBNA não é simplesmente aprender a utilizar outra ferramenta.

É aprender a fazer uma pergunta melhor.

Um problema de performance não significa automaticamente:

NEED MORE CAPACITY

A janela batch é resultado de uma combinação muito mais interessante:

BATCH WINDOW
     =
CPU
+
DEPENDENCIES
+
SERIALIZATION
+
PARALLELISM
+
I/O
+
CONTENTION
+
SCHEDULING
+
RESOURCE AVAILABILITY
+
APPLICATION BEHAVIOR

O processador está dentro dessa equação.

Às vezes ele será justamente o gargalo e aumentar capacidade será a decisão correta.

Mas precisamos demonstrar isso.

Harry Caul não condenaria alguém porque uma palavra pareceu suspeita na primeira reprodução.

Ele limparia o ruído.

Voltaria a fita.

Compararia os sinais.

Procuraria o contexto.

No capacity planning deveríamos ter a mesma disciplina.

Antes de perguntar:

“Qual IBM Z devemos comprar?”

pergunte:

“Quem está segurando o batch?”

Depois encontre o critical path.

Descubra quanto do elapsed realmente depende de CPU.

Investigue I/O, locks, datasets, scheduler, JES2, WLM, Db2, VSAM, ENQ e dependências.

Descubra quanto paralelismo é realmente utilizável.

Meça.

Simule.

Altere.

Meça novamente.

E somente depois faça sizing.

Porque existe uma diferença enorme entre possuir uma gravação e compreender a conversa.

Da mesma maneira, existe uma diferença enorme entre possuir métricas e compreender o workload.

🎧 Não faça sizing do mainframe antes de fazer sizing do problema.

O processador pode fornecer a potência.

Mas é o critical path que possui o relógio.

E, às 03:17, quando todos estiverem olhando para a CPU, talvez o verdadeiro gargalo esteja silenciosamente esperando em algum lugar da conversação.

sexta-feira, 27 de fevereiro de 2026

O Caso dos MIPS que Cresceram Três Vezes Mais Rápido : Quando Dick Tracy entra no CPD para investigar o assassinato do COBOL

 

Bellacosa Mainframe e o caso do mips comilao

☕ Um Café no Bellacosa Mainframe

O Caso dos MIPS que Cresceram Três Vezes Mais Rápido

Quando Dick Tracy entra no CPD para investigar o assassinato do COBOL — e descobre que a vítima continua processando milhões de transações

A madrugada havia engolido a cidade.

Do lado de fora, a chuva desenhava linhas tortas nas janelas do edifício. Do lado de dentro, no vigésimo andar de um banco que jamais dormia, milhares de transações atravessavam silenciosamente um IBM Z.

Cartões eram autorizados.

Pagamentos eram compensados.

Contas eram atualizadas.

Fraudes eram avaliadas.

Arquivos eram classificados.

Jobs eram executados.

E, em uma sala iluminada apenas pelo brilho verde de um terminal 3270, um programador COBOL iniciante observava uma mensagem inquietante no monitor:

A INTELIGÊNCIA ARTIFICIAL VAI MATAR O COBOL.

Ele afastou as mãos do teclado.

Naquele instante, a porta se abriu.

Entrou um homem de sobretudo amarelo, chapéu inclinado sobre os olhos e um estranho relógio-comunicador preso ao pulso.

— Meu nome não importa — disse o detetive. — O que importa é descobrir quem inventou essa história.

Sobre a mesa havia três objetos:

  1. uma queda de 13% nas ações da IBM;

  2. uma ferramenta chamada watsonx Code Assistant for Z;

  3. uma declaração afirmando que clientes usuários da ferramenta estavam aumentando sua capacidade em MIPS três vezes mais rapidamente.

Parecia um caso simples.

Mas, no mainframe, como em toda boa investigação, o primeiro suspeito raramente é o verdadeiro culpado.


Capítulo 1 — A manchete que assustou Wall Street

Em fevereiro de 2026, a Anthropic anunciou recursos de inteligência artificial voltados à compreensão e modernização de sistemas escritos em COBOL. A reação do mercado foi imediata: as ações da IBM caíram aproximadamente 13,2% em um único pregão.

A interpretação de muitos investidores foi direta:

IA compreende COBOL
        ↓
IA converte COBOL
        ↓
Empresas abandonam o mainframe
        ↓
IBM perde clientes
        ↓
Fim do IBM Z

A Reuters registrou que a queda ocorreu após o mercado interpretar o anúncio como uma possível ameaça ao negócio de modernização de aplicações legadas e ao ecossistema de mainframe da IBM. (Reuters)

Para quem observa o mainframe apenas de fora, o raciocínio parece razoável.

Existem milhões de programas COBOL em bancos, seguradoras, governos, indústrias, empresas de telecomunicações e companhias aéreas. Se uma inteligência artificial puder converter tudo isso para Java, Python ou outra linguagem, então bastaria apertar um botão, esperar algumas horas e desligar o mainframe.

Caso encerrado.

O detetive, porém, olhou para a manchete e comentou:

— Rápido demais. Quando alguém apresenta uma migração corporativa como se fosse um MOVE, procure as provas que desapareceram.

Porque transformar um sistema corporativo não é isto:

MOVE PROGRAMA-COBOL TO PROGRAMA-JAVA.

A sintaxe pode ser convertida.

O significado do negócio, não necessariamente.


Capítulo 2 — O COBOL não trabalha sozinho

Um programador iniciante pode imaginar que uma aplicação COBOL seja apenas um arquivo-fonte contendo algumas centenas de linhas.

Em um exercício de treinamento, talvez seja assim:

       IDENTIFICATION DIVISION.
       PROGRAM-ID. CALCULA-SALDO.

       DATA DIVISION.
       WORKING-STORAGE SECTION.

       01 WS-SALDO        PIC S9(9)V99 COMP-3.
       01 WS-CREDITO      PIC S9(9)V99 COMP-3.
       01 WS-DEBITO       PIC S9(9)V99 COMP-3.

       PROCEDURE DIVISION.

           COMPUTE WS-SALDO =
                   WS-CREDITO - WS-DEBITO

           DISPLAY 'SALDO: ' WS-SALDO

           GOBACK.

Entretanto, uma aplicação real pode envolver:

Programa COBOL
   │
   ├── COPYBOOKS
   ├── arquivos sequenciais
   ├── VSAM
   ├── tabelas Db2
   ├── transações CICS
   ├── mensagens IBM MQ
   ├── chamadas IMS
   ├── serviços REST
   ├── programas Assembler
   ├── rotinas PL/I
   ├── JCL
   ├── PROCs catalogadas
   ├── Control-M, IWS ou outro scheduler
   ├── regras RACF
   └── procedimentos operacionais

O programa não vive isolado.

Ele pertence a uma teia operacional.

Considere um simples campo:

01 WS-TIPO-CLIENTE PIC X(01).

Uma ferramenta automática pode reconhecer que se trata de um caractere.

Mas o que significa A?

Pode significar:

  • cliente ativo;

  • cliente antigo;

  • cliente especial;

  • conta de alto risco;

  • agência;

  • pessoa autorizada;

  • produto categoria A.

E o valor B?

Talvez não exista em nenhum manual. Pode ter sido criado em 1997 para atender uma resolução temporária que, por alguma razão, tornou-se permanente.

É aí que começa o verdadeiro mistério.

Código não é apenas código. Código corporativo é história empresarial executável.


Capítulo 3 — O cadáver que nunca apareceu

O mercado procurava o corpo do COBOL.

Não encontrou.

Cinco meses depois da queda provocada pelo temor de que a IA aceleraria a saída do mainframe, a própria IBM voltou a mencionar um dado curioso: clientes que implantaram o watsonx Code Assistant for Z estariam aumentando sua capacidade em MIPS três vezes mais rapidamente do que clientes que não o utilizavam.

A afirmação apareceu nos comentários financeiros da IBM já no primeiro trimestre de 2026 e foi repetida posteriormente. Nos comentários preparados do primeiro trimestre, a empresa declarou que os clientes que haviam implantado a solução apresentavam crescimento de capacidade três vezes superior. (IBM)

O mesmo indicador foi novamente citado na conferência de resultados de julho de 2026, associado à expansão de cargas, modernização e adoção de inteligência artificial no IBM Z. (Roic AI)

O detetive colocou duas fotografias sobre a mesa.

Na primeira:

FEVEREIRO DE 2026

IA PARA COBOL
       ↓
MERCADO IMAGINA MIGRAÇÃO
       ↓
AÇÃO DA IBM CAI

Na segunda:

MESES DEPOIS

IA PARA COBOL
       ↓
APLICAÇÕES SE TORNAM MAIS FÁCEIS DE EVOLUIR
       ↓
NOVOS PROJETOS ENTRAM EM PRODUÇÃO
       ↓
CAPACIDADE CRESCE

— Temos uma contradição — disse o programador.

— Não — respondeu o detetive. — Temos uma hipótese errada.

A inteligência artificial pode ajudar uma empresa a migrar partes de uma aplicação. Mas também pode tornar o ambiente existente mais compreensível, produtivo e modernizável.

Nesse segundo cenário, a IA não esvazia o mainframe.

Ela o destrava.


Capítulo 4 — O que são MIPS?

Antes de prosseguir, precisamos examinar uma das principais pistas.

MIPS significa:

Millions of Instructions Per Second
Milhões de instruções por segundo.

Historicamente, o termo foi usado como uma forma de representar a capacidade de processamento de um computador. No universo mainframe, ele também se tornou uma maneira informal de falar sobre o tamanho da capacidade instalada ou consumida.

Entretanto, para um profissional iniciante, é importante não transformar MIPS em uma medida mágica.

MIPS não responde sozinho a perguntas como:

  • o sistema está eficiente?

  • o programa está bem escrito?

  • o custo está controlado?

  • o tempo de resposta está adequado?

  • a carga está sendo executada no processador correto?

  • o crescimento corresponde a novas receitas?

  • houve aumento de desperdício?

No licenciamento e no gerenciamento de capacidade do IBM Z também aparecem conceitos como:

  • MSU;

  • R4HA;

  • rolling four-hour average;

  • capacidade contratada;

  • subcapacity;

  • Tailored Fit Pricing;

  • zIIP eligibility;

  • consumo por workload;

  • métricas de WLM e SMF.

Portanto, quando a IBM afirma que determinado grupo está crescendo capacidade em MIPS três vezes mais rapidamente, a leitura correta não é:

“A IA deixou o processador três vezes mais veloz.”

A leitura mais razoável é:

“As organizações que usam a ferramenta estão adicionando ou consumindo capacidade em ritmo significativamente maior.”

A IA não colocou nitroglicerina na CPU.

Ela pode ter acelerado o ciclo de desenvolvimento, análise e modernização.


Capítulo 5 — Correlação não é confissão

Todo bom detetive precisa desconfiar das evidências fáceis.

A declaração dos três vezes mais MIPS vem da IBM, fabricante tanto do mainframe quanto da ferramenta de inteligência artificial. Portanto, deve ser tratada como um indicador comercial relevante, não como uma prova científica independente.

Existem várias explicações possíveis.

Hipótese A — A ferramenta provoca crescimento

O watsonx Code Assistant for Z reduz o esforço de compreensão e modernização. Com isso, mais projetos são concluídos e mais cargas entram em produção.

Hipótese B — Empresas que já cresciam compraram a ferramenta

Organizações que adotam soluções avançadas de IA talvez já estivessem ampliando seus ambientes, aumentando transações e modernizando aplicações.

Nesse caso, o crescimento não teria sido causado exclusivamente pela ferramenta.

Hipótese C — Os dois fatores trabalham juntos

Clientes em expansão adotam a IA; a IA aumenta a produtividade; a produtividade permite ainda mais expansão.

Provavelmente, a realidade contém uma combinação dessas hipóteses.

A estatística é interessante, mas não demonstra sozinha causalidade. Ela não nos informa, por exemplo:

  • quantos clientes foram analisados;

  • qual foi o período exato;

  • quais setores estavam representados;

  • quanto do crescimento veio de novas aplicações;

  • quanto veio de crescimento orgânico;

  • quanto foi capacidade geral ou consumo específico;

  • como os clientes foram comparados.

Por isso, não devemos transformar o “3x” em religião.

Mas também não devemos ignorá-lo.

Em uma investigação, uma pegada não condena o suspeito. Porém, mostra onde ele esteve.


Capítulo 6 — O que o watsonx Code Assistant for Z realmente faz?

Aqui está uma das maiores confusões sobre IA e COBOL.

Muita gente imagina que a ferramenta possua apenas uma função:

COBOL → Java

Na realidade, a proposta é muito mais ampla.

A IBM descreve o watsonx Code Assistant for Z como uma solução que apoia diferentes fases do ciclo de vida: descoberta e análise de aplicações, explicação de código, refatoração, geração, otimização, transformação para linguagens mais novas e testes. (IBM)

Entre suas possibilidades estão:

1. Descoberta da aplicação

Antes de modernizar, é necessário saber o que existe.

A ferramenta pode ajudar a identificar:

  • programas;

  • chamadas;

  • COPYBOOKS;

  • arquivos;

  • tabelas;

  • jobs;

  • transações;

  • dependências;

  • fluxos de dados.

É o equivalente digital a espalhar fotografias, endereços e linhas vermelhas sobre a parede da delegacia.

PGM-A
  │
  ├── CALL PGM-B
  │      └── DB2.TBCLIENTE
  │
  ├── READ ARQVSAM
  │
  └── CALL PGM-C
         └── MQ.PUT

Sem esse mapa, uma alteração aparentemente pequena pode atingir dezenas de componentes.

2. Explicação de código

O desenvolvedor pode pedir uma explicação de determinada rotina ou fluxo.

Isso é particularmente útil quando encontramos algo assim:

       IF WS-COD-OPERACAO = '17'
          AND WS-TIPO-CONTA NOT = '9'
          AND WS-FLAG-ESP = 'S'
              PERFORM 4300-TRATA-LIMITE
       ELSE
              PERFORM 4500-TRATA-EXCECAO
       END-IF.

A IA pode resumir a lógica:

Quando a operação for do tipo 17, a conta não pertencer à categoria 9 e estiver marcada como especial, o programa processa o limite; caso contrário, executa o tratamento de exceção.

Isso ajuda.

Mas ainda precisamos perguntar:

  • O que é operação 17?

  • Por que a conta 9 foi excluída?

  • Quem define o indicador especial?

  • Essa regra continua válida?

  • Existe uma exigência regulatória?

  • O comportamento está coberto por testes?

A IA explica o que está escrito.

O especialista descobre o que aquilo significa para a empresa.

3. Descoberta de regras de negócio

A interface Z Understand foi criada para ajudar arquitetos e desenvolvedores a analisar aplicações e descobrir regras de negócio usando uma abordagem conversacional. (IBM)

Essa capacidade pode revelar que uma regra importante está espalhada entre:

3 programas COBOL
2 COPYBOOKS
1 tabela Db2
1 parâmetro em arquivo
1 passo de JCL

É muito comum que a regra real não esteja concentrada em um único lugar.

4. Documentação

Sistemas antigos nem sempre possuem documentação atualizada.

Na verdade, existe uma piada clássica no CPD:

“A documentação está perfeita. Só não corresponde mais ao programa.”

A IA pode auxiliar na produção de:

  • resumo funcional;

  • descrição técnica;

  • fluxo de execução;

  • inventário de componentes;

  • explicação de parágrafos;

  • documentação de interfaces;

  • identificação de entradas e saídas.

Em um caso divulgado pela IBM, a NOSI utilizou o produto para obter visibilidade sobre código e integrações não documentadas e automatizar parte da documentação. A IBM afirma que houve redução de 94% no tempo necessário para analisar código COBOL considerado supérfluo naquele contexto específico. É um estudo de caso do fornecedor, portanto deve ser interpretado dentro dessas condições. (IBM)

5. Refatoração

Refatorar não significa necessariamente trocar de linguagem.

Pode significar:

  • dividir um programa gigantesco;

  • isolar uma regra de negócio;

  • reduzir duplicações;

  • remover código morto;

  • separar acesso a dados;

  • transformar uma função em serviço;

  • melhorar nomes;

  • facilitar testes;

  • preparar uma API.

Imagine um programa de 40 mil linhas chamado:

PGM0001

Ele calcula tarifas, consulta clientes, atualiza contas, gera relatórios e talvez prepare café.

A modernização pode começar separando responsabilidades:

PGM0001
   │
   ├── SERVICO-CLIENTE
   ├── SERVICO-TARIFA
   ├── SERVICO-LIMITE
   └── SERVICO-AUDITORIA

O programa continua em COBOL, mas torna-se mais modular.

6. Transformação seletiva

Em alguns casos, uma parte da aplicação pode ser transformada em Java ou outra tecnologia. A própria IBM apresenta a transformação como seletiva e incremental, não como uma conversão automática indiscriminada de todo o ambiente. (IBM Mediacenter)

Essa diferença é crucial.

Modernização séria não pergunta:

“Como removemos todo o COBOL?”

Ela pergunta:

“Qual componente deve permanecer, qual deve ser refatorado, qual deve ser exposto por API e qual realmente precisa ser substituído?”


Capítulo 7 — O teste é a testemunha principal

Suponha que a IA converta o seguinte cálculo:

COMPUTE WS-JUROS ROUNDED =
        WS-SALDO * WS-TAXA / 100.

A versão gerada em Java pode parecer correta.

Mas precisamos investigar:

  • o COBOL utiliza decimal empacotado?

  • qual é a precisão?

  • onde ocorre o arredondamento?

  • existe truncamento intermediário?

  • o sinal está preservado?

  • quais valores máximos são permitidos?

  • existe ON SIZE ERROR?

  • o Java está usando double ou BigDecimal?

  • como os valores nulos são tratados?

  • existe diferença na representação da data?

  • como ocorre o commit?

Uma tradução sintaticamente bonita pode produzir resultados financeiramente errados.

COBOL: R$ 1.245,37
JAVA:  R$ 1.245,36

Um centavo parece pouco.

Multiplique por dez milhões de operações.

Agora temos uma ocorrência para a divisão de crimes financeiros.

Pesquisas sobre transformação automática de COBOL mostram que a validação da equivalência funcional continua sendo um dos pontos mais difíceis. Um trabalho publicado por pesquisadores ligados ao desenvolvimento de testes para o watsonx Code Assistant for Z observa que código transformado por modelos de linguagem não deve ser considerado correto sem validação, tornando necessários testes de equivalência entre o COBOL original e o código gerado. (arXiv)

Outro relato anterior de migração real de COBOL para Java também identificou os testes como uma das partes mais problemáticas do projeto, além da transferência do conhecimento do domínio. (arXiv)

Essa é a pista decisiva:

Converter código é uma atividade. Demonstrar que o negócio continua correto é outra completamente diferente.


Capítulo 8 — Como a IA pode aumentar os MIPS?

Agora conseguimos reconstruir o crime.

Imagine um banco com 120 solicitações de modernização.

Sem assistência de IA, cada equipe gasta grande parte do tempo tentando localizar componentes, interpretar código e mapear impactos.

120 solicitações
      ↓
análise lenta
      ↓
fila crescente
      ↓
poucas entregas
      ↓
aplicação congelada

Com ferramentas de descoberta, explicação e documentação:

120 solicitações
      ↓
análise mais rápida
      ↓
melhor compreensão
      ↓
mais testes preparados
      ↓
mais entregas
      ↓
mais serviços em produção

Essas entregas podem gerar:

  • novas transações CICS;

  • consultas adicionais ao Db2;

  • mensagens MQ;

  • chamadas de APIs;

  • processamento antifraude;

  • integração com aplicativos móveis;

  • novos lotes noturnos;

  • uso de IA próximo aos dados;

  • novos produtos bancários;

  • expansão da base de clientes.

O consumo de capacidade cresce não porque a IA tornou um ADD mais pesado, mas porque a organização conseguiu colocar mais funcionalidades em operação.

A equação é esta:

MAIOR COMPREENSÃO DO LEGADO
             +
MENOR TEMPO DE MODERNIZAÇÃO
             +
MAIOR VELOCIDADE DE ENTREGA
             =
MAIS CARGAS EXECUTADAS

O aumento de MIPS pode ser consequência de crescimento do negócio, modernização bem-sucedida ou novas cargas.

Isso não significa necessariamente desperdício.

Também não significa automaticamente economia.

Significa que o ambiente está evoluindo.


Capítulo 9 — Um roteiro prático para o programador COBOL iniciante

O detetive abriu o caderno.

— Chega de teoria. Vamos ao procedimento operacional.

Passo 1 — Aprenda COBOL antes de delegá-lo à IA

Não use a inteligência artificial como substituta dos fundamentos.

Você precisa compreender:

  • divisões do programa;

  • níveis de dados;

  • cláusula PIC;

  • USAGE;

  • COMP, COMP-3 e binários;

  • MOVE;

  • COMPUTE;

  • IF;

  • EVALUATE;

  • PERFORM;

  • tabelas;

  • arquivos;

  • tratamento de erros;

  • chamadas;

  • SQL embutido;

  • conceitos de CICS.

Sem conhecimento básico, você não consegue avaliar a resposta recebida.

A IA pode afirmar algo incorreto com aparência impecável.

Passo 2 — Peça explicações pequenas

Em vez de entregar um programa inteiro com 30 mil linhas, selecione uma rotina.

Exemplo:

Explique o objetivo deste parágrafo COBOL.
Identifique entradas, saídas, condições e possíveis erros.
Não invente o significado comercial dos códigos.

Essa última frase é importante.

A ferramenta deve separar:

  • o que pode observar;

  • o que está inferindo;

  • o que não sabe.

Passo 3 — Confirme no código

Se a IA disser que um campo recebe dados de uma tabela Db2, procure:

EXEC SQL
   SELECT ...
END-EXEC

Se afirmar que um programa é chamado, procure:

CALL 'PROGRAMA'

ou uma chamada dinâmica:

CALL WS-NOME-PROGRAMA

A resposta da IA é uma pista.

O código é a cena do crime.

Passo 4 — Consulte especialistas

Converse com:

  • analista de negócios;

  • programador experiente;

  • DBA;

  • administrador CICS;

  • equipe de produção;

  • segurança;

  • operação;

  • suporte;

  • usuário-chave.

Um operador pode saber que determinado job não deve executar antes das 2 horas porque depende de um arquivo externo que chega por transmissão.

Essa regra talvez não esteja no COBOL.

Passo 5 — Gere documentação revisável

Produza um documento contendo:

Nome do programa
Objetivo
Entradas
Saídas
Arquivos
Tabelas
Chamadas
Regras identificadas
Pontos de dúvida
Riscos
Testes necessários

Marque claramente o que foi:

  • confirmado;

  • inferido;

  • informado por especialista;

  • ainda não investigado.

Passo 6 — Crie testes antes de alterar

Antes de modernizar, capture o comportamento atual.

Inclua:

  • caso normal;

  • valores mínimos;

  • valores máximos;

  • zero;

  • negativo;

  • campo vazio;

  • dado inválido;

  • data de virada de mês;

  • ano bissexto;

  • duplicidade;

  • falha de arquivo;

  • erro SQL;

  • rollback;

  • timeout.

O programa antigo pode conter comportamentos estranhos.

Alguns são defeitos.

Outros são regras do negócio que ninguém documentou.

Não corrija aquilo que você ainda não compreendeu.

Passo 7 — Faça mudanças incrementais

Evite a estratégia:

Converter tudo
Desligar tudo
Torcer

Prefira:

Descobrir
      ↓
Documentar
      ↓
Testar
      ↓
Isolar
      ↓
Refatorar
      ↓
Comparar
      ↓
Implantar gradualmente
      ↓
Monitorar

Em mainframe, coragem sem controle de mudança recebe outro nome:

incidente de produção.


Capítulo 10 — O que a IA não consegue fazer sozinha

Mesmo uma ferramenta avançada não possui automaticamente:

  • conhecimento completo do negócio;

  • responsabilidade jurídica;

  • autoridade para alterar produção;

  • compreensão de acordos informais;

  • conhecimento de exceções históricas;

  • garantia absoluta de equivalência;

  • contexto de todos os sistemas externos;

  • discernimento político da organização;

  • memória dos incidentes antigos;

  • responsabilidade pelo resultado.

Ela também pode:

  • interpretar incorretamente uma condição;

  • ignorar uma chamada dinâmica;

  • não perceber dados montados em tempo de execução;

  • confundir código morto com código raramente usado;

  • sugerir tipos inadequados;

  • gerar testes insuficientes;

  • explicar com confiança uma regra que não existe.

Portanto:

IA SEM ESPECIALISTA
       =
SUSPEITO INTERROGANDO A SI MESMO

A inteligência artificial deve atuar como assistente.

O profissional continua responsável pela decisão.


Capítulo 11 — Curiosidades encontradas no arquivo confidencial

Curiosidade 1 — COBOL não sobreviveu por acidente

Ele permanece porque milhões de regras empresariais foram codificadas, testadas e refinadas durante décadas.

Um programa pode parecer antigo, mas ter sobrevivido a:

  • mudanças de moeda;

  • fusões bancárias;

  • novas regulamentações;

  • crises econômicas;

  • mudanças tributárias;

  • milhões de execuções diárias.

Idade não é prova de qualidade.

Mas também não é prova de inutilidade.

Curiosidade 2 — “Legado” não significa “abandonado”

Legado é aquilo que foi herdado.

Uma aplicação pode ser antiga e continuar recebendo manutenção, integração, atualização de compilador, APIs e recursos de segurança.

O problema não é ser legado.

O problema é ser legado incompreendido.

Curiosidade 3 — A melhor modernização pode preservar o COBOL

Uma empresa pode:

  • manter o núcleo transacional em COBOL;

  • expor serviços por APIs;

  • integrar com aplicações móveis;

  • usar eventos e mensageria;

  • incorporar análises de IA;

  • modernizar a experiência do desenvolvedor;

  • automatizar testes e pipelines.

Modernização não exige obrigatoriamente remoção da linguagem.

Curiosidade 4 — Código morto pode estar apenas dormindo

Uma rotina pode não ser chamada há meses e ainda representar um processo anual, uma contingência ou um procedimento de recuperação.

Antes de removê-la, investigue:

  • scheduler;

  • JCL;

  • chamadas dinâmicas;

  • transações;

  • procedimentos manuais;

  • execução de fechamento anual;

  • planos de continuidade.

Como diria o detetive:

“Ausência de execução recente não é atestado de óbito.”


Easter egg — O comunicador de pulso

O jovem programador observou o relógio do detetive.

— Isso é uma espécie de smartphone?

— Smartphone? — respondeu ele. — Em 1946 eu já usava rádio de pulso nas histórias em quadrinhos.

O programador sorriu.

A ideia parecia futurista décadas antes de relógios inteligentes se tornarem produtos comuns.

O detetive então apontou para o terminal 3270:

— A tecnologia adora anunciar como novidade aquilo que alguém imaginou muito antes.

No canto da tela apareceu:

READY

Era o TSO aguardando o próximo comando.

Ou talvez fosse o próprio mainframe respondendo à notícia de sua morte.


Capítulo 12 — A sentença do caso

Depois de examinar programas, relatórios, declarações financeiras, diagramas e testes, o detetive reuniu todos na sala de operações.

— Já sei quem tentou matar o COBOL.

O programador arregalou os olhos.

— Foi a IA?

— Não.

— Java?

— Também não.

— A nuvem?

— Inocente neste caso.

O detetive escreveu no quadro:

CULPADO:

A SIMPLIFICAÇÃO EXCESSIVA

A narrativa de que uma IA converterá milhões de linhas COBOL e eliminará instantaneamente o mainframe ignora quase tudo o que torna uma aplicação corporativa complexa:

  • dados;

  • regras;

  • integrações;

  • segurança;

  • operação;

  • testes;

  • desempenho;

  • disponibilidade;

  • auditoria;

  • conhecimento humano;

  • risco empresarial.

A IA pode facilitar migrações? Sim.

Pode ajudar a transformar COBOL em Java? Sim.

Pode auxiliar na remoção de partes do legado? Sim.

Mas também pode:

  • documentar aplicações;

  • acelerar novos profissionais;

  • encontrar dependências;

  • preparar testes;

  • melhorar código COBOL;

  • isolar serviços;

  • aumentar a velocidade de entrega;

  • prolongar a vida econômica do IBM Z.

A tecnologia não possui uma única direção obrigatória.

Ela amplia a capacidade de quem a utiliza.


Conclusão — O COBOL não precisa de um coveiro; precisa de investigadores

A pergunta inicial era:

E se a inteligência artificial não fosse inimiga do COBOL, mas sua melhor aliada?

Depois de examinar as evidências, a resposta mais honesta é:

Ela pode ser uma grande aliada, desde que seja utilizada com conhecimento, governança, testes e responsabilidade humana.

O dado dos clientes que ampliaram MIPS três vezes mais rapidamente é uma declaração da própria IBM e não deve ser tratado como prova independente de causalidade. Ainda assim, ele oferece uma pista importante: aparentemente, pelo menos em parte do mercado, a adoção de IA para modernização não está sendo acompanhada por uma fuga imediata do mainframe.

Ao contrário, organizações capazes de compreender melhor suas aplicações podem encontrar novas razões para investir nelas.

O verdadeiro gargalo nunca foi simplesmente escrever COBOL.

O verdadeiro gargalo era entrar em um sistema com 30 ou 40 anos de história e responder com segurança:

O que este programa faz?

Quem o chama?

Quais dados ele altera?

Que regra empresarial está escondida aqui?

O que acontece se modificarmos esta condição?

Como provamos que nada foi quebrado?

Ferramentas como o watsonx Code Assistant for Z podem reduzir o tempo necessário para investigar essas perguntas. Elas não eliminam a necessidade do programador COBOL. Na realidade, tornam o profissional que conhece COBOL, negócio, testes, dados e arquitetura ainda mais valioso.

O iniciante não deve temer a IA.

Também não deve ajoelhar-se diante dela.

Deve aprender a interrogá-la.

Deve exigir evidências.

Deve comparar respostas com o código.

Deve verificar os dados.

Deve construir testes.

Deve conversar com especialistas.

Deve registrar as conclusões.

E, sobretudo, deve desconfiar de qualquer relatório que termine com:

RC=0000

sem explicar exatamente o que foi executado.

A chuva parou.

O detetive vestiu o sobretudo, ajustou o chapéu e caminhou em direção à porta.

Antes de partir, olhou uma última vez para o programador.

— Então o COBOL está salvo? — perguntou o jovem.

O detetive respondeu:

— Linguagens não são salvas por discursos. São salvas quando continuam resolvendo problemas.

No terminal, uma nova transação foi processada.

Depois outra.

Depois mais dez mil.

O relógio marcou duas da manhã.

O mainframe não estava morto.

Ele estava apenas começando o próximo batch.

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