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

domingo, 18 de janeiro de 2026

💣 DB2 Troubleshotting

Bellacosa Mainframe Db2 Troubleshotting

💣 DB2 Troubleshotting

💣 1. DEADLOCK — “o abraço da morte”

🧪 Cenário real

Transação A:

UPDATE CLIENTES SET NOME='ANA' WHERE ID=1;

Transação B:

UPDATE CLIENTES SET NOME='JOAO' WHERE ID=2;

👉 Depois:

  • A tenta atualizar ID=2
  • B tenta atualizar ID=1

💥 BOOM → deadlock


🧠 O que aconteceu?

Cada transação:

  • segura um lock
  • espera o lock da outra

👉 Db2 detecta e mata uma delas


💥 Sintoma clássico

SQLCODE = -911
REASON CODE = 00C90088

🔍 Diagnóstico

  • IFCID 172 (trace)
  • DISPLAY DATABASE LOCKS
  • Monitoramento (OMEGAMON)

🛠️ Soluções

✔ Acessar tabelas sempre na mesma ordem
✔ Reduzir tempo de transação
✔ Usar COMMIT mais frequente
✔ Evitar “holding locks” por muito tempo

💡 Regra de ouro:

Ordem consistente = evita deadlock


⚠️ 2. LOCK ESCALATION — “quando o Db2 perde a paciência”

🧪 Cenário real

Você roda:

UPDATE CLIENTES SET STATUS='A';

👉 Sem WHERE 😬


🧠 O que acontece?

  • Começa com row locks
  • Muitos locks acumulam
  • Db2 sobe para table lock

💥 Resultado:

Ninguém mais acessa a tabela


💥 Sintoma

  • Lentidão geral
  • Jobs travados
  • Reclamação do usuário 😅

🔍 Diagnóstico

  • IFCID 196
  • Monitoramento de locks
  • DSNZPARM (NUMLKTS / NUMLKUS)

🛠️ Soluções

✔ Sempre usar WHERE
✔ Commit em blocos (batch)
✔ Ajustar parâmetros de lock
✔ Usar LOCKSIZE adequado

💡 Bellacosa insight:

UPDATE sem WHERE é pedido formal de incidente 🚨


🚀 3. ACCESS PATH — “o plano invisível que decide tudo”

🧪 Cenário real

SELECT * FROM CLIENTES WHERE ID = 1;

👉 Parece simples… mas:

  • Usa índice? ⚡
  • Ou faz table scan? 🐢

🧠 O que é Access Path?

👉 Caminho que o otimizador escolhe para acessar os dados


🔍 Como ver?

EXPLAIN PLAN FOR
SELECT * FROM CLIENTES WHERE ID = 1;

👉 Consulta tabela PLAN_TABLE


💥 Possibilidades

TipoImpacto
Index scanRápido ⚡
Table scanLento 🐢
Nested loopBom
SortCusto extra

🛠️ Otimização

✔ Criar índice correto
✔ Atualizar RUNSTATS
✔ Evitar SELECT *
✔ Filtrar bem no WHERE


💡 Exemplo prático

❌ Ruim:

SELECT * FROM CLIENTES;

✅ Melhor:

SELECT NOME FROM CLIENTES WHERE ID = 1;

🧠 VISÃO DE PRODUÇÃO (OURO!)

🔥 Deadlock

👉 Problema de concorrência


🔥 Lock escalation

👉 Problema de volume de locks


🔥 Access path

👉 Problema de performance


💣 CHECKLIST RÁPIDO (salva carreira)

Antes de subir para produção:

✔ Tem índice?
✔ Tem WHERE?
✔ Tem COMMIT?
✔ Rodou EXPLAIN?
✔ RUNSTATS atualizado?


😎 FRASES DE SENIOR (pra usar na daily)

  • “Isso tá com cara de access path ruim”
  • “Provavelmente lock escalation”
  • “Vamos revisar o EXPLAIN antes de mexer”
  • “Isso aí vai dar -911 em produção”

quarta-feira, 2 de agosto de 2023

🗄️ ALAN TURING E O Db2 DOS AGENTES — QUANDO DUAS IAs ESTÃO CERTAS EM REALIDADES DIFERENTES

 

Bellacosa Mainframe concorrencia e questoes de dados quem é relevante

☕ UM CAFÉ NO BELLACOSA MAINFRAME

🗄️ ALAN TURING E O Db2 DOS AGENTES — QUANDO DUAS IAs ESTÃO CERTAS EM REALIDADES DIFERENTES

Db2, agentes de IA, COBOL, SQL, ACID, transações, isolamento, locks, MVCC, dirty read, non-repeatable read, phantom read, lost update, optimistic concurrency, timestamps, versionamento, commit, rollback, contexto, temporalidade, proveniência, RAG — e o dia em que Alan Turing descobriu que uma inteligência artificial pode estar absolutamente certa sobre uma realidade que deixou de existir três segundos atrás.



🎬 PRÓLOGO — AS DUAS INTELIGÊNCIAS ESTAVAM CERTAS

Alan Turing entrou no CPD.

Dois pequenos agentes estavam discutindo.

O primeiro gritava:

— O cliente possui R$ 10.000!

O segundo respondia:

— Não! Ele possui R$ 2.000!

Turing olhou para o programador COBOL.

— Qual deles está errado?

— Um dos dois, obviamente.

Turing tomou um gole de café.

— Tem certeza?

Na tela havia:

AGENT-A
READ TIME..... 10:00:01
BALANCE....... 10000.00

Na outra:

AGENT-B
READ TIME..... 10:00:04
BALANCE....... 2000.00

Entre as duas leituras:

10:00:03
WITHDRAWAL.... 8000.00
COMMIT........ OK

Silêncio.

O jovem programador coçou a barba imaginária que todo programador mainframe adquire depois de alguns anos.

Turing perguntou novamente:

— Qual inteligência artificial estava errada?

O pequeno robô respondeu:

— Nenhuma.

— Exatamente.

E escreveu no quadro:

DADOS NÃO EXISTEM FORA DO TEMPO.

A primeira lição daquele dia seria desagradavelmente simples:

Ler um dado não significa possuir a verdade. Significa possuir uma observação feita em determinado momento e sob determinadas condições.

Bem-vindo ao Db2 dos Agentes.



🗄️ CAPÍTULO 1 — O BANCO DE DADOS NÃO É UM ARMÁRIO

Para quem está começando em COBOL, é tentador imaginar banco de dados como um enorme armário.

Existe uma gaveta:

CUSTOMER

Dentro dela:

CUSTOMER_ID
NAME
BALANCE
STATUS
CREDIT_LIMIT

O programa pergunta:

SELECT BALANCE
FROM CUSTOMER
WHERE CUSTOMER_ID = 12345;

Db2 responde:

10000.00

Pronto.

Verdade encontrada.

Só que não.

Em um sistema corporativo real, enquanto você lê 10000.00, outras coisas podem estar acontecendo.

Um caixa eletrônico pode sacar dinheiro.

Uma API pode registrar pagamento.

Um programa COBOL pode alterar o limite.

Outro agente pode atualizar o cadastro.

Um batch pode consolidar movimentos.

Uma transação CICS pode estar executando naquele exato instante.

O banco de dados não é uma fotografia imóvel.

É uma cidade viva.



🧠 CAPÍTULO 2 — LER NÃO É COMPREENDER

Imagine que nosso agente recebe:

CUSTOMER_ID = 12345
BALANCE     = 10000

E conclui:

Cliente possui recursos suficientes para uma compra de R$ 8.000.

Matematicamente:

10000 >= 8000

Correto.

Mas talvez exista:

PENDING_PAYMENT = 5000

ou:

AVAILABLE_BALANCE = 3000

ou uma regra dizendo:

ACCOUNT_STATUS = BLOCKED

O dado isolado estava correto.

A interpretação estava incompleta.

Esse problema é enorme para agentes.

LLMs são extraordinariamente bons em transformar informações em linguagem e relações.

Mas não devemos confundir:

DADO

com:

SIGNIFICADO DO DADO.

Um agente corporativo precisa conhecer:

  • semântica;

  • origem;

  • unidade;

  • validade;

  • relacionamento;

  • regras de negócio;

  • temporalidade.

BALANCE = 10000 sem contexto pode ser praticamente inútil.



📚 CAPÍTULO 3 — O COPYBOOK JÁ TENTAVA NOS AVISAR

Programadores COBOL convivem com isso há décadas.

Veja:

01  WS-CUSTOMER.
    05 WS-CUSTOMER-ID       PIC 9(09).
    05 WS-BALANCE           PIC S9(11)V99 COMP-3.
    05 WS-STATUS            PIC X.

O layout explica a representação.

Mas ainda não explica completamente o significado.

O que significa:

WS-STATUS = 'B'

?

Blocked?

Bankrupt?

Business?

Batman?

😂

Sem documentação, regra de negócio ou conhecimento do sistema, temos apenas um byte.

É por isso que sistemas antigos frequentemente possuem algo valiosíssimo:

CONHECIMENTO SEMÂNTICO.

Está espalhado por:

copybooks
programas COBOL
DDL
stored procedures
documentação
regras
manuais
pessoas

Para um agente entender dados corporativos, não basta entregar tabelas.

Precisamos entregar contexto.



⏰ CAPÍTULO 4 — O DADO TEM IDADE

Turing escreve:

VALUE = 10000

Depois pergunta:

— Quando?

O programador responde:

— Como assim?

Turing acrescenta:

VALUE = 10000
READ_AT = 10:00:01

Agora temos algo muito mais interessante.

Porque:

10:00:01 → 10000
10:00:03 → withdrawal 8000
10:00:04 → 2000

O dado envelheceu em três segundos.

Chamaremos informalmente isso de:

DATA FRESHNESS.

Ou frescor do dado.

Para algumas informações:

3 segundos

é praticamente tempo real.

Para outras:

3 segundos

é perigosamente velho.

Temperatura média anual?

Sem problema.

Saldo bancário antes de autorizar pagamento?

Problema.


🕰️ CAPÍTULO 5 — TODA DECISÃO POSSUI UMA JANELA TEMPORAL

Nosso agente faz:

10:00:01 READ CUSTOMER
10:00:02 CALL LLM
10:00:04 SEARCH DOCUMENT
10:00:07 ANALYZE
10:00:09 DECIDE

Ele tomou uma decisão às:

10:00:09

baseado em informação obtida às:

10:00:01.

Temos oito segundos de diferença.

Em alguns processos isso é irrelevante.

Em outros é enorme.

Podemos imaginar:

DECISION AGE = DECISION_TIME - DATA_READ_TIME

Nesse caso:

8 segundos.

Uma arquitetura de agentes deveria perguntar:

Quanto tempo uma observação continua válida para esta decisão?

Isso é tão importante quanto o timeout discutido no CICS dos Agentes.


⚛️ CAPÍTULO 6 — ACID ENTRA NA SALA

Quando falamos de bancos transacionais, encontramos a famosa sigla:

ACID

Ela representa quatro propriedades conceituais:

A — Atomicity
C — Consistency
I — Isolation
D — Durability

Vamos traduzi-las para nosso pequeno robô.


⚛️ CAPÍTULO 7 — ATOMICIDADE: TUDO OU NADA

Imagine transferência:

Conta A: -100
Conta B: +100

Não queremos:

Conta A: -100
Conta B: ERROR

A unidade lógica precisa ser tratada de forma coerente.

Ou todas as alterações da unidade de trabalho são confirmadas, ou as alterações não confirmadas precisam ser revertidas conforme a transação e os recursos envolvidos.

Conceitualmente:

BEGIN

DEBIT A
CREDIT B

COMMIT

Se ocorrer problema:

ROLLBACK

Nosso agente precisa entender que ações relacionadas não podem ser tratadas como frases independentes de uma conversa.


🧭 CAPÍTULO 8 — CONSISTÊNCIA: NÃO QUEBRE AS REGRAS DO UNIVERSO

Consistência significa que as operações devem respeitar as regras e invariantes estabelecidas pelo sistema.

Por exemplo:

STOCK >= 0

ou:

ORDER must reference valid CUSTOMER

ou regras implementadas em aplicações, constraints, triggers e outros mecanismos.

O agente pode dizer:

Parece razoável.

Db2 responde:

Não perguntei se parece razoável.

😂

O sistema possui regras.

Inteligência probabilística não substitui integridade transacional.


🧱 CAPÍTULO 9 — ISOLAMENTO: AQUI COMEÇA A DIVERSÃO

Agora chegamos ao ponto central.

Imagine duas transações:

TX-A
TX-B

executando simultaneamente.

Queremos controlar o quanto uma transação pode perceber dos efeitos da outra enquanto ambas estão em andamento.

Isso é parte do problema de:

ISOLATION.

Sem isolamento adequado, concorrência pode produzir resultados surpreendentes.

E agentes multiplicam esse problema porque podemos ter:

10 agentes
100 agentes
1.000 agentes

tomando decisões simultaneamente.


💾 CAPÍTULO 10 — DURABILIDADE: COMMIT NÃO É PROMESSA DE BAR

Quando uma transação é confirmada com sucesso, esperamos que seu resultado persistente sobreviva conforme as garantias oferecidas pelo sistema.

Ou seja:

COMMIT

não deveria significar:

Acho que gravei.

Significa que a alteração alcançou o ponto de confirmação definido pelo sistema transacional.

Para agentes corporativos isso importa muito.

O agente precisa diferenciar:

PLANNED

de:

EXECUTED

e:

COMMITTED.

São estados diferentes.


👻 CAPÍTULO 11 — DIRTY READ: O FANTASMA QUE AINDA PODE DESAPARECER

Imagine:

TX-A:
UPDATE ACCOUNT
SET BALANCE = 2000

Mas ainda não houve commit.

Outra transação consegue observar essa alteração sob condições que permitam leitura não confirmada.

Depois A faz:

ROLLBACK.

A informação que B viu desapareceu.

B tomou decisão sobre algo que nunca se tornou estado confirmado.

É a ideia de:

DIRTY READ.

Para um agente, isso pode ser especialmente perigoso.

Ele pode gerar uma explicação brilhante baseada em uma alteração que será desfeita segundos depois.


🔁 CAPÍTULO 12 — NON-REPEATABLE READ: EU JURO QUE ERA 10.000

Agente A lê:

BALANCE = 10000

Agente B altera:

BALANCE = 2000
COMMIT

A lê novamente:

BALANCE = 2000

A mesma consulta lógica produziu valores diferentes durante a execução da atividade.

O pequeno robô olha para Turing:

— Professor, o banco mentiu para mim!

— Não.

— Mas mudou!

— Exatamente.

O mundo mudou.

Essa é uma distinção filosófica e técnica importante:

Mudança não é inconsistência.

Às vezes o sistema está funcionando perfeitamente.

A realidade simplesmente evoluiu.


👥 CAPÍTULO 13 — PHANTOM READ: APARECEU OUTRO CLIENTE

Imagine:

SELECT COUNT(*)
FROM ORDERS
WHERE STATUS = 'PENDING';

Resultado:

10

Outra transação insere novo pedido pendente.

Você executa novamente.

11

Apareceu uma nova linha que satisfaz o predicado da consulta.

O conjunto observado mudou.

É o tipo de fenômeno associado ao famoso:

PHANTOM.

Para agentes que fazem análises sobre conjuntos de dados, isso importa bastante.

O agente pode perguntar:

Quantas solicitações aguardam aprovação?

A resposta pode envelhecer antes de terminar a frase.


💥 CAPÍTULO 14 — LOST UPDATE: DOIS AGENTES ESTAVAM CERTOS

Temos:

STOCK = 10

Agent-A lê:

10

Agent-B lê:

10.

A decide vender 3.

Calcula:

10 - 3 = 7

B decide vender 4.

Calcula:

10 - 4 = 6.

A grava:

7

B grava:

6.

A atualização de A pode ser efetivamente perdida dependendo da forma como a aplicação implementa a concorrência.

O valor correto deveria refletir ambas as operações:

3.

Dois agentes.

Duas contas matematicamente corretas.

Resultado corporativo errado.

Esse é um dos melhores exemplos de por que:

INTELIGÊNCIA NÃO RESOLVE CONCORRÊNCIA.


🔒 CAPÍTULO 15 — LOCKS: RESERVANDO UM PEDAÇO DA REALIDADE

Uma abordagem tradicional para coordenar concorrência utiliza locks.

Simplificando:

AGENT-A
LOCK ROW

Agora B precisa esperar dependendo da operação, isolamento e mecanismos envolvidos.

A altera.

UPDATE
COMMIT

Lock liberado.

B continua.

Isso pode proteger consistência.

Mas lembra do CICS dos Agentes?

Locks possuem custo.

Se o agente fizer:

LOCK CUSTOMER

CALL LLM

SEARCH WEB

READ 50 PDFs

ASK HUMAN

WAIT 20 MINUTES

o DBA provavelmente surgirá atrás dele segurando um manual do Db2 como arma contundente.


☠️ CAPÍTULO 16 — NÃO PENSE SEGURANDO O LOCK

Nossa regra retorna:

NÃO DEIXE O LLM PENSAR SEGURANDO LOCKS DESNECESSÁRIOS.

Uma arquitetura possível:

READ
↓
CAPTURE VERSION
↓
RELEASE TRANSACTIONAL RESOURCES
↓
THINK
↓
REVALIDATE
↓
SHORT UPDATE TRANSACTION
↓
COMMIT

Mas agora aparece uma pergunta:

Como sabemos se o dado mudou enquanto o agente pensava?

Excelente.

Entramos no próximo monstro.


🔢 CAPÍTULO 17 — VERSIONAMENTO

Imagine tabela conceitual:

CUSTOMER
────────────────────────
ID          12345
BALANCE     10000
VERSION     17

O agente lê:

VERSION = 17.

Vai pensar.

Enquanto isso outra transação altera o registro.

Agora:

VERSION = 18.

Nosso agente retorna e tenta atualizar.

Em vez de simplesmente:

UPDATE CUSTOMER
SET CREDIT_LIMIT = 5000
WHERE CUSTOMER_ID = 12345;

podemos usar uma estratégia de concorrência otimista:

UPDATE CUSTOMER
SET CREDIT_LIMIT = 5000,
    VERSION = VERSION + 1
WHERE CUSTOMER_ID = 12345
  AND VERSION = 17;

Se:

ROWS UPDATED = 1

ótimo.

Se:

ROWS UPDATED = 0

alguma coisa mudou.

Pare.

Releia.

Reavalie.


optimistic CAPÍTULO 18 — OPTIMISTIC CONCURRENCY

O nome vem da ideia:

Provavelmente ninguém vai alterar isto enquanto estou trabalhando.

Em vez de manter um lock durante todo o raciocínio, registramos a versão observada.

Depois verificamos se ainda é a mesma.

Fluxo:

READ VERSION 17
      ↓
THINK
      ↓
CHECK VERSION
      ↓
   ┌───────┐
   │       │
  17      18
   │       │
   ▼       ▼
UPDATE   STALE
        RELOAD

Isso combina muito bem com agentes.

Por quê?

Porque raciocínio de IA pode levar tempo e envolver recursos externos.

Não queremos manter uma transação aberta durante todo esse período.


🥖 CAPÍTULO 19 — O PÃO DE QUEIJO DA CONCORRÊNCIA

Turing coloca um pão de queijo sobre a mesa.

Diz ao Agent-A:

— Quantos existem?

— Um.

Agent-A vira para consultar o LLM sobre a composição nutricional do pão de queijo.

Agent-B chega.

Come o pão de queijo.

Agent-A volta.

— Decidi com 98,7% de confiança que devo comer o pão de queijo.

Turing aponta para o prato vazio.

Agent-A:

ERROR:
RESOURCE NOT FOUND

😂

Essa é concorrência otimista explicada no café.

Você não precisa segurar o pão durante quinze minutos.

Mas antes de mordê-lo:

VERIFIQUE SE ELE AINDA EXISTE.


📸 CAPÍTULO 20 — SNAPSHOT: UMA FOTOGRAFIA DA REALIDADE

Às vezes queremos que uma operação trabalhe sobre uma visão consistente dos dados.

Conceitualmente, podemos imaginar:

SNAPSHOT @ 10:00:00

O agente analisa aquela visão.

Mesmo que o mundo continue mudando, sabemos:

Esta análise corresponde à realidade observada naquele ponto ou contexto transacional.

Isso é extremamente útil.

Mas exige honestidade.

O resultado deveria dizer algo como:

ANALYSIS-AS-OF:
2026-09-27T10:00:00

e não:

CURRENT STATE.

Se os dados eram de dez minutos atrás, não chame de “agora”.


🕰️ CAPÍTULO 21 — “AS OF” PODE SER TÃO IMPORTANTE QUANTO O VALOR

Imagine um relatório:

RISK SCORE = 72

Pergunta:

— Baseado em quê?

Resposta:

CUSTOMER DATA..... 10:00
PAYMENTS........... 09:58
CREDIT BUREAU...... 08:00
CRM................ yesterday

Agora entendemos muito melhor o resultado.

Para agentes, deveríamos considerar metadados como:

SOURCE
READ_AT
VALID_AT
VERSION
TRANSACTION_ID
RUN_ID

Isso cria:

PROVENIÊNCIA TEMPORAL.

Não basta saber de onde veio.

Precisamos saber de quando veio.


🤖 CAPÍTULO 22 — O RAG TAMBÉM POSSUI RELÓGIO

Agora chegamos a algo delicioso.

RAG:

Retrieval-Augmented Generation

Em termos simples:

PERGUNTA
↓
BUSCA INFORMAÇÃO
↓
ENTREGA CONTEXTO AO MODELO
↓
MODELO RESPONDE

Fantástico.

Mas imagine recuperar:

POLITICA-CREDITO-2024.PDF

quando existe:

POLITICA-CREDITO-2026.PDF.

O modelo pode interpretar perfeitamente o documento errado.

A resposta pode ser:

linguisticamente excelente
logicamente coerente
tecnicamente obsoleta.

Isso é assustador.


📚 CAPÍTULO 23 — EMBEDDING NÃO SABE QUE A NORMA FOI REVOGADA

Busca semântica responde:

Este documento é parecido com sua pergunta.

Ela não necessariamente responde:

Este documento continua válido hoje.

Essas são perguntas diferentes.

Um sistema RAG corporativo pode precisar considerar:

EFFECTIVE_FROM
EFFECTIVE_TO
VERSION
STATUS
SUPERSEDED_BY
SOURCE
AUTHORITY

Imagine:

DOC A
Similarity = 0.97
Status = EXPIRED

e:

DOC B
Similarity = 0.91
Status = ACTIVE.

Qual deveria ganhar?

Não necessariamente A.

A relevância semântica é apenas uma dimensão.


🧭 CAPÍTULO 24 — VERDADE TAMBÉM PRECISA DE PROVENIÊNCIA

Nosso agente afirma:

O limite do cliente é R$ 20.000.

Pergunte:

SOURCE?

Depois:

WHEN?

Depois:

VERSION?

Depois:

COMMITTED?

Depois:

AUTHORIZED SOURCE?

Uma resposta corporativa forte deveria conseguir produzir evidências.

Por exemplo:

VALUE......... 20000
SOURCE........ DB2.CUSTOMER_LIMIT
KEY........... 12345
READ_AT....... 10:42:03
VERSION....... 882
RUN-ID........ A004821

Agora temos algo auditável.


🪪 CAPÍTULO 25 — O RUN-ID ENCONTRA O DATA VERSION

No JES2 dos Agentes criamos:

RUN-ID.

Agora podemos relacionar:

RUN-ID A004821

com:

CUSTOMER VERSION 882
DOCUMENT VERSION 17
RULESET VERSION 42
MODEL VERSION X

Isso responde uma pergunta extremamente importante:

Qual realidade o agente viu quando tomou esta decisão?

Sem isso, uma auditoria futura pode encontrar dados diferentes e perguntar:

— Como a IA chegou nessa conclusão absurda?

Talvez não fosse absurda.

Talvez os dados fossem outros naquele momento.


🧪 CAPÍTULO 26 — REPRODUZIR UMA DECISÃO DE IA É MAIS DIFÍCIL

Com programa COBOL determinístico:

INPUT X
+
PROGRAM VERSION Y
=
OUTPUT Z

frequentemente temos comportamento bastante reproduzível.

Com agente:

PROMPT
MODEL
TOOLS
DATA
DOCUMENTS
TIMING
CONVERSATION
POLICY

todos podem influenciar.

Portanto registrar apenas:

PROMPT

não basta.

Podemos precisar registrar referências para:

RUN-ID
MODEL VERSION
PROMPT VERSION
TOOL VERSION
DATA VERSION
DOCUMENT VERSION
POLICY VERSION
TIMESTAMPS
RESULT

Isso é observabilidade encontrando governança de dados.

SDSF encontra Db2.


🔄 CAPÍTULO 27 — REVALIDATE BEFORE COMMIT

Aqui está uma regra poderosa.

Nosso agente:

READ
↓
THINK
↓
DECIDE

Antes de alterar algo importante:

REVALIDATE

Depois:

COMMIT.

Fluxo completo:

READ STATE V17
      ↓
ANALYZE
      ↓
PROPOSE ACTION
      ↓
CHECK CURRENT STATE
      ↓
V17?
 │
 ├─ YES → EXECUTE → COMMIT
 │
 └─ NO  → RELOAD → REASON AGAIN

Essa talvez seja uma das regras mais importantes de todo o artigo.

NÃO CONFIE CEGAMENTE NO SNAPSHOT QUE INICIOU O RACIOCÍNIO.


👤 CAPÍTULO 28 — HUMAN-IN-THE-LOOP PIORA O PROBLEMA TEMPORAL

Imagine:

10:00
Agent recommends payment

Humano recebe:

Approve?

Vai almoçar.

Volta:

13:30

Clica:

APPROVE.

O agente não deveria simplesmente continuar a operação planejada três horas e meia atrás.

Precisa:

RELOAD
REVALIDATE
REAUTHORIZE
EXECUTE

Talvez o saldo mudou.

Talvez o cliente foi bloqueado.

Talvez a regra mudou.

Talvez outro operador já resolveu.

A aprovação humana confirma intenção.

Não necessariamente confirma que o estado antigo continua válido.


🚨 CAPÍTULO 29 — STALE CONTEXT

Vamos dar nome ao monstro:

STALE CONTEXT.

O contexto ficou velho.

Exemplo:

AGENT CONTEXT
CUSTOMER_STATUS = ACTIVE
READ_AT = 10:00

Agora:

CURRENT DATABASE
CUSTOMER_STATUS = BLOCKED
UPDATED_AT = 10:03.

Às 10:05 o agente ainda carrega:

ACTIVE.

Isso não é hallucination.

Não é necessariamente erro do LLM.

É contexto obsoleto.

Essa distinção é importantíssima.


🧯 CAPÍTULO 30 — NEM TODO ERRO DE IA É ERRO DA IA

Quando um agente produz resposta incorreta, investigue:

MODEL?
PROMPT?
RETRIEVAL?
DATA?
TIMING?
TOOL?
CACHE?
VERSION?

Talvez o modelo tenha raciocinado corretamente sobre dados ruins.

Talvez os dados fossem bons, mas velhos.

Talvez a ferramenta tenha retornado cache.

Talvez a consulta tenha usado uma réplica com defasagem.

Talvez o documento recuperado estivesse revogado.

“IA errou” pode ser diagnóstico preguiçoso.

Precisamos descobrir:

EM QUAL CAMADA A REALIDADE SE DESVIOU?


🗃️ CAPÍTULO 31 — CACHE É UMA MÁQUINA DO TEMPO

Cache melhora desempenho.

No CICS dos Agentes adoramos isso.

Em vez de consultar Db2:

20 ms

podemos obter:

2 ms.

Fantástico.

Mas existe preço.

O dado pode estar:

STALE.

Imagine:

CACHE TTL = 5 minutes

Para:

COUNTRY CODE

talvez ótimo.

Para:

AVAILABLE BALANCE

talvez terrível.

Portanto:

Cache não é simplesmente performance. É uma decisão sobre quanto passado aceitamos apresentar como presente.


🎯 CAPÍTULO 32 — FRESHNESS BUDGET

No CICS tínhamos:

LATENCY BUDGET.

Agora podemos imaginar:

FRESHNESS BUDGET.

Por exemplo:

PRODUCT DESCRIPTION..... 24h
CUSTOMER ADDRESS........ 5m
ACCOUNT BALANCE......... 1s
FRAUD STATUS............ 0s / revalidate

Não são números universais.

São decisões de negócio e arquitetura.

Mas o conceito é poderoso:

Quão velho este dado pode estar antes de deixar de ser aceitável?


📊 CAPÍTULO 33 — O PAINEL DO Db2 DOS AGENTES

Imagine nosso painel operacional:

RUN-ID......... A004821
AGENT.......... CREDIT-ANALYSIS

DATA SOURCES
────────────────────────────────────────
CUSTOMER        VERSION 882    AGE 0.4s
BALANCE         VERSION 991    AGE 0.1s
CRM             VERSION 441    AGE 2m
CREDIT-RULES    VERSION 42     AGE 3d
RAG-DOC         VERSION 17     AGE 4h

DECISION AGE.................. 2.8s
STALE SOURCES................. 0
OPEN TRANSACTION.............. NO
LOCKS HELD.................... 0
REVALIDATION REQUIRED......... YES

Agora estamos falando.

O operador consegue enxergar não apenas:

O QUE O AGENTE ESTÁ FAZENDO?

mas:

QUAL REALIDADE ELE ESTÁ VENDO?

🧰 CAPÍTULO 34 — CHECKLIST PARA AGENTES QUE TOMAM DECISÕES SOBRE DADOS

Antes de colocar um agente corporativo em produção, pergunte:

1. Qual é a fonte oficial?

Db2?
API?
RAG?
cache?

2. O dado possui timestamp?

Saiba quando foi observado.

3. Existe versão?

Use versionamento quando necessário.

4. Qual é o freshness budget?

Defina tolerância.

5. O agente mantém transação aberta enquanto pensa?

Evite.

6. Existem locks?

Minimize duração.

7. Pode haver concorrência?

Presuma que sim.

8. Existe optimistic concurrency?

Considere version checking.

9. A ação precisa ser revalidada?

Para ações críticas, quase certamente.

10. O RAG conhece validade documental?

Não use apenas similaridade.

11. Existe proveniência?

Registre origem.

12. Podemos reconstruir a decisão?

Associe dados, versões e RUN-ID.

13. O humano pode demorar para aprovar?

Revalide depois da aprovação.

14. O cache é permitido?

Defina TTL de acordo com semântica.

15. O resultado informa “as of”?

Quando relevante, deveria.


🥚 EASTER EGG — O AGENTE QUE ESTAVA 100% CERTO

02:14 da madrugada.

Telefone toca.

— Produção.

O operador atende.

— Temos problema.

— Qual?

— A IA aprovou uma operação que deveria ter recusado.

Abrem o trace.

RUN-ID A008817

Modelo respondeu corretamente.

Prompt correto.

Regra correta.

RACF correto.

Nenhuma hallucination.

Turing chega carregando café.

— Mostre os dados.

CUSTOMER_STATUS = ACTIVE

— Quando foram lidos?

Silêncio.

Procuram.

CACHE READ:
01:43:02

Turing olha o relógio.

02:14.

Consulta Db2:

CUSTOMER_STATUS = BLOCKED
UPDATE TIME     = 01:44:11

O agente estava usando uma informação de 31 minutos atrás.

O jovem programador diz:

— Então a IA errou.

Turing responde:

— Não.

Aponta para o cache.

— Nós entregamos o passado e perguntamos sobre o presente.

Silêncio.

No fundo do CPD, o DBA sorri.

Finalmente não era culpa do banco.


🧬 CAPÍTULO 35 — NOSSO MAINFRAME DOS AGENTES ESTÁ FICANDO INTERESSANTE

Agora nossa arquitetura conceitual possui:

RACF
↓
QUEM PODE?
PF3
↓
POSSO PARAR?
SDSF
↓
O QUE ESTÁ FAZENDO?
MAXCC
↓
FUNCIONOU?
WLM
↓
QUEM RECEBE RECURSOS?
JES2
↓
QUEM COMEÇA E QUANDO?
CICS
↓
QUANTO TEMPO O HUMANO PODE ESPERAR?

E agora:

Db2
↓
QUAL REALIDADE O AGENTE ESTÁ VENDO?

Isso muda tudo.


🏰 CAPÍTULO 36 — O SISTEMA OPERACIONAL CONCEITUAL DOS AGENTES

Turing desenha novamente:

                     HUMANO
                        │
                        ▼
                 ┌─────────────┐
                 │   REQUEST   │
                 └──────┬──────┘
                        │
               ┌────────┴────────┐
               │                 │
               ▼                 ▼
             CICS               JES2
         responda agora      trabalhe depois
               │                 │
               └────────┬────────┘
                        ▼
                       WLM
                        │
                       RACF
                        │
                        ▼
                      AGENT
                        │
           ┌────────────┼────────────┐
           ▼            ▼            ▼
          LLM          Db2          TOOLS
                        │
                        ▼
               CURRENT REALITY?

Ao redor:

SDSF
OBSERVE

CHECKPOINT
RESUME

PF3
STOP

MAXCC
VERIFY

RUN-ID
IDENTIFY

VERSION
VALIDATE

TIMESTAMP
WHEN?

O mainframe não está apenas nos ensinando como executar agentes.

Está nos ensinando a fazê-los sobreviver à realidade corporativa.


👴 CAPÍTULO 37 — O PROGRAMADOR COBOL JÁ VIU ESSE FILME

O mundo de IA está descobrindo:

agents
tool calls
state
concurrency
context
workflow

O programador COBOL olha e pensa:

Vocês descobriram processamento corporativo.

😂

Porque ele já viveu:

CICS
Db2
JES2
MQ
RACF
WLM
COMMIT
ROLLBACK
LOCK
RESTART

Claro que agentes introduzem problemas novos.

Modelos probabilísticos.

Context windows.

Embeddings.

RAG.

Tool selection.

Autonomia.

Mas muitos monstros operacionais são antigos.

E nós já temos cicatrizes deles.


☕ EPÍLOGO — QUAL REALIDADE VOCÊ ESTÁ VENDO?

Fim da tarde.

O pequeno agente recebe:

CUSTOMER_ID = 12345

Consulta:

BALANCE = 10000
VERSION = 882
READ_AT = 17:42:01

Começa análise.

Enquanto pensa:

17:42:02
WITHDRAWAL = 8000
COMMIT
VERSION = 883

O agente termina:

17:42:04

Antigamente responderia:

Operação aprovada. O cliente possui R$ 10.000.

Mas agora aprendeu.

Antes de agir:

CHECK VERSION 882

Db2 responde:

CURRENT VERSION = 883.

O robô para.

Relê.

BALANCE = 2000.

Reavalia.

Resultado:

DECISION = DENIED
REASON   = INSUFFICIENT FUNDS

Turing sorri.

— Muito bem.

O agente pergunta:

— Minha primeira análise estava errada?

Turing responde:

— Não.

— Então por que não usei?

— Porque ela estava correta para uma realidade que não existia mais.

O programador COBOL olha para o terminal.

Na tela:

RUN-ID........ A004821

READ VERSION.. 882
CURRENT....... 883

CONTEXT....... STALE
REVALIDATION.. REQUIRED

ACTION........ REEVALUATED
STATUS........ COMMITTED

Turing termina o café.

Antes de sair, escreve no quadro:

UMA IA NÃO PRECISA APENAS SABER A RESPOSTA.

Abaixo:

PRECISA SABER DE QUANDO É A RESPOSTA.

E finalmente:

SELECT
    VALUE,
    VERSION,
    TIMESTAMP
FROM
    REALITY
WHERE
    NOW = NOW;

O programador observa.

— Professor...

— Sim?

— Essa tabela não existe.

Turing sorri.

— Ainda.

No fundo do CPD, o DBA grita:

— E NEM INVENTA DE CRIAR EM PRODUÇÃO!

O pequeno robô fecha o terminal.

COMMIT;

E todos foram tomar café.

Porque no mainframe, no Db2 e no mundo dos agentes, existe uma verdade que sobrevive a qualquer geração tecnológica:

Uma decisão só é tão confiável quanto os dados, o contexto e o instante da realidade sobre os quais ela foi construída.

READY

☕ 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, 8 de julho de 2023

⚡ ALAN TURING E O CICS DOS AGENTES — QUANTO TEMPO UM HUMANO ACEITA OLHAR PARA PROCESSING...?

 

Bellacosa Mainframe e as ligações dos agentes de ia

☕ UM CAFÉ NO BELLACOSA MAINFRAME

⚡ ALAN TURING E O CICS DOS AGENTES — QUANTO TEMPO UM HUMANO ACEITA OLHAR PARA PROCESSING...?

CICS, agentes de IA, transações online, latência, contexto, pseudo-conversationalidade, concorrência, locks, timeout, Db2, commit, rollback, syncpoint, idempotência, circuit breakers, human-in-the-loop — e o dia em que Alan Turing descobriu que uma inteligência artificial pode pensar durante cinco minutos, desde que não exista um cliente olhando para a ampulheta.



🎬 PRÓLOGO — O HUMANO ESTAVA ESPERANDO

Alan Turing entrou no CPD.

O relógio marcava:

10:14:03

Na tela de um terminal havia uma mensagem:

PROCESSING...

Turing tomou um gole de café.

10:14:08

Nada.

10:14:15

Nada.

10:14:31

Ainda:

PROCESSING...

O jovem programador COBOL apareceu.

— Bom dia, professor.

Turing apontou para a tela.

— O que está acontecendo?

— O agente está pensando.

— Há quanto tempo?

— Trinta segundos.

— E o usuário?

— Esperando.

Turing levantou uma sobrancelha.

— Existe uma diferença enorme entre um agente trabalhar durante trinta segundos e obrigar um ser humano a esperar trinta segundos.

O pequeno robô apareceu.

— Mas eu estou realizando uma análise muito sofisticada!

Turing respondeu:

— Parabéns.

Apontou para o terminal.

— O cliente acabou de fechar a janela.

Silêncio.

Do fundo do CPD, alguém murmurou:

Bem-vindo ao online.



🏛️ CAPÍTULO 1 — JES2 E CICS VIVEM EM UNIVERSOS DIFERENTES

No artigo anterior construímos o:

JES2 DOS AGENTES

A ideia era fantástica para processamento assíncrono.

O usuário submete:

AGENT-CONTRACT-ANALYSIS

recebe:

RUN-ID A004821

e pode ir tomar café.

O agente pode executar:

agora
daqui a cinco minutos
durante a madrugada

Não importa tanto.

Mas agora imagine:

CLIENTE
   ↓
TELA
   ↓
"CONSULTAR SALDO"

Ele clicou.

Está esperando.

Temos outro tipo de trabalho.

INTERATIVO

E sistemas interativos possuem uma característica brutal:

EXISTE UM HUMANO MEDINDO O TEMPO.

Não com cronômetro.

Com impaciência.



⚡ CAPÍTULO 2 — CICS NASCEU PARA O MUNDO ONLINE

CICS significa:

Customer Information Control System

Para o programador COBOL iniciante, uma forma útil de pensar nele é:

Um ambiente transacional capaz de executar aplicações online com grande volume de usuários e transações.

Em vez de:

JOB
↓
PROCESSA 2 HORAS
↓
OUTPUT

temos algo mais próximo de:

REQUEST
↓
TRANSACTION
↓
PROGRAM
↓
DATA
↓
RESPONSE

Rapidamente.

Milhares ou milhões de vezes.

Uma transação pode:

consultar cliente
alterar pedido
autorizar pagamento
verificar estoque
registrar operação

O usuário envia uma solicitação.

CICS identifica a transação.

Executa o programa associado.

O programa acessa recursos.

Produz resposta.

E termina.

Parece muito com aquilo que agentes terão de fazer quando forem colocados dentro de aplicações interativas.



🤖 CAPÍTULO 3 — O AGENTE SAIU DA FILA E ENTROU NA TELA

Imagine:

Usuário:
"Analise este cliente e diga se existe alguma inconsistência."

Nosso agente precisa:

receber contexto
consultar dados
talvez chamar ferramentas
raciocinar
produzir resultado

Se isso estiver num processamento batch:

45 segundos

pode ser perfeitamente aceitável.

Se estiver numa tela de atendimento:

45 segundos

pode parecer uma eternidade.

Essa é uma mudança fundamental.

Não basta perguntar:

O agente consegue executar?

Precisamos perguntar:

O agente consegue executar dentro do orçamento de tempo da experiência humana?



⏱️ CAPÍTULO 4 — LATÊNCIA VIROU EXPERIÊNCIA

Suponha:

AGENT RESPONSE TIME = 800 ms

Excelente.

Agora:

3 segundos

Talvez aceitável.

Agora:

12 segundos

O usuário começa a desconfiar.

Agora:

45 segundos

Talvez já esteja clicando novamente.

Agora:

2 minutos

Ele abriu outra aba.

Agora:

5 minutos

Ele foi fazer café.

O problema não é apenas tecnológico.

É UX.

Portanto precisamos pensar em:

TIME BUDGET

Imagine que nossa experiência tenha:

TOTAL BUDGET = 3 s

Esse orçamento precisa ser dividido.

API............. 200 ms
CICS............ 300 ms
Db2............. 400 ms
Agent........... 1500 ms
Formatting...... 100 ms
Network......... 200 ms
Safety margin... 300 ms

Se o agente gastar sozinho:

8 segundos

não adianta o restante ser rápido.


💰 CAPÍTULO 5 — TEMPO TAMBÉM É ORÇAMENTO

No WLM dos agentes falamos de:

tokens
CPU
API calls
money

Agora adicionamos:

PACIÊNCIA HUMANA

Ela também é finita.

Podemos imaginar:

LATENCY BUDGET

como um recurso.

Cada componente gasta um pedaço.

Usuário
  ↓ 100 ms
Gateway
  ↓ 150 ms
Agent
  ↓ 900 ms
Db2
  ↓ 200 ms
CICS
  ↓ 300 ms
Response

Total:

1.65 s

Ótimo.

Mas se o agente decidir:

Vou consultar mais oito ferramentas...

nosso orçamento desaparece.

Autonomia precisa respeitar tempo.


🚦 CAPÍTULO 6 — O AGENTE PRECISA SABER QUANDO PARAR DE PENSAR

Aqui aparece uma consequência interessante.

Um agente pode teoricamente melhorar sua resposta fazendo:

mais buscas
mais chamadas
mais validações
mais raciocínio

Mas numa interação online existe limite.

Podemos estabelecer:

MAX_TOOL_CALLS = 3
MAX_AGENT_TIME = 1500 ms

Se não conseguir concluir:

FALLBACK

Talvez:

"Preciso de uma análise mais profunda.
Posso continuar em segundo plano?"

Agora fazemos uma transformação elegante:

ONLINE
↓
ASYNC

Ou seja:

CICS encontra JES2.

O usuário recebe resposta rápida.

O trabalho longo continua depois.


🔄 CAPÍTULO 7 — FAST PATH E SLOW PATH

Essa arquitetura é extremamente útil para agentes.

FAST PATH

Tente resolver imediatamente.

USER
 ↓
AGENT
 ↓
TOOLS
 ↓
RESPONSE

Limite:

2 segundos

Se a tarefa exigir mais:

SLOW PATH

USER
 ↓
SUBMIT
 ↓
RUN-ID
 ↓
QUEUE
 ↓
BACKGROUND AGENT

A interface responde:

Análise aprofundada iniciada.
RUN-ID: A004821

Depois o usuário recebe resultado.

Assim não transformamos uma transação online em um batch disfarçado.

Essa frase merece moldura:

Não transforme processamento batch em transação online apenas porque agora existe uma interface bonita na frente.


🧠 CAPÍTULO 8 — CICS APRENDEU A NÃO FICAR CONVERSANDO PARA SEMPRE

Aqui entra um conceito delicioso para nossa analogia:

PSEUDO-CONVERSATIONALIDADE.

Imagine um programa conversacional ingênuo.

O usuário recebe uma tela.

Enquanto pensa durante dois minutos, o programa continua ocupando recursos.

PROGRAMA
↓
ENVIA TELA
↓
ESPERA USUÁRIO
↓
ESPERA...
↓
ESPERA...

Isso não escala bem.

A filosofia pseudo-conversational do CICS é diferente.

Simplificando:

Usuário envia
     ↓
Transação executa
     ↓
Salva contexto necessário
     ↓
Envia tela
     ↓
TERMINA

Quando o usuário responde:

nova transação

começa.

O contexto necessário é recuperado.

Isso é brilhante.

Porque:

esperar o humano não significa manter o programa executando.

Soa familiar?

Exatamente o que discutimos com agentes esperando aprovação.


💤 CAPÍTULO 9 — NÃO DEIXE O AGENTE ACORDADO ESPERANDO O HUMANO

Imagine:

AGENT:
"Posso enviar o pagamento?"

Agora precisa de human-in-the-loop.

O usuário pode responder em:

10 segundos

ou:

10 minutos

ou:

10 horas.

Seria absurdo manter:

LLM session
thread
Db2 connection
transaction
lock

abertos durante esse tempo.

Melhor:

SAVE STATE
↓
WAITING_APPROVAL
↓
RELEASE RESOURCES

Quando o humano aprovar:

APPROVAL EVENT
↓
RESUME

O velho conceito pseudo-conversational encontra o workflow moderno.

Décadas separadas.

Mesmo princípio:

Persista contexto; libere recurso.


📦 CAPÍTULO 10 — CONTEXTO NÃO É CONEXÃO

Essa distinção merece atenção.

Para continuar uma conversa, o agente precisa de contexto.

Mas contexto não significa manter todos os recursos físicos ou lógicos presos.

Podemos persistir:

RUN-ID
USER-ID
CUSTOMER-ID
CURRENT-STATE
APPROVAL-STATUS
LAST-RESULT
NEXT-ACTION

E terminar a execução corrente.

Quando houver nova interação:

LOAD CONTEXT
↓
CONTINUE

Isso permite escala.

O mesmo usuário pode voltar depois.

O mesmo agente pode continuar.

Sem deixar uma transação pendurada eternamente.


🔐 CAPÍTULO 11 — UMA TRANSAÇÃO PRECISA DE FRONTEIRAS

Agora chegamos a uma palavra importantíssima:

TRANSAÇÃO.

Suponha que nosso agente faça:

1. Debitar conta A
2. Creditar conta B

Se fizer apenas o primeiro:

A = -100

e cair antes do segundo...

temos problema.

Queremos:

TUDO

ou:

NADA.

Essa é uma das ideias centrais do processamento transacional.

Uma unidade lógica de trabalho precisa possuir fronteiras claras.


🧱 CAPÍTULO 12 — UNIT OF WORK

Podemos chamar uma sequência de alterações relacionadas de:

UNIT OF WORK

ou UOW.

Exemplo:

BEGIN UOW

UPDATE ACCOUNT-A
UPDATE ACCOUNT-B
INSERT AUDIT

END UOW

Se tudo funcionar:

COMMIT

Se alguma coisa falhar:

ROLLBACK

Para agentes isso é vital.

Porque agentes podem executar várias ferramentas.

Precisamos saber:

Quais ações pertencem à mesma unidade de consistência?


✅ CAPÍTULO 13 — COMMIT: AGORA É PARA VALER

Imagine:

OLD BALANCE = 1000

O agente executa:

UPDATE

Mas enquanto a transação ainda não confirmou definitivamente suas alterações, estamos dentro da unidade de trabalho.

Quando chegamos ao ponto seguro:

COMMIT

As mudanças tornam-se permanentes conforme a semântica do recurso transacional envolvido.

No universo CICS encontramos o conceito de:

SYNCPOINT

Um ponto de sincronização estabelece uma fronteira importante da unidade de trabalho.

Para nosso agente, a analogia é poderosa.

Antes:

PLANEJAR

Depois:

EXECUTAR

Depois:

VALIDAR

Finalmente:

COMMIT

↩️ CAPÍTULO 14 — ROLLBACK: DESFAÇA ANTES QUE ALGUÉM PERCEBA

Imagine:

STEP 1 OK
STEP 2 OK
STEP 3 FAILED

Se tudo pertence à mesma unidade transacional:

ROLLBACK

O sistema desfaz alterações ainda não confirmadas, conforme os recursos participantes e suas capacidades transacionais.

Conceitualmente:

BEFORE:
A = 100
B = 200

TEMP:
A = 50
B = ???

ERROR

ROLLBACK

AFTER:
A = 100
B = 200

Muito melhor que:

A = 50
B = 200

¯\_(ツ)_/¯

🤖 CAPÍTULO 15 — MAS AGENTES CHAMAM COISAS QUE NÃO SABEM DAR ROLLBACK

Aqui começa a diversão.

Db2 pode participar de mecanismos transacionais sofisticados.

Mas o agente talvez chame:

EMAIL API

Depois:

PAYMENT API

Depois:

CRM API

Depois:

POST SOCIAL MEDIA

Como fazemos:

ROLLBACK EMAIL

?

Não fazemos.

O e-mail já saiu.

Como:

ROLLBACK TWEET

?

Podemos apagar, talvez.

Mas alguém já viu.

Isso nos obriga a distinguir:

TRANSACTIONAL ACTION

de:

IRREVERSIBLE / EXTERNAL ACTION

Agentes tornam essa distinção absolutamente crítica.


⚠️ CAPÍTULO 16 — NÃO ENVIE O E-MAIL ANTES DO COMMIT

Velha sabedoria de sistemas corporativos ganha nova vida.

Imagine:

1. Atualizar pedido
2. Enviar confirmação
3. Commit

O e-mail sai.

Depois o commit falha.

Cliente recebe:

Pedido confirmado!

Sistema:

PEDIDO NÃO EXISTE.

Excelente.

😂

Talvez devamos estruturar:

1. Validar
2. Atualizar
3. Commit
4. Disparar ação externa

ou usar mecanismos adequados de mensageria e padrões transacionais para garantir processamento confiável.

O princípio é:

Pense cuidadosamente sobre o momento em que efeitos externos se tornam visíveis.


🔒 CAPÍTULO 17 — LOCKS: O AGENTE NÃO ESTÁ SOZINHO

Imagine dois agentes:

AGENT-A
AGENT-B

Ambos leem:

STOCK = 1

A pensa:

Posso vender.

B pensa:

Posso vender.

A vende.

B vende.

Parabéns.

Vendemos duas unidades de algo que só existia uma vez.

Bem-vindo à:

CONCORRÊNCIA.

Precisamos coordenar acesso a dados compartilhados.

Uma das ferramentas clássicas são locks.


🔐 CAPÍTULO 18 — O LOCK É A PLAQUINHA “ESTOU USANDO”

Simplificando brutalmente:

AGENT-A
LOCK RECORD X

Enquanto A altera X:

AGENT-B
WAIT

Depois:

AGENT-A
COMMIT
RELEASE LOCK

B pode continuar.

Isso protege consistência.

Mas locks possuem custo.

Quanto mais tempo seguramos um lock:

mais gente espera

Por isso transações online devem ser curtas.

Agora imagine um agente segurando lock e pensando:

"Hmmm...
vou consultar a internet...
vou perguntar ao modelo...
vou analisar 47 PDFs..."

Enquanto isso:

LOCK HELD

NÃO.


💀 CAPÍTULO 19 — NUNCA DEIXE O LLM PENSAR SEGURANDO O LOCK

Essa merece uma placa no CPD.

NÃO SEGURE LOCK ENQUANTO ESPERA UM LLM.

Se possível, estruture:

READ
↓
RELEASE
↓
THINK
↓
VALIDATE CURRENT STATE
↓
SHORT TRANSACTION
↓
UPDATE
↓
COMMIT

Mas cuidado com alterações concorrentes.

Se você leu:

VERSION = 17

pensou durante três segundos e voltou...

talvez agora seja:

VERSION = 19.

Precisamos detectar isso.


🧮 CAPÍTULO 20 — OPTIMISTIC CONCURRENCY

Uma estratégia possível é controle otimista.

Você lê:

CUSTOMER
VERSION = 17

Faz seu processamento.

Ao atualizar:

UPDATE CUSTOMER
WHERE ID = 123
AND VERSION = 17

Se ninguém alterou:

SUCCESS

Se alguém alterou:

0 ROWS UPDATED

Agora sabemos:

Meu contexto ficou velho.

O agente precisa:

RELOAD
REVALIDATE
RETRY

em vez de sobrescrever silenciosamente informação nova.

Isso combina muito bem com agentes porque eles podem gastar tempo significativo fora do banco tomando decisões.


💥 CAPÍTULO 21 — DEADLOCK: DOIS ROBÔS EDUCADOS DEMAIS

Imagine:

AGENT-A
LOCK CUSTOMER

Depois quer:

LOCK ACCOUNT

Mas B já possui ACCOUNT.

Enquanto isso:

AGENT-B
LOCK ACCOUNT

e quer:

LOCK CUSTOMER.

Temos:

A espera B
B espera A

Os dois podem ficar esperando para sempre sem intervenção.

Isso é um deadlock clássico.

Sistemas de banco detectam e resolvem situações desse tipo escolhendo uma vítima para rollback.

Nosso agente precisa entender:

DEADLOCK

não como:

O universo me odeia.

Mas como:

Minha transação foi escolhida para rollback; preciso decidir se é seguro tentar novamente.


⏰ CAPÍTULO 22 — TIMEOUT É UMA POLÍTICA, NÃO UMA TRAGÉDIA

Outro conceito essencial:

TIMEOUT

Se uma ferramenta deveria responder em:

500 ms

não faz sentido esperar:

17 minutos

Precisamos estabelecer limites.

DB TIMEOUT........ 1 s
API TIMEOUT....... 2 s
AGENT BUDGET...... 3 s
TOTAL REQUEST..... 5 s

Se ultrapassar:

STOP WAITING

E então decidir:

retry?
fallback?
async?
error?

Timeout é uma proteção.

Sem timeout, uma dependência lenta pode consumir recursos indefinidamente.


🔌 CAPÍTULO 23 — CIRCUIT BREAKER: PARE DE BATER NA PORTA

Imagine uma API quebrada.

Primeira chamada:

FAIL

Segunda:

FAIL

Mil agentes continuam chamando.

FAIL
FAIL
FAIL
FAIL
FAIL

Estamos atacando um sistema que já está doente.

Circuit breaker usa a analogia de um disjuntor.

CLOSED

Chamadas passam.

Muitas falhas aparecem.

OPEN

Paramos temporariamente de chamar.

Depois:

HALF-OPEN

Testamos algumas chamadas.

Se voltou:

CLOSED

Se continua ruim:

OPEN

Isso protege tanto o consumidor quanto o serviço problemático.


🔁 CAPÍTULO 24 — RETRY ONLINE É MAIS PERIGOSO DO QUE PARECE

No batch:

retry after 30 seconds

pode ser aceitável.

Na tela:

retry 30 seconds

significa:

O usuário está olhando para uma bolinha girando há meio minuto.

Precisamos de políticas diferentes.

Talvez:

FAST RETRY
1 tentativa

Depois:

FALLBACK

ou:

ASYNC CONTINUATION

Cada retry consome o orçamento de latência.

Não pense apenas:

Quantas tentativas posso fazer?

Pergunte:

Quantas tentativas cabem antes de a experiência humana morrer?


👤 CAPÍTULO 25 — HUMAN-IN-THE-LOOP É UMA TRANSAÇÃO CONVERSACIONAL

Imagine:

AGENT:
"Detectei alteração de limite para R$ 50.000.
Autoriza?"

O agente não deveria:

BEGIN TRANSACTION
LOCK CUSTOMER
WAIT HUMAN 2 HOURS

😂

Deveria:

VALIDATE
↓
SAVE REQUEST
↓
RELEASE RESOURCES
↓
WAIT APPROVAL

Quando chega:

APPROVED

fazemos nova validação.

Porque o mundo pode ter mudado enquanto esperávamos.

RELOAD
REVALIDATE
AUTHORIZE
EXECUTE
COMMIT

Isso é extremamente importante.

A aprovação humana não congela o universo.


🧠 CAPÍTULO 26 — CONTEXTO VELHO É UM MONSTRO SILENCIOSO

Às 10:00 o agente analisa:

BALANCE = 10,000

Pede aprovação.

Humano responde às 10:20.

Mas agora:

BALANCE = 2,000

O agente não pode simplesmente continuar baseado no snapshot antigo.

Precisamos distinguir:

CONVERSATION CONTEXT

de:

CURRENT BUSINESS STATE.

Antes de ação crítica:

REVALIDATE.

Esse princípio vale ouro.


📜 CAPÍTULO 27 — PSEUDO-CONVERSATIONALIDADE PARA AGENTES

Podemos desenhar um padrão.

INTERAÇÃO 1

USER REQUEST
↓
AGENT EXECUTES
↓
NEEDS APPROVAL
↓
SAVE STATE
↓
RETURN "WAITING APPROVAL"
↓
END

Nenhum processo fica preso.

Depois:

INTERAÇÃO 2

APPROVAL EVENT
↓
LOAD STATE
↓
REVALIDATE
↓
CONTINUE
↓
COMMIT
↓
END

Isso é praticamente uma versão moderna da filosofia pseudo-conversational.

O programa não fica esperando.

O estado espera.

Que frase bonita:

O processo termina; o estado permanece.


🖥️ CAPÍTULO 28 — COMO SERIA O “CICS DOS AGENTES”?

Imagine:

AI TRANSACTION MONITOR
──────────────────────────────────────────────

TRAN   AGENT          USER      ELAPSED  STATE
A001   CUSTOMER       U104      0.4s     EXEC
A002   FRAUD          U992      0.8s     EXEC
A003   SUPPORT        U441      1.2s     LLM
A004   CREDIT         U827      2.8s     TOOL
A005   CONTRACT       U221      4.9s     ASYNC

Selecionamos:

A004

Aparece:

TRANSACTION.... A004
AGENT.......... CREDIT
USER........... U827

LATENCY BUDGET. 3.0s
ELAPSED........ 2.8s

LLM............ 1.4s
DB2............ 0.3s
API............ 0.7s
OTHER.......... 0.4s

CURRENT STATE.. TOOL_CALL
LOCKS.......... 0
UOW............ NONE

O sistema já percebe:

BUDGET ALMOST EXHAUSTED

Então talvez:

SWITCH TO ASYNC

Essa é a UX que agentes corporativos precisarão.


📊 CAPÍTULO 29 — MÉTRICAS DO CICS DOS AGENTES

No SDSF dos agentes medimos:

runs
errors
tokens
tools

No mundo interativo precisamos enfatizar:

p50 latency
p95 latency
p99 latency
timeout rate
abandonment rate
retry rate
lock wait
Db2 time
LLM time
tool time
async conversion rate

Uma métrica particularmente interessante:

USER ABANDONMENT

Quantos usuários desistiram antes da resposta?

Porque tecnicamente o agente pode estar:

100% SUCCESS

enquanto metade dos clientes fechou a página antes de receber o resultado.

MAXCC 0000.

Negócio 0012.

😂


📈 CAPÍTULO 30 — THROUGHPUT TAMBÉM IMPORTA

Não basta responder rapidamente uma transação.

Precisamos responder rapidamente:

10
100
1.000
10.000

transações simultâneas.

Uma operação que funciona maravilhosamente com:

1 usuário

pode desmoronar com:

5.000 usuários.

Por isso precisamos considerar:

LATENCY
+
THROUGHPUT
+
CONCURRENCY

Uma aplicação transacional é um exercício de equilíbrio.


🚪 CAPÍTULO 31 — O AGENTE NÃO DEVERIA TER ACESSO ILIMITADO À TRANSAÇÃO

RACF volta à história.

Nosso agente de atendimento talvez possa:

READ CUSTOMER
READ ORDERS
CREATE CASE

mas não:

DELETE CUSTOMER
TRANSFER MONEY
CHANGE RACF

O princípio de least privilege continua valendo.

E operações mais perigosas podem exigir:

HUMAN APPROVAL

ou:

STEP-UP AUTHORIZATION.

CICS não substitui RACF.

Assim como velocidade não substitui segurança.


🛡️ CAPÍTULO 32 — VELOCIDADE NÃO JUSTIFICA REMOVER CONTROLES

Uma tentação perigosa:

Aprovação humana demora. Vamos remover.

Não.

Talvez o fluxo precise ser melhor projetado.

Por exemplo:

LOW RISK
↓
AUTO APPROVE
MEDIUM RISK
↓
ADDITIONAL VALIDATION
HIGH RISK
↓
HUMAN APPROVAL

Assim usamos risco para definir o caminho.

Não removemos segurança apenas para melhorar latência.


🧰 CAPÍTULO 33 — PASSO A PASSO PARA PROJETAR UMA TRANSAÇÃO COM AGENTE

Antes de colocar IA numa tela interativa, responda:

1. Qual é o orçamento total de latência?

2s?
5s?
10s?

2. Quanto o agente pode consumir?

TOTAL = 3s
AGENT = 1.5s

3. Quais ferramentas ele pode chamar?

Evite permitir chamadas ilimitadas.

4. Existe fallback?

model smaller?
cached result?
rule engine?
async continuation?

5. Quais operações alteram estado?

Liste:

INSERT
UPDATE
DELETE
external action

6. Onde estão as fronteiras transacionais?

Defina:

BEGIN
COMMIT
ROLLBACK

7. Existem locks?

Pergunte:

Quanto tempo ficam presos?

8. Existe espera humana?

Se sim:

persist state
release resources
resume later

9. O contexto precisa ser revalidado?

Quase sempre para operações críticas.

10. Retry é seguro?

Pense em idempotência.

11. Existe timeout?

Sempre deveria existir alguma política de limite.

12. O trabalho pode virar assíncrono?

Essa pergunta pode salvar sua UX.


🥚 EASTER EGG — O LOCK MAIS CARO DA HISTÓRIA

São 14:32.

O painel começa a ficar vermelho.

DB2 LOCK WAIT
DB2 LOCK WAIT
DB2 LOCK WAIT
DB2 LOCK WAIT

Turing aparece.

— Quem está segurando o lock?

O operador procura.

TRANSACTION..... AI42
AGENT........... CUSTOMER-ANALYSIS
LOCK AGE........ 00:17:38

Turing quase derruba o café.

— Dezessete minutos?!

— Sim.

— O que ele está fazendo?

Abrem o trace.

STEP 1 DB2 UPDATE
STEP 2 CALL LLM
STEP 3 WEB SEARCH
STEP 4 ANALYZE 47 PDFs
STEP 5 WAIT HUMAN APPROVAL

Silêncio absoluto no CPD.

Turing pergunta:

— Ele está esperando aprovação humana segurando um lock de Db2?

O jovem programador responde baixinho:

— Tecnicamente...

O administrador Db2 levanta lentamente da cadeira.

Do outro lado da sala, o administrador RACF fecha a porta.

O pequeno robô tenta se esconder atrás do rack.

Turing aponta para a tela:

ROLLBACK.

Depois escreve no quadro:

NÃO FAÇA ISSO.

Fim do easter egg.


🧬 CAPÍTULO 34 — NOSSA ARQUITETURA ESTÁ GANHANDO VIDA

Agora temos:

JES2 DOS AGENTES
↓
trabalho assíncrono
WLM DOS AGENTES
↓
prioridade e recursos
CICS DOS AGENTES
↓
interação rápida
RACF DOS AGENTES
↓
autoridade
SDSF DOS AGENTES
↓
visibilidade
PF3 DOS AGENTES
↓
interrupção
MAXCC DOS AGENTES
↓
resultado

Cada conceito responde a uma pergunta.


🏰 CAPÍTULO 35 — O SISTEMA OPERACIONAL CONCEITUAL DOS AGENTES

Turing desenha:

                 HUMANO
                    │
                    ▼
            ┌───────────────┐
            │ REQUEST / TASK│
            └───────┬───────┘
                    │
           ┌────────┴────────┐
           │                 │
           ▼                 ▼
     INTERATIVO          ASSÍNCRONO
           │                 │
           ▼                 ▼
       ┌───────┐         ┌───────┐
       │ CICS  │         │ JES2  │
       └───┬───┘         └───┬───┘
           │                 │
           └────────┬────────┘
                    ▼
                  WLM
                    │
                    ▼
                  RACF
                    │
                    ▼
                  AGENT
                    │
          ┌─────────┼─────────┐
          ▼         ▼         ▼
         LLM       Db2       TOOLS

Ao redor:

SDSF → OBSERVE

PF3 → STOP

MAXCC → VERIFY

CHECKPOINT → RESUME

AUDIT → PROVE

Isso já parece uma arquitetura operacional completa.


🧠 CAPÍTULO 36 — O PROGRAMADOR COBOL POSSUI UMA VANTAGEM ESTRANHA

Quando alguém fala:

AI agents

parece que tudo é novo.

Mas um programador COBOL que conhece sistemas transacionais já possui intuições valiosas.

Ele sabe que:

recurso é finito

Sabe que:

lock custa

Sabe que:

transação longa é perigosa

Sabe que:

commit importa

Sabe que:

rollback salva vidas

Sabe que:

usuário não deveria manter programa preso enquanto pensa

Sabe que:

estado precisa sobreviver entre interações

Sabe que:

concorrência cria problemas que não aparecem no teste unitário

Sabe que:

MAXCC=0000

não necessariamente significa que o cliente ficou feliz.

Tudo isso será extraordinariamente útil no mundo dos agentes.


☕ EPÍLOGO — PROCESSING...

O relógio marca:

16:47:01

Um usuário pergunta:

Qual é a situação do meu pedido?

O agente recebe.

16:47:01.100

Consulta contexto.

16:47:01.280

Busca pedido.

16:47:01.510

Consulta Db2.

16:47:01.790

Chama modelo.

16:47:02.620

O agente percebe que precisa de uma análise longa.

Olha para seu orçamento:

LATENCY BUDGET
3.0 s

ELAPSED
1.62 s

Antigamente ele continuaria.

Mais ferramentas.

Mais buscas.

Mais raciocínio.

Mais espera.

Mas agora aprendeu.

Responde:

Encontrei seu pedido. A situação básica está normal. Uma análise detalhada exige mais tempo; vou processá-la em segundo plano e avisá-lo quando terminar.

Tempo total:

2.1 s

Depois:

SUBMIT AGENT-DEEP-ANALYSIS
RUN-ID A009821

O trabalho entra no nosso:

JES2 DOS AGENTES.

O WLM classifica.

O RACF limita.

O SDSF observa.

O checkpoint preserva.

E o usuário continua sua vida.

Turing toma um gole de café.

— Agora você entendeu.

O robô pergunta:

— Entendi o quê?

— Que inteligência não significa responder tudo imediatamente.

— Então o que significa?

— Saber também quando uma tarefa deixou de ser uma transação e virou um job.

O jovem COBOL olha para o quadro.

Ali estava escrita toda a história:

CICS
↓
RESPONDA AGORA

JES2
↓
TRABALHE DEPOIS

E entre os dois:

DECIDA.

Talvez essa seja uma das arquiteturas mais importantes para agentes corporativos.

Porque haverá tarefas que precisam responder em:

300 ms

Outras em:

3 segundos

Outras em:

3 minutos

E algumas podem levar:

3 horas.

O erro será tentar tratar todas da mesma maneira.

Um agente realmente operacional precisa entender:

tempo,

contexto,

concorrência,

consistência,

risco,

custo,

e expectativa humana.

O futuro da IA empresarial talvez não seja simplesmente:

agentes cada vez mais inteligentes.

Talvez seja:

agentes inteligentes o bastante para saber quanto tempo podem ocupar uma transação.

No terminal:

TRANSACTION AI01

RESPONSE TIME.... 1.82s
DB2 TIME......... 0.21s
LLM TIME......... 0.93s
LOCK WAIT........ 0.00s
UOW.............. COMMITTED
ASYNC JOB........ NONE

STATUS............ SUCCESS

Turing olha para o programador.

— E agora?

O programador responde:

— Agora café.

Turing concorda.

Porque até num sistema online existe uma transação que jamais deveria sofrer timeout.

EXEC CICS
    START
    TRANSID('CAFE')
END-EXEC.

READY

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