Fevereiro de 2026: sai o ITIL 5.
Doze de outubro: o Google anuncia a segunda edição do livro Site Reliability Engineering, dez anos depois da primeira.
Quinze dias depois, a ISACA lança o COBIT 7.
Três das referências que mais orientam a gestão de TI no mundo se atualizaram no mesmo ano. Duas delas, no mesmo mês.
Se 2026 tivesse um tema, eu apostaria neste: o ano em que as refrências correram atrás do mundo.
Já escrevi aqui sobre o ITIL 5, e o COBIT 7 merece um texto só dele. Hoje quero falar do SRE v2 (como venho chamando a nova edição). Dos três, é o que mais tem a ensinar a quem vive de ITSM, justamente porque não nasceu no ITSM.
E o que mais me chamou a atenção nem foi o livro.
Não passa uma semana sem que alguém me diga que a IA já resolve incidente sozinha. A conversa é sempre animada. E quase nunca alguém pergunta o que aquela IA tem permissão para fazer quando ninguém está olhando.
O Google fez essa pergunta. Num paper publicado pelo próprio time de SRE, ele conta que o agente que responde aos alertas de produção, o AI Operator, só age sozinho em incidentes minor. Em operações críticas (pense no seu Major Incident), um humano revisa e aprova cada plano antes. Estamos falando da empresa com mais dados, mais engenheiros e mais incentivo do mundo para soltar a IA na produção.
O que é SRE, para quem nunca precisou saber?
O SRE (Site Reliability Engineering) nasceu no Google no começo dos anos 2000, quando Ben Treynor Sloss recebeu a missão de montar um time de operações. A ideia dele era simples: entregar a operação a engenheiros de software e deixar que eles tratassem os problemas de produção como problemas de software.
Daí vem quase tudo que o SRE ficou famoso por defender. Automatizar o trabalho repetitivo, o tal do toil. Medir a confiabilidade pelo que o usuário sente, com SLOs (service level objectives). E aceitar que 100% de disponibilidade é a meta errada.
Esse último ponto é o que mais diferencia o SRE. O error budget (orçamento de erro) é a distância entre 100% e o SLO. Se a meta é 99,9%, o 0,1% que sobra é um orçamento que o time pode “gastar” com mudanças, experimentos e riscos. Estourou o orçamento, as mudanças desaceleram até a confiabilidade voltar.
Quem vem do ITIL reconhece o parentesco. O SLO lembra o SLA, o postmortem lembra a revisão pós-incidente e o RCA (Root Cause Analysis), a obsessão por eliminar toil lembra a melhoria contínua.
Mas o caminho foi outro. O ITIL partiu do processo para chegar à prática; o SRE partiu do código para chegar à cultura. Por isso tanto praticante de SRE torce o nariz quando alguém diz que “SRE é ITIL com outro nome”.
Eu prefiro ver assim: o SRE é o jeito Google de gerenciar serviços. Ele mira os mesmos problemas que o ITSM, com as ferramentas e a cultura que o Google tinha.
Por que dez anos para uma segunda edição?
A primeira edição saiu em 2016, pela O’Reilly. Virou um dos livros mais populares da editora e levou SLO, error budget e postmortem sem culpa para empresas que nunca vão ter a escala do Google.
A segunda edição foi anunciada em outubro de 2026, completamente reescrita. Os autores são Betsy Beyer, Chris Jones, Christof Leng, David Huska, Jennifer Petoff e Niall Murphy, com mais de 150 contribuidores. O livro passa das 770 páginas.
Dez anos é muito tempo. Nesse intervalo vieram microsserviços, multicloud, serverless, platform engineering e, claro, a IA generativa. O livro de 2016 descrevia um mundo de dashboards estáticos e triagem manual de alertas.
E aqui está o paralelo que me chamou a atenção. Entre o ITIL v3 e o ITIL 4 passaram-se doze anos, e no artigo sobre o ITIL 5 eu mostrei o quanto o interesse pelo ITIL caiu nesse período. O SRE passou dez anos com o mesmo livro de referência.
Por isso o calendário de 2026 me parece mais do que coincidência. ITIL, COBIT e SRE nasceram em mundos bem diferentes: um no governo britânico, outro na auditoria, outro dentro de uma big tech. E mesmo assim os três decidiram se reescrever no mesmo ano, todos com IA no centro e todos reforçando o fator humano.
Todo framework público envelhece mais rápido do que é atualizado. Quando três mundos tão diferentes chegam às mesmas conclusões ao mesmo tempo, é sinal de que o chão mudou para todo mundo.
O que mudou na segunda edição?
No anúncio do livro, o próprio Google resumiu a evolução em seis frentes. Todas apontam na mesma direção: sair do trabalho manual, tarefa por tarefa, para capacidades automatizadas que valem para a plataforma inteira.
SLOs e error budgets
Antes: métricas básicas de disponibilidade e políticas de error budget aplicadas na mão. Agora: SLOs centrados no usuário, em vários níveis, com alertas disparados pela velocidade com que o orçamento está sendo consumido (burn rate) e políticas aplicadas automaticamente.
O capítulo de SLOs vai além. Fala de SLOs baseados nas jornadas críticas do usuário, de SLOs por cliente em ambientes B2B e da importância de medir do lado de quem usa, não só do servidor.
Na prática, o SLO por cliente é praticamente o SLA de contrato entrando pela porta dos fundos. A diferença é que ele não é apurado no fim do mês. É um sinal vivo, que pode travar mudanças sozinho quando o serviço começa a degradar.
E um detalhe que me fez gostar ainda mais do livro: o índice tem uma seção sobre as fraquezas do próprio modelo de SLO. Framework que admite os próprios limites é raro.
Observabilidade
Os dashboards estáticos e a triagem manual de alertas deram lugar a OpenTelemetry, rastreamento distribuído e correlação automática de anomalias. É o gerenciamento de eventos com muito mais contexto chegando antes de o incidente ser aberto.
Automação e plataformas
Esta é a mudança de fundo. Saem os scripts customizados para tarefas isoladas, entram a infraestrutura declarativa como código, as plataformas internas de desenvolvimento e os sistemas que se recuperam sozinhos.
A confiabilidade deixa de depender de cada time lembrar das boas práticas e passa a vir embutida na plataforma. A comunidade tem chamado isso de shift down, em oposição ao shift left, que jogou tudo no colo do desenvolvedor.
Testes de confiabilidade
Os game days agendados viraram verificação contínua de resiliência e validação de canary direto em produção. O teste de continuidade que acontecia uma vez por ano vira rotina.
Capacidade e recursos
Provisionamento manual e previsão estática deram lugar ao auto-scaling dinâmico, ao alinhamento com FinOps e à otimização de clusters de GPU (Graphics Processing Unit) e TPU (Tensor Processing Unit). Com o preço de uma GPU, confiabilidade virou conversa de CFO.
Modelo organizacional
O SRE deixou de ser só um time dedicado a aplicações específicas. Agora aparece em modelos híbridos, integrado à platform engineering, e em “reliability champions” espalhados pelos times de produto.
É a velha discussão do ITSM sobre centralizar ou distribuir a gestão de serviços. E é curioso ver o Google, que inventou o time de SRE, dizer que o time sozinho não basta.
O SRE descobriu as pessoas?
Para mim, a mudança mais interessante da segunda edição não é técnica.
Num post de divulgação, um dos autores contou que uma das maiores críticas à primeira edição era a pouca atenção a cultura e organização. A segunda tenta corrigir isso: como contratar, como engajar, como defender o valor da confiabilidade, como entender o contexto cultural em que o time está.
O livro abre propondo uma “hierarquia de saúde da produção” que coloca segurança psicológica, melhoria contínua e confiabilidade emergente como fundações. Não ferramenta. Não automação. Fundações.
Quem vem do ITSM pode sorrir de canto. A gente fala de cultura, de pessoas e de melhoria contínua há décadas. O ITIL 4 colocou “organizações e pessoas” como uma das quatro dimensões do gerenciamento de serviços, e o ITIL 5 reforçou o foco humano.
Mas cabe uma ressalva. O SRE mede o que o ITSM muitas vezes só declara. Error budget, SLO e burn rate são números que mudam decisões na segunda-feira de manhã. Quantas vezes você já viu uma “cultura de melhoria contínua” que só existia no slide da reunião de resultados?
O SRE chegou atrasado ao discurso sobre pessoas. O ITSM ainda está atrasado na disciplina de medir. Cada lado tem algo a aprender com o outro.
Quanto a IA pode decidir sozinha?
Volto à conversa do começo.
O paper “AI in SRE” foi, de longe, o material mais útil que li recentemente. E a parte mais útil dele é uma tabela simples, em que o Google classifica a autonomia da IA em operações em cinco níveis:
L0, manual: humanos investigam, aprovam e executam.
L1, assistido: a automação monitora e investiga; humanos aprovam e executam.
L2, parcial: a automação pode executar, mas um humano aprova cada plano antes.
L3, alto: a automação resolve cenários delimitados sem aprovação em tempo real; humanos são avisados e cuidam do que é novo.
L4, total: o sistema conduz o incidente de ponta a ponta, se adaptando aos resultados.
Lembra alguma coisa? Para mim é a lógica dos tipos de mudança. A mudança padrão é pré-autorizada porque o risco é conhecido e o procedimento é repetível: isso é L3. A mudança normal passa por avaliação e aprovação: isso é L2.
E onde o Google colocou o próprio agente? Em L2 para operações críticas e L3 para incidentes minor. Ninguém lá está em L4.
Vale lembrar o que o Google entende por incidente. No livro, o ciclo vai da detecção à triagem, investigação, mitigação e resolução, e termina no aprendizado. O incidente não acaba quando o serviço volta; acaba quando alguém aprendeu alguma coisa com ele. Repare em que etapas o AI Operator atua: nas primeiras.
Os ganhos medidos também são bem mais modestos do que os demos sugerem. Um sistema que apenas sugere hipóteses para o incidente reduziu o tempo médio de mitigação em 10%, num teste A/B. Dashboards de investigação montados sob demanda chegaram a cerca de 44% de redução, mas só nos tipos de incidente que eles suportam.
São ganhos reais. Não são mágica.
Para refletir: se o Google, com tudo o que tem, ainda mantém um humano no laço para o que é crítico, talvez a sua empresa devesse pelo menos ter essa conversa antes de soltar o agente.
Como o Google impede o agente de fazer besteira?
A arquitetura descrita no paper tem uma ideia central: quem decide não é quem executa.
O AI Operator investiga, levanta hipóteses e propõe a mitigação. Mas ele não mexe na produção. Quem executa é o Actus, um agente separado, com regras determinísticas, que verifica a proposta antes de qualquer coisa acontecer.
O Google chama seu modelo de governança de “Safety Trifecta”: transparência, avaliação de risco em tempo real e autorização progressiva. Na prática, o Actus cuida de:
Dry run obrigatório. Todo sistema que um agente pode acionar precisa aceitar um modo de simulação (
dry_run=true), para prever o raio de impacto antes de mudar o estado da produção.Verificação da justificativa e checagem de ações concorrentes, para dois agentes não mexerem na mesma coisa ao mesmo tempo.
Rebaixamento de autonomia: se o risco sobe, um pedido que seria L3 vira L2 e passa a exigir aprovação humana.
Um “botão vermelho”, que pausa as ações em andamento, bloqueia novas e revoga as permissões de L3.
Leia essa lista de novo na perspectiva de ITSM. Avaliação de risco, autorização proporcional ao risco, segregação entre quem propõe e quem executa, mecanismo de interrupção. É change enablement com sotaque de engenharia. A diferença é que roda em segundos, e não na reunião de quinta-feira.
“Voltar a versão” deixou de ser resposta segura?
Em 2017, um engenheiro do Google escreveu no blog da empresa que, por lá, rollback é normal: primeiro se volta a versão, depois se investiga. Era quase um mandamento.
O paper de 2026 traz uma ressalva importante. Quando muitas mudanças entram em sequência, voltar para a “última versão boa” fica arriscado, porque pode desfazer correções e patches de segurança que vieram depois. O Google batizou isso de Intervening Pull Request Problem, o problema do PR interveniente.
Pense no ritmo de hoje. Assistentes de IA gerando código, deploys várias vezes por dia. Entre a mudança que quebrou e o momento em que alguém percebe, outras dez mudanças entraram. Uma delas pode ser a correção de uma vulnerabilidade.
O livro novo vai na mesma linha. A última parte trata de como a IA está comprimindo o ciclo de desenvolvimento e forçando a troca da revisão humana pela avaliação automatizada, e do rollback pela correção para frente.
A recomendação do Google é usar mitigações mais granulares, como feature flags (desligar a funcionalidade problemática sem mexer no resto), e fix-forward assistido por IA.
Para quem aprova mudanças, isso derruba uma premissa antiga: a de que todo plano de rollback é seguro por definição. Se a sua empresa já tem cadência alta de deploy, vale levar uma pergunta para a próxima reunião de mudança: se voltarmos essa versão, o que mais volta junto?
A causa raiz ainda é a pergunta certa?
Esta é a parte do livro novo em que eu me sinto mais em casa. E também a que mais me rende discussão.
Muitos times ainda partem do princípio de que todo problema tem uma causa, e que o trabalho é encontrá-la. A “causa raiz”, no singular. O meu ponto é sempre o mesmo: na complexidade dos ambientes atuais, dificilmente existe uma causa única.
O Google acaba de colocar isso por escrito.
A segunda edição tem um capítulo dedicado à engenharia de segurança, e o índice não deixa dúvida sobre a direção. Uma das seções trata dos limites dos modelos tradicionais de causalidade. Outras citam o modelo do queijo suíço, “How Complex Systems Fail” e “Engineering a Safer World”.
Quem conhece a literatura de segurança reconhece as referências. O queijo suíço é de James Reason: o acidente acontece quando os furos de várias camadas de proteção se alinham. “How Complex Systems Fail” é o ensaio clássico de Richard Cook, que mostra como falhas graves nascem da combinação de várias falhas menores. E “Engineering a Safer World” é o livro de Nancy Leveson, do MIT, que criou o STAMP.
O STAMP troca a pergunta. Em vez de “o que quebrou?”, ele pergunta “que controles falharam em manter o sistema seguro?”. Dele saem os dois métodos que o livro adota: o CAST, para analisar o que já aconteceu, e o STPA, para antecipar o que pode acontecer.
A causa raiz única é uma história confortável, não uma descrição do sistema. Ela dá um nome, fecha o registro e deixa todo mundo dormir tranquilo. Até o próximo incidente, causado pela combinação de três coisas que a última análise chamou de “fatores contribuintes” (e mandou para o rodapé do relatório).
Para ser justo, nenhum framework recomenda procurar uma causa única, e o ITIL fala em gestão de problemas proativa há anos. O problema não está no livro. Está no hábito: no template com um campo só para “causa raiz”, nos 5 porquês que sempre terminam numa pessoa ou numa mudança, no indicador que conta quantos problemas foram “resolvidos”.
E há uma tensão que o SRE assume sem rodeios. O livro tem uma seção que coloca mitigação e análise de causa raiz frente a frente. Para o SRE, restaurar o serviço vem antes de entender o porquê. Quem já precisou segurar uma evidência enquanto a operação queria reiniciar tudo sabe que essa briga existe dos dois lados.
O que eu levo daqui é uma troca de pergunta. Na próxima reunião de RCA / postmortem, em vez de “qual foi a causa raiz?”, experimente “que combinação de condições permitiu isso, e que controle deveria ter segurado?”. O STPA, aliás, é o que a gestão proativa de problemas sempre prometeu e raramente entregou: um método para encontrar o problema antes do incidente.
O que a base de conhecimento (e a CMDB) tem a ver com tudo isso?
Tudo.
Para treinar e avaliar o AI Operator, o Google precisava saber como os humanos resolvem incidentes de verdade. Então criou o IRM Analyzer (IRMA), que lê chats, notas de incidente e comandos de terminal e reconstrói, em ordem, o que as pessoas fizeram. O paper chama isso de “trajetórias humanas”.
Essas trajetórias viram conjuntos de dados classificados em bronze (heurístico), prata (calibrado contra o ouro) e ouro (verificado por humanos). Toda noite, uma plataforma chamada Everest avalia o agente contra esses dados. E o critério é rigoroso: a mitigação só conta como correta se bater exatamente com os parâmetros do dado ouro, binário e versão incluídos.
Agora pense na sua base. No incidente com “resolvido conforme orientação” no campo de solução. No problema encerrado sem causa raiz documentada. No contorno que só existe na cabeça de um analista do N2.
A IA que você está comprando vai aprender com isso.
Já escrevi aqui sobre de quem é a base de conhecimento em tempos de IA generativa. O SRE do Google responde a essa pergunta por outro ângulo: a base de conhecimento é o combustível do agente. Se o combustível é ruim, o motor não vai longe, por melhor que seja.
Talvez seja essa a lição mais prática para quem vive de ITSM. Antes de discutir qual agente desenvolver, vale olhar a qualidade do que você registra. (O KCS nunca foi tão atual)
O mesmo vale para a configuração. Lembra do critério do Everest? A mitigação só está certa se acertar o binário e a versão exatos. E o Actus só libera uma ação depois de checar se outro agente já está mexendo no mesmo item. Nada disso funciona sem saber, com precisão, o que está rodando onde.
A comunidade já percebeu. A newsletter The Ratio chama isso de “imposto oculto” dos agentes: eles precisam de contexto sobre o seu ambiente para não alucinar no meio de um incidente, e esse contexto exige investimento antes de qualquer retorno. Traduzindo para o ITSM: uma CMDB desatualizada pode alimentar a alucinação do seu agente.
E o que eu faço com isso?
Primeiro, o que você não deve fazer: copiar o Google.
O Google tem escala, dinheiro e gente que talvez a sua empresa não tenha. O próprio livro reconhece isso, com material novo sobre como aplicar SRE em organizações de qualquer tamanho. A ideia é se inspirar, não importar.
As implicações práticas também são desconhecidas. O livro acabou de sair, o paper descreve sistemas internos do Google, e a comunidade ainda está digerindo os dois.
Mas algumas perguntas já dá para levar para a próxima reunião em que alguém disser que “a IA resolve”:
Em que nível de autonomia esse agente vai operar? E quem decidiu isso?
Quem decide e quem executa são a mesma coisa? Se o agente que propõe a ação é o mesmo que mexe na produção, falta uma camada.
Existe dry run e botão vermelho? Se não dá para simular nem interromper, o agente não deveria ter permissão de escrita.
Do que esse agente vai aprender? Se a resposta for “dos nossos chamados”, abra uma amostra deles antes.
Talvez essa seja a boa notícia do novo SRE para quem vive de ITSM: o que você já sabe continua valendo. Só precisa ser aplicado a um novo tipo de executor.
ITIL, COBIT e SRE nasceram em mundos diferentes, falam línguas diferentes e, em 2026, chegaram às mesmas perguntas. Vale a pena conhecer o vizinho.
