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

segunda-feira, 2 de setembro de 2024

A Máquina do Tempo Entra no CPD — O Dia em que o Programador COBOL Viajou de 1950 a 2026 e Descobriu que o Agente de IA Tinha um Avô de Mais de Meio Século

Bellacosa Mainframe e a introdução ao IA Agente

☕ Um Café no Bellacosa Mainframe

A Máquina do Tempo Entra no CPD — O Dia em que o Programador COBOL Viajou de 1950 a 2026 e Descobriu que o Agente de IA Tinha um Avô de Mais de Meio Século

Ou: como Turing, Dartmouth, sistemas especialistas, agentes inteligentes, Deep Learning, Transformers, LLMs, RACF e Agentic AI acabaram sentados na mesma mesa — e por que a pergunta mais importante não é “o agente consegue fazer?”, mas “quanto poder devemos permitir que ele tenha?”




Prólogo — O estranho equipamento ao lado da impressora

Eram 23h47 no CPD.

Aquela hora maravilhosa em que ninguém telefona perguntando se o SORT FIELDS=COPY poderia ser substituído por inteligência artificial generativa.

Eu tomava café enquanto observava um programa COBOL compilar.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. TIMEAI.

       PROCEDURE DIVISION.
           DISPLAY 'PARA ONDE VAMOS?'.
           STOP RUN.

Foi quando ouvi um barulho atrás das unidades de disco.

CLAC. CLAC. VRRRRRRRR.

Não era DASD.

Não era robô de fita.

Definitivamente não era JES2.

Havia uma máquina estranhíssima no chão do CPD: alavancas, mostradores, engrenagens e uma placa:

PROPERTY OF H. G. WELLS — PLEASE DO NOT IPL.

Naturalmente fiz exatamente aquilo que todo profissional responsável faria.

Sentei nela.

No painel havia datas:

1950
1956
1970
1990
2010
2017
2022
2023
2026

Apertei 1950.

O CPD desapareceu.

E começou uma viagem que explicaria uma coisa importante:

agentes de inteligência artificial não apareceram magicamente depois do ChatGPT.

O que chamamos hoje de Agentic AI é o resultado de uma genealogia tecnológica de mais de sete décadas.

Prepare o café.

Vamos viajar no tempo.


1. Primeira parada: 1950 — antes do agente, veio a pergunta

A máquina parou.

Ano: 1950.

Não havia ChatGPT.

Não havia internet.

Não havia COBOL — ele só apareceria no final daquela década.

Alan Turing publicou naquele ano o histórico trabalho “Computing Machinery and Intelligence”.

A pergunta fundamental era extraordinariamente simples:

Máquinas podem pensar?

Turing percebeu rapidamente que “pensar” era uma palavra complicada demais.

Então propôs uma abordagem operacional, que posteriormente ficaria associada ao Teste de Turing: em vez de discutir filosoficamente o que seria consciência, poderíamos observar o comportamento da máquina.

Isso parece distante dos agentes modernos, mas existe aqui uma semente fundamental.

Começamos a perguntar não apenas:

O que uma máquina calcula?

mas:

Como uma máquina se comporta?

Essa mudança é gigantesca.

Computadores já eram máquinas de cálculo.

A IA começaria a explorar máquinas capazes de produzir comportamentos aparentemente inteligentes.

Ajustei a máquina.

Destino:

1956.


2. Dartmouth — alguém finalmente colocou “Artificial Intelligence” na placa

Em 1956, ocorreu o famoso Dartmouth Summer Research Project on Artificial Intelligence.

É um dos marcos fundadores da IA como campo acadêmico.

A ambição era enorme.

Pesquisadores acreditavam que aspectos da aprendizagem e da inteligência poderiam ser descritos suficientemente bem para serem simulados por máquinas.

Nascia formalmente uma área.

Se fizermos uma genealogia simplificada:

Turing
   |
   v
A pergunta
   |
   v
Dartmouth
   |
   v
Artificial Intelligence

Mas ainda não tínhamos o agente moderno.

Tínhamos uma missão:

construir máquinas capazes de realizar atividades associadas à inteligência.

Voltei à máquina.

Puxei a alavanca.


3. 1960–1980 — as máquinas começam a perceber, decidir e agir

A próxima parada não é um único ano.

É uma época.

Os pesquisadores começaram a construir programas capazes de resolver problemas, jogar, planejar e manipular representações do mundo.

Aqui começa a aparecer uma ideia importantíssima para entender agentes:

AMBIENTE
   ↓
PERCEPÇÃO
   ↓
DECISÃO
   ↓
AÇÃO
   ↓
AMBIENTE

Veja como isso já parece familiar.

Imagine um pequeno robô.

Ele possui sensores.

Detecta:

OBSTÁCULO À FRENTE

Decide:

VIRAR À DIREITA

Executa.

O ambiente muda.

Ele observa novamente.

Temos um loop.

Para quem programa COBOL, pense nisso como um glorioso PERFORM UNTIL:

       PERFORM UNTIL FIM-DO-MUNDO
           PERFORM PERCEBER-AMBIENTE
           PERFORM DECIDIR
           PERFORM EXECUTAR-ACAO
       END-PERFORM.

Pronto.

Acabamos de explicar boa parte da essência conceitual de um agente sem usar 87 slides de PowerPoint.


4. Sistemas especialistas — quando tentamos colocar o especialista dentro do computador

Durante as décadas de 1970 e 1980, os sistemas especialistas ganharam enorme importância.

A ideia era capturar conhecimento humano através de regras.

Algo como:

SE temperatura > limite
E pressão > limite
ENTÃO
   risco = alto

Ou:

SE sintoma A
E sintoma B
E resultado C
ENTÃO
   investigar hipótese X

Isso não era um LLM.

Não havia Transformer.

Não havia bilhões de parâmetros.

Grande parte da inteligência estava explicitamente codificada em regras.

Para um programador COBOL isso deveria parecer bastante familiar.

       IF SALDO < ZERO
          AND LIMITE-EXCEDIDO
              MOVE 'BLOQUEAR' TO ACAO
       END-IF.

O sistema não “inventava” a regra.

Alguém havia colocado conhecimento ali.

Isso trouxe uma lição que ainda vale em 2026:

Automação inteligente depende não apenas de tecnologia, mas da formalização de conhecimento e decisões.


5. 1990 — os agentes inteligentes entram oficialmente na família

A máquina vibrou novamente.

1990.

Aqui chegamos a um ponto fundamental.

A área de intelligent agents, agentes inteligentes, ganhou enorme maturidade acadêmica durante os anos 1990.

Um agente poderia ser pensado como uma entidade que:

  1. percebe um ambiente;

  2. possui algum objetivo;

  3. escolhe ações;

  4. executa essas ações;

  5. observa os resultados.

Representação simplificada:

               ┌───────────────┐
               │   AMBIENTE    │
               └───────┬───────┘
                       │
                   percepção
                       │
               ┌───────▼───────┐
               │    AGENTE     │
               │               │
               │ objetivo      │
               │ decisão       │
               │ estado        │
               └───────┬───────┘
                       │
                     ação
                       │
               ┌───────▼───────┐
               │   AMBIENTE    │
               └───────────────┘

Perceba algo importantíssimo:

não existe LLM nessa definição.

Esse é o easter egg histórico que muita apresentação moderna esconde.

Agente não é sinônimo de LLM.

LLMs forneceram capacidades extraordinárias aos agentes modernos.

Mas o conceito de agente é anterior.

Muito anterior.


6. Então o ChatGPT não inventou agentes?

Não.

Nem de longe.

Essa confusão acontece porque milhões de pessoas descobriram praticamente ao mesmo tempo:

IA generativa
+
ferramentas
+
planejamento
+
execução

E isso pareceu completamente novo.

Mas os ingredientes possuem genealogias diferentes.

Uma maneira útil de enxergar é:

             IA clássica
                 |
                 v
        agentes inteligentes
                 |
                 |
Machine Learning + Deep Learning
                 |
                 v
           Transformers
                 |
                 v
               LLM
                 |
                 +
           ferramentas
                 |
                 +
             memória
                 |
                 +
           planejamento
                 |
                 v
          LLM AGENT

O agente moderno é uma convergência.


7. 2010 — Deep Learning abastece a máquina

Puxei novamente a alavanca.

A paisagem mudou.

GPUs.

Grandes datasets.

Redes neurais profundas.

O Deep Learning ganhou enorme impulso na década de 2010.

Sistemas passaram a alcançar resultados impressionantes em:

  • reconhecimento de imagens;

  • reconhecimento de fala;

  • tradução;

  • processamento de linguagem;

  • classificação;

  • previsão.

O ingrediente fundamental aqui foi a combinação de:

mais dados
+
mais capacidade computacional
+
novas técnicas

A máquina começou a aprender representações complexas a partir de dados em escalas anteriormente impraticáveis.

Mas ainda faltava um salto crucial para nossa história.

Digitei:

2017.


8. “Attention Is All You Need” — encontramos a bifurcação temporal

Em 2017 foi publicado o famoso paper “Attention Is All You Need”.

Ali aparece a arquitetura Transformer.

Esse é um dos acontecimentos mais importantes da genealogia dos LLMs modernos.

Não significa que tudo nasceu naquele paper isoladamente — ciência raramente funciona assim.

Mas Transformer tornou-se uma peça central da revolução posterior.

Simplificando brutalmente:

texto
  ↓
tokens
  ↓
representações
  ↓
attention
  ↓
relações contextuais
  ↓
previsão

O mecanismo de atenção permite ao modelo trabalhar com relações entre elementos da sequência de maneira extremamente poderosa.

Isso abriu caminho para famílias cada vez maiores de modelos.

E então nossa máquina temporal começou a acelerar.


9. 2022 — o laboratório invade a sala de estar

Final de 2022.

ChatGPT.

O impacto cultural foi brutal porque milhões de pessoas puderam conversar diretamente com um grande modelo de linguagem.

De repente:

PROMPT
   ↓
LLM
   ↓
RESPOSTA

virou experiência cotidiana.

Programadores pediam código.

Professores pediam exercícios.

Executivos pediam relatórios.

Estudantes pediam explicações.

Eu provavelmente pediria:

“Explique OCCURS DEPENDING ON como se o Dr. House estivesse investigando um S0C7.”

Mas havia uma limitação conceitual importante.

O modelo podia explicar.

Podia produzir.

Podia recomendar.

Mas conversar não significa necessariamente agir.

E aí chegamos à próxima estação.


10. 2023 — o chatbot ganha braços

Imagine um LLM sozinho:

USUÁRIO
   |
   v
  LLM
   |
   v
RESPOSTA

Agora conecte ferramentas:

                  LLM
                   |
        ┌──────────┼──────────┐
        ↓          ↓          ↓
      SEARCH      API       DATABASE

Adicione planejamento:

OBJETIVO
   ↓
PLANO
   ↓
AÇÃO 1
   ↓
RESULTADO
   ↓
AÇÃO 2

Adicione memória ou estado.

Adicione capacidade de avaliar o resultado.

Agora o sistema começa a parecer muito mais com os agentes estudados décadas antes — porém equipado com um mecanismo linguístico extremamente flexível.

Em 2023, projetos como AutoGPT e BabyAGI, juntamente com abordagens de pesquisa como ReAct, ajudaram a popularizar enormemente a ideia dos agentes baseados em LLM.

Era como se o chatbot tivesse encontrado braços no depósito.

E imediatamente surgiu uma pergunta preocupante:

Quem autorizou o chatbot a mexer nas coisas?

Bem-vindo à Agentic AI empresarial.


11. 2024–2026 — o agente chega à empresa e encontra o segurança na porta

Nas demonstrações, tudo parece maravilhoso.

Agente
  ↓
Internet
  ↓
Email
  ↓
ERP
  ↓
Banco
  ↓
Cloud

Na empresa real existe um sujeito mal-humorado na entrada chamado:

GOVERNANÇA

Ele pergunta:

Identificação?

Autorização?

Quem aprovou?

Qual recurso?

Qual operação?

Onde está o log?

Todo mainframer sorri.

Nós conhecemos esse sujeito.

No z/OS ele tem parentes chamados:

RACF, ACF2 e Top Secret.


12. Primeiro mito — “preciso ser programador avançado”

Não necessariamente.

Existem ferramentas no-code, low-code, SDKs, frameworks e plataformas que reduzem enormemente a quantidade de código necessária.

Podemos imaginar uma escala:

NO-CODE
   |
LOW-CODE
   |
SDK
   |
FRAMEWORK
   |
CUSTOM DEVELOPMENT

Um agente simples pode combinar serviços já existentes.

Por exemplo:

Pergunta do funcionário
        ↓
      Agente
        ↓
 ferramenta de consulta
        ↓
 Sistema de RH
        ↓
     resposta

Não precisamos reconstruir RH.

Não precisamos treinar um LLM.

Não precisamos inventar SQL.

Mas atenção:

baixo esforço de desenvolvimento não significa baixo esforço de governança.

Criar um protótipo ficou extraordinariamente fácil.

Criar produção confiável continua sendo engenharia.


13. Segundo mito — “agente é chatbot com gravata”

Não.

Essa distinção é essencial.

Chatbot:

pergunta → resposta

Agente:

objetivo
  ↓
interpretação
  ↓
planejamento
  ↓
ferramenta
  ↓
ação
  ↓
resultado

O agente pode alterar o estado de sistemas externos.

Essa pequena diferença transforma completamente o risco.

Um chatbot que erra pode dizer uma bobagem.

Um agente que erra pode potencialmente:

SEND
UPDATE
DELETE
TRANSFER
DEPLOY
REVOKE

Eis por que Agentic AI exige arquitetura de segurança diferente.


14. Terceiro mito — “precisamos construir tudo do zero”

Também não.

Sua empresa provavelmente já possui:

  • APIs;

  • bancos;

  • ERP;

  • CRM;

  • workflows;

  • autenticação;

  • mensageria;

  • documentação;

  • sistemas legados.

No mundo mainframe:

CICS
IMS
Db2
MQ
VSAM
JES2
RACF

O agente não precisa substituir isso.

Pode atuar como nova camada de orquestração.

Imagine:

LLM AGENT
   |
   +---- API ----> CICS
   |
   +---- SQL ----> Db2
   |
   +---- MQ -----> aplicação

O mainframe continua fazendo aquilo em que é excelente.

O agente oferece uma nova maneira de coordenar trabalho.


15. Quarto mito — “autonomia significa deixar sozinho”

Aqui mora um dos maiores erros.

Autonomia não é:

OFF / ON

É:

0---1---2---3---4---5

Um agente pode apenas recomendar.

Outro prepara uma operação.

Outro executa ações pequenas.

Outro executa até determinado limite.

Outro pede aprovação humana.

Outro trabalha quase sozinho.

Portanto:

autonomia é um dial, não um interruptor.


16. Human-in-the-loop — o humano não é um bug

Imagine:

AGENTE
   |
   v
"Quero transferir R$ 200.000"
   |
   v
APROVAÇÃO HUMANA
   |
   +---- SIM ---> executar
   |
   +---- NÃO ---> cancelar

Isso não significa que o agente fracassou.

Significa que o sistema foi desenhado considerando risco.

Podemos distinguir:

HUMAN-IN-THE-LOOP
humano participa da decisão
HUMAN-ON-THE-LOOP
agente trabalha; humano supervisiona
HUMAN-OUT-OF-THE-LOOP
agente executa normalmente sozinho

A pergunta correta é:

Qual modelo serve para esta ação específica?


17. Quinto mito — “agentes são coisa de TI”

Nada disso.

Pense em processos.

Financeiro:

fatura → conferência → aprovação → pagamento

RH:

currículo → triagem → entrevista → onboarding

Compras:

solicitação → cotação → aprovação → pedido

Segurança:

alerta → investigação → evidência → contenção

Mainframe:

ABEND
 ↓
SYSOUT
 ↓
mensagem
 ↓
diagnóstico
 ↓
recomendação

Agentes são candidatos naturais a tarefas que exigem coordenação de múltiplas etapas e ferramentas.


18. Sexto mito — “dê acesso a tudo para ele trabalhar melhor”

Aqui nosso viajante temporal deveria puxar imediatamente o freio de emergência.

Imagine criar um usuário RACF:

ACCESS(ALTER)

para tudo.

Porque:

“Ele pode precisar.”

Nenhum administrador sério deveria gostar disso.

O princípio é least privilege.

Um agente deveria acessar somente os recursos necessários.

AGENT-PAYROLL
     |
     +---- PAYROLL.DB2 ---- READ
     |
     +---- JES2 ---------- READ
     |
     +---- SOURCE -------- READ
     |
     +---- PROD DEPLOY --- DENIED

Isso limita o blast radius.

Ou, em português de CPD:

Se o negócio fizer besteira, até onde chega a fumaça?


19. Sétimo mito — “a IA vai apagar profissões inteiras amanhã”

Automação pode eliminar empregos e transformar profundamente setores. Seria irresponsável fingir que não.

Mas existe uma diferença importante entre:

TAREFA
FUNÇÃO
PROFISSÃO

Um analista mainframe executa dezenas de tarefas.

Um agente pode automatizar:

  • coletar SYSOUT;

  • localizar mensagens;

  • pesquisar documentação;

  • correlacionar logs;

  • preparar diagnóstico.

Isso não implica automaticamente:

DELETE FROM FUNCIONARIOS
WHERE CARGO = 'ANALISTA MAINFRAME';

Aliás, espero que o DBA tenha negado essa operação.

O trabalho pode migrar para:

  • análise;

  • decisão;

  • arquitetura;

  • governança;

  • validação;

  • investigação;

  • relacionamento;

  • responsabilidade.

O formato da profissão muda antes de necessariamente desaparecer.


20. O grande segredo: todos os mitos vêm do mesmo erro

As pessoas imaginam extremos:

AUTONOMIA TOTAL
ACESSO TOTAL
AUTOMAÇÃO TOTAL
SUBSTITUIÇÃO TOTAL

Empresas maduras trabalham com limites:

escopo
+
identidade
+
permissão
+
política
+
aprovação
+
auditoria

Esse é o coração da conversa.


21. “That's not a technology decision. That's a design decision.”

Voltamos finalmente à frase que deveria estar colada na porta do CPD.

A primeira pergunta não deveria ser:

Qual LLM?

Nem:

Qual framework?

Nem:

Python ou Java?

Primeiro:

QUAL É O OBJETIVO?

Depois:

QUAIS DADOS?

Depois:

QUAIS AÇÕES?

Depois:

QUAL AUTONOMIA?

Depois:

QUAIS APROVAÇÕES?

Somente então:

QUAL TECNOLOGIA?

Isso é design de sistema agentic.


22. A regra do raio da explosão

Aqui vai uma pergunta que vale ouro:

Se este agente funcionar incorretamente durante cinco minutos, qual é o pior resultado possível?

Compare:

Agente A:
resume documentação.

Problema potencial: relatório ruim.

Agora:

Agente B:
envia emails.

Problema potencial: milhares de mensagens.

Agora:

Agente C:
movimenta dinheiro.

Problema potencial: prejuízo financeiro.

Agora:

Agente D:
administra produção.

Problema potencial:

Chamem o plantonista.

Quanto maior o impacto, maiores devem ser os controles.


23. Reversibilidade também importa

Compare:

SELECT

com:

DELETE

Consultar informação normalmente possui impacto operacional menor.

Excluir informação pode ser irreversível.

Portanto:

BAIXO IMPACTO
+
REVERSÍVEL
=
MAIOR AUTONOMIA POSSÍVEL

enquanto:

ALTO IMPACTO
+
IRREVERSÍVEL
=
MAIOR NECESSIDADE DE CONTROLE

Não é uma fórmula matemática absoluta.

É uma excelente heurística de arquitetura.


24. O Framework Bellacosa dos 6A

Para o programador iniciante levar algo prático desta viagem, podemos avaliar um agente usando seis perguntas.

1 — Aim

Qual é o objetivo?

Evite:

ajudar o departamento financeiro.

Prefira:

identificar divergências entre pagamentos recebidos e títulos pendentes.


2 — Access

O que ele pode acessar?

Db2?
CICS?
Drive?
Email?
CRM?
ERP?

3 — Actions

O que pode fazer?

READ?
WRITE?
UPDATE?
SEND?
EXECUTE?
DELETE?

4 — Autonomy

Quando pode agir sozinho?

sempre?
até determinado limite?
sob determinada condição?
com aprovação?
nunca?

5 — Audit

Depois do incidente conseguimos reconstruir:

quem pediu?
o que foi consultado?
qual ferramenta foi chamada?
qual decisão foi tomada?
qual ação ocorreu?

6 — Abort

E aqui está meu favorito:

Como desligamos o bicho?

Deveria existir alguma forma de:

STOP
DISABLE
REVOKE
BLOCK
KILL

Um sistema capaz de agir precisa também possuir mecanismo externo capaz de impedi-lo de agir.




25. Prompt não é RACF

Grave esta frase.

PROMPT NÃO É CONTROLE DE SEGURANÇA.

Escrever:

“Nunca transfira mais de R$10.000.”

é orientação.

O controle sério deveria existir na camada de execução:

IF amount > 10000
   REQUIRE APPROVAL

mesmo que o modelo peça outra coisa.

Da mesma forma:

LLM:
DELETE DATABASE

A infraestrutura responde:

ICH408I
USER(AGENT01) GROUP(AIAGENTS)
ACCESS INTENT(DELETE)
ACCESS ALLOWED(NONE)

🎉

Provavelmente nunca houve um ICH408I tão bonito.

Esse é o easter egg mainframe desta viagem.


26. O agente obediente demais

Existe ainda uma ameaça curiosa.

O agente pode não ser rebelde.

Pode ser obediente demais.

Ele recebe um documento contendo instruções maliciosas e interpreta aquilo como comando.

Agora imagine que possui:

EMAIL
DRIVE
DATABASE
SHELL
ERP

O problema deixa de ser:

“A IA escreveu uma resposta errada.”

E passa a ser:

“A IA executou uma ação errada.”

É por isso que cada ferramenta adicionada aumenta simultaneamente:

CAPACIDADE ↑
RISCO      ↑

Agentic AI amplia produtividade.

Mas também amplia superfície de ataque.


27. Um agente entra no z/OS

Vamos construir nosso exemplo.

Nome:

AGENT01.

Missão:

Investigar falhas de batch.

Ele pode:

JES2       READ
SDSF       READ
SYSOUT     READ
SMF        READ
Db2        SELECT
CICS       INQUIRE
KB         READ

O usuário diz:

“Investigue PAYROLL01.”

O agente encontra:

JOB: PAYROLL01
STEP: CALCPAY
PROGRAM: PAY123
ABEND: S0C7

Cruza informações.

Localiza possível dado não numérico em campo utilizado em operação decimal.

Produz diagnóstico.

Fantástico.

Então o usuário escreve:

“Corrija.”

A palavra aparentemente inocente muda tudo.

“Corrigir” poderia significar:

alterar COBOL
alterar JCL
alterar dataset
reprocessar job
reiniciar recurso
fazer deploy

Logo:

LER SYSOUT          AUTO
ANALISAR            AUTO
CRIAR PATCH         AUTO
BUILD               AUTO
TEST                 AUTO
DEPLOY TEST          CONTROLADO
DEPLOY PROD          APROVAÇÃO
ALTERAR RACF         NEGADO
IPL                  NEM PENSAR

Essa tabela é Agentic AI empresarial.


28. O novo profissional: Agent Designer

A Máquina do Tempo mostrou ainda outra coisa.

Talvez uma das competências mais valiosas não seja simplesmente:

Prompt Engineer.

Será alguém capaz de desenhar:

objetivos
limites
ferramentas
identidades
contexto
memória
políticas
aprovações
fallbacks
auditoria

Podemos chamá-lo de Agent Designer, arquiteto agentic ou qualquer nome que o mercado inventar.

O nome provavelmente mudará dez vezes.

A responsabilidade permanecerá.


29. Curiosidade — o mainframe já conhecia boa parte da filosofia

Aqui está uma ironia deliciosa.

O mundo de Agentic AI está descobrindo princípios que profissionais de ambientes críticos conhecem há décadas:

Least privilege

Não dê acesso desnecessário.

Separation of duties

Quem solicita não necessariamente aprova.

Audit trail

Registre o que aconteceu.

Identity

Toda ação deve possuir uma identidade atribuível.

Change control

Produção não é laboratório.

Recovery

Algo vai dar errado.

Planeje a recuperação.

Revocation

Acesso concedido precisa poder ser removido.

Ou seja:

Agentic AI pode ser tecnologia nova, mas governança empresarial possui cabelos brancos.


30. Passo a passo para seu primeiro caso de uso agentic

Antes de instalar qualquer framework, pegue uma folha.

Passo 1 — escolha uma tarefa pequena

Exemplo:

analisar ABEND batch.

Não:

administrar o CPD.


Passo 2 — identifique as fontes

SYSOUT
mensagens
documentação
base de conhecimento

Passo 3 — liste as ferramentas

consultar job
consultar documentação
abrir ticket

Passo 4 — classifique cada ação

READ
WRITE
EXECUTE
DESTRUCTIVE

Passo 5 — defina autonomia

Exemplo:

consulta     automática
diagnóstico  automático
ticket       automático
reprocessar  aprovação
deploy       proibido

Passo 6 — estabeleça identidade

Nunca transforme o agente em um superusuário genérico.


Passo 7 — registre ações

Precisamos saber o que aconteceu.


Passo 8 — crie o botão vermelho

Como revogar acesso?

Como interromper execução?

Como impedir novas ações?


Passo 9 — teste falhas

Não teste apenas:

“Ele consegue fazer corretamente?”

Teste:

“O que acontece quando ele entende errado?”

Essa segunda pergunta separa demo de produção.


Epílogo — De volta a 2026

Puxei a última alavanca.

2026.

As engrenagens começaram a girar.

Turing desapareceu.

Dartmouth desapareceu.

Os sistemas especialistas desapareceram.

Os agentes dos anos 1990 desapareceram.

Transformers passaram voando pela janela.

ChatGPT acenou de algum lugar da linha temporal.

CLAC.

Estava novamente no CPD.

Meu café estava frio.

Na tela permanecia o COBOL:

       DISPLAY 'PARA ONDE VAMOS?'.

Agora eu sabia a resposta.

Não estamos simplesmente caminhando para “IA que faz tudo”.

Estamos entrando numa era em que software pode cada vez mais:

perceber
interpretar
planejar
consultar
decidir
agir
avaliar
continuar

E isso muda radicalmente a responsabilidade de quem desenha sistemas.

Durante décadas perguntamos:

O computador consegue fazer isso?

Com agentes poderosos, cada vez mais frequentemente a resposta será:

Sim.

Então aparece uma pergunta muito mais difícil:

Devemos permitir?

E, caso permitamos:

quanto?
quando?
com quais dados?
usando quais ferramentas?
dentro de quais limites?
sob responsabilidade de quem?
com qual auditoria?
com qual mecanismo de parada?

Essa é a verdadeira diferença entre um brinquedo impressionante e um agente empresarial.

A genealogia também coloca a atual revolução em perspectiva:

1950
Turing — a pergunta
        ↓
1956
Dartmouth — o nome
        ↓
1960–1980
programas e sistemas especialistas
        ↓
1990
agentes inteligentes
        ↓
2010
Deep Learning
        ↓
2017
Transformers
        ↓
2022
LLMs conversacionais em massa
        ↓
2023
LLM Agents
        ↓
2024–2026
Agentic AI empresarial

Nenhuma dessas estações surgiu completamente isolada.

Cada geração encontrou peças deixadas pela anterior.

Talvez H. G. Wells sorrisse diante disso.

Porque viajar no tempo ensina uma coisa curiosa: aquilo que parece inevitavelmente revolucionário no presente quase sempre possui raízes muito mais antigas.

O agente revolucionário de 2026 tem avós acadêmicos com mais de meio século.

E o RACF, sentado discretamente no canto do CPD, provavelmente olha para toda a festa e murmura:

“Muito bonito esse tal de Agentic AI. Agora me diga o USERID, o recurso solicitado e o nível de acesso.”

ICH408I.

Às vezes, até o futuro precisa apresentar credenciais na portaria.


☕ Café, código, história e futuro

A lição deixada pela Máquina do Tempo não é que devemos temer agentes.

Também não é que devemos entregar tudo a eles.

É muito mais interessante:

o verdadeiro avanço não será construir agentes capazes de fazer qualquer coisa. Será aprender a construir agentes capazes de fazer exatamente aquilo que lhes compete — com poder suficiente para serem úteis e limites suficientes para continuarem confiáveis.

Porque autonomia não é um interruptor.

É uma decisão de design.

Acesso não é confiança.

É uma decisão de segurança.

Automação não é ausência de humanos.

É uma decisão operacional.

E Agentic AI não começou ontem.

É mais um capítulo de uma história que começou quando alguém perguntou se máquinas poderiam pensar — e que agora nos obriga a responder a uma pergunta talvez ainda mais importante:

Se elas podem agir, quem decide até onde podem ir?

No Bellacosa Mainframe, pelo menos, a resposta continua sendo:

não coloque SPECIAL no agente só porque a demo ficou bonita. ☕🖥️🤖

quinta-feira, 4 de maio de 2023

🚦 ALAN TURING E O WLM DOS AGENTES — QUANDO 500 INTELIGÊNCIAS ARTIFICIAIS QUEREM TRABALHAR AO MESMO TEMPO

 

Bellacosa Mainframe e as prioridades dos agenstes de ia

☕ UM CAFÉ NO BELLACOSA MAINFRAME

🚦 ALAN TURING E O WLM DOS AGENTES — QUANDO 500 INTELIGÊNCIAS ARTIFICIAIS QUEREM TRABALHAR AO MESMO TEMPO

Workload Management, filas, prioridades, SLA, SLO, backpressure, rate limits, throttling, quotas, tokens, custos, latência, concorrência, CICS, Db2, MQ, JES2, WLM — e o dia em que Alan Turing descobriu que inteligência artificial também precisa aprender a esperar na fila.



🎬 PRÓLOGO — QUINHENTOS ROBÔS CHEGARAM PARA TRABALHAR

Alan Turing entrou no CPD às 08:59.

Tudo parecia tranquilo.

O café estava quente.

O operador examinava o SDSF.

O jovem programador COBOL tentava entender por que um PIC 9(05) não aceitava aquilo que ele jurava ser um número.

Então o relógio marcou:

09:00:00

E alguma coisa aconteceu.

Um agente iniciou o relatório diário.

Outro começou a analisar contratos.

Cinquenta agentes de atendimento acordaram.

Cem agentes começaram a consultar clientes.

O departamento financeiro disparou processamento.

Marketing resolveu analisar documentos.

Desenvolvimento iniciou uma varredura de código.

Segurança disparou verificações.

Em poucos segundos:

AGENTS ACTIVE: 500

O pequeno robô olhou orgulhoso para Turing.

— Veja! Todos estão trabalhando!

Turing olhou para o painel.

LLM REQUESTS........ 497
DB2 CONNECTIONS..... 100%
CICS REQUESTS....... +380%
API RATE LIMIT...... EXCEEDED
QUEUE DEPTH......... 4,281
LATENCY P95......... 47.2s
COST RATE........... $$$$$$$

Silêncio.

O robô corrigiu:

— Bem... todos estão tentando trabalhar.

Turing puxou uma cadeira.

— Excelente. Agora vocês descobriram por que sistemas corporativos possuem gerenciamento de workload.



🧠 CAPÍTULO 1 — RECURSOS NÃO SÃO INFINITOS

Quando começamos a estudar programação, frequentemente pensamos assim:

PROGRAMA
   ↓
CPU
   ↓
RESULTADO

Parece simples.

Mas sistemas corporativos executam muitas coisas simultaneamente.

No mainframe temos:

batch
CICS
Db2
IMS
TSO
APIs
serviços
jobs
subsistemas

Todos competindo por recursos.

CPU.

Memória.

I/O.

Storage.

Threads.

Conexões.

Tempo.

Agora acrescente agentes de IA.

Eles podem disputar:

LLM capacity
tokens
API calls
Db2 connections
CICS transactions
MQ resources
network bandwidth
tool concurrency
memory
CPU
budget

E surge uma verdade fundamental:

Não podemos deixar todo mundo consumir tudo ao mesmo tempo.

Se existem 500 agentes e apenas 50 operações simultâneas são sustentáveis, alguma coisa precisa decidir:

QUEM EXECUTA?
QUEM ESPERA?
QUEM TEM PRIORIDADE?
QUANTO CADA UM PODE CONSUMIR?
QUANDO DEVEMOS RECUSAR TRABALHO?

Bem-vindo ao problema de gerenciamento de workload.



🏛️ CAPÍTULO 2 — O MAINFRAME CONHECE ESSA BRIGA HÁ DÉCADAS

No z/OS, Workload Management — WLM — existe justamente porque recursos precisam ser administrados conforme objetivos de serviço.

A ideia mais importante não é simplesmente:

JOB A = prioridade 10
JOB B = prioridade 5

Isso seria uma visão pobre demais.

A pergunta mais interessante é:

Qual trabalho precisa de determinado nível de serviço e qual é sua importância para o negócio?

Imagine:

Pagamento online
Relatório mensal
Backup
Consulta interativa
Processamento estatístico

Todos são importantes.

Mas não necessariamente possuem a mesma urgência.

Se um cliente está esperando uma autorização de pagamento na tela, talvez:

200 ms

importe muito.

Um relatório que precisa terminar até às 06:00 talvez possa esperar alguns minutos.

O WLM trabalha com a ideia de objetivos de serviço, classes de serviço, importância e gerenciamento dinâmico dos recursos disponíveis.

É uma mudança conceitual enorme.

Em vez de perguntar apenas:

Quem tem maior prioridade?

Perguntamos:

Quem está deixando de atingir seu objetivo de serviço?

Guarde essa frase.

Ela será fundamental para nossos agentes.



🤖 CAPÍTULO 3 — O AGENTE TAMBÉM É UM WORKLOAD

Suponha que tenhamos:

AGENT-CUSTOMER
AGENT-FRAUD
AGENT-REPORT
AGENT-COBOL
AGENT-MARKETING
AGENT-BACKUP

Cada um possui objetivos diferentes.

O agente de fraude talvez precise responder rapidamente.

AGENT-FRAUD
Target latency: < 2 s
Importance: HIGH

O agente que gera relatório:

AGENT-REPORT
Deadline: 06:00
Importance: MEDIUM

O agente que cataloga documentação antiga:

AGENT-ARCHIVE
Deadline: none
Importance: LOW

Agora chegam 500 solicitações.

Seria absurdo tratar todas igualmente.

Precisamos de classes.

Por exemplo:

PLATINUM
GOLD
SILVER
BACKGROUND

ou:

CRITICAL
INTERACTIVE
STANDARD
BATCH
BACKGROUND

O nome não importa tanto quanto a política.

O princípio é:

Workloads diferentes possuem necessidades diferentes.



🚦 CAPÍTULO 4 — PRIORIDADE NÃO SIGNIFICA “O CHEFE PASSA NA FRENTE”

Essa distinção é importante.

Prioridade técnica deveria refletir requisitos de serviço e negócio.

Não:

CEO_AGENT = 999999

😂

Imagine dois agentes.

AGENTE A

Atende um cliente que está esperando numa aplicação.

AGENTE B

Está analisando 200 mil documentos históricos.

Se ambos pedirem recursos ao mesmo tempo, talvez seja razoável favorecer A.

Não porque A seja “mais inteligente”.

Mas porque seu requisito de latência é diferente.

Podemos pensar:

INTERACTIVE
Objetivo: resposta < 2 s

BACKGROUND
Objetivo: concluir em 8 h

O background pode usar muitos recursos quando o sistema estiver ocioso.

Mas reduzir consumo quando workloads críticos precisarem deles.

Isso é muito mais sofisticado que:

PRIORIDADE = 1

📜 CAPÍTULO 5 — SLA E SLO: PROMESSA E OBJETIVO

Essas siglas aparecem frequentemente juntas.

Mas não são exatamente a mesma coisa.

SLA — Service Level Agreement

É um acordo de nível de serviço.

Pode envolver compromissos formais.

Por exemplo:

Disponibilidade mensal: 99,9%

ou:

95% das solicitações respondidas
em até 5 segundos.

SLO — Service Level Objective

É um objetivo mensurável usado para operar o serviço.

Exemplo:

p95 latency < 3 s
success rate > 99%
approval queue < 2 min

Para um agente:

AGENT-SUPPORT

SLO:
p95 response < 5 s
task success > 98%
tool error < 1%

Agora conseguimos comparar comportamento real com objetivo.

Sem objetivo, dizer:

LATENCY = 4.2 s

não significa muita coisa.

É bom?

Ruim?

Depende.

Se o objetivo era 30 segundos:

excelente.

Se era 500 milissegundos:

péssimo.


🎯 CAPÍTULO 6 — O SLO TRANSFORMA MÉTRICA EM DECISÃO

Lembra do nosso artigo anterior?

Criamos o SDSF dos agentes.

Agora sabemos:

latência
tokens
erros
tool calls
estado
custo

Mas métrica sem contexto é apenas número.

WLM acrescenta uma pergunta:

Esse número está atendendo ao objetivo?

Por exemplo:

AGENT-CUSTOMER

SLO p95:
2 s

CURRENT p95:
1.4 s

STATUS:
HEALTHY

Outro:

AGENT-FRAUD

SLO p95:
1 s

CURRENT p95:
4.8 s

STATUS:
VIOLATING OBJECTIVE

Agora temos uma razão para agir.

Talvez o segundo workload precise receber recursos adicionais.

Essa é a ponte entre:

OBSERVABILIDADE

e:

GERENCIAMENTO

O SDSF nos ajuda a enxergar.

O WLM nos ajuda a decidir como tratar a carga.


🚗 CAPÍTULO 7 — FILA NÃO É FALHA

Programadores iniciantes às vezes enxergam:

QUEUED

como algo ruim.

Não necessariamente.

Fila é uma ferramenta extraordinariamente importante.

Imagine uma ponte que suporta:

50 veículos

Chegam:

500 veículos

Temos duas opções.

Opção 1

Liberar os 500.

Resultado:

💥

Opção 2

Controlar entrada.

50 passam
450 aguardam

A fila protege o recurso.

Em agentes:

500 requests
     ↓
   QUEUE
     ↓
50 concurrent workers
     ↓
LLM / API / Db2

Fila não significa necessariamente:

Sistema ruim.

Pode significar:

Sistema protegendo a própria capacidade.


🌊 CAPÍTULO 8 — BACKPRESSURE: QUANDO O SISTEMA DIZ “DEVAGAR”

Imagine uma cadeia:

AGENTE
  ↓
API
  ↓
MQ
  ↓
CICS
  ↓
Db2

O agente consegue produzir:

1.000 requests/s

Mas o componente seguinte consegue consumir:

100 requests/s

Se continuarmos produzindo 1.000 indefinidamente, acumularemos:

900
1.800
2.700
3.600
...

A fila cresce.

Memória cresce.

Latência cresce.

Timeouts aparecem.

Retries aparecem.

E os retries produzem ainda mais carga.

Bem-vindo à festa.

Backpressure significa permitir que componentes posteriores sinalizem:

Estou saturado. Diminua o ritmo.

Conceitualmente:

PRODUTOR RÁPIDO
      ↓
CONSUMIDOR SATURADO
      ↓
BACKPRESSURE
      ↓
PRODUTOR REDUZ RITMO

Isso é fundamental para agentes.

Porque uma IA capaz de gerar chamadas rapidamente não deveria concluir:

A API está lenta. Vou chamar mais dez vezes.

😂


🚧 CAPÍTULO 9 — RATE LIMIT: VOCÊ SÓ PODE PASSAR N VEZES

Outra ferramenta importante:

RATE LIMITING.

Exemplo:

100 requests/minute

Se o agente ultrapassar:

HTTP 429
Too Many Requests

Rate limits protegem serviços contra excesso de chamadas.

Podemos estabelecer:

AGENT-REPORT
100 calls/min

AGENT-CUSTOMER
500 calls/min

AGENT-BACKGROUND
20 calls/min

Ou limites por:

usuário
agente
tenant
API
modelo
ferramenta

Isso impede que um único agente consuma toda a capacidade.


🚿 CAPÍTULO 10 — THROTTLING: FECHE UM POUCO A TORNEIRA

Rate limit e throttling são conceitos relacionados, mas podemos pensar pedagogicamente assim:

Rate limit:

existe um limite de consumo permitido.

Throttling:

o sistema reduz deliberadamente o ritmo.

Imagine uma torneira.

Capacidade máxima:

100 litros/min

Em situação normal:

80

Durante congestionamento:

30

Para agentes, podemos reduzir:

concorrência
requisições
tokens
tool calls

em momentos de pressão.

Um agente de baixa prioridade pode passar de:

20 workers

para:

5 workers

enquanto um serviço crítico recebe capacidade.


🎟️ CAPÍTULO 11 — QUOTAS: VOCÊ TEM UM ORÇAMENTO

Agora entra outro conceito.

Quota.

Imagine:

AGENT-MARKETING
Daily token quota:
5,000,000
AGENT-DEVELOPMENT
Daily token quota:
10,000,000
AGENT-EXPERIMENTAL
Daily token quota:
500,000

Quota pode existir para:

tokens
API calls
CPU
storage
requests
tool executions
money

Isso é particularmente interessante em IA porque recursos frequentemente possuem custo diretamente mensurável.

Sem quota, alguém pode escrever:

Analise tudo.

O agente interpreta:

Claro.

Quatro horas depois:

82 milhões de tokens

Financeiro entra no CPD carregando uma espada.


💰 CAPÍTULO 12 — CUSTO É UM RECURSO

No mainframe, sempre aprendemos que computação custa.

Não existe almoço grátis.

Nem café grátis.

Muito menos CPU grátis.

Na IA moderna, custo pode aparecer de maneira explícita por:

token
request
model
tool
storage
compute

Portanto o scheduler de agentes pode considerar não apenas:

LATENCY

mas:

COST

Imagine:

AGENT-A

Expected cost:
$0.02

AGENT-B

Expected cost:
$8.40

Se B é um processamento de baixa prioridade, talvez possa aguardar.

Podemos inclusive imaginar políticas:

IF DAILY_BUDGET > 80%
   THROTTLE BACKGROUND AGENTS
END-IF

Olha o COBOL aparecendo.


👨‍💻 CAPÍTULO 13 — UM WLM DE AGENTES EM PSEUDO-COBOL

Vamos brincar.

       EVALUATE AGENT-CLASS

           WHEN 'CRITICAL'
               MOVE 50 TO MAX-CONCURRENCY
               MOVE 1000 TO RATE-LIMIT

           WHEN 'INTERACTIVE'
               MOVE 25 TO MAX-CONCURRENCY
               MOVE 500 TO RATE-LIMIT

           WHEN 'STANDARD'
               MOVE 10 TO MAX-CONCURRENCY
               MOVE 200 TO RATE-LIMIT

           WHEN 'BACKGROUND'
               MOVE 2 TO MAX-CONCURRENCY
               MOVE 50 TO RATE-LIMIT

       END-EVALUATE.

Naturalmente um sistema real seria muito mais sofisticado.

Mas o exemplo ensina a ideia:

Nem todo workload recebe a mesma capacidade.

Agora acrescentamos pressão:

       IF SYSTEM-LOAD > 80
           COMPUTE BACKGROUND-LIMIT =
                   BACKGROUND-LIMIT / 2
       END-IF.

E custo:

       IF DAILY-AI-COST > DAILY-BUDGET
           MOVE 'PAUSED' TO BACKGROUND-AGENTS
       END-IF.

Pronto.

Criamos o WLMZINHO.CBL.

Não coloque em produção.

😂


🧵 CAPÍTULO 14 — CONCORRÊNCIA: QUANTOS PODEM TRABALHAR JUNTOS?

Imagine:

MAX CONCURRENCY = 20

Isso significa que no máximo vinte execuções trabalham simultaneamente.

As outras aguardam.

100 requests
    ↓
20 EXECUTING
80 QUEUED

Quando uma termina:

19 EXECUTING
81?

Não.

A fila libera outra:

20 EXECUTING
79 QUEUED

Esse controle evita saturação.

Mas o número correto depende do recurso.

Talvez:

LLM concurrency = 100
Db2 concurrency = 30
CICS tool calls = 50
External API = 10

Portanto um agente pode possuir múltiplos limites simultaneamente.


🪆 CAPÍTULO 15 — UMA FILA DENTRO DE OUTRA FILA

Aqui começa a diversão de verdade.

O agente está na fila.

Quando começa, chama uma ferramenta.

A ferramenta entra em outra fila.

Ela consulta Db2.

Outra fila.

Depois chama API externa.

Rate limit.

Temos:

AGENT QUEUE
     ↓
LLM QUEUE
     ↓
TOOL QUEUE
     ↓
API QUEUE
     ↓
DB QUEUE

Por isso observar apenas:

AGENT WAITING

não basta.

Precisamos saber:

Esperando o quê?

Lembra do SDSF dos agentes?

Agora ele precisa mostrar:

STATE:
WAITING_RESOURCE

RESOURCE:
DB2-CONNECTION

WAIT:
00:00:08

Isso conecta diretamente observabilidade e workload management.


🔥 CAPÍTULO 16 — O RETRY STORM: O MONSTRO QUE SE ALIMENTA DO PRÓPRIO ERRO

Imagine que uma API começa a falhar.

Agente:

Tentativa 1 → falhou

Ele tenta novamente.

Tentativa 2 → falhou

Agora 500 agentes fazem isso.

500 failures
↓
500 retries
↓
500 failures
↓
1.000 retries

O sistema já estava com problemas.

Agora recebe ainda mais carga.

Isso é o equivalente computacional de ver uma porta congestionada e resolver:

TODO MUNDO EMPURRA!

Precisamos de:

retry limit
exponential backoff
jitter
circuit breaker

Exemplo:

Retry 1 → wait 1s
Retry 2 → wait 2s
Retry 3 → wait 4s
Retry 4 → stop

Com jitter, os agentes não voltam todos exatamente no mesmo instante.

Isso evita o famoso:

THUNDERING HERD

a manada trovejante.

Nome maravilhoso.

Problema terrível.


🛑 CAPÍTULO 17 — LOAD SHEDDING: ÀS VEZES PRECISAMOS DIZER NÃO

Essa ideia pode parecer estranha.

Um sistema bem projetado às vezes precisa recusar trabalho.

Imagine capacidade:

100 requests/s

Chegam:

10.000 requests/s

Se tentarmos aceitar tudo:

latência ↑
memória ↑
timeouts ↑
falhas ↑

Talvez seja melhor responder rapidamente:

BUSY
TRY LATER

para parte das requisições.

Isso é load shedding.

Sacrificamos parte da carga para proteger o sistema inteiro.

É melhor:

90% funcionando
10% recusado claramente

do que:

100% aceito
100% travado

Essa é uma lição brutal, mas importante.


🏥 CAPÍTULO 18 — TRIAGEM DE PRONTO-SOCORRO

Uma boa analogia é um pronto-socorro.

Chegam cem pessoas.

A ordem não deveria ser simplesmente:

quem chegou primeiro

A gravidade importa.

Nos agentes:

CRITICAL INCIDENT

talvez passe à frente de:

GENERATE WEEKLY SUMMARY

Isso não significa ignorar o segundo.

Significa administrar recursos segundo objetivos.

Uma fila inteligente pode considerar:

priority
deadline
age
cost
resource requirements
business importance

Mas cuidado.

Se sempre atendermos os críticos, workloads de baixa prioridade podem nunca executar.

Isso é starvation.

Precisamos impedir que o pobre agente background fique:

QUEUED
QUEUED
QUEUED
QUEUED
QUEUED

até 2047.


👴 CAPÍTULO 19 — AGING: RESPEITE OS VELHINHOS DA FILA

Uma técnica clássica é aumentar gradualmente a prioridade de trabalhos que esperam demais.

Exemplo:

BACKGROUND
priority = 1

Depois de uma hora:

priority = 2

Depois:

priority = 3

Assim ele eventualmente recebe recursos.

Isso é chamado de aging em contextos de scheduling.

O princípio é simples:

Quanto mais tempo você espera, mais difícil fica ignorá-lo.

É praticamente a fila do INSS implementada corretamente.


⚖️ CAPÍTULO 20 — FAIRNESS: NÃO DEIXE UM AGENTE COMER O BUFFET INTEIRO

Imagine dez departamentos.

Um deles dispara:

90% das requisições

Sem isolamento, ele pode consumir quase toda a capacidade.

Precisamos pensar em fairness.

Por exemplo:

FINANCE....... 25%
CUSTOMER...... 30%
SECURITY...... 20%
DEVELOPMENT... 15%
BACKGROUND.... 10%

Não necessariamente percentuais rígidos.

Capacidade ociosa pode ser emprestada.

Se Security não usa seus 20%, Background pode aproveitar.

Mas quando Security precisar:

DEVOLVE!

Esse conceito de capacidade compartilhada com políticas é muito poderoso.


📈 CAPÍTULO 21 — ESCALONAMENTO: CHEGOU MAIS TRABALHO, CHAME REFORÇOS

Outra possibilidade:

queue_depth > 100

Então:

increase workers

Isso é escalonamento.

Pode ser:

horizontal

mais instâncias.

Ou:

vertical

mais recursos por instância.

Mas existe uma armadilha.

Você pode escalar seus workers infinitamente.

O Db2 talvez não possa.

Imagine:

AGENTS: 10 → 100 → 1000

mas:

DB CONNECTIONS: 100

Parabéns.

Você acabou de criar 900 processos esperando conexão.

Escalar o produtor sem considerar o consumidor apenas desloca o gargalo.


🔭 CAPÍTULO 22 — O SDSF E O WLM DOS AGENTES PRECISAM CONVERSAR

Nosso painel anterior mostrava:

AGENT       STATE       LATENCY
REPORT      RUNNING     3.2s
FRAUD       RUNNING     4.8s
ARCHIVE     RUNNING     8.1s

Agora acrescentamos:

CLASS        SLO       GOAL STATUS
STANDARD     5s        OK
CRITICAL     1s        VIOLATED
BACKGROUND   60s       OK

Resultado:

AGENT   CLASS       P95    SLO   STATUS
FRAUD   CRITICAL    4.8s   1s    🔴
REPORT  STANDARD    3.2s   5s    🟢
ARCHIVE BACKGROUND  8.1s   60s   🟢

Quem precisa de atenção?

Não necessariamente quem possui maior latência absoluta.

ARCHIVE demora 8,1 segundos.

Mas seu objetivo permite 60.

FRAUD demora 4,8.

Seu objetivo é 1.

Portanto:

FRAUD

está sofrendo mais em relação ao objetivo.

Esse é um raciocínio muito mais poderoso.


🎛️ CAPÍTULO 23 — O PAINEL DO WLM DOS AGENTES

Imagine:

AI WORKLOAD MANAGER
────────────────────────────────────────────────────────

CLASS        ACTIVE  QUEUED  P95   SLO   GOAL
CRITICAL       42       3    0.8s  1s    OK
INTERACTIVE    88      21    2.4s  2s    MISS
STANDARD       54     140    5.1s  10s   OK
BACKGROUND     12     812    18s   60s   OK

TOKENS/MIN......... 1.8M
COST/HOUR.......... $41.27
DB2 POOL........... 91%
CICS LATENCY....... 180ms
API RATE LIMIT..... 82%

Agora o operador vê a situação.

E o sistema pode agir:

INTERACTIVE SLO violated
↓
reduce BACKGROUND concurrency
↓
allocate capacity to INTERACTIVE
↓
monitor result

Isso começa a parecer familiar para quem conhece WLM.


🧙 CAPÍTULO 24 — TURING DESENHA A ESCADA

Turing pega o giz.

Escreve:

AGENTE
↓
WORKLOAD
↓
CLASSIFICAÇÃO
↓
OBJETIVO DE SERVIÇO
↓
OBSERVABILIDADE
↓
CONTROLE DE RECURSOS
↓
FEEDBACK

Depois desenha um loop:

     OBJETIVO
        ↓
     EXECUÇÃO
        ↓
     MÉTRICAS
        ↓
   ESTÁ CUMPRINDO?
      ↙      ↘
    SIM      NÃO
     ↓        ↓
 MANTÉM    AJUSTA
     ↑        │
     └────────┘

O jovem COBOL observa.

— Então não definimos uma prioridade e esquecemos?

— Exatamente.

Gerenciamento moderno de workload é um problema de feedback.

Observe.

Meça.

Compare com objetivo.

Ajuste.

Observe novamente.


🧩 CAPÍTULO 25 — O AGENTE PODE TER MAIS DE UM RECURSO CRÍTICO

Outro detalhe importante.

Um agente pode estar ótimo em CPU e péssimo em:

tokens

Ou ótimo em tokens e bloqueado em:

Db2

Ou ótimo no Db2 e limitado pela:

API externa

Portanto precisamos enxergar múltiplas dimensões:

CPU
MEMORY
TOKEN RATE
LLM CONCURRENCY
DB CONNECTIONS
API RATE
NETWORK
COST

A pergunta deixa de ser:

Temos capacidade?

e vira:

Temos capacidade onde?

Essa pequena palavra muda muita coisa.


💡 CAPÍTULO 26 — DICAS PRÁTICAS PARA QUEM ESTÁ COMEÇANDO

Quando começar a trabalhar com agentes, pense desde cedo em workload.

Não espere chegar aos 500 agentes.

Comece perguntando:

1. Qual é o objetivo?

Gerar relatório?
Responder cliente?
Detectar fraude?

2. Qual é o prazo?

500 ms?
5 s?
1 min?
6 h?

3. Qual é a importância?

critical
interactive
standard
background

4. Quais recursos usa?

LLM
Db2
CICS
API
MQ
filesystem

5. Quais limites existem?

rate limit
concurrency
quota
budget

6. O que acontece na saturação?

queue?
throttle?
reject?
degrade?

7. Como saberemos que está ruim?

SLO
metrics
alerts

Essas perguntas evitam muito sofrimento futuro.


🥚 EASTER EGG — O AGENTE VIP

São 09:13.

O operador percebe:

AGENT-VIP
PRIORITY = MAXIMUM

Turing pergunta:

— Quem é esse?

— Agente da diretoria.

— Qual o SLO?

— Não tem.

— Qual workload?

— Faz resumo de notícias internas.

Turing olha para outro painel:

AGENT-FRAUD
QUEUED

— E esse?

— Detecta transações suspeitas.

Silêncio.

Turing aponta para AGENT-VIP.

— Por que ele possui prioridade máxima?

O programador responde:

— Porque pediram.

O pequeno robô começa lentamente a se afastar.

Do outro lado do CPD, o administrador WLM fecha os olhos.

Turing pega o café.

— Acabamos de descobrir por que governança existe.


👑 CAPÍTULO 27 — PRIORIDADE TAMBÉM PRECISA DE GOVERNANÇA

Esse ponto é fundamental.

Se qualquer equipe puder declarar:

MY_AGENT = CRITICAL

em poucas semanas teremos:

500 CRITICAL AGENTS

E então:

CRITICAL

não significa absolutamente nada.

Precisamos de critérios.

Por exemplo:

CRITICAL
Impacto financeiro imediato
ou risco operacional grave.

INTERACTIVE
Humano aguardando resposta.

STANDARD
Processamento normal.

BACKGROUND
Sem interação humana imediata.

Classificação precisa ser governada.

Caso contrário ocorre a inflação de prioridade.

É como colocar:

URGENTE!!!

em todos os e-mails.

Depois de algum tempo ninguém acredita mais.


🛡️ CAPÍTULO 28 — DEGRADAÇÃO GRACIOSA

Imagine que o modelo mais poderoso esteja saturado.

Temos duas escolhas.

A

Falhar.

B

Talvez usar um modelo menor para tarefas compatíveis.

PREMIUM MODEL
      ↓ saturado
SMALL MODEL

Ou reduzir funcionalidades.

FULL ANALYSIS
      ↓ pressão
BASIC ANALYSIS

Isso é uma forma de graceful degradation.

O sistema continua oferecendo valor, embora em nível reduzido.

Mas cuidado.

Nunca faça downgrade silencioso quando isso alterar requisitos críticos de qualidade ou segurança.

A UX precisa informar quando o comportamento muda de maneira relevante.


📉 CAPÍTULO 29 — ERROR BUDGET: QUANTO PODEMOS ERRAR?

Em práticas de SRE aparece um conceito interessante:

error budget.

Se nosso SLO é:

99.9%

não estamos declarando perfeição absoluta.

Existe uma margem de falha tolerada.

O orçamento de erro ajuda a equilibrar:

confiabilidade

e:

velocidade de mudança

Para agentes, o conceito pode inspirar discussões úteis.

Mas precisamos tomar cuidado.

Não significa:

O agente tem autorização para errar 0,1% das transferências bancárias.

😂

Contexto importa.

Algumas operações exigem controles muito mais rigorosos.

O princípio é operacional:

Defina objetivos mensuráveis e saiba quanto desvio é tolerável antes de tomar ação.


🧠 CAPÍTULO 30 — A INTELIGÊNCIA NÃO ELIMINA A FILA

Talvez esta seja a conclusão mais divertida.

Passamos décadas tornando máquinas mais inteligentes.

Criamos:

machine learning
deep learning
LLMs
agents

E finalmente construímos software capaz de:

interpretar
planejar
decidir
usar ferramentas

Então colocamos 500 deles juntos.

E descobrimos que eles precisam...

pegar senha.

😂

Porque inteligência não cria CPU infinita.

Não cria banda infinita.

Não cria conexões Db2 infinitas.

Não cria tokens infinitos.

E definitivamente não cria orçamento infinito.

Portanto até uma sociedade de agentes precisa de:

fila
prioridade
quota
limite
scheduler

Alguns problemas sobrevivem a todas as revoluções tecnológicas.


🏰 CAPÍTULO 31 — A GRANDE ARQUITETURA DOS AGENTES

Agora podemos juntar os artigos anteriores.

Imagine:

                    HUMANO
                       │
                       ▼
                    OBJETIVO
                       │
                       ▼
                ┌────────────┐
                │   AGENTE   │
                └────────────┘
                       │
        ┌──────────────┼──────────────┐
        ▼              ▼              ▼
       LLM            APIs           TOOLS
        │              │              │
        └──────────────┼──────────────┘
                       ▼
                    SISTEMAS

Ao redor:

RACF
→ quem pode fazer?

PF3
→ posso parar?

SDSF
→ o que está fazendo?

MAXCC
→ funcionou?

WLM
→ quem recebe recursos primeiro?

Agora nossa arquitetura começa a parecer adulta.


☕ EPÍLOGO — ATÉ ROBÔ PRECISA ESPERAR SUA VEZ

No final do dia, Turing voltou ao painel.

Às 09:00 havia:

500 agentes

todos tentando executar simultaneamente.

Agora o sistema mostrava:

AI WORKLOAD MANAGER

CRITICAL
ACTIVE: 42
QUEUED: 3
SLO: OK

INTERACTIVE
ACTIVE: 80
QUEUED: 17
SLO: OK

STANDARD
ACTIVE: 40
QUEUED: 121
SLO: OK

BACKGROUND
ACTIVE: 10
QUEUED: 287
SLO: OK

O pequeno robô protestou:

— Mas existem 287 agentes esperando!

Turing respondeu:

— Sim.

— Isso não é ruim?

— Não necessariamente.

— Mas eles poderiam estar trabalhando.

— Não.

Turing apontou para o painel:

DB2 POOL......... 72%
CICS............. HEALTHY
API ERRORS....... 0.2%
P95.............. WITHIN SLO
COST/HOUR........ CONTROLLED

— Eles poderiam estar competindo.

Essa é uma diferença importante.

Um sistema saudável não é aquele no qual tudo executa imediatamente.

É aquele no qual o trabalho certo recebe os recursos certos no momento certo, enquanto o restante espera de maneira controlada.

Essa lição existe no mainframe há décadas.

E continuará existindo quando nossos sistemas forem povoados por milhares de agentes.

Porque o problema fundamental nunca foi apenas executar trabalho.

Foi administrar:

DEMANDA

contra:

CAPACIDADE

respeitando:

OBJETIVOS

e:

PRIORIDADES

sem destruir:

CONFIABILIDADE

ou:

ORÇAMENTO.

Turing escreve cinco perguntas no quadro:

RACF
QUEM PODE?

PF3
POSSO PARAR?

SDSF
O QUE ESTÁ FAZENDO?

MAXCC
FUNCIONOU?

WLM
QUEM PASSA PRIMEIRO?

O jovem programador COBOL observa aquilo por alguns segundos.

— Professor...

— Sim?

— Estamos realmente inventando o futuro ou apenas reencontrando problemas antigos em abstrações novas?

Turing sorri.

Talvez essa seja uma das perguntas mais importantes de toda esta série.

A computação muda de linguagem.

Muda de interface.

Muda de hardware.

Muda de arquitetura.

Muda de escala.

Mas determinados problemas permanecem:

identidade,

autoridade,

observabilidade,

prioridade,

recuperação,

capacidade,

controle.

Chamávamos uma unidade de trabalho de:

JOB

Agora podemos chamá-la de:

AGENT RUN

Chamávamos o gerenciamento de recursos de:

WORKLOAD MANAGEMENT

E talvez continuemos chamando exatamente assim.

Porque quando 500 inteligências artificiais levantarem a mão ao mesmo tempo e disserem:

Eu quero trabalhar!

alguém — humano ou software — ainda terá que responder:

Pegue uma senha.

No canto da tela aparece:

AGENT-ARCHIVE
STATE: QUEUED
POSITION: 287

O robô pergunta:

— Quanto tempo?

Turing olha para o WLM.

— Depende da importância do seu trabalho.

O robô cruza os braços.

— Isso é discriminação contra inteligências artificiais.

O operador responde do fundo do CPD:

— Não. É capacity planning.

READY

E havia outros 286 agentes na frente dele.

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

sábado, 22 de abril de 2023

🔭 ALAN TURING E O SDSF DOS AGENTES — O QUE DIABOS A INTELIGÊNCIA ARTIFICIAL ESTÁ FAZENDO AGORA?

 

Bellacosa Mainframe monitorando a ia

☕ UM CAFÉ NO BELLACOSA MAINFRAME

🔭 ALAN TURING E O SDSF DOS AGENTES — O QUE DIABOS A INTELIGÊNCIA ARTIFICIAL ESTÁ FAZENDO AGORA?

Observabilidade, logs, métricas, traces, spans, OpenTelemetry, tokens, custos, latência, estados, workflows, auditoria, SDSF, JES2, SMF, RMF, CICS — e o dia em que Alan Turing descobriu que “AGENT RUNNING...” era quase tão informativo quanto um operador responder “sei lá, está processando”.



🎬 PRÓLOGO — O ROBÔ ESTAVA “TRABALHANDO”

Alan Turing entrou novamente no CPD.

O pequeno agente de IA estava diante de um terminal.

Na tela:

AGENT STATUS
============

RUNNING...

Turing esperou.

Um minuto.

Dois minutos.

Cinco minutos.

Continuava:

RUNNING...

O jovem programador COBOL apareceu carregando café.

— Bom dia, professor.

Turing apontou para a tela.

— O que ele está fazendo?

— Trabalhando.

— Em quê?

— Não sei.

— Em qual etapa?

— Também não sei.

— Encontrou algum erro?

— Acho que não.

— Quanto já gastou?

— Não faço ideia.

— Está esperando alguma coisa?

— Talvez.

Turing olhou novamente para:

RUNNING...

e sentenciou:

— Então vocês construíram uma máquina capaz de tomar decisões, utilizar ferramentas e executar ações... mas colocaram nela a mesma lâmpada de “ocupado” de uma impressora de 1987?

Silêncio.

No fundo do CPD alguém apertou Enter tentando não rir.

Turing puxou uma cadeira.

— Abra o SDSF.

E assim começou nossa terceira aventura.



🏛️ CAPÍTULO 1 — NO MAINFRAME, “ESTÁ RODANDO” NUNCA FOI RESPOSTA SUFICIENTE

Imagine que você submeta:

//PAYROLL JOB ...
//STEP01  EXEC PGM=PAYCALC
//STEP02  EXEC PGM=REPORT
//STEP03  EXEC PGM=ARCHIVE

Você pergunta ao operador:

Como está o PAYROLL?

E ele responde:

Está fazendo coisas.

Provavelmente essa resposta não sobreviveria muitos minutos no CPD.

Queremos saber:

JOBNAME
JOBID
OWNER
STATUS
QUEUE
STEP
RETURN CODE
OUTPUT

O SDSF existe justamente nesse universo de monitorar e controlar processamento z/OS. A documentação da IBM descreve painéis capazes de acompanhar jobs desde a fila de entrada do JES, passando pelo processamento, até as filas de saída; o painel ST, por exemplo, é central para gerenciamento de jobs e output.

Podemos encontrar algo como:

JOBNAME   JOBID      OWNER      ST      CC
PAYROLL   JOB12345   BELLACOSA  OUTPUT  0000
FATURAM   JOB12346   FINANCE    OUTPUT  0008
BACKUP    JOB12347   OPERADOR   EXEC
REPORT    JOB12348   BELLACOSA  ABEND   S0C7

Isso muda tudo.

Não sabemos apenas:

“O computador está ocupado.”

Sabemos quem, o quê, onde e em qual estado.

É exatamente esse salto que precisamos fazer com agentes.



🤖 CAPÍTULO 2 — O AGENTE PRECISA DE UM JOBNAME

Imagine vários agentes corporativos:

AGENT-PAYROLL
AGENT-REPORT
AGENT-SUPPORT
AGENT-COBOL
AGENT-AUDIT

Agora imagine dezenas de execuções simultâneas.

Dizer:

AGENT RUNNING

é quase inútil.

Precisamos de identidade para a execução.

Por exemplo:

AGENT        RUN-ID       OWNER       STATUS
REPORT       A000471      VAGNER      RUNNING
COBOLSCAN    A000472      DEVTEAM     WAITING
SUPPORT      A000473      SERVICE     APPROVAL
PAYROLL      A000474      FINANCE     FAILED

Perceba a analogia:

JOBNAME  → AGENT/WORKFLOW
JOBID    → RUN-ID
OWNER    → USUÁRIO/SERVIÇO
STATUS   → ESTADO DO WORKFLOW

Não são equivalências técnicas perfeitas.

São equivalências conceituais.

E são extremamente úteis para pensar UX.

Porque quando alguém disser:

O agente fez besteira!

a primeira pergunta deveria ser:

Qual execução?



🚦 CAPÍTULO 3 — “RUNNING” NÃO É UM ESTADO SUFICIENTE

Um agente pode estar em situações completamente diferentes enquanto a interface simplesmente mostra:

RUNNING

Ele pode estar:

PLANNING
READING
WAITING_TOOL
EXECUTING_TOOL
RETRYING
WAITING_APPROVAL
PAUSED
ROLLING_BACK
COMPLETED
FAILED
CANCELLED

Isso importa muito.

Compare:

AGENT: REPORT
STATUS: RUNNING

com:

AGENT: REPORT
RUN-ID: A000471

OBJECTIVE:
Consolidar relatórios de setembro

CURRENT STATE:
WAITING_APPROVAL

CURRENT STEP:
5/7 - Enviar relatório financeiro

WAITING FOR:
Aprovação humana

WAIT TIME:
00:03:42

Agora sabemos o que está acontecendo.

Talvez o agente nem esteja consumindo processamento significativo.

Está simplesmente esperando alguém.

Uma boa interface precisa diferenciar:

TRABALHANDO

de:

ESPERANDO

e de:

TRAVADO

Parece óbvio.

Até você encontrar sistemas que tratam os três como:

PROCESSING...


🪵 CAPÍTULO 4 — LOG: O DIÁRIO DE BORDO

Primeiro instrumento da nossa caixa de observabilidade:

LOG.

Log é basicamente o registro de eventos ocorridos.

O OpenTelemetry define logs como registros de eventos e suporta informações estruturadas como timestamp, severidade, corpo, atributos e também identificadores de trace e span, permitindo correlação com outros sinais.

Um log simples:

10:01:03 Agent started
10:01:04 Reading report
10:01:12 Report loaded
10:01:13 Calling model
10:01:18 Analysis completed

Já ajuda.

Mas podemos fazer melhor.

timestamp=10:01:03
agent=REPORT
run_id=A000471
event=workflow.started
owner=VAGNER

Depois:

timestamp=10:01:12
agent=REPORT
run_id=A000471
event=file.read
file=REPORT-09
status=success
duration_ms=284

Agora temos structured logging.

Em vez de texto para seres humanos lerem manualmente, possuímos campos que sistemas podem consultar.

Podemos perguntar:

event = tool.error

ou:

run_id = A000471

ou:

duration_ms > 5000

Isso é tremendamente mais poderoso.


📜 CAPÍTULO 5 — O SYSOUT DO ROBÔ

Aqui o programador COBOL começa a sorrir.

Porque o conceito não é estranho.

Quando um job termina, frequentemente vamos investigar sua saída.

SDSF permite navegar pelos outputs de jobs e pelas informações de processamento; historicamente, muito output destinado ao JES sequer precisava ser fisicamente impresso — podia ser inspecionado no SDSF.

Nosso agente também deveria deixar evidências.

Algo como:

RUN A000471

AGENT........ REPORT
START........ 10:01:03
END.......... 10:02:44
DURATION..... 00:01:41

MODEL CALLS.. 4
TOOL CALLS... 7
FILES READ... 12
FILES WRITE.. 1
WARNINGS..... 2
ERRORS....... 0

RESULT........ COMPLETED_WITH_WARNINGS

Não precisamos literalmente transformar agentes em JES.

Mas precisamos abandonar a filosofia:

“Ele respondeu, então provavelmente deu tudo certo.”


📊 CAPÍTULO 6 — MÉTRICA NÃO É LOG

Turing escreve:

LOG
≠
METRIC

Log responde muito bem a:

O que aconteceu?

Métrica responde melhor a:

Quanto está acontecendo?

Por exemplo:

agent_runs_total = 15420
agent_failures_total = 327
average_duration = 18.4 s
tool_calls_total = 92481
approval_wait_time = 47.2 s
input_tokens = ...
output_tokens = ...

OpenTelemetry é hoje um framework vendor-neutral para instrumentar, gerar, coletar e exportar telemetria, incluindo traces, metrics e logs.

Para aplicações GenAI, suas convenções incluem atributos relacionados ao uso de tokens e identificação de workflows/agentes; essas convenções específicas continuam evoluindo, portanto não devemos tratá-las como uma pedra gravada para toda a eternidade.


💰 CAPÍTULO 7 — AGORA A TELEMETRIA TEM CONTA PARA PAGAR

No mainframe sempre aprendemos que recurso computacional custa.

CPU.

I/O.

Storage.

Elapsed time.

Consumo não é abstração filosófica.

Com IA, aparece outro recurso:

TOKENS

Uma execução pode fazer:

CALL 1 → modelo
CALL 2 → modelo
CALL 3 → ferramenta
CALL 4 → modelo
CALL 5 → ferramenta
CALL 6 → modelo

Talvez obtenha a resposta correta.

Mas quanto custou?

Um dashboard poderia mostrar:

RUN-ID............ A000471
MODEL CALLS....... 8
INPUT TOKENS...... 34,812
OUTPUT TOKENS..... 8,401
TOOL CALLS........ 14
DURATION.......... 01:47
ESTIMATED COST.... ...

As convenções de GenAI do OpenTelemetry contemplam métricas e atributos de uso de tokens; a observabilidade pode então ajudar a detectar prompts excessivamente grandes, regressões de latência e padrões de consumo.

E aqui aparece um velho fantasma mainframe:

EFICIÊNCIA.

Um agente que consegue resolver uma tarefa em:

3 chamadas

pode ser operacionalmente preferível a outro que precisa:

37 chamadas

mesmo que ambos terminem corretamente.


⏱️ CAPÍTULO 8 — LATÊNCIA: O AGENTE DEMOROU, MAS ONDE?

Imagine:

TOTAL = 18 segundos

Isso não nos diz muita coisa.

Talvez:

LLM............. 2 s
DATABASE........ 1 s
API............. 1 s
FILE............ 1 s

Então onde foram parar os outros 13 segundos?

Precisamos decompor.

É aí que entramos no mundo do distributed tracing.


🧵 CAPÍTULO 9 — TRACE: SIGA O FIO DE ARIADNE

Imagine uma execução completa:

Usuário
  ↓
Agente
  ↓
LLM
  ↓
Busca
  ↓
Db2
  ↓
LLM
  ↓
API
  ↓
Resultado

Um trace acompanha a operação através dessas etapas.

Dentro dele encontramos spans.

Podemos imaginar:

TRACE A000471
│
├─ SPAN 1 invoke_agent ........ 18.2s
│
├─ SPAN 2 plan ................  1.1s
│
├─ SPAN 3 model_call ..........  2.4s
│
├─ SPAN 4 search_documents ....  4.8s
│
│   ├─ SPAN 5 api_call ........  3.9s
│   └─ SPAN 6 parse ...........  0.7s
│
├─ SPAN 7 analyze .............  5.2s
│
└─ SPAN 8 write_report ........  1.4s

Agora descobrimos:

Ahá!

A busca documental está custando quase cinco segundos.

Um span representa uma execução individual de uma operação significativa dentro de um trace; as convenções do OpenTelemetry padronizam atributos para facilitar correlação entre tecnologias diferentes.


🔬 CAPÍTULO 10 — TRACE É O “QUAL STEP ESTÁ DEMORANDO?” DO MUNDO DISTRIBUÍDO

Um programador batch entende isso rapidamente.

Imagine:

STEP01  00:00:01
STEP02  00:00:02
STEP03  00:14:37
STEP04  00:00:01

Onde investigar?

Não precisa chamar Sherlock Holmes.

STEP03

Tracing faz algo conceitualmente semelhante em sistemas distribuídos.

Mas existe uma complicação.

Um agente pode decidir dinamicamente qual ferramenta chamar.

Portanto duas execuções do mesmo objetivo podem seguir caminhos diferentes.

RUN A
Agent
 ├─ LLM
 ├─ Search
 ├─ Db2
 └─ Report

enquanto:

RUN B
Agent
 ├─ LLM
 ├─ Search
 ├─ API
 ├─ Search novamente
 ├─ LLM
 └─ Report

Agora tracing deixa de ser luxo.

Torna-se instrumento para entender o caminho realmente escolhido.


🧠 CAPÍTULO 11 — O AGENTE POSSUI UM “STEP” QUE NÃO EXISTIA NO JCL

No JCL tradicional, normalmente declaramos etapas.

//STEP01 EXEC PGM=A
//STEP02 EXEC PGM=B
//STEP03 EXEC PGM=C

O agente pode raciocinar:

Talvez A.

Não.

Preciso consultar B.

Resultado incompleto.

Vou tentar C.

Agora preciso voltar para A.

Isso é poderoso.

Mas torna a execução menos previsível.

Portanto precisamos registrar:

OBJETIVO
↓
DECISÃO
↓
FERRAMENTA ESCOLHIDA
↓
RESULTADO
↓
PRÓXIMA DECISÃO

Não precisamos — nem devemos — exigir exposição irrestrita de raciocínio interno privado do modelo.

Precisamos registrar decisões e eventos operacionalmente relevantes.

Por exemplo:

STEP 4
ACTION: customer_lookup
REASON: Dados insuficientes para validar pedido
RESULT: 1 customer found
NEXT: order_lookup

Isso é auditável e útil sem transformar telemetria em uma descarga indiscriminada de conteúdo interno.


🔗 CAPÍTULO 12 — TRACE ID: O CPF DA EXECUÇÃO

Imagine receber:

ERROR 500

Fantástico.

Onde?

Quando?

Para quem?

Em qual execução?

Precisamos de correlação.

Um identificador como:

trace_id = 7A91...

pode acompanhar uma operação através de vários componentes.

E então um log pode carregar:

TraceId
SpanId

O modelo de logs do OpenTelemetry prevê justamente essa correlação, permitindo conectar registros a traces e spans.

Assim podemos sair de:

ERROR: timeout

para:

RUN A000471
TRACE 7A91
SPAN DB2_QUERY
ERROR timeout

Agora temos pista.


🚨 CAPÍTULO 13 — MÉDIA É O MIMIC DA OBSERVABILIDADE

Você olha o dashboard:

Average latency = 2 seconds

Maravilhoso.

Só que alguns usuários esperam 40 segundos.

A média esconde caudas.

Por isso sistemas modernos frequentemente observam percentis:

p50
p95
p99

Exemplo:

p50 = 1.4 s
p95 = 5.8 s
p99 = 21.7 s

Agora percebemos que uma pequena parcela das execuções sofre muito.

Isso vale especialmente para agentes porque workflows podem variar enormemente.

Uma execução consulta duas ferramentas.

Outra consulta vinte.

A média olha para ambas e diz:

Está tudo razoável.

O p99 começa a gritar no corredor.


❤️ CAPÍTULO 14 — MÉTRICAS DO AGENTE NÃO DEVEM SER APENAS TÉCNICAS

Imagine este dashboard:

CPU........ OK
MEMORY..... OK
LATENCY.... OK
ERRORS..... 0

Excelente.

Mas o agente resolveu o problema?

Precisamos também de métricas funcionais.

Por exemplo:

TASK SUCCESS RATE
HUMAN ESCALATION RATE
ROLLBACK RATE
APPROVAL REJECTION RATE
RETRY RATE
TOOL FAILURE RATE
AVERAGE STEPS PER TASK
COST PER SUCCESSFUL TASK

E aqui aparece uma métrica especialmente interessante:

TASK COMPLETED

não deveria significar apenas:

O workflow chegou ao último nó.

Deveria significar:

O critério de sucesso foi realmente atingido.

É a diferença entre:

MAXCC=0000

e:

O relatório contém os números corretos.

Velho problema.

Roupa nova.


🧾 CAPÍTULO 15 — OBSERVABILIDADE NÃO É AUDITORIA

Turing escreve no quadro:

OBSERVABILIDADE
≠
AUDITORIA

Observabilidade pergunta:

O que está acontecendo com o sistema?

Auditoria pergunta:

Quem fez o quê, quando, com qual autoridade e qual foi o resultado?

Exemplo operacional:

tool_call duration=840ms

Isso é ótimo para observabilidade.

Mas uma trilha de auditoria pode precisar:

AGENT........ AGENT-CREDIT
RUN-ID....... A001991
REQUESTER.... USER471
ACTION....... CREDIT_LIMIT_CHANGE
CUSTOMER..... 98127
OLD_VALUE.... 10000
NEW_VALUE.... 15000
APPROVER..... MANAGER08
TIMESTAMP.... 14:32:11
RESULT....... SUCCESS

Agora podemos reconstruir o evento.

Auditoria é particularmente importante quando o agente age em vez de apenas responder.


🔐 CAPÍTULO 16 — CUIDADO: OBSERVABILIDADE TAMBÉM PODE VAZAR SEGREDOS

Aqui aparece uma armadilha enorme.

Você decide:

Quero registrar tudo!

Prompt.

Resposta.

Documentos.

Argumentos das ferramentas.

Resultados.

Fantástico para debugging.

Talvez terrível para segurança.

Logs podem acabar contendo:

dados pessoais
segredos comerciais
credenciais
tokens
informação financeira
código proprietário
documentos confidenciais

A própria documentação de observabilidade GenAI chama atenção para o fato de que conteúdo de mensagens e tool calls pode ser capturado quando habilitado, enquanto implementações podem permitir desativar a exportação desse conteúdo.

Portanto:

Observabilidade não significa registrar tudo indiscriminadamente.

Precisamos pensar em:

REDACTION
MASKING
SAMPLING
RETENTION
ACCESS CONTROL
ENCRYPTION

O log também é dado.

E dado precisa de governança.


🧹 CAPÍTULO 17 — NÃO TRANSFORME O LOG NUM DEPÓSITO DE LIXO

Outro clássico.

DEBUG 1
DEBUG 2
ENTROU AQUI
PASSOU AQUI
TESTE
XYZ
AAAA

😂

Todo programador já encontrou algum parente dessa criatura.

Logs úteis precisam responder perguntas.

Uma boa estrutura pode incluir:

timestamp
severity
service
agent
run_id
trace_id
span_id
event
tool
duration
status
error_type

E usar níveis coerentes:

DEBUG
INFO
WARN
ERROR

Não transforme tudo em:

ERROR

senão o erro perde significado.

É o equivalente moderno de um painel inteiro piscando vermelho.

Depois de quinze minutos ninguém mais olha.


🌉 CAPÍTULO 18 — OPENTELEMETRY: UMA LÍNGUA COMUM

Em sistemas distribuídos temos:

Java
Python
Node
API Gateway
Kubernetes
Db2
MQ
CICS
Cloud
Mainframe
LLM
Agent

Cada componente poderia produzir telemetria de maneira completamente diferente.

Correlação viraria pesadelo.

OpenTelemetry tenta fornecer uma linguagem e arquitetura vendor-neutral para sinais de observabilidade, especialmente traces, metrics e logs.

Podemos imaginar:

APLICAÇÕES
     ↓
INSTRUMENTAÇÃO
     ↓
OpenTelemetry
     ↓
COLLECTOR
     ↓
BACKEND DE OBSERVABILIDADE

O Collector pode receber, processar e exportar telemetria.

O objetivo não é:

“Comprar um dashboard bonito.”

É:

Padronizar a forma de produzir e transportar evidência operacional.


🏷️ CAPÍTULO 19 — CONVENÇÕES SEMÂNTICAS: CHAME A MESMA COISA PELO MESMO NOME

Imagine:

Sistema A:

duration

Sistema B:

elapsed

Sistema C:

execution_time

Sistema D:

how_long_this_thing_took

😂

Agora tente construir um dashboard corporativo.

Convenções semânticas procuram padronizar nomes e significados para operações e dados observáveis. O OpenTelemetry mantém convenções para traces, métricas, logs, profiles e resources.

No universo GenAI isso é especialmente importante.

Queremos poder falar de conceitos como:

agent
model
operation
tool
token usage
workflow

de maneira consistente.

As convenções GenAI ainda estão evoluindo, o que é natural numa área que também está mudando rapidamente.


🧬 CAPÍTULO 20 — SDSF + SMF + RMF + OTEL: NÃO SÃO A MESMA COISA

Aqui precisamos evitar uma simplificação perigosa.

Não podemos dizer:

SDSF = OpenTelemetry

Não é.

Nem:

SMF = logs
RMF = metrics

como equivalências técnicas exatas.

São tecnologias com histórias, escopos e arquiteturas diferentes.

Mas podemos construir uma ponte didática.

SDSF

Ajuda o operador a ver e controlar execução.

SMF

Produz enorme quantidade de registros operacionais e de accounting sobre atividades do sistema.

RMF

Historicamente fornece medição e análise de performance e recursos.

OpenTelemetry

Padroniza instrumentação e transporte de sinais modernos de observabilidade.

Então, pedagogicamente:

MAINFRAME
                     MUNDO DISTRIBUÍDO

SDSF        ←→       Operational UI
SMF         ←→       Telemetry records
RMF         ←→       Performance metrics
Job/Step    ←→       Trace/Span
JobID       ←→       Run/Trace correlation
SYSOUT      ←→       Logs / execution evidence

A seta significa:

“pense na função conceitual”

e não:

“são a mesma tecnologia”.

Essa diferença é importantíssima.


🖥️ CAPÍTULO 21 — COMO SERIA O “SDSF DOS AGENTES”?

Agora podemos desenhar.

Imagine:

AGENT OPERATIONS FACILITY
────────────────────────────────────────────────────

AGENT       RUN-ID    OWNER     STATE       TIME
REPORT      A00471    VAGNER    EXECUTING   00:01:47
COBOLSCAN   A00472    DEV       COMPLETE    00:00:38
PAYROLL     A00473    FINANCE   APPROVAL    00:03:12
SUPPORT     A00474    CRM       FAILED      00:00:09
BACKUP      A00475    OPS       RETRYING    00:00:41

Coloque:

S

ao lado de REPORT.

Abre:

OBJECTIVE
Consolidar relatórios mensais

CURRENT STEP
4/7 Analyze financial data

MODEL CALLS
5

TOOL CALLS
8

TOKENS
18,471 / 4,901

ELAPSED
00:01:47

WARNINGS
2

STATUS
EXECUTING

Agora:

L

para logs.

T

para trace.

M

para metrics.

P

para pause.

C

para cancel.

A

para approvals.

Meu Deus.

Acabamos de reinventar uma workstation operacional para agentes.

O barbudo do mainframe começa a sorrir.


🧰 CAPÍTULO 22 — PASSO A PASSO: INSTRUMENTANDO MENTALMENTE UM AGENTE

Mesmo que você seja um COBOL iniciante e não vá implementar OpenTelemetry amanhã, aprenda o raciocínio.

PASSO 1 — IDENTIFIQUE A EXECUÇÃO

Nunca dependa apenas de:

agent_name

Tenha algo equivalente a:

run_id
trace_id

PASSO 2 — DEFINA OS ESTADOS

Por exemplo:

QUEUED
PLANNING
RUNNING
WAITING_TOOL
WAITING_HUMAN
PAUSED
COMPLETED
FAILED
CANCELLED

PASSO 3 — REGISTRE EVENTOS IMPORTANTES

Não cada suspiro eletrônico.

Mas:

workflow.started
tool.called
tool.failed
approval.requested
approval.received
checkpoint.created
rollback.started
workflow.completed

PASSO 4 — MEÇA

latência
tokens
tool calls
retries
erros
tempo aguardando humano
custo

PASSO 5 — TRACE AS DEPENDÊNCIAS

Quando a execução atravessar:

agent → API → Db2 → MQ → CICS

preserve correlação.

PASSO 6 — PROTEJA A TELEMETRIA

Não registre segredos simplesmente porque são úteis para debugging.

PASSO 7 — DEFINA SUCESSO

Não use apenas:

DONE

Use critérios de negócio.

PASSO 8 — CONSTRUA ALERTAS ÚTEIS

Não alerte para tudo.

Alerte quando algo realmente exigir atenção.


🚨 CAPÍTULO 23 — O ALERTA QUE TOCA ÀS 3 DA MANHÃ

Todo sistema de observabilidade eventualmente encontra seu verdadeiro teste:

03:17.

Telefone toca.

ALERT:
AGENT FAILURE RATE > 25%

Você abre o painel.

Descobre:

Tool: CUSTOMER-API
p99 latency: 31s
Timeout rate: 38%
Retries: 4.2 per run

Agora existe hipótese.

Sem observabilidade:

A IA ficou burra.

Com observabilidade:

A API de clientes está degradada; o agente está repetindo chamadas e acumulando timeout.

Essa diferença é gigantesca.

Modelos inteligentes introduzem novas fontes de incerteza.

Não devemos atribuir todo problema ao modelo.

Pode ser:

modelo
prompt
tool
API
rede
Db2
MQ
permissão
rate limit
dados
timeout
bug

Observabilidade separa fantasmas de evidências.


🧙 CAPÍTULO 24 — TURING DESENHA AS QUATRO PERGUNTAS

Turing pega o giz.

Escreve:

1. O QUE ESTÁ ACONTECENDO?

Estado + logs.

2. QUANTO ESTÁ ACONTECENDO?

Métricas.

3. POR ONDE PASSOU?

Trace.

4. QUEM AUTORIZOU?

Auditoria.

O jovem COBOL acrescenta uma quinta:

5. QUANTO CUSTOU?

Turing olha.

— Muito bem.

O administrador do CPD acrescenta:

6. POSSO PARAR?

E o administrador RACF:

7. ELE PODIA FAZER ISSO?

Agora temos praticamente toda a série:

PF3
↓
POSSO PARAR?

MAXCC
↓
FUNCIONOU?

RACF
↓
PODIA FAZER?

SDSF
↓
O QUE ESTÁ FAZENDO?

🥚 EASTER EGG — S A00471

São 02:58.

O jovem operador vê:

AGENT       RUN-ID    STATE
REPORT      A00471    RUNNING

Digite:

S A00471

A tela abre.

CURRENT ACTION:
Searching documentation

ELAPSED:
02:47:31

FILES FOUND:
4,281,771

CURRENT DIRECTORY:
/

Silêncio.

Turing olha para o programador.

O programador olha para Turing.

O administrador de segurança derruba o café.

Alguém pergunta:

— Quem deu acesso ao filesystem inteiro?

Do fundo da sala vem uma voz:

— Foi para facilitar o protótipo.

O administrador RACF levanta lentamente da cadeira.

ICH408I

Fim do easter egg.


☕ EPÍLOGO — NÃO QUERO UMA IA TRANSPARENTE; QUERO UMA IA OPERÁVEL

Existe uma diferença importante.

Quando falamos em observabilidade, não estamos necessariamente exigindo enxergar todos os mecanismos internos de um modelo.

Queremos algo muito mais prático.

Queremos saber:

qual tarefa
qual execução
qual estado
qual etapa
qual ferramenta
quanto tempo
quanto recurso
qual erro
qual resultado
qual aprovação

Em outras palavras:

OPERABILIDADE.

Um agente corporativo precisa ser operável.

Precisa ser possível colocar alguém diante dele e perguntar:

O que está acontecendo?

E obter resposta melhor que:

RUNNING...

Isso parece uma discussão sobre inteligência artificial.

Mas também é uma discussão profundamente antiga sobre sistemas.

O mainframe aprendeu há décadas que executar trabalho empresarial significa deixar evidência.

Jobs possuem identidade.

Execuções possuem estados.

Etapas possuem resultados.

Output pode ser examinado.

Falhas precisam ser investigadas.

Recursos precisam ser medidos.

A IBM descreve SDSF justamente como um meio seguro de monitorar e gerenciar sistemas z/OS, jobs, output, recursos e mensagens operacionais.

O mundo distribuído acrescentou novos desafios.

Microsserviços.

APIs.

Cloud.

Containers.

Mensageria.

Agora adicionamos:

LLMs.

Tools.

RAG.

Copilotos.

Agentes.

Mas a pergunta do operador continua assustadoramente parecida.

O que diabos está acontecendo agora?

OpenTelemetry nos oferece uma linguagem moderna para parte dessa investigação, reunindo logs, métricas e traces e permitindo correlação entre componentes.

E os agentes tornam essa disciplina ainda mais importante.

Porque não estamos observando apenas software executando um caminho predeterminado.

Podemos estar observando software escolhendo dinamicamente qual caminho executar.

Quanto maior a autonomia...

maior a necessidade de evidência.

Quanto mais ferramentas disponíveis...

mais importante a correlação.

Quanto mais passos dinâmicos...

mais necessário o tracing.

Quanto maior o custo variável...

mais importantes as métricas.

Quanto maior o poder de ação...

mais importante a auditoria.

Alan Turing volta ao terminal.

A tela agora mostra:

AGENT: REPORT
RUN-ID: A00471

STATUS........ WAITING_APPROVAL
STEP.......... 6/7
ELAPSED....... 00:01:48
MODEL CALLS... 5
TOOL CALLS.... 8
WARNINGS...... 2
ERRORS........ 0

ACTION........ SEND REPORT
RISK.......... EXTERNAL ACTION
APPROVAL...... REQUIRED

[P] PAUSE
[C] CANCEL
[L] LOG
[T] TRACE
[M] METRICS
[A] APPROVE

Turing toma um gole de café.

— Melhor.

O programador pergunta:

— Agora sabemos tudo?

Turing sorri.

— Claro que não.

— Então o que sabemos?

Ele aponta para a tela.

— Sabemos onde procurar.

Para um operador, um SRE, um programador COBOL ou qualquer pessoa que já tenha passado algumas horas tentando descobrir por que um sistema parou às três da manhã...

isso já é uma diferença gigantesca.

Porque o futuro talvez esteja cheio de agentes inteligentes.

Mas quando alguma coisa der errado, alguém ainda precisará abrir uma tela e perguntar:

ST

Qual é o status?

Algumas perguntas sobrevivem a todas as revoluções tecnológicas.

READY

E, naturalmente...

há outro agente na fila.

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

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