TOTVS lançou agente de IA dentro do Cloud RM. Sankhya comprou Magis5. O cerco está fechando para a software house brasileira que ainda roda Delphi on-prem.

Christophe Trevisani · 2026-05-11 · 10 min

TL;DR: Em 90 dias, TOTVS, Sankhya, Selbetti e Senior reposicionaram o tabuleiro do ERP brasileiro. O cliente da sua software house está vendo concorrente cloud-native e pedindo o mesmo. Modernizar o monolito Delphi não exige reescrever — exige começar pelo módulo que mais dói, em C#, com durabilidade já embutida.

O tabuleiro mudou em 90 dias

Você ainda manda o seu time apagar incêndio toda segunda de manhã.

O cliente seu já está em outro lugar.

Nos últimos 90 dias o terreno embaixo da software house brasileira de médio porte se moveu de quatro formas, simultaneamente. Vale listar.

• Sankhya comprou a Magis5 (abril de 2026). O ERP que disputa cliente com o seu agora tem marketplace embutido. O argumento "integramos com todo mundo" virou commodity.
• A Selbetti anunciou 5 a 6 aquisições para 2026, com tíquete somado de R$ 80 a 100 milhões. O alvo declarado: verticais regionais. Se você atende 200 clientes em um nicho, alguém em São Paulo já te colocou em uma planilha.
• A Senior reportou +26,1% de receita recorrente em cloud — recorde do segmento. Não é mais "vai migrar". Está migrando, e o mercado está pagando o múltiplo.
• A TOTVS pivotou para cloud broker e lançou a LYNN agent platform — agente de IA dentro do Cloud RM. O concorrente direto do seu produto agora vende IA empacotada que conversa com o ERP nativamente. Jaguar Mining, Romagnole e Grupo Sinova já estão migrando para SAP S/4 Hana no mesmo período.

Some-se a isso o que veio de Brasília na mesma semana: o Banco Central publicou novas exigências de governança e resiliência operacional para fintechs, e a Receita Federal manteve a deadline de fevereiro para CNPJ alfanumérico. Cada item é um vetor. Nenhum atua sozinho.

"São softwares que foram se adaptando desde os anos 90. Fica aquela torre de bloquinhos que, se você tirar o de baixo, cai tudo." — fundador da Tamborine, falando sobre infraestrutura legada de pagamentos.

A frase descreve a infraestrutura de quem está sendo comprado. Não a de quem está comprando.

Quatro pressões simultâneas — não uma de cada vez

A leitura clássica é: "ok, IA, cloud, M&A, regulação — vamos priorizar". A leitura honesta é que as quatro pressões não atuam em isolamento. Elas se reforçam.

Pressão 1 — o cliente seu. Ele viu o concorrente entregar uma tela web, um agente que responde no WhatsApp, um dashboard que abre no celular. Pediu o mesmo. Quando você diz que está no roadmap, ele anota o nome de outro fornecedor.

Pressão 2 — o concorrente direto. TOTVS e Sankhya não estão mais competindo só com você por feature de ERP. Estão competindo com você dentro do Cloud RM, com agente de IA acoplado, em um produto que o seu cliente também usa. O TOTVS LYNN não é um pitch — é um produto vendido nesse trimestre.

Pressão 3 — o regulador. O Banco Central agora pede prova, não promessa. Resiliência operacional vira exigência mostrável. CNPJ alfanumérico entra em vigor em fevereiro. A reforma tributária pressiona o módulo fiscal. Nenhuma dessas exigências o monolito Delphi atende sem retrabalho — e retrabalho é tempo de engenheiro caro que sai da fila do roadmap comercial.

Pressão 4 — o consolidador. A Selbetti não é a única jogando esse jogo. O cálculo de quem está comprando software house regional é simples: empresa de 50-300 funcionários, base recorrente, sem cloud, sem narrativa de modernização — múltiplo baixo, integração rápida, sinergia óbvia. Quem não modernizar entra na planilha do próximo Selbetti, do próximo private equity.

Quatro vetores apertando ao mesmo tempo, em uma janela curta. É esse o quadro, não o anterior.

Reescrever nunca foi resposta. E menos ainda agora.

A tentação clássica é a reescrita. "Vamos parar tudo seis meses, refazer o produto em .NET, lançar a versão cloud, e voltar a competir." O ciclo passado (2018-2023) deu o veredito sobre essa estratégia:

• Quem tentou reescrever monolito Delphi em 12-18 meses ou estourou orçamento e voltou para o legado com prejuízo, ou foi comprado no meio do caminho, ou faliu.
• O melhor case do mercado é uma software house que reescreveu em 2,5 anos. Nesses 2,5 anos, ela parou de entregar feature, perdeu market share, e a marca cliente-novo já tinha mudado quando o produto novo ficou pronto.

Reescrever monolito de 15 anos em 18 meses é como trocar o motor do avião em voo. As regras de negócio embutidas em forms do Delphi, integrações banco-a-banco com 12 conectores, particularidades fiscais por estado — nada disso vira documentação dentro do prazo. Vira retrabalho dentro do prazo.

E o tempo agora é mais curto que no ciclo anterior. Quem tinha 3 anos em 2020 tem 12 a 18 meses em 2026. Os vetores apertando ao mesmo tempo não permitem o luxo do "vamos parar seis meses".

Há uma ironia que vale a pena registrar: o C# foi criado por Anders Hejlsberg, o mesmo arquiteto que criou o Delphi na Borland nos anos 90. A sua equipe não está saindo de um mundo para outro completamente estranho — está saindo de um Delphi para o sucessor que o próprio criador do Delphi desenhou.

Strangler-fig: a única estratégia que casa com a janela

Existe uma estratégia que casa com a janela curta e com a base de 200 clientes que precisa continuar sendo atendida. Chama-se strangler-fig (estrangulador, em referência à figueira-mata-pau que cresce em volta da árvore hospedeira até substituí-la sem derrubar tudo de uma vez).

A ideia é mecânica:

1. Identifica-se o módulo que mais dói. Para a maioria das software houses ERP brasileiras, é faturamento (NFe, integração SEFAZ, geração de PDF, conciliação) ou integração bancária. O módulo que toda segunda-feira o suporte abre ticket.
2. Extrai-se as regras de negócio desse módulo para C#. O dev de Delphi já conhece a lógica — não é uma reescrita conceitual, é uma transcrição. C# é familiar para quem leu Delphi a vida inteira (mesmo arquiteto, lembra).
3. Adicionam-se os atributos de durabilidade na entrada e em cada passo do processo. Cada passo passa a ser salvo automaticamente — se cair no meio, retoma de onde parou, sem retry manual, sem tabela de idempotência caseira, sem cron de reconciliação.
4. O módulo extraído vira API. O resto do sistema continua em Delphi. Os dois conversam por HTTP.

Em código, o módulo extraído fica assim:

// Faturamento de NFe — orquestração inteira em uma função, cada passo salvo
[SkailFunction]
public async SkailTask EmitirNotaFiscal(Guid pedidoId)
{
    var pedido = await CarregarPedido(pedidoId);
    var nfe = await EnviarParaSefaz(pedido);
    await SalvarRespostaSefaz(pedidoId, nfe);
    await GerarPdfNfe(nfe);
    await NotificarCliente(pedido.ClienteId, nfe);
}

// Cada passo é um método à parte. O atributo [SkailCommand]
// faz com que ele seja durável — se a SEFAZ der timeout, retenta sozinho;
// se o servidor cair no meio, retoma do próximo passo, não do começo.
[SkailCommand]
private async SkailTask<Pedido> CarregarPedido(Guid pedidoId)
{
    return await PedidoRepository.GetByIdAsync(pedidoId);
}

[SkailCommand]
private async SkailTask<NfeResposta> EnviarParaSefaz(Pedido pedido)
{
    return await SefazClient.EmitirAsync(pedido);
}

[SkailCommand]
private async SkailTask SalvarRespostaSefaz(Guid pedidoId, NfeResposta nfe)
{
    await NfeRepository.SaveAsync(pedidoId, nfe);
}

[SkailCommand]
private async SkailTask GerarPdfNfe(NfeResposta nfe)
{
    await PdfService.RenderAsync(nfe);
}

[SkailCommand]
private async SkailTask NotificarCliente(Guid clienteId, NfeResposta nfe)
{
    await EmailService.EnviarNotaAsync(clienteId, nfe);
}

O que está acontecendo aqui, em português claro: a equipe escreveu C# normal. Cinco passos, cinco métodos, um orquestrador. Dois atributos — [SkailFunction] no método de fora, [SkailCommand] em cada passo. Nada de fila, nada de tabela de idempotência, nada de retry helper.

Se a SEFAZ der timeout no segundo passo, o runtime retenta sozinho. Se o servidor cair entre o terceiro e o quarto passo, ao subir de novo a execução retoma do quarto passo — não recomeça do começo, não duplica nota, não manda PDF duas vezes. Cada passo fica salvo. Cada execução fica auditável passo a passo na ferramenta de Monitor — qual rodou, quanto tempo levou, qual foi o input e o output, quantos retries por execução.

É a forma que o regulador pede a prova. E é a forma que o time deixa de gastar madrugada reconstituindo o que aconteceu.

A documentação do [SkailFunction], do [SkailCommand] e oito padrões prontos de extração (saga compensável, retry com backoff, fan-out/fan-in, aprovação humana com timeout) vivem em docs.skailhq.com — vale o link tanto para o time técnico fazer a primeira leitura quanto para o sócio se convencer de que a especificação existe e está pública.

A escolha não é técnica. É temporal.

Aqui é onde a conversa muda de assunto. Modernizar não é mais uma decisão de arquitetura. É uma decisão de prazo.

Coluna A — modernizar agora: 12 a 18 meses extraindo processos um por um via strangler-fig. Custo de infraestrutura durável incremental — não compra cluster, não compra equipe nova de DevOps, não para o roadmap comercial. Em 12 meses o produto tem uma narrativa cloud, base retida, e sai da lista dos alvos óbvios de aquisição predatória.

Coluna B — esperar: inflação de manutenção mês a mês (o time gasta cada vez mais para manter a luz acesa), churn para concorrente cloud-native que entrega a tela web e o agente que o cliente pediu, valuation caindo trimestre a trimestre, software house entrando na planilha do próximo Selbetti — não com o múltiplo de quem está modernizando, com o múltiplo de quem precisa ser salvo.

O que mudou em 90 dias não foi a tecnologia disponível para você. A tecnologia para modernizar incrementalmente um monolito Delphi sem reescrever existe há mais de dois anos. O que mudou foi o tempo disponível para usar essa tecnologia antes do tabuleiro se acomodar em volta.

Em alguns mercados, o atraso de seis meses é absorvido. No ERP brasileiro de 2026, com TOTVS empacotando IA dentro do Cloud RM, Sankhya empilhando marketplace, Selbetti com R$ 100 milhões para gastar e BC pedindo prova de resiliência — seis meses é a diferença entre estar na mesa e estar na planilha.

A escolha não é entre uma stack e outra. É entre estar no mercado em 18 meses, ou ser parte do mercado de outra pessoa.

Para fechar

O que o time de engenharia da sua software house precisa decidir nesse trimestre não é "qual framework" nem "qual cloud". É: por qual módulo a gente começa, e quanto da equipe Delphi a gente realoca para C# nos próximos 90 dias.

A janela para modernizar sem precisar reescrever é a janela em que o cliente ainda não pediu cancelamento, o concorrente ainda não comprou a sua área, e o regulador ainda não bateu na porta com pedido de evidência. Essa janela está aberta. Ela não fica aberta para sempre.

Modernização incremental, strangler-fig, durabilidade no nível da linguagem. É a estratégia que o ciclo passado validou e o ciclo atual exige.

Sobre links: as referências a TOTVS, Sankhya, Magis5, Selbetti, Senior, Jaguar Mining, Romagnole e Grupo Sinova são todas a empresas listadas em comunicados públicos do trimestre. O fato técnico de Anders Hejlsberg ter criado o Delphi (Borland, 1995) e depois o C# (Microsoft, 2000) é histórico documentado e relevante para o leitor que migra entre as duas linguagens. A skail é uma plataforma de execução durável agnóstica de linguagem; o exemplo de código está em C# porque é o destino natural da migração Delphi → backend moderno, mas a runtime conversa por HTTP com qualquer stack.