https://mcp.tecjustica.com/

https://ocr.tecjustica.com/

INSTALAR EXTENSÃO

Processo grande tem um problema que aparece antes do prompt: contexto demais.

Quem trabalha com autos extensos conhece a cena. A linha do tempo tem centenas de documentos, vários deles com títulos genéricos, e a peça que resolve a dúvida pode estar escondida entre certidões, anexos e movimentações de expediente. Antes mesmo de perguntar algo à IA, alguém precisa decidir o que vale a pena ler.

A versão 0.56 do TecJustiça PJe mexe justamente nessa etapa. A extensão ganhou novas formas de selecionar peças, exportação de conteúdo em Markdown com OCR e um Modo Sigiloso que tenta impedir que nomes e identificadores pessoais saiam do computador junto com o texto enviado à nuvem.

É uma atualização menos vistosa do que “mais um modelo de IA” e muito mais útil para quem abre processos todos os dias.

Primeiro, escolher melhor

Na primeira apresentação da extensão, o fluxo era simples: abrir os autos, marcar as peças e conversar com o modelo. Continua sendo assim. A diferença é que agora há mais de um jeito de chegar à seleção certa.

O filtro Chave busca a espinha dorsal do processo. É a seleção mais enxuta para entender rapidamente do que se trata o caso. O filtro Principal amplia esse conjunto e inclui outras peças com conteúdo relevante, sem marcar automaticamente cada documento da linha do tempo.

Quando o recorte é temporal ou sequencial, dá para marcar um bloco com o botão direito do mouse: clique, arraste e selecione várias peças de uma vez. Isso resolve situações comuns, como separar os documentos juntados depois de uma decisão ou reunir uma sequência de manifestações sem clicar em dezenas de caixas.

E há a nova Seleção com IA. Nessa etapa, a extensão analisa a lista de documentos a partir de dados como título, tipo, identificador e data. Se já houver uma pergunta escrita, a escolha é orientada por ela. Sem pergunta, a IA procura as peças que melhor descrevem o processo. O conteúdo integral dos documentos não precisa ser enviado apenas para decidir o que será lido.

Esse último recurso é especialmente útil quando os títulos não ajudam. Sete arquivos chamados “Petição” dizem muito pouco; uma triagem baseada no conjunto de metadados consegue organizar melhor o ponto de partida. Ainda assim, a seleção continua visível e pode ser alterada pelo usuário antes da análise.

Dos autos para Markdown, inclusive quando o PDF é escaneado

A versão 0.56 também permite extrair o conteúdo das peças escolhidas para arquivos Markdown (.md). O formato é leve, pesquisável e pode ser aberto em editores comuns, ferramentas de notas ou fluxos de trabalho com IA.

Quando a peça contém texto nativo, a extensão aproveita esse texto. Quando a página é apenas uma imagem, entra o OCR local. O reconhecimento ocorre no próprio computador, sem contratar um serviço separado de OCR. Ao final, o usuário recebe o conteúdo estruturado das peças selecionadas, pronto para consultar, comparar ou arquivar.

Isso não transforma o Markdown em uma cópia visual do PDF. O objetivo é outro: recuperar o texto e sua organização para que ele possa ser pesquisado e reutilizado.

O Modo Sigiloso muda a ordem do fluxo

Até aqui, o caminho normal de uma ferramenta de IA é conhecido: a pessoa seleciona os documentos e o conteúdo segue para a API do provedor escolhido.

Com o Modo Sigiloso, há uma etapa anterior. O texto é extraído e examinado localmente. A extensão procura nomes de pessoas e organizações, CPFs, CNPJs e outros identificadores. Para isso, combina reconhecimento de entidades com regras determinísticas, validação de documentos e contexto jurídico.

Os trechos detectados são substituídos por marcadores estáveis, como [PESSOA_1], [ORGANIZACAO_1] e [CPF_1]. Se a mesma pessoa aparece várias vezes, o marcador permite acompanhar a referência ao longo do texto sem revelar o nome à API.

Antes do envio, a extensão apresenta um relatório e uma tabela de reidentificação. O usuário pode conferir o que foi protegido, corrigir falsos positivos e perceber o que o modelo não encontrou. Só depois dessa validação o texto protegido segue para o provedor de IA.

Quando a resposta volta, a extensão troca os marcadores pelos dados originais na própria máquina. A tabela que permite essa reversão permanece local.

Em termos técnicos, essa parte reversível do processo se aproxima da pseudonimização ou tokenização, porque existe uma chave local capaz de associar os marcadores aos dados originais. A distinção importa: reduzir a exposição é diferente de afirmar que um documento se tornou anônimo de forma irreversível.

O que a Resolução CNJ nº 615 tem a ver com isso

A Resolução CNJ nº 615, de 11 de março de 2025, com as alterações posteriores da Resolução nº 674/2026, estabeleceu regras de desenvolvimento, uso e governança de IA no Poder Judiciário. Ela trata de supervisão humana, proteção de dados, segurança, auditabilidade e uso de modelos generativos externos.

O texto atual permite o uso funcional de LLMs privados ou externos com documentos sigilosos quando os dados estiverem devidamente anonimizados na origem ou quando houver mecanismos técnicos e procedimentais que garantam proteção efetiva. O art. 30 também fala expressamente em anonimização ou pseudonimização na origem nos casos em que sites, aplicativos ou APIs utilizem os dados compartilhados para alimentar repositórios, treinar ou readequar modelos. E o anexo classifica a anonimização de documentos, o item BR8, entre as aplicações de baixo risco.

O Modo Sigiloso foi pensado na mesma direção: proteger antes de transmitir, manter a revisão humana e deixar o fluxo verificável.

Isso não significa que ativar um botão resolva sozinho todas as obrigações da LGPD, do segredo de justiça ou das normas internas de cada tribunal. A Resolução nº 615 disciplina o uso de IA no âmbito do Poder Judiciário. Advogados e demais profissionais também precisam observar a LGPD, o sigilo profissional, as regras aplicáveis ao caso e os termos do provedor de IA escolhido.

Modelos abertos ajudaram a organizar o problema

Para construir a camada local de reconhecimento, não bastava procurar “o modelo com a maior nota”. Era preciso comparar domínio, categorias reconhecidas, tamanho, formato dos pesos, licença, limite de contexto e comportamento em documentos jurídicos reais.

O principal candidato técnico foi o dominguesm/legal-bert-ner-base-cased-ptbr, um BERT para reconhecimento de entidades em textos jurídicos brasileiros. Ele identifica categorias como pessoa, organização e local, usa pesos em formato safetensors e declara licença CC BY 4.0. A própria página informa F1 geral de aproximadamente 0,952 em seu conjunto de teste, uma métrica auto-relatada que ainda precisa ser confirmada no tipo de documento que passa pelo PJe.

O pierreguillou/ner-bert-base-cased-pt-lenerbr, treinado com o conjunto jurídico LeNER-Br, entrou como referência de comparação. Já o celiudos/legal-bert-lgpd foi estudado por trazer rótulos diretamente ligados a dados pessoais, como nome, CPF, telefone, endereço e e-mail.

Esses modelos ajudaram a organizar critérios e testes. Não são tratados como verdade absoluta, nem como componentes intercambiáveis. O candidato principal só deve virar padrão depois de um benchmark cego com corpus autorizado ou previamente anonimizado, incluindo texto nativo, páginas com OCR, nomes em caixa alta e documentos de áreas diferentes.

A proposta técnica é converter o modelo aprovado para ONNX em FP32, sem quantização, e executá-lo localmente no navegador. Identificadores estruturados, como CPF e CNPJ, continuam sendo tratados também por expressões regulares, dígitos verificadores e palavras de contexto. Um detector cobre as falhas do outro, e os resultados de baixa confiança ficam para revisão.

Privacidade não combina com promessa de 100%

Reconhecimento de entidades erra. OCR também erra. Um nome pode ser confundido com órgão público, uma linha mal digitalizada pode quebrar um CPF e um trecho fora do domínio de treinamento pode passar despercebido.

Por isso, o relatório de conferência não é um detalhe da interface. Ele é parte do mecanismo de segurança. O Modo Sigiloso reduz a exposição e torna o envio mais controlado, mas a decisão final continua com a pessoa que conhece o processo.

Vale a mesma regra para a resposta da IA: ela ajuda a localizar, resumir e redigir, mas não substitui a leitura da peça original nem a revisão jurídica.

Quando falamos de Inteligência Artificial no judiciário, é muito comum pensarmos imediatamente na geração de minutas, resumos de peças ou chatbots que respondem perguntas sobre a legislação. No entanto, como já abordamos anteriormente no TecJustiça, a IA jurídica começa muito antes do PDF.

Hoje, quero compartilhar a segunda parte da demonstração do Agente PJe, um sistema interno que desenvolvi e administro para otimizar nossa rotina. A grande novidade? Ele deixou de ser apenas um assistente de análise e criação de expedientes para se tornar um verdadeiro gestor de tarefas proativo.

Muito mais que um modelo de linguagem: Um “Hermes Agent”

A nova arquitetura do Agente PJe funciona, essencialmente, como um Hermes Agent focado no fluxo de trabalho das varas. Ele não é uma ferramenta engessada; ele possui uma memória inteligente.

Isso significa que o sistema aprende com o seu uso diário, com as suas observações e com as instruções que você fornece. Ele realiza pesquisas automáticas nos autos respeitando o seu jeito de trabalhar, registrando o histórico de forma contextualizada.

Na Prática: Análise e Criação de Tarefas no Kanban

No vídeo de demonstração, podemos ver exatamente como essa integração funciona. O objetivo não é apenas que a IA diga o que tem no processo, mas que ela te ajude a não esquecer o que precisa ser feito.

Ao solicitar a análise de um processo (como a preparação para uma audiência de instrução, por exemplo), o agente utiliza seus submódulos (leitor-de-pecas) para varrer os autos. Ele verifica o status das intimações, mandados expedidos e cartas precatórias.

O grande diferencial acontece logo em seguida: se o agente identifica, por exemplo, que faltam os comprovantes de cumprimento de mandados de uma comarca específica ou que há cartas precatórias sem retorno, ele não apenas avisa, ele propõe uma tarefa.

Diretamente na interface de chat, o Agente PJe:

1. Gera um checklist detalhado (ex: “Certidão de cumprimento do mandado do réu X”, “Retorno da carta precatória Y”).

2. Recomenda o acompanhamento contínuo para que a pauta não seja liberada sem as devidas comprovações.

3. Permite que, com um único clique no botão “Criar tarefa”, todas essas pendências sejam enviadas para um quadro Kanban (Gestor de Tarefas) nativo do sistema.

Dessa forma, a análise processual se transforma imediatamente em um item de acompanhamento visual na sua rotina, garantindo que nenhum prazo ou retorno passe despercebido.

Como testar?

É importante ressaltar que o Agente PJe é uma iniciativa criada por mim e o uso atual é exclusivamente interno. A infraestrutura é própria e administrada de forma isolada, não estando disponível para o público em geral.

No entanto, se você é colega do Tribunal de Justiça do Ceará (TJCE) e tem interesse em ver como essa automação pode facilitar o seu dia a dia, sinta-se à vontade para entrar em contato. Estou disponibilizando algumas contas de acesso para colegas que queiram testar a ferramenta na prática e me dar um feedback sobre a experiência.

A verdadeira inovação na justiça não está em substituir o servidor, mas em dar a ele as ferramentas para gerenciar a complexidade com tranquilidade. Vamos juntos?

PJe Agent Ceará · TJCE, 1º e 2º grau · Beta

Você não deveria precisar montar um dossiê para só então pedir ajuda à inteligência artificial. Se o trabalho começa no PJe, é ali que o agente precisa começar também.

Quem já tentou analisar um processo com inteligência artificial conhece o ritual. Abrir o PJe. Baixar a inicial. Baixar a contestação. Procurar a certidão de citação entre centenas de documentos. Reunir tudo num PDF, torcer para o arquivo caber e, por fim, enviar ao chat.

Há uma ironia nesse fluxo: quando a IA finalmente entra, a parte mais ingrata já foi feita. Alguém precisou localizar, selecionar e organizar as peças. E, para saber o que era relevante, quase sempre precisou ler.

A tecnologia aparece no fim, como acabamento. O PJe Agent Ceará foi construído para inverter essa ordem.

Um número de processo. Uma pergunta. Os autos.

Em vez de receber um pacote preparado por você, o agente acessa o processo no PJe do Tribunal de Justiça do Ceará com a sua credencial e o seu nível de acesso, no 1º ou no 2º grau. Você informa o número do processo e faz a pergunta. Ele entra nos autos.

Isso muda mais do que a conveniência. A análise passa a usar o que está no processo naquele momento, sem depender de uma cópia exportada ontem ou de uma pasta paralela. Se uma petição entrou pela manhã, ela pode fazer parte da resposta à tarde.

A conexão é oferecida ao modelo por MCP, o protocolo que permite ao agente usar ferramentas externas. Na prática, o modelo deixa de comentar apenas o texto que recebeu: ele pode mapear os autos, escolher o que precisa abrir e buscar a evidência necessária para responder.

A pergunta fica maior

“Este processo está pronto para sentença? O que falta?”

“Resuma a defesa e indique o que ela não impugnou.”

“Há réu preso? Qual é o prazo aplicável?”

“Compare o pedido da inicial com a conclusão da perícia.”

Antes de ler, ele mostra o plano

Perguntas reais raramente se resolvem com uma única peça. Por isso, antes de abrir o primeiro documento, o agente explicita o caminho: mapear os autos, localizar inicial e contestação, conferir citações e intimações, encontrar o último ato decisório, verificar o ponto controvertido. O plano aparece na tela e é executado item por item.

Essa etapa evita dois desperdícios comuns: ler tudo sem critério e mandar material demais ao modelo. Em um processo com 412 documentos, por exemplo, o agente pode distinguir as 218 peças processuais dos registros acessórios e aplicar reconhecimento de texto apenas às imagens necessárias para aquela pergunta.

Também não precisa ler em fila. Quando a tarefa permite, vários leitores trabalham em paralelo, cada um com uma missão definida. O ganho não vem de fingir que um processo grande é pequeno; vem de dividir o trabalho com método.

Uma resposta que você consegue contestar

Velocidade sem rastreabilidade não serve para trabalho jurídico. Por isso, a conclusão não termina em uma frase convincente. Ela aponta o documento que sustenta cada afirmação, com um identificador que pode ser aberto para conferência.

Esse detalhe muda a relação com a ferramenta. A resposta deixa de pedir confiança e passa a oferecer prova. Você pode confirmar a leitura, discordar da interpretação ou corrigir o agente sem refazer toda a busca.

Ele aprende o seu jeito — sem aprender escondido

Um assistente que recomeça do zero em cada conversa transforma preferências em instruções repetitivas. O PJe Agent Ceará mantém memória entre sessões: o formato do resumo, o vocabulário da unidade, uma correção anterior e a ficha do processo que será retomado semanas depois.

Também pode aprender procedimento. Se você determina uma sequência — primeiro conferir a citação, depois enfrentar a preliminar e só então avaliar o mérito —, esse roteiro pode ser guardado e reaplicado nas próximas tarefas.

Mas memória útil precisa ser governável. Sempre que algo é armazenado, a interface informa o que foi guardado. Os itens ficam reunidos com data e origem e podem ser arquivados ou apagados. Aprendizado que não pode ser visto e desfeito não é personalização; é risco.

A Bancada troca a consulta pela pauta

A rotina forense não acontece um processo por vez. A Bancada reúne várias conversas lado a lado, cada uma ligada ao seu processo. Você pode iniciar análises em três autos, trabalhar no quarto e retornar quando as respostas estiverem prontas.

É uma mudança discreta de interface, mas profunda de escala: a ferramenta deixa de atender apenas a uma dúvida e passa a acompanhar uma pauta.

O agente não termina onde o produto termina

O PJe Agent Ceará já nasce com roteiros de análise cível e penal, verificação de prescrição e redação de minutas com base nos modelos da unidade. A arquitetura, porém, foi pensada para crescer com o trabalho de quem usa.

• Roteiros próprios. Você descreve uma vez, em português, como determinada tarefa deve ser feita. O agente passa a seguir esse procedimento sem exigir programação.

• Novas conexões. O mesmo protocolo pode ligar o agente a outras fontes, como pesquisa de jurisprudência e busca na web, conforme a necessidade da rotina.

• Modelos e minutas. O acervo da unidade pode servir de referência antes da redação, e o resultado chega ao editor pronto para ser copiado para o PJe com a formatação preservada.

A mudança real não está no modelo

A conversa sobre IA no direito costuma girar em torno de parâmetros, janelas de contexto e rankings. Nada disso, sozinho, muda a rotina de um gabinete, de uma secretaria ou de um escritório.

O que muda a rotina é quem abre os autos. Enquanto esse trabalho continuar com você, a IA será a etapa final de um processo manual. Quando o agente entra no PJe, mostra o plano, seleciona as peças, trabalha em paralelo, cita a fonte e aprende o seu procedimento sob controle, muda o tipo de pergunta que pode ser feita — e a quantidade de trabalho que pode ser delegada.

Essa é a ideia do PJe Agent Ceará: você traz o número do processo e a pergunta difícil. O caminho até a resposta fica com o agente. E fica todo à vista.

Quer testar e entender melhor?

Mande uma mensagem pelo WhatsApp para (88) 9365-0420. Posso criar uma conta de teste em cerca de sete dias.

PJe Agent Ceará · TecJustiça · agosto de 2026

A skill do TecJustiça MCP Lite foi atualizada para acompanhar as otimizações recentes do MCP. O que entrou:

- Pergunta direta ao processo. A ferramenta pdpj_perguntar_processo agora está no guia: você pergunta (”o réu foi citado?”, “houve sentença e qual o resultado?”) e recebe a resposta com os trechos literais dos autos, em um turno só — o que antes levava três.

- Regras de economia medidas, não estimadas. Uma análise completa de um processo passou a custar 4 chamadas, e a sequência mapa → partes → movimentos custa 1 no total. A skill ensina o Claude a seguir essa ordem.

- Mapa “a ferramenta que você procura”. O Claude deixa de inventar nome de ferramenta e queimar cota com chamada que não existe.

Como atualizar — 3 passos:

1. Apague a skill antiga. No Claude Code, remova a pasta ~/.claude/skills/tecjustica-mcp-lite/. No Claude Desktop ou no Cowork, remova tecjustica-mcp-lite nas configurações de skills. Se você usa o guia colado como Custom Instructions, apague o texto antigo.

2. Baixe a nova: mcp.tecjustica.com/skill-download — dá para conferir o conteúdo antes em /skill.

3. Use normalmente. Nada muda no seu acesso nem na configuração do servidor: é só a skill.

A versão antiga ainda ensina custos e sequências que não valem mais. Com a nova, a mesma cota rende bem mais consulta.

Quem trabalha diariamente com processos judiciais provavelmente já passou por esta situação:

Você tem uma petição, decisão, laudo, termo de audiência ou um processo inteiro e gostaria de usar uma ferramenta de inteligência artificial para resumir, organizar, pesquisar ou analisar aquele conteúdo.

Só existe um problema.

O documento contém nomes, CPFs, endereços, telefones, números de documentos e vários outros dados pessoais.

E simplesmente copiar tudo para um serviço externo nem sempre é uma boa ideia.

Foi pensando nesse problema que desenvolvi o TecJustiça Sigilo, um aplicativo para Windows que identifica e anonimiza automaticamente dados pessoais presentes em documentos jurídicos brasileiros.

O projeto é gratuito, open source e funciona localmente no computador.

👉 Projeto no GitHub:
https://github.com/marcosmarf27/tecjustica-sigilo

👉 Baixar a versão para Windows:
https://github.com/marcosmarf27/tecjustica-sigilo/releases/latest

A ideia é simples

Imagine um texto como este:

João da Silva, CPF 123.456.789-XX, residente na Rua Exemplo, nº 100, Fortaleza/CE...

O TecJustiça Sigilo identifica automaticamente esses elementos e permite transformar o texto em algo semelhante a:

[PESSOA_1], CPF [CPF_1], residente em [ENDERECO_1], [LOCAL_1]...

A estrutura jurídica do documento continua existindo.

Mas os dados que poderiam identificar diretamente as pessoas são removidos ou mascarados.

Isso abre uma possibilidade interessante: preparar documentos antes de utilizá-los em ferramentas de IA, mecanismos de pesquisa, RAGs, agentes ou outros sistemas de processamento de texto.

Tudo acontece na sua máquina

Essa talvez seja a característica mais importante do projeto.

O processamento dos documentos ocorre localmente no computador.

Não existe uma API externa recebendo o processo.

Não existe servidor do TecJustiça armazenando documentos.

Não existe cadastro.

Não existe assinatura.

Não existe telemetria.

Durante a anonimização, os documentos permanecem na máquina do usuário.

Até as fontes utilizadas pela interface são embarcadas no aplicativo. O modelo de linguagem utilizado para reconhecer entidades é baixado na primeira execução e, posteriormente, o processamento pode funcionar offline.

A ideia do projeto é justamente reduzir a necessidade de movimentar dados sensíveis para outros ambientes.

Não é apenas uma coleção de regex

Quando comecei a pensar nesse problema, uma das primeiras dificuldades ficou evidente.

Documentos jurídicos brasileiros são diferentes de textos comuns.

Temos coisas como:

• CPF;

• CNPJ;

• RG;

• PIS/NIT/PASEP;

• OAB;

• números de processo no padrão CNJ;

• CEP;

• endereços;

• contas bancárias;

• telefones;

• e-mails;

• nomes de partes;

• testemunhas;

• advogados;

• magistrados;

• cidades e outros locais.

Além disso, OCR de processo judicial costuma produzir coisas bastante peculiares.

Um nome pode aparecer em uma página como:

JOÃO DA SILVA

Em outra:

João da Silva

E depois aparecer quebrado entre linhas ou colunas.

Por isso, o TecJustiça Sigilo combina diferentes estratégias.

NER treinado em textos jurídicos brasileiros

Para identificar nomes e outras entidades, o aplicativo utiliza como modelo principal o:

pierreguillou/ner-bert-large-cased-pt-lenerbr

Ele é baseado em BERT e foi treinado no LeNER-Br, dataset criado especificamente a partir de documentos jurídicos brasileiros.

Isso é importante porque modelos genéricos frequentemente têm dificuldade com a linguagem encontrada em processos.

Expressões como:

Ministério Público

Tribunal de Justiça

Juíza de Direito

Código de Processo Penal

não deveriam simplesmente ser tratadas como nomes de pessoas.

O projeto possui inclusive uma deny list jurídica configurável, utilizada para impedir que determinadas expressões institucionais sejam mascaradas erroneamente.

CPF não é identificado apenas pelo formato

Existe outro problema interessante.

Imagine encontrar onze números consecutivos dentro de um documento.

Isso é necessariamente um CPF?

Não.

Por isso, para documentos que possuem dígitos verificadores, o TecJustiça Sigilo não se limita ao reconhecimento por expressão regular.

Ele também verifica matematicamente o documento.

Isso acontece, por exemplo, com:

CPF

CNPJ

PIS/NIT

e com o próprio número de processo CNJ.

Um candidato com dígito verificador inválido pode ser descartado.

Essa estratégia ajuda a reduzir falsos positivos sem simplesmente diminuir a sensibilidade do detector.

PDF, Word, planilha, apresentação e até documento digitalizado

Outro objetivo era evitar a necessidade de preparar manualmente os arquivos.

Você pode simplesmente arrastar documentos para o aplicativo.

Ele consegue trabalhar com formatos como:

PDF

DOCX

XLSX

PPTX

TXT

Markdown

RTF

e imagens como:

PNG, JPG e TIFF.

Quando o PDF possui texto, ele pode extrair esse conteúdo diretamente.

Quando existem páginas digitalizadas, entra o OCR local.

O projeto utiliza o liteparse, com PDFium e Tesseract, para realizar essa etapa sem enviar as páginas para um serviço externo.

E existe uma tela para revisar tudo

Uma coisa que eu não queria fazer era criar uma espécie de botão mágico:

“Clique aqui e confie que todos os dados desapareceram.”

Anonimização não deveria funcionar dessa maneira.

Por isso existe uma tela de revisão.

As entidades encontradas aparecem destacadas no documento.

Você consegue navegar pelas ocorrências e visualizar:

qual trecho foi detectado;

qual o tipo da entidade;

qual o grau de confiança da detecção.

Se encontrar um falso positivo, é possível indicar:

“Não é PII”.

Essa exceção passa a ser considerada nos processamentos seguintes.

Ou seja, existe uma etapa humana de conferência antes de utilizar o resultado.

Três maneiras de anonimizar

Nem todo caso de uso exige o mesmo tipo de anonimização.

Por isso o aplicativo possui três estratégias.

Marcadores

O dado é completamente substituído:

[PESSOA_1]

[CPF_1]

[ENDERECO_1]

A numeração permanece consistente, permitindo compreender que duas referências a [PESSOA_1] correspondem à mesma entidade.

Essa é particularmente interessante para utilização posterior com modelos de linguagem.

Máscara parcial

Parte da informação permanece visível.

Por exemplo:

J**** d* S****

Pode ser útil para conferência humana, embora naturalmente revele mais informação.

Cobertura completa

Todo o conteúdo é substituído:

***************

Aqui até o formato original pode desaparecer.

Acurácia também precisa ser medida

Talvez a parte que eu mais tenha aprendido desenvolvendo esse projeto seja esta:

não adianta dizer que um anonimizador “funciona”.

É preciso medir.

Na versão atual foi criado um processo de avaliação utilizando documentos processuais reais e um gabarito construído independentemente do detector.

Na medição descrita no release atual foram utilizados três processos, totalizando 819 páginas e aproximadamente 1,6 MB de texto proveniente de OCR.

Os resultados registrados foram:

Recall por ocorrência: 99,94%

Proteção por valor único: 99,40%

Endereço e CEP: 100%

RG: 100%

Nome de pessoa: 99,94%

O relatório completo e a metodologia utilizada estão disponíveis dentro do próprio repositório.

E existe um ponto importante aqui:

99,94% não significa 100%.

Anonimização automática não elimina a necessidade de revisão quando a informação for especialmente sensível.

OCR continua sendo um dos grandes problemas

Quem trabalha com processos antigos conhece bem a situação.

Documento escaneado.

Página torta.

Carimbo em cima do texto.

Cópia de cópia.

Máquina de escrever.

Texto quase ilegível.

Nesses casos, existe uma regra fundamental:

se o OCR não conseguiu ler corretamente uma informação, o anonimizador também não consegue identificar aquilo que não virou texto.

O próprio projeto declara essa limitação.

O OCR embarcado apresenta desempenho muito melhor em documentos impressos modernos do que em documentos antigos ou muito degradados. Assinaturas manuscritas também não podem ser consideradas automaticamente protegidas simplesmente porque o texto ao redor foi anonimizado.

Por isso a tela de revisão continua sendo importante.

Um detalhe de segurança que parece pequeno, mas não é

O TecJustiça Sigilo possui uma aplicação desktop em Electron e um backend local em Python.

Inicialmente seria fácil pensar:

“Se a API está rodando em 127.0.0.1, então ela está segura.”

Mas localhost sozinho não é uma barreira suficiente.

Uma página aberta no navegador pode tentar conversar com serviços que estão rodando localmente.

Como o backend do programa consegue acessar arquivos escolhidos pelo usuário, isso merece cuidado.

Na versão atual, a API local utiliza credencial de sessão para impedir que qualquer página simplesmente encontre a porta local e comece a fazer solicitações ao backend.

É um daqueles detalhes que aparecem quando começamos a tratar uma ferramenta local como software de verdade e não apenas como uma demonstração.

Também existe uma CLI

Essa parte provavelmente interessa mais aos desenvolvedores.

O aplicativo também disponibiliza o comando:

tecjustica-sigilo

Depois de instalado, ele pode ser utilizado pelo CMD, PowerShell e também pelo WSL.

Por exemplo:

tecjustica-sigilo processo.txt -o processo_anon.txt

Ou através de pipes:

cat peticao.txt | tecjustica-sigilo --entities PERSON,CPF_BR

Também existe saída estruturada em JSON.

Isso significa que o anonimizador pode participar de pipelines maiores.

Por exemplo:

Processo
   ↓
TecJustiça Sigilo
   ↓
texto anonimizado
   ↓
LLM / agente
   ↓
análise

Esse fluxo também permite integrar a anonimização com agentes executados localmente ou com outras automações.

A arquitetura

Para quem gosta da parte técnica, atualmente o projeto utiliza:

Electron 41 + React 19 + TypeScript + Tailwind 4

para a aplicação desktop.

No backend:

Python + FastAPI + Microsoft Presidio

Para reconhecimento de entidades:

BERT + LeNER-Br

com opção de fallback utilizando spaCy.

Para documentos e OCR:

liteparse + PDFium + Tesseract.

É, portanto, uma aplicação que junta várias áreas que tenho estudado bastante:

documentos
      ↓
extração
      ↓
OCR
      ↓
NER
      ↓
regex + validações
      ↓
detecção de PII
      ↓
revisão humana
      ↓
anonimização
      ↓
IA / RAG / agentes

Open source de verdade

Também decidi disponibilizar todo o projeto.

O TecJustiça Sigilo está sob licença MIT.

Isso significa que você pode estudar o código, modificar, criar melhorias, adaptar reconhecedores para necessidades específicas e reutilizar o software respeitando os termos da licença.

E, principalmente:

o programa é gratuito.

Sem versão premium.

Sem limite mensal de documentos.

Sem cadastro.

Sem assinatura.

A intenção é que qualquer servidor, magistrado, advogado, pesquisador ou desenvolvedor interessado no problema possa experimentar e também contribuir com melhorias.

Como instalar

Por enquanto disponibilizei um instalador pronto para:

Windows 10/11 x64.

Basta acessar:

👉 https://github.com/marcosmarf27/tecjustica-sigilo/releases/latest

e baixar o instalador da versão mais recente.

O instalador é grande porque já inclui boa parte do ambiente necessário para executar Python, PyTorch, Transformers e os demais componentes localmente.

Na primeira execução ainda é necessário baixar o modelo BERT. Depois disso, o processamento pode funcionar offline.

Linux e macOS ainda podem executar o projeto em ambiente de desenvolvimento, mas o binário que estou distribuindo neste primeiro momento é destinado ao Windows.

O projeto ainda pode evoluir bastante

Eu considero especialmente interessante abrir esse tipo de projeto porque anonimização jurídica não é um problema que uma única pessoa consegue mapear completamente.

Cada tribunal possui documentos diferentes.

Cada sistema produz OCRs diferentes.

Cada estado possui peculiaridades.

Cada novo documento problemático pode virar um novo caso de teste.

Esse é justamente um dos benefícios do open source.

Um falso positivo encontrado hoje pode virar um teste.

Um formato de documento não reconhecido pode virar um novo detector.

Uma melhoria no OCR pode beneficiar todo o pipeline.

E o software vai ficando melhor conforme esses casos reais aparecem.

IA no Judiciário também passa por infraestrutura

Quando falamos sobre inteligência artificial aplicada ao Judiciário, normalmente a conversa começa pelo modelo:

GPT.

Claude.

Gemini.

Modelos locais.

Mas existe toda uma camada anterior que talvez seja tão importante quanto:

Como extrair os documentos?

Como fazer OCR?

Como identificar informações sensíveis?

Como anonimizar?

Como revisar?

Como garantir que os dados não estão sendo enviados desnecessariamente para outros serviços?

Antes de perguntar:

“Qual IA vai analisar este processo?”

talvez também precisemos perguntar:

“Que informações realmente precisam sair deste computador para que essa análise aconteça?”

O TecJustiça Sigilo é uma tentativa open source de trabalhar justamente nessa camada.

Ainda há muito para melhorar.

Mas agora o código está aberto.

E qualquer pessoa pode testar.

TecJustiça Sigilo

🔒 Anonimização de dados jurídicos
💻 Processamento local
🪟 Windows 10/11
🧠 NER jurídico brasileiro
📄 PDF, Word, planilhas, apresentações e imagens
🔍 Tela de revisão
⌨️ Interface gráfica + CLI
❤️ Open source
💰 Gratuito

Código-fonte

https://github.com/marcosmarf27/tecjustica-sigilo

Download para Windows

https://github.com/marcosmarf27/tecjustica-sigilo/releases/latest

Se o projeto for útil para você, uma ⭐ no GitHub ajuda bastante a fazê-lo chegar a outras pessoas.

E, se você trabalha com documentos jurídicos e encontrar um caso em que a anonimização falhou, abra uma issue.

Esses casos reais são justamente o que pode ajudar a tornar a ferramenta cada vez melhor.

O botão ⬇ Baixar .zip, abaixo da lista de peças, monta um único arquivo com as peças do processo e um índice — para trabalhar os autos fora da extensão: num editor, num script, ou com uma ferramenta de IA que leia pastas.

Ele exporta as peças marcadas; sem nenhuma marcada, exporta todas as da lista. Como o PJe entrega uma peça de cada vez, um processo grande leva alguns minutos — o cartão de progresso mostra peça a peça e tem botão Cancelar.

O que vem dentro

processo-3000145-28.2026.8.06.0203/
├── LEIA-ME.md      convenção de nomes + formato de citação
├── indice.txt      ficha do processo + uma linha por peça
├── indice.json     os mesmos dados, para programas
└── pecas/
    ├── 001_Peticao-Inicial_215300001.pdf
    └── 002_Despacho_215300002.txt

• Os arquivos já vêm na ordem dos autos. O prefixo NNN é a posição cronológica da peça no processo, então a ordenação alfabética da pasta é a ordem do processo — inclusive numa exportação parcial. O id fica no nome porque é por ele que a peça é reencontrada no PJe.

• Peças digitalizadas saem em .pdf; as redigidas no editor do PJe saem em .txt, com o texto já extraído (inclusive as peças RTF de processos migrados).

• O indice.txt traz a ficha do processo — classe judicial, assunto, jurisdição, autuação, valor da causa, segredo de justiça, gratuidade, prioridade, órgão julgador, competência — e as partes com seus advogados. Depois, uma linha por peça com id, nome, tipo oficial, data e autor da juntada, formato, páginas e tamanho.

• O LEIA-ME.md explica o pacote a quem abrir a pasta depois, inclusive pedindo que toda afirmação venha com a origem no formato (Título da peça, id 123456, fl. 7) — o mesmo padrão do chat, das minutas e do mapa mental.

⚠️ O arquivo contém as peças integrais e dados pessoais das partes (CPF/CNPJ, OAB dos advogados). Se o processo correr em segredo de justiça, o LEIA-ME e o índice avisam logo no topo — mas a guarda do arquivo passa a ser sua.

Nenhuma permissão nova. A extensão continua pedindo apenas storage e clipboardWrite: ela não usa a API de downloads do Chrome e não enxerga sua pasta de downloads.

Também nesta versão (acumulado desde a v0.14.0)

Estas mudanças já estavam no código, mas não tinham chegado a uma release.

Novos recursos

• Biblioteca de modelos de peças (v0.15.0) — cadastre suas sentenças, decisões, despachos e ofícios por categoria e, ao gerar uma minuta, escolha a categoria para o assistente seguir a sua forma e a sua linguagem. Os fatos continuam saindo só das peças do processo em tela. Disponível nos modelos de 1M de contexto.

• Terceiro provedor: OpenAI (GPT-5.6) (v0.16.0) — Sol, Terra e Luna, todos com 1M de contexto, ao lado de Claude e Gemini. Minutas, mapa mental e busca funcionam igual nos três.

• Tela “Documentos” do PJe como fonte da lista (v0.19.0) — o ⟳ Carregar todas as peças passou a consultar a lista oficial do processo, que informa o total de páginas. Com isso a extensão consegue dizer “leitura parcial, 3 de 6 páginas” em vez de entregar uma lista incompleta com cara de completa. De quebra traz o tipo oficial de cada peça, que melhora a classificação por categoria.

• Importar .docx na biblioteca de modelos, e as bibliotecas (minutas e modelos) agora são alcançáveis direto pelas Configurações, sem precisar de uma aba de autos aberta.

Interface

• Sistema de design aplicado ao painel (v0.17.0 / v0.18.x) — paleta, tipografia e espaçamento unificados em variáveis; o número do processo (CNJ) passou a aparecer no cabeçalho do painel, que resolve não saber a qual aba o painel se refere quando há vários processos abertos.

Correções

• Peças que voltavam vazias — a extensão usava apenas a rota curta de download, que só funciona para PDF: em peça HTML o servidor devolve uma casca vazia. Agora tenta primeiro a rota completa e aceita a primeira que devolva conteúdo útil.

• Peças RTF (editor antigo do PJe, comuns em processos migrados) passaram a ser convertidas em texto legível. Antes chegavam ao modelo como marcação crua — milhares de tokens e nenhum conteúdo.

• Custo correto em contexto longo — os modelos GPT-5.6 cobram o dobro do input acima de 272 mil tokens, e o medidor mostrava metade do valor real justamente nos processos volumosos.

• Watchdog do serviço da extensão e outras correções de estabilidade em turnos longos.

Como atualizar

Quem usa a versão da Chrome Web Store recebe a atualização sozinho, em segundo plano — nada é perdido (chaves de API, prompts e configurações continuam).

Quem usa a versão de desenvolvimento: baixe o .zip desta release, recarregue a extensão em chrome://extensions e recarregue a aba do processo.

Existe uma distância enorme entre “os dados do processo estão disponíveis” e “eu consigo usar os dados do processo”. No PJe do TJCE os dados sempre estiveram lá, via MNI — o canal oficial de interoperabilidade do Judiciário. O que faltava era a ponte entre esse canal e as ferramentas de IA que a gente já usa todo dia.

Essa ponte agora existe: o MCP do PJe — TJCE.

Explico aqui, na ordem: o que é MCP, o que fizemos com o MNI do Tribunal de Justiça do Ceará, quais ferramentas o servidor expõe, como cada uma recebe e devolve dados, e como usar tudo isso no cliente de IA que você já tem.

1. O que é MCP

MCP é o Model Context Protocol, um padrão aberto que define como um assistente de IA conversa com sistemas externos.

A analogia que funciona é a do conector universal. Antes do padrão, cada integração era um cabo diferente: uma extensão só para o Claude, um plugin só para o Cursor, um script só para o terminal. Com MCP você constrói um servidor e ele funciona em todos os clientes que falam o protocolo.

O servidor publica três coisas: tools (ações que o modelo executa — “liste os documentos do processo X”), resources (informação de referência, como o formato CNJ e os limites do serviço) e prompts (roteiros prontos que você dispara com um clique).

O ponto que mais importa: o modelo não inventa os dados. Ele chama a ferramenta, o servidor vai ao PJe do TJCE buscar de verdade, e a resposta sai em cima do que voltou.

2. O ponto de partida: o MNI é SOAP

O MNI (Modelo Nacional de Interoperabilidade) foi instituído pela Resolução Conjunta CNJ/CNMP n. 3, de 16 de abril de 2013. Ele obriga os órgãos do Judiciário a expor os dados processuais por um conjunto padronizado de serviços: consulta de processo, download de documento, movimentações.

Não é robô, não é raspagem de tela, não é API interna descoberta por engenharia reversa. É o canal institucional, com contrato formal e versionamento previsto em norma.

O problema é a tecnologia da época: SOAP com envelopes XML, WSDL e respostas MTOM/XOP multipart. Na prática isso significa montar envelopes XML à mão com quatro namespaces distintos; lidar com respostas em que o PDF vem anexado ao XML; descobrir na tentativa e erro que a biblioteca “rápida” às vezes perde documentos vinculados, e que é preciso um segundo caminho mais bruto para preservar a ordem; e traduzir códigos numéricos (classeProcessual: 7, tipoDocumento: 490) que ninguém sabe de cabeça o que são.

A primeira etapa do trabalho foi essa tradução: de SOAP/XML para REST/JSON. Uma API que recebe um número CNJ e devolve JSON limpo, com os documentos na ordem certa, os códigos já traduzidos para rótulos legíveis — "Certidão de Dívida Ativa (CDA) (490)" em vez de 490 — e o binário acessível por um endpoint simples.

3. Da API REST ao servidor MCP

Com a API REST funcionando, faltava o último salto. E ele não é óbvio: uma API REST não vira um bom servidor MCP automaticamente.

Um endpoint REST espera um desenvolvedor do outro lado, que leu a documentação e sabe qual chamada fazer. Um servidor MCP tem um modelo de linguagem do outro lado, decidindo sozinho o que chamar. Isso muda o desenho em três pontos:

• As ferramentas precisam de nomes e descrições que expliquem quando usá-las, não só o que fazem.

• Devolver um PDF binário é inútil: o protocolo entrega texto, imagem e áudio ao modelo — binário ele não lê. Daí as ferramentas de extração de texto (OCR de PDF no servidor; HTML e RTF processados localmente).

• É preciso evitar idas e voltas. Em vez de obrigar o modelo a dez chamadas para montar um panorama, criamos ferramentas que entregam o mapa do processo inteiro de uma vez.

O resultado é a cadeia acima: PJe TJCE (MNI/SOAP) → API REST (JSON) → Servidor MCP (16 ferramentas) → seu assistente de IA.

4. As ferramentas do MCP do PJe — TJCE

São 16 ferramentas, mais 4 resources e 3 prompts, em quatro famílias.

Consulta — espelham a API REST:

• consultar_processo — dados completos e lista robusta de documentos

• consultar_capa — capa enxuta: partes, classe, assuntos, movimentos

• listar_documentos_ids — IDs ordenados de todos os documentos, inclusive vinculados

• consultar_peticao_inicial — metadados da inicial e dos anexos

• baixar_documento — o arquivo original (PDF/RTF/HTML) para salvar no disco

Leitura e extração — o coração do serviço:

• extrair_texto_documento — devolve o texto do documento, pronto para o modelo ler

• extrair_textos_documentos — até 4 documentos numa única chamada

• listar_documentos_para_leitura — lista enriquecida, paginada e filtrável, com a marcação de “dá para extrair texto?”

• preparar_roteiro_leitura — o mapa do processo em uma chamada, sem OCR

• ler_documentos_iniciais — lê automaticamente as primeiras peças

• ler_ultimos_documentos — lê as últimas peças relevantes, ignorando certidões e expedientes

Utilitárias:

• validar_numero_processo — valida e decompõe o número CNJ (grátis)

• filtrar_documentos_por_tipo — acha documentos por termo: “sentença”, “contestação”, “laudo”

• sumarizar_processo — resumo executivo: capa, contagens e últimos movimentos

• minha_assinatura — status do seu acesso (grátis)

Jurisprudência:

• pdpj_buscar_precedentes — busca no Banco Nacional de Precedentes (BNP/CNJ): súmulas, súmulas vinculantes, repercussão geral, IRDR, IRR e temas repetitivos

O extrair_texto_documento merece um parágrafo próprio. Ele escolhe o caminho pelo tipo do arquivo: PDF vai para OCR com GPU (com opção de enhance por IA para certidões de layout ruim), HTML é limpo no servidor, RTF vira texto puro, TXT é decodificado direto. Tudo em memória — o documento não fica gravado em disco do lado de cá.

5. Entrada e saída: a anatomia de uma chamada

Esta é a parte que mais gera dúvida em quem nunca mexeu com MCP. Toda ferramenta tem argumentos de entrada (o que você informa) e um retorno estruturado (o que ela devolve).

Veja a extrair_texto_documento. A entrada são quatro argumentos: numero_processo (o número CNJ), documento_id (que vem das ferramentas de listagem), grau (1 para primeiro grau, o padrão, ou 2 para o Tribunal) e usar_ai_vision (liga o enhance de IA no OCR — mais lento, melhor em certidões).

A saída é um JSON assim:

{
  "sucesso": true,
  "documento_id": "12345",
  "descricao": "Petição inicial",
  "mimetype_origem": "application/pdf",
  "formato_extracao": "pdf_ocr",
  "texto": "EXCELENTÍSSIMO SENHOR DOUTOR JUIZ DE DIREITO...",
  "caracteres": 12345,
  "metadados": {
    "num_paginas": 10,
    "paginas_ocr": 2,
    "tempo_processamento_segundos": 5.42,
    "cache_hit": false
  }
}

Repare no que vem junto do texto: quantas páginas precisaram de OCR, quanto tempo levou, se veio do cache. Não é decoração — é o que permite ao modelo (e a você) saber se a extração foi confiável ou se aquele documento é uma digitalização ruim que merece uma segunda passada com usar_ai_vision.

E é por isso que a saída é JSON estruturado, não texto solto: o modelo encadeia sozinho. Ele lê o documento_id de uma ferramenta e usa na seguinte, sem você copiar e colar nada.

Um aviso honesto sobre os retornos do MNI, porque você vai esbarrar neles: o número do processo volta sem pontuação (20 dígitos puros), o polo das partes vem como "AT" e "PA" em vez de “ativo” e “passivo”, e alguns códigos ainda aparecem numéricos quando a tabela do tribunal não está em cache. O servidor normaliza o que dá; o resto está documentado.

6. Ler o processo como um humano leria

Aqui está o que mais impressiona quem vê funcionando pela primeira vez. Você não pede “faça um GET no endpoint tal”. Você pergunta em português.

O caminho que o assistente segue é o mesmo de um advogado ou servidor abrindo autos desconhecidos:

1. Mapear os autos. preparar_roteiro_leitura devolve, numa chamada, os documentos iniciais, os mais recentes, as prováveis decisões e as petições relevantes. É o equivalente a folhear o processo inteiro para ver o que tem ali.

2. Ler a inicial. ler_documentos_iniciais extrai o texto das primeiras peças — o que foi pedido e por quê.

3. Ler as decisões. filtrar_documentos_por_tipo com “sentença” ou “decisão”, depois extrair_texto_documento na peça encontrada.

4. Resumir e responder. O modelo cruza tudo e responde citando o documento de onde tirou cada afirmação.

Na prática, as perguntas ficam assim:

“Resuma o processo 3000066-83.2025.8.06.0203: quem são as partes, o que se pede e em que fase está.”

“Tem sentença nesse processo? Se tiver, leia e me diga o dispositivo.”

“Leia as três últimas peças e me diga se há alguma pendência que eu precise cumprir.”

“Esse caso discute dano moral em consignado. Busca no Banco Nacional de Precedentes se existe tema repetitivo aplicável.”

Cada uma dessas perguntas dispara duas, três, quatro chamadas encadeadas. Você não precisa saber quais.

7. Funciona no cliente que você já usa

O servidor é HTTP remoto: não instala nada e não roda nada na sua máquina. É uma URL e um cabeçalho de autenticação.

Claude Code (CLI) — um comando:

claude mcp add --transport http --scope user \
  --header "Authorization: Bearer SUA_API_KEY" \
  pje https://pje-mni-mcp-production.up.railway.app/mcp

Claude Desktop no Windows — precisa passar pelo mcp-remote, porque o app no Windows ainda não fala HTTP nativo. Em %APPDATA%\Claude\claude_desktop_config.json:

{
  "mcpServers": {
    "pje": {
      "command": "cmd",
      "args": [
        "/c", "npx", "mcp-remote",
        "https://pje-mni-mcp-production.up.railway.app/mcp",
        "--header", "Authorization: Bearer SUA_API_KEY"
      ]
    }
  }
}

No macOS e Linux o Claude Desktop aceita a URL direto, com um objeto headers contendo o mesmo Authorization. O Codex CLI usa ~/.codex/config.toml com url e bearer_token_env_var; o OpenCode usa opencode.json com "type": "remote"; o Cursor aceita servidor MCP remoto com headers. Os exemplos completos estão no repositório.

⚠️ Duas armadilhas conhecidas. A URL termina em /mcp, sem barra no final — com barra, a borda da hospedagem faz um redirecionamento que perde o corpo da requisição. E no Windows, se você mudar a configuração e continuar vendo o erro antigo, apague o cache de autenticação: rmdir /s /q "%USERPROFILE%\.mcp-auth".

ChatGPT tem suporte limitado. Os conectores dele não permitem cabeçalhos customizados, então não há como enviar as suas credenciais do PJe — e o modo Deep Research exige ferramentas search/fetch que este servidor não expõe. Para uso sério, prefira Claude Code, Claude Desktop, Cursor, Codex CLI ou OpenCode.

8. O diferencial: você usa as suas credenciais

Este é o ponto que separa este MCP de uma solução genérica de acesso a dados processuais.

Você pode informar seu CPF e sua senha do PJe nos cabeçalhos X-MNI-CPF e X-MNI-SENHA. Quando faz isso, o servidor consulta o TJCE com o seu cadastro: você enxerga exatamente o que enxergaria logando no PJe — os processos em que é parte, advogado ou tem acesso legítimo. Nem mais, nem menos.

Isso importa por três razões. A visibilidade é a sua: o perímetro de acesso é o do seu próprio cadastro no tribunal, definido pelo PJe, não por uma regra nossa. Sigilo continua sigilo: o que o seu login não vê, o MCP não vê. E há rastreabilidade: a consulta acontece sob a sua identidade, como qualquer outro acesso seu ao sistema.

Os cabeçalhos são opcionais — sem eles o servidor usa uma credencial padrão compartilhada, suficiente para processos públicos. Mas se o seu caso é acompanhar a sua própria carteira, use as suas credenciais: é para isso que o suporte existe.

Vale o cuidado óbvio: a senha fica no arquivo de configuração do cliente, na sua máquina. Prefira apontar para variáveis de ambiente (${PJE_MNI_SENHA}) a escrever a senha direto, e nunca versione esse arquivo.

9. Primeiro e segundo grau

O número CNJ não diz em que instância o processo está — quem define é o endpoint consultado. Por isso as ferramentas aceitam o argumento grau: 1 para as varas (padrão) e 2 para o Tribunal, quando você quer o recurso.

As mesmas credenciais valem para os dois graus, desde que o seu cadastro no PJe esteja habilitado na instância consultada. Se não estiver, o segundo grau responde com falha de login — e isso é característica do seu cadastro no tribunal, não do servidor.

10. Limites, com transparência

Sem letra miúda:

• Documentos até 15 MB. Acima disso a ferramenta recusa e orienta a baixar pela API REST.

• Até 4 documentos por chamada nas extrações múltiplas, por controle de tempo e memória.

• Cache de 24 horas. Reconsultar o mesmo recurso volta do cache, sem novo SOAP: mais rápido para você, menos carga para o TJCE.

• OCR de PDF leva tempo. Um escaneado grande pode levar dezenas de segundos; HTML e RTF são instantâneos.

• O TJCE às vezes está lento ou fora. Quando o MNI do tribunal não responde, nenhuma ponte resolve — há retentativas, não milagre.

• Testado no TJCE, 1º e 2º grau. É o escopo que garantimos.

11. Quer usar em outro tribunal? Leia esta parte com atenção

O MNI é um padrão nacional e, em tese, todo tribunal com PJe expõe os mesmos serviços. Na prática, este servidor foi construído, testado e validado para o PJe do Tribunal de Justiça do Ceará — e é só isso que ele promete.

Se você atua em outro tribunal e quer algo equivalente, o caminho é:

1. Baixar o código-fonte e adaptar. O endpoint muda, e com ele mudam detalhes que não são cosméticos: tabelas de tipos de documento, comportamento do MTOM, campos que um tribunal preenche e outro não.

2. Verificar se o endpoint MNI do tribunal está publicamente disponível. Nem todo tribunal publica o WSDL abertamente.

3. Entrar em contato com a área de tecnologia do tribunal e confirmar que o acesso está liberado para o seu perfil e para o seu caso de uso. Este passo não é opcional. Cada tribunal define suas regras de habilitação no MNI, e usar o serviço sem essa confirmação é problema seu com o tribunal — não uma zona cinzenta a explorar.

4. Testar e assumir a manutenção. Você vira o responsável pela sua instância.

Ou seja: o código ajuda, mas a autorização é uma conversa que você precisa ter com o seu tribunal. Para o TJCE, o serviço já está no ar, funcionando e mantido.

12. Como começar no TJCE

O acesso é por assinatura mensal de R$ 49,90, com uso ilimitado — sem cobrança por consulta, sem contar créditos. Contas novas têm 7 dias grátis para testar antes de decidir.

1. Crie sua conta e acesse o painel: pjece.tecjustica.com

2. Gere sua API key na área de chaves.

3. Cole a chave na configuração do seu cliente MCP (seção 7).

4. Se quiser consultar com o seu próprio cadastro do PJe, acrescente X-MNI-CPF e X-MNI-SENHA.

Para confirmar que conectou, peça ao assistente as duas ferramentas gratuitas: “use a tool minha_assinatura e me diga meu status” e “valide o número 3000066-83.2025.8.06.0203”. Se as duas responderem, está tudo certo — a partir daí é só perguntar sobre os autos.

Fechando

O MNI existe desde 2013 e é obrigatório. As ferramentas de IA que leem, resumem e cruzam documentos existem desde ontem e são excelentes. O MCP do PJe do TJCE é o pedaço que faltava no meio — pequeno, chato de construir e absolutamente necessário.

O que era um envelope SOAP com quatro namespaces virou uma pergunta em português. Essa é a história inteira.

Comece agora → pjece.tecjustica.com

Projeto independente de tecnologia jurídica, mantido pela TecJustiça. Sem vínculo institucional com o Tribunal de Justiça do Ceará, com o CNJ ou com qualquer órgão público. O acesso aos dados se dá pelo MNI — o canal oficial de interoperabilidade instituído pela Resolução Conjunta CNJ/CNMP n. 3/2013 — e sempre dentro do perímetro de visibilidade das credenciais utilizadas.

Acabou.

👉 Instalar o TecJustiça PJe — Análise de Processos

Um clique, e o Chrome cuida das atualizações sozinho. Sem cadastro, sem mensalidade, sem plano, sem período de teste que expira.

O que a extensão faz

Ela coloca um assistente de IA dentro da tela dos autos do PJe. Você não copia texto, não baixa PDF, não abre outra aba: marca as peças que interessam, pergunta em português e recebe a resposta ali mesmo, ao lado do processo.

Na prática:

• Você escolhe o que entra na análise. Checkbox por peça — ou digite @ no campo de pergunta (@contestação, @sentença) e marque sem tirar a mão do teclado.

• Peças destacadas por cor. Decisões, audiências, petições e provas aparecem sinalizadas na lista, o que já ajuda a se localizar num processo com 200 documentos.

• Lê PDF digitalizado. Peça escaneada, ofício de papel, laudo antigo — o próprio modelo lê a imagem. Sem OCR externo, sem serviço à parte.

• Cita pelo nome da peça. A resposta diz “na Contestação…”, não “no id 145209”.

• Responde em tabela, linha do tempo, lista. Markdown completo, em streaming, aparecendo enquanto é gerado.

Perguntas que ela responde bem no dia a dia:

“Resuma o pedido da inicial e os argumentos da contestação.” “Monte uma tabela com a linha do tempo dos atos processuais.” “Quais provas foram juntadas e o que cada uma demonstra?” “A sentença enfrentou todos os pedidos da inicial?”

A ideia é simples de propósito: uma ferramenta pequena, que faz uma coisa só, mas faz onde a dor está — na leitura de autos, que é onde servidor, advogado e magistrado gastam a maior parte do tempo.

Você escolhe o modelo: Claude ou Gemini

A extensão não é casada com um único fornecedor de IA. Você aponta a chave que quiser e ela usa:

• Claude (Anthropic) — quando você quer a leitura mais criteriosa de peça longa e raciocínio jurídico mais cuidadoso.

• Gemini 3.6 Flash (gemini-3.6-flash) — o modelo de trabalho do dia a dia: rápido, multimodal e com janela de 1 milhão de tokens, o que engole processo volumoso sem picotar.

• Gemini 3.5 Flash-Lite (gemini-3.5-flash-lite) — o mais veloz e barato da família, ideal para tarefa repetitiva e de alto volume: triar fila de tarefas, classificar peça, extrair dado pontual de dezenas de processos seguidos.

Na prática, o critério é simples: Flash-Lite para triar, Flash para analisar, Claude para redigir. Comece pelo Flash-Lite naquilo que você faria batendo o olho, e suba de modelo só quando a resposta não te convencer.

Gratuita e aberta — com uma ressalva honesta

A extensão é gratuita e open source, sob licença MIT. O código inteiro está no GitHub:

🔗 github.com/marcosmarf27/pje-ia

Pode ler, auditar, alterar, adaptar para o PJe do seu tribunal, abrir issue, mandar PR ou fazer um fork e seguir sozinho. Não tem servidor meu no meio, não tem telemetria, não tem coleta de dados.

A ressalva: a extensão não cobra nada, mas o cérebro dela é a API do modelo e você usa a sua própria chave — da Anthropic ou do Google, como preferir. São créditos pré-pagos, sem assinatura e sem fidelidade: você paga o que consumir, direto ao fornecedor. O popup da extensão traz o passo a passo para criar a chave. Prefiro dizer isso na primeira linha a deixar alguém descobrir depois de instalar.

Duas consequências boas desse desenho: sua chave fica só no seu navegador, e as peças vão direto do seu Chrome para a API, sem passar por nenhum servidor intermediário.

⚠️ E o aviso que não dá para pular: autos contêm dados pessoais e, às vezes, segredo de justiça. Enviar peças a um provedor de IA é decisão do usuário, sob as normas do seu tribunal e a LGPD. E a resposta da IA é apoio à leitura — não substitui análise jurídica humana. Confira sempre na peça original.

Se você é do TJCE, tem mais

A extensão funciona dentro da tela do PJe. Mas dá para ir além: acessar os autos em tempo real, de fora do navegador, direto do Claude, do Cursor ou do Codex.

É o que faz o PJe MNI Lab — um laboratório que expõe o PJe do TJCE (1º e 2º grau) como servidor MCP. Você pergunta ao agente, e ele abre o processo no instante da pergunta, lê as peças uma a uma, roda OCR no que for digitalizado e responde com o que está nos autos agora.

Nada de base replicada, nada de robô raspando tela: a consulta vai pelo MNI, o canal oficial do CNJ (Resolução Conjunta CNJ/CNMP nº 3/2013), com o seu próprio login do PJe.

🔗 pjece.tecjustica.com — 7 dias grátis, sem cartão.

Transparência total, porque as duas coisas são diferentes: a extensão é gratuita; o laboratório é beta e tem assinatura, que serve para ratear a infraestrutura e o OCR. É projeto pessoal, sem vínculo com o TJCE, mantido nas horas livres. E se algum tribunal quiser oferecer algo assim a seus magistrados e servidores, o código-fonte vai sem custo — é só pedir.

Instale e me diga o que quebrou

O PJe muda de versão, cada tribunal tem sua variação, e eu testo no que uso todo dia. Se algo não funcionar no seu, abra uma issue com o tribunal e a mensagem de erro — ou responda este e-mail.

⚖️ Instalar na Chrome Web Store

Feito para quem lê autos o dia inteiro.

A fila diz 229.

É o que aparece no alto da tarefa [GAB] – ATO JUDICIAL – MINUTAR DESPACHO no painel do PJe de uma vara única do interior do Ceará. Duzentos e vinte e nove processos esperando que alguém abra, leia e escreva. Do lado direito de cada card, o PJe oferece o de sempre: um alfinete para criar lembrete, um livro para abrir os autos, dois contadores de dias em verde.

E, desde este mês, mais um botão. Escrito Assessor.

O botão fica na barra de ícones do próprio card, ao lado do alfinete e do livro. Embaixo, no processo 3000421-93.2025.8.06.0203, o resultado já voltou: Entregue — Análise, um DOCX para baixar sem sair da tela.

Clicar nele abre uma caixa de texto que pede uma coisa só: o que você quer que ele faça neste processo. “Minutar o despacho saneador.” “Relatório do status atual e o que falta para sentenciar.” “Analisar a prescrição da pretensão punitiva.” Em alguns minutos, o documento volta para o mesmo card, em DOCX.

Este texto é sobre o que existe entre esses dois cliques. Porque a parte interessante não é o botão — é a infraestrutura que ele aciona.

O mal-entendido de sempre: “isso a IA já faz”

Quem trabalha em gabinete já tentou. Abre o assistente de IA em outra aba, copia a inicial, cola. Copia a contestação, cola. Pergunta. A resposta vem bonita, e mesmo assim o trabalho não anda. Três motivos, todos concretos:

Primeiro: o processo não cabe. Uma execução fiscal de 2000 com vinte anos de tramitação tem centenas de folhas. Você não cola isso numa conversa. Então você recorta — e recortar já é a análise. Se você soubesse quais são as trinta folhas que importam, metade do serviço estaria feito.

Segundo: metade dos autos é imagem. Mandado cumprido, AR, procuração assinada, laudo digitalizado. Sem OCR que preserve a numeração, o assistente lê um borrão. E aí ele não consegue dizer “fls. 234” — vai dizer “conforme consta nos autos”, que é exatamente a frase que o revisor não pode aceitar.

Terceiro, e o mais grave: ele não confere nada. O modelo devolve a súmula com a mesma segurança tranquila, exista ela ou não. Quem descobre o erro é o revisor, lendo. E se o revisor precisa reler tudo para confiar, o assistente não economizou tempo — apenas mudou o lugar do trabalho.

Existe uma frase que circula em toda demonstração de “IA jurídica”: basta colocar a lei no contexto. Ela erra o alvo. O que decide um caso concreto quase nunca é a lei — é o que está nos autos: quem foi citado e em que endereço, o que a contestação admitiu, qual decisão interlocutória já transitou, se o laudo chegou. Isso não está em nenhuma base de conhecimento. Está em quatrocentas folhas dentro de um sistema que exige login.

Análise processual não é uma pergunta. É um procedimento. E procedimento se resolve com infraestrutura.

Primeiro pilar: dar ferramentas ao modelo (o tal do MCP)

MCP (Model Context Protocol) é um padrão aberto que permite dar ferramentas a um modelo de linguagem. Sem jargão: é a diferença entre duas situações.

Na primeira, você contrata alguém que só pode responder pelo telefone, sobre o que você ler em voz alta para ele. Ele é inteligente, mas depende inteiramente do que você recortou.

Na segunda, você dá a essa pessoa a credencial do PJe. Ela entra, olha a capa, vê a lista de peças, decide o que vale ler, abre o que escolheu, e volta para reler quando a análise pede.

O TecJustiça Auto trabalha na segunda situação. O agente acessa o PJe pelo MNI — o Modelo Nacional de Interoperabilidade, o canal oficial do próprio sistema —, com o login do usuário. São 17 ferramentas disponíveis:

Repare no grupo do meio, porque é ali que mora a diferença. Antes de ler qualquer coisa, o agente chama preparar_roteiro_leitura: lista os documentos e decide, em função do que foi pedido, o que merece leitura. Um pedido de despacho saneador manda ler a inicial, a contestação e a réplica. Um pedido sobre prescrição manda ler a denúncia, o recebimento e as certidões de suspensão.

É contraintuitivo, mas a ferramenta mais valiosa do conjunto é a que descarta. Ler tudo não é virtude: dilui o que interessa, estoura qualquer limite técnico e cobra caro por folha irrelevante.

E há uma ferramenta que muda a natureza do resultado: pdpj_buscar_precedentes, que consulta o Banco Nacional de Precedentes do CNJ. Quando o documento cita uma súmula ou um tema repetitivo, aquilo não veio da memória do modelo — veio de uma consulta. O que a consulta não confirma entra no documento marcado como NÃO CONFIRMADO, em vez de aparecer disfarçado de certeza.

Segundo pilar: o loop

Aqui está a diferença entre um assistente e uma infraestrutura. Um assistente responde uma vez. Uma infraestrutura repete um procedimento até ele passar nas conferências.

Vale ler cada fase pelo que ela não faz:

A primeira sessão não escreve o documento. Ela lê a capa, monta o roteiro e decompõe o pedido em 7 a 11 tarefas de análise — identificar as partes e sua situação processual, mapear a cronologia, levantar as provas, apurar as pendências. É a mesma coisa que um assessor experiente faz numa folha de rascunho antes de começar.

As sessões seguintes não carregam o processo inteiro. Cada uma pega um lote de até quatro tarefas, lê só o que aquelas tarefas exigem e grava o resultado no banco de dados do caso. A sessão seguinte nasce limpa e lê o que a anterior apurou. É por isso que o tamanho dos autos deixa de ser um teto: o que se acumula é resultado, não texto bruto.

A sessão de verificação não produz conteúdo novo. Ela audita: cada folha citada existe? Cada artigo está dentro da faixa daquele código? Cada súmula se confirma no Banco Nacional de Precedentes? A saída dela é uma lista de correções.

A consolidação não converte texto em documento. Ela monta o DOCX do zero, com tabelas de verdade, títulos, corpo justificado e numeração de página — aplicando antes as correções da verificação.

A conferência final não usa IA. É código Python comum, rodando em cima do arquivo pronto: artigo fora de faixa, folha que não existe nos autos, campo [A PREENCHER] esquecido, documento sem rodapé ou sem tabela. Se reprovar, o trabalho volta para a fase anterior — e o agente reconstrói o documento, sem ninguém pedir.

Uma história curta sobre por que essa última fase existe

Semana passada, revisando entregas reais em produção, encontramos um relatório que tinha saído torto: sem numeração de página, sem parágrafo justificado, com o que deveria ser tabela virando texto corrido. O conteúdo estava certo; a forma, não. O documento tinha sido gerado por um conversor de emergência que existia como rede de segurança — e ninguém percebeu, porque a única verificação automática era “o arquivo está vazio?”.

A correção não foi escrever um prompt pedindo capricho. Foi ensinar o sistema a auditar o próprio produto: abrir o arquivo, contar parágrafos justificados, procurar o rodapé, verificar se há tabelas — e, reprovando, gastar uma sessão inteira refazendo o documento pela ferramenta certa.

É essa a diferença de tratar o assunto como infraestrutura. Um erro achado vira uma camada de conferência permanente, que protege todos os processos seguintes. Não vira um lembrete na cabeça de quem usa.

Terceiro pilar: o assessor mora onde o trabalho acontece

Um sistema excelente que exige abrir outra aba, fazer login, colar um número e voltar já perdeu. A rotina do gabinete não tem esse intervalo.

Por isso a extensão. Ela não recria o PJe nem substitui nada: injeta um botão na fila que o servidor já abre todo dia. A tarefa é escrita em português, o caso entra na fila do painel, e o resultado volta para o mesmo card. Se a análise falhar — sem créditos, senha do PJe expirada, processo em segredo de justiça — o card diz “Falhou — ver motivo”, mostra o motivo registrado e oferece o botão de tentar de novo. Se já houve entrega anterior, ela continua acessível.

E há um ganho que nenhum cronômetro de caso isolado mostra:

Enquanto o servidor abre o processo seguinte e analisa na mão, do jeito que sempre fez, outros dez estão sendo lidos em paralelo. O gargalo deixa de ser a leitura — que a máquina faz em lote, de madrugada, sem competir com o expediente — e passa a ser a revisão, que é onde o julgamento humano vale mais.

Quarto pilar: a unidade ensina o assessor

Um assessor recém-chegado não sabe o padrão da casa. Aprende: vê os despachos anteriores, entende como aquele magistrado estrutura a fundamentação, decora os modelos da secretaria.

O sistema faz isso por skills — pacotes de instruções e modelos que a unidade escolhe usar em cada análise. Hoje existem quatro no repositório, e a lógica delas mostra bem o desenho:

• Modelos de decisões cíveis — despacho, decisão interlocutória e sentença no padrão da unidade, com a estrutura de fundamentação que o gabinete adota.

• Expedientes — mandados, ofícios, cartas precatórias e editais, preenchidos com os dados reais dos autos; o que não está nos autos vira [A PREENCHER] explícito, nunca invenção.

• Prescrição penal — e esta merece atenção. O cálculo não é feito pela IA. Ele roda num programa em Python que implementa a tabela do art. 109 do Código Penal e monta a linha do tempo segmentada por marcos interruptivos e suspensões. O agente lê os autos, extrai as datas e opera a calculadora; a conta em si é determinística e testada contra processos criminais reais.

• Geração do documento — a montagem do DOCX propriamente dita.

O princípio vale além do jurídico: onde a resposta precisa ser exata, a IA não calcula — ela chama uma ferramenta que calcula. E a personalização da unidade fica versionada em arquivo, revisável, igual para todo mundo que usar o sistema. Não fica na cabeça de quem escreveu o prompt.

O painel: a fila inteira em uma tela

Cada caso atribuído aparece aqui, com quantas tarefas de análise já foram concluídas, quanto tempo levou e em que coluna está. Nada vai sozinho para “Concluído”: o destino do trabalho da máquina é a coluna Revisão. De lá, um humano lê, ajusta e decide — ou devolve para “Fazendo” com um comentário, e o agente refaz considerando o que foi dito.

O que ele não faz

Vale ser explícito, porque a área é séria:

• Não assina, não protocola, não decide. Entrega minuta. Revisão humana é parte do desenho, não um aviso legal no rodapé.

• Não inventa jurisprudência. O que o Banco Nacional de Precedentes não confirma sai marcado como não confirmado.

• Não funciona onde o PJe não entrega. Hoje o alcance é o PJe do Ceará, 1º grau. MNI fora do ar ou senha expirada param a fila — e o card diz isso, em vez de entregar um documento pela metade.

• Não é mágica de tamanho fixo. Autos maiores custam mais tempo e mais leitura; no benchmark, o processo pesado consumiu 3,4× mais que o leve.

Infraestrutura é o que sobra quando a novidade passa

O que a unidade instalou não foi um chatbot jurídico. Foi uma esteira: um canal oficial de acesso aos autos, um procedimento que fatia o trabalho em tarefas verificáveis, camadas de conferência que falham por motivos diferentes, modelos próprios da casa versionados em arquivo, e um botão no lugar onde a fila já está.

O botão é a parte visível. A parte que importa é que, quando aparecer um modelo melhor no mês que vem, a esteira continua valendo — troca-se o motor, não a fábrica. E quando um erro novo aparecer, ele vira mais uma camada de conferência, que protege daí em diante todos os 229 processos da fila.

A fila continua dizendo 229. A diferença é que agora ela anda enquanto você trabalha.

TecJustiça Auto · agente de análise processual conectado ao PJe/TJCE via MNI ·

A extensão PJe IA, que adiciona um assistente de inteligência artificial à tela de autos do PJe, chegou à versão 0.9 com sua maior novidade até aqui: além dos modelos Claude (Anthropic), agora você pode cadastrar uma chave do Google e usar o Gemini 3.6 Flash e o Gemini 3.5 Flash-Lite — este último, o modelo mais barato e veloz disponível na extensão, ideal para triagens e resumos do dia a dia. Os dois têm janela de 1 milhão de tokens e leem até 1.000 páginas de PDF de uma vez, o que faz diferença em autos volumosos.

A atualização também deixou o uso mais transparente e rápido: um selo na barra de ferramentas mostra o modelo e o nível de raciocínio ativos (chega de salvar as opções e torcer para ter funcionado), o novo atalho “principais” marca com um clique as peças destacadas por categoria — decisões, audiências, petições e provas — e a extensão agora avisa claramente quando a lista de peças está incompleta, oferecendo o botão que rola a linha do tempo do PJe por você.

Na página de ajuda, uma tabela compara todos os modelos (janela, páginas, preço e perfil) e um passo a passo mostra o fluxo recomendado de uso. Suas chaves ficam só no seu navegador e as peças vão direto à API do provedor escolhido — nenhum serviço no meio do caminho.

Baixe a versão 0.9.1 no GitHub: https://github.com/marcosmarf27/pje-ia/releases/latest

Quem lê autos o dia inteiro conhece o problema de cor: processos com dezenas de peças, petições que remetem a anexos, contestações de cinquenta páginas, laudos técnicos, e o relógio sempre correndo. Já apareceram ferramentas de IA para ajudar nisso, mas quase todas cobram assinatura mensal: você paga todo mês, use muito ou use pouco, e ainda fica preso a um fornecedor.

Hoje estou disponibilizando de graça, com código aberto, a PJe IA: uma extensão para o Google Chrome que coloca um assistente de inteligência artificial dentro da própria tela de autos digitais do PJe. Você marca as peças, pergunta em linguagem natural e recebe a análise ali mesmo, com citação das peças de origem.

Repositório no GitHub: github.com/marcosmarf27/pje-ia

Como funciona

A extensão conversa com o Claude, da Anthropic, a mesma família de modelos por trás do Claude Code, hoje uma referência em trabalho com documentos longos. Por padrão ela usa o Claude Sonnet 5, que equilibra qualidade de análise e custo baixo. Nas configurações dá para trocar por modelos mais econômicos ou mais avançados, conforme o caso.

O fluxo é simples:

1. Abra os autos de um processo no PJe, já logado, e clique no botão ⚖️ Analisar com IA, no canto da tela.

2. Marque as peças que quer analisar. Dá para clicar na lista lateral ou digitar @ dentro do campo de pergunta — por exemplo, @contestacao encontra a Contestação, sem precisar de acento.

3. Pergunte o que quiser, em português comum: “Resuma o pedido da inicial e os argumentos da contestação”, “Monte a linha do tempo dos atos numa tabela”, “Quais provas foram juntadas e o que cada uma demonstra?”.

4. A resposta aparece em tempo real, com tabelas e listas, citando cada peça pelo nome.

Alguns detalhes que mudam o dia a dia:

• As peças aparecem categorizadas por cor. Decisões, atas de audiência, petições e provas ganham destaque na lista, então você acha o que interessa mesmo num processo com dezenas de documentos.

• Peça digitalizada é lida sem rodeio. O Claude enxerga imagens e PDFs escaneados diretamente, sem depender de um OCR à parte.

• A conversa tem memória. Você pode fazer perguntas em sequência sobre as mesmas peças, refinando a análise aos poucos.

• O contexto fica sempre à vista. Pequenos marcadores mostram exatamente quais peças estão na análise, e cada pergunta registra o que foi enviado.

Por que você não fica refém de assinatura

Aqui mora a diferença que importa, e vale explicar com calma para quem não é da área técnica.

A extensão não tem mensalidade. Em vez disso, ela usa uma chave da API da Anthropic — pense nela como um cartão pré-pago seu, ligado à sua própria conta. Você põe crédito quando quiser, e ele só é descontado quando você de fato usa. Passou um mês inteiro sem abrir a ferramenta? Não pagou nada por esse mês. Sem plano, sem fidelidade, sem fatura recorrente.

E o valor consumido surpreende. Uma análise típica, com algumas peças somando dezenas de páginas, sai por centavos. A extensão ainda aproveita um recurso da Anthropic, o cache de prompt, que barateia em torno de 90% as perguntas seguintes sobre as mesmas peças. Na prática, US$ 20 de crédito rendem de dezenas a centenas de análises, dependendo do tamanho dos processos. Faça a conta e compare com qualquer ferramenta de análise judicial por assinatura.

Há outro ponto que considero inegociável: privacidade por arquitetura. A extensão roda inteira dentro do seu navegador. As peças que você marca vão direto do seu Chrome para a API da Anthropic, sem passar por nenhum servidor meu nem de terceiros. A chave fica guardada só no seu navegador, não há telemetria, e o código é aberto: qualquer pessoa pode auditar.

Uso responsável. Autos podem conter dados pessoais e processos em segredo de justiça. Enviar peças a um provedor de IA, que as processa fora do tribunal, é decisão e responsabilidade de quem usa, observadas as normas do seu tribunal, a LGPD e eventuais sigilos. A IA é apoio à leitura; não substitui a análise jurídica humana.

Instale em 5 minutos

1. Baixe o projeto no GitHub (Code → Download ZIP) e extraia a pasta.

2. Abra chrome://extensions, ative o Modo do desenvolvedor e clique em Carregar sem compactação, apontando para a pasta.

3. Clique no ícone da extensão, cole sua chave da API da Anthropic e salve. O próprio popup traz um guia passo a passo para criar a chave e adicionar crédito no console.anthropic.com.

4. Abra os autos de um processo no PJe e clique em ⚖️ Analisar com IA.

Livre de verdade: use, ajuste, melhore, distribua

A extensão está sob licença MIT. Ou seja: você pode instalar, usar, estudar o código, adaptar para o PJe do seu tribunal, criar a sua própria versão e até oferecê-la a terceiros, como quiser. Issues e pull requests são bem-vindos no repositório. É a minha contribuição aos usuários e leitores do Tec Justiça: uma ferramenta que devolve o controle, e o orçamento, a quem trabalha com processo eletrônico.

Conheça os outros projetos do Tec Justiça

• pjece.tecjustica.com — soluções para o PJe do Ceará.

• mcp.tecjustica.com — servidor MCP do Tec Justiça, para conectar assistentes de IA aos sistemas judiciais.

• ocr.tecjustica.com — OCR para documentos judiciais digitalizados.

Dúvidas, sugestões ou problemas na instalação? Deixe um comentário ou abra uma issue no GitHub.

Arrastar o auto de 200 páginas pro Claude e pedir um resumo parece o caminho. Mas é caro, impreciso e — na maioria dos processos brasileiros — simplesmente não funciona. A camada que falta vem antes do modelo: é o OCR. E no Judiciário, ela precisa ser feita sob medida.

O erro silencioso: jogar o PDF direto no modelo

Você abre o Claude Code, arrasta o PDF de um processo e pede uma análise. Funciona? Mais ou menos — e cobra um preço que você nem percebe. Três coisas acontecem ao mesmo tempo:

1. A maioria dos autos é escaneada. O modelo não recebe texto — recebe imagem. Antes de raciocinar sobre qualquer coisa, ele precisa “enxergar” cada página.

2. Imagem custa caro em tokens. Um processo escaneado vira centenas de milhares de tokens só para ser lido, antes de responder uma única pergunta.

3. Você paga essa leitura de novo a cada pergunta. Toda nova consulta reenvia as páginas. O custo de extração se repete, e repete, e repete.

O resultado é o pior dos mundos — lento, caro e com erro — justamente em documentos onde uma palavra trocada muda o sentido de uma decisão.

A ordem certa: OCR primeiro, modelo depois

A correção é simples e poderosa: extraia o texto uma vez, com uma camada de OCR, e só então converse com o LLM.

   PDF do processo          camada de OCR            texto limpo            LLM
  (parte imagem)      →    (extrai uma vez)    →   (.md reutilizável)  →  (raciocina)
  ───────────────          ──────────────          ────────────────       ──────────
  centenas de milhares     custa centavos          fração dos tokens      barato e
  de tokens, relidos       1 vez, e pronto         cacheável, reusável    preciso
  a cada pergunta ✗

Repare onde o custo mora. Não é o OCR — é mandar imagem pro modelo, de novo e de novo. Com o texto extraído:

• ele ocupa uma fração dos tokens de uma imagem — e é reutilizável e cacheável em quantas análises você quiser;

• funciona com documentos escaneados, não só com PDFs digitais;

• o modelo para de gastar energia “decifrando” a página e faz o que faz bem: raciocinar sobre texto estruturado.

OCR não é um detalhe técnico. É a primeira etapa de qualquer pipeline sério de análise processual — com Claude Code, com agentes, com qualquer modelo. Pule essa etapa e tudo que vem depois fica mais caro e menos confiável.

As ferramentas genéricas resolvem o caso fácil

Vamos ser honestos: existe ferramenta livre e boa para extrair texto de documento — e algumas hospedadas que são baratas e devolvem markdown estruturado.

• Docling — projeto aberto que converte PDFs em markdown estruturado. Excelente para documentos digitais bem diagramados.

• Tesseract — o motor de OCR open-source mais conhecido do mundo. Maduro, gratuito, onipresente.

• Mistral OCR, AWS Textract, Azure Document Intelligence — motores de nuvem robustos, com SLA e escala. Alguns saem por centavos por página.

Se o seu caso é documento digital, limpo, bem diagramado — talvez em inglês —, qualquer um deles resolve. De verdade. O problema nunca foi a qualidade deles. É que nenhum foi pensado para o documento que chega na sua mesa.

Porque “documento digital bem-comportado” é quase o oposto de um auto processual brasileiro.

O auto brasileiro é outro nível — e é onde os genéricos tropeçam

Quem lida com isso todo dia sabe o que chega:

• escaneados de décadas atrás, tortos, manchados, com marca d’água do tribunal por cima do texto;

• datilografados de entrelinha apertada — matrículas, certidões antigas, contratos batidos à máquina;

• carimbo do escrivão, selo de cartório, despacho manuscrito, texto em duas colunas, tabela e texto vertical na margem disputando espaço.

É exatamente aqui que o pipeline genérico falha: perde linha inteira, embaralha coluna, confunde a marca d’água com conteúdo, troca acento, erra termo jurídico. Para quem lê processo todo dia, “quase certo” vira retrabalho — e revisão linha a linha.

Foi para esse caso — e só para ele — que construímos o TecJustiça OCR. Cada heurística do motor foi calibrada com PDF real do PJe, eproc, esaj e Projudi de tribunais brasileiros — TJCE, TJBA, TJSP, TRFs:

• Marca d’água do tribunal é tratada como ruído, não como conteúdo — o parser sabe distinguir o “texto fantasma” da assinatura digital do texto real da página.

• Layout preservado. Tabelas, colunas, listas e texto vertical são reconstruídos na ordem certa de leitura — não viram um bloco único bagunçado.

• Documento difícil, sinalizado. Onde o caso é genuinamente duro — um despacho manuscrito à caneta, um carimbo borrado —, o motor devolve um score de confiança por documento. Em vez de fingir que acertou, ele te diz onde conferir. Você sabe exatamente qual trecho merece um segundo olhar.

Você manda qualquer PDF jurídico — sem marcar o tipo, sem parâmetro especial — e recebe markdown estruturado de volta, com um sinal honesto de quão confiável está cada parte.

Por que o TecJustiça, então — se OCR barato já existe?

Aqui está o ponto que quase todo material de venda inverte: o diferencial não é o preço por página. Se o seu único critério é custo, há opções de nuvem tão baratas quanto. O que você não encontra em outro lugar é o conjunto:

1. Não OCRiza o que já é texto

Antes de qualquer coisa, o motor detecta, página a página, o que já nasceu digital e o que é imagem escaneada. A petição protocolada no PJe já tem camada de texto: ela é extraída direto, idêntica ao original, em tempo zero. Só o que é imagem de verdade passa por OCR.

Parece detalhe — é o coração da coisa. Ferramentas que jogam o documento inteiro num modelo de visão (é o caso do Mistral OCR) re-processam até as páginas que já estavam perfeitas. Isso é mais lento e, pior, arrisca introduzir erro num texto que já estava correto. Por que passar OCR num parágrafo que o PDF já entrega sem falha?

É, no fundo, a tese deste post aplicada um nível abaixo: não jogue OCR cego em toda página — detecte antes o que precisa. A mesma disciplina que faz você extrair o texto antes de chamar o LLM, o motor aplica antes de chamar o OCR.

2. Calibrado para o auto brasileiro

Marca d’água de tribunal, datilografado de entrelinha apertada, layout de duas colunas — os casos em que o OCR genérico mais erra são o nosso ponto de partida, não a exceção. Nenhum motor de nuvem internacional foi ajustado para o que sai do PJe.

3. Três jeitos de usar — do clique à automação completa

A maioria das ferramentas te dá uma porta só. O TecJustiça te dá três, sobre o mesmo motor:

• Dashboard web — sobe o PDF, baixa o markdown. Pro servidor ou advogado que só quer o texto, sem instalar nada.

• CLI / skill no Claude Code — pede em linguagem natural e o .md cai na sua pasta (logo abaixo).

• API REST — autenticada por chave, integra o OCR direto no seu sistema, com o mesmo consumo do dashboard.

A API é o que destrava a automação end-to-end: dá pra montar um fluxo que, sozinho, baixa o auto, extrai o texto, mapeia as peças e entrega a análise — sem ninguém clicar em nada. Um OCR genérico até tem API; o que ele não tem é o resto do ecossistema do lado — a começar pelo TJ-MAPA.

E, sim, é barato — mas isso é o bônus

Centavos por documento: R$ 0,19 a cada 100 páginas. Um auto de 2.892 páginas (371 MB) saiu em ~23 minutos. É uma fração do que se paga por extração estruturada com tabela e layout nas nuvens grandes. Mas o preço baixo é consequência de fazer OCR sob medida — não é a promessa. É o que sobra depois de você parar de processar cego o que dava pra resolver antes.

Do PDF à análise, sem você no meio do caminho

Se você usa Claude Code (ou Claude Cowork), o OCR não precisa ser um passo manual num site. Ele entra no seu fluxo em linguagem natural:

▸ Você:
  Faz OCR desses autos aí: autos-12345.pdf

⎔ Claude (skill: tjocr):
  $ tjocr autos-12345.pdf -o autos-12345.md
  ✓ 87 páginas em 36s (12 digitais + 75 OCR) · qualidade 91/100
  ✓ Salvo em: autos-12345.md

Repare no detalhe da saída: 12 digitais + 75 OCR. As 12 páginas que já tinham texto saíram na hora, intactas; só as 75 escaneadas passaram pelo motor. É a detecção seletiva trabalhando, ali, na sua frente.

A skill TJOCR é um binário nativo — Windows e WSL/Linux, sem Python, sem dependência pra compilar.

Do texto ao mapa do processo: o TJ-MAPA

Extrair o texto é metade do caminho. Um auto de 87 páginas em markdown ainda é um paredão — e fazer o LLM reler tudo a cada pergunta é o mesmo desperdício de tokens, de volta pela porta dos fundos.

O TJ-MAPA resolve isso. É a segunda linha de comando do ecossistema: lê o markdown do OCR e devolve um índice navegável do processo.

▸ Você:
  Mapeia esse processo: autos-12345.md

⎔ Claude (skill: tj-mapa):
  $ tj-mapa -in autos-12345.md -out mapa.json -formato ambos
  → Costurando 87 páginas… 41 peças
  ✓ mapa.json + mapa.md · 41 peças
    (petição → despacho → decisão → sentença)
  ✓ cada peça com tipo, resumo, página e linha

Cada peça — petição, despacho, decisão, sentença, certidão, ofício — sai com tipo, resumo e página/linha exatas. O agente abre só o intervalo de linhas da peça que importa, em vez de reler o auto inteiro. Menos tempo, menos token, resposta mais precisa.

O encadeamento que vira automação

Junte as peças e você tem um pipeline que roda sem ninguém olhando, tudo via API:

baixa o auto → OCR (API) → TJ-MAPA → seu agente analisa — fire-and-forget.

É o pipeline completo — PDF → texto → mapa → análise — e cada etapa é programável. Pro servidor, é o site: sobe e baixa. Pro dev, é a automação que processa um lote de autos enquanto você faz outra coisa. A mesma ferramenta, do clique manual ao end-to-end.

Experimente com o auto mais difícil que você tiver

Se você trabalha com processo e já usa (ou quer usar) IA pra analisá-lo, comece pelo começo. Não pegue o PDF fácil: pegue aquele — o escaneado de entrelinha apertada, o cheio de carimbo, o que nenhuma ferramenta genérica deu conta. Suba e compare o resultado.

Crie a conta em segundos e teste sem cartão.

👉 Testar com meu processo — ocr.tecjustica.com

É exatamente para o caso difícil que a gente existe.

Em 2024, o Judiciário brasileiro teve o melhor ano produtivo da sua história. Foram 44,8 milhões de processos baixados, o maior volume da série, e a taxa de congestionamento caiu para 64,3%, a menor em dezesseis anos. E ainda assim, ao fim do ano, restavam 80,6 milhões de processos pendentes (Justiça em Números 2025, CNJ).

Leia esse número de novo. Mesmo com produtividade recorde, mesmo com magistrados e servidores baixando processos num ritmo inédito, o estoque é de outra ordem de grandeza. O problema não é falta de esforço — é volume. E volume é precisamente o tipo de problema em que a inteligência artificial deveria ser a maior aliada do Judiciário.

A boa notícia: os tribunais perceberam isso e estão investindo. A má notícia: na maioria dos lugares, esse investimento não está chegando à ponta — à vara, ao gabinete, ao servidor que olha para a fila e não sabe por onde começar.

O erro silencioso de adoção

Quando um tribunal decide “adotar IA”, o reflexo quase automático é treinar todo mundo. Compra-se acesso a uma ferramenta, organiza-se um curso, e espera-se que a produtividade apareça. Ela não aparece — ou aparece numa fração tão pequena dos servidores que o investimento se dissipa.

Não é culpa de ninguém. É um erro de premissa. Operar uma ferramenta de IA com método — saber o que pedir, como estruturar o trabalho, como revisar criticamente o resultado — é uma competência real, que leva tempo para se desenvolver. Exigir que cada servidor a domine, no meio de um expediente já assoberbado, é transferir o custo de aprendizado justamente para quem tem menos margem para arcar com ele.

O resultado é previsível: alguns poucos entusiastas extraem valor, a maioria desiste na primeira semana, e a tecnologia ganha fama de “promessa que não se cumpriu”. Pior: IA distribuída sem governança é IA usada sem padrão — prompts improvisados, dados sensíveis manuseados sem cuidado, ausência de revisão. O caminho mais curto para um incidente.

O ativo escasso, percebi, nunca foi a ferramenta. É a competência para operá-la com método e segurança. E competência não se distribui jogando licenças para todo lado. Concentra-se.

A virada: não distribua a ferramenta, concentre a competência

A proposta é simples de enunciar e poderosa na prática: em vez de tentar transformar cada servidor num operador de IA, cria-se um núcleo — uma força-tarefa tecnológica formada por poucos servidores, oficialmente designados e capacitados, equipados com as melhores ferramentas de inteligência artificial disponíveis.

Esse núcleo recebe demandas dos gabinetes e devolve o trabalho pronto.

O gabinete não usa a ferramenta. Ele abre um pedido — “estes cem processos parados, preciso de um relatório estruturado de cada um” — e recebe de volta os cem relatórios, prontos para uso. A inteligência artificial, e toda a especialização para operá-la, fica concentrada no núcleo. O gabinete consome o resultado, não a tecnologia.

É o mesmo princípio que já consagramos no Judiciário com os mutirões e as forças-tarefa de apoio. Quando uma comarca trava, não se espera que cada servidor da unidade vire um expert no problema; envia-se uma equipe especializada que resolve e entrega. A novidade aqui é apenas aplicar essa lógica à camada tecnológica.

Como funciona na prática

Imagine uma vara do interior com cem processos parados aguardando triagem. O fluxo seria mais ou menos assim:

O gabinete registra a demanda, descrevendo o que precisa: relatório com partes, objeto, fase processual, últimas movimentações relevantes e pendências de cada feito. O núcleo prioriza, ingere os autos (do PJe ou do PDPJ), e aciona suas ferramentas — algumas de mercado, como agentes de IA capazes de ler documentos extensos e raciocinar sobre eles; outras desenvolvidas sob medida para a realidade judicial, que fazem a análise processual e geram o relatório já formatado em Word.

Então vem a etapa que torna tudo isso defensável: um servidor especializado revisa cada produto antes da entrega. A IA produz o insumo; o humano valida. Nada sai do núcleo sem passar por esse filtro. O gabinete recebe o lote pronto e usa seu tempo no que é genuinamente indelegável — decidir.

E há um efeito composto que o modelo distribuído jamais alcança: cada padrão que o núcleo resolve vira um modelo reutilizável. O segundo lote de triagem é mais rápido que o primeiro. O conhecimento, em vez de se dispersar entre dezenas de pessoas que mal usam a ferramenta, acumula-se num só lugar.

“Mas meu tribunal já tem robôs e IA”

Tem, e isso é ótimo. Tribunais mais avançados já operam soluções integradas ao sistema processual — ferramentas que resumem, classificam por similaridade, agrupam petições, transcrevem audiências. O Ceará, por exemplo, tem um ecossistema rico nesse sentido, com várias soluções em produção e dezenas de robôs.

O núcleo não concorre com isso. Ele complementa. Essas ferramentas são produtos padronizados: fazem muito bem aquilo para que foram programadas, em massa. O núcleo cobre o outro território — a análise complexa, multidocumento, sob demanda, que não cabe num produto fixo. O cruzamento atípico, a extração específica, o relatório que aquele gabinete precisa naquele formato. E atende a comarca do interior que não tem equipe nem capacitação para usar nenhuma das ferramentas oficiais.

Mais: o núcleo funciona como laboratório de campo. Os padrões que ele descobre e automatiza podem ser entregues à área de tecnologia do tribunal para virarem produto. Ele é a ponte entre a demanda real do gabinete e a esteira de produtização institucional.

Já existe respaldo normativo — e é robusto

Esta não é uma ideia que precisa esperar uma reforma. O arcabouço já está posto.

A Resolução CNJ nº 615/2025, que rege o uso de IA no Judiciário, foi praticamente desenhada para um modelo assim: exige supervisão humana obrigatória (que aqui é etapa estruturante, não acessória), classifica como baixo risco exatamente as atividades de extração e organização de informação, e impõe cuidado com LGPD e segredo de justiça — cuidado que um núcleo centralizado cumpre muito mais facilmente do que o uso difuso jamais cumpriria.

E há precedente organizacional direto: os Núcleos de Justiça 4.0 em apoio a unidades jurisdicionais (Resolução CNJ nº 398/2021) já autorizam estruturas de apoio voltadas a acervo represado, temas repetitivos e descumprimento de metas. Não é preciso inventar uma figura nova — basta dar conteúdo tecnológico a um modelo de apoio que o CNJ já consagrou.

E os dados? A pergunta que todo mundo faz

A primeira reação de qualquer gestor responsável é: “não vamos mandar processo para a IA”. É a pergunta certa, e tem resposta madura.

Comece pelo que é seguro: apenas processos públicos, com pseudonimização dos dados pessoais, e usando ferramentas contratadas sob termos comerciais que vedam o uso dos dados para treinamento — algo que, na prática de mercado, é hoje a regra para acesso corporativo, não a exceção. Há acervo público de sobra para provar valor sem tocar em uma única peça sigilosa. Com o sucesso demonstrado, conquista-se o capital institucional para avançar, com a infraestrutura adequada, para os dados sensíveis. É a lógica de ganhar o direito de escalar.

Comece pequeno. Comece agora.

A beleza desse modelo é que ele não exige orçamento de transformação digital, comitê interministerial nem dois anos de planejamento. Exige uma equipe enxuta de servidores que já existem no quadro, um piloto de noventa dias, um punhado de comarcas dispostas a testar, e disciplina para medir o resultado contra um ponto de partida real. O custo de IA de um piloto inteiro tende a ser inferior ao de uma única diária.

É barato, é de baixo risco, e é mensurável. Tudo o que um tribunal precisa para dizer “sim” a uma experiência.

Há anos defendo, aqui na TecJustiça, uma ideia que resume bem o espírito disso tudo: no Judiciário, devemos construir a ponte, não o arreio. Não se trata de domar cada servidor para cavalgar uma tecnologia difícil. Trata-se de construir a passagem que leva a capacidade da IA até onde o trabalho realmente acontece — e deixar que cada um continue fazendo o que só o humano faz.

O núcleo é essa ponte. E qualquer tribunal pode começar a construí-la na próxima segunda-feira.

Se a ideia faz sentido para a sua realidade — ou se você enxerga uma falha que eu não vi —, me escreva. É exatamente esse o tipo de conversa que esta newsletter existe para provocar.

Quando a gente pede pra uma IA analisar um processo, o instinto é jogar o documento inteiro no contexto do modelo e esperar a resposta. Funciona, mas é o jeito mais caro de trabalhar. E em processo grande, muitas vezes nem funciona: o texto estoura o limite de contexto e a análise simplesmente não roda.

Resolvi medir isso direito, com telemetria de verdade, pra parar de falar no achismo. O resultado foi uma economia de 77% no custo só ajustando como a IA lê o processo. E o caminho passa por duas ferramentas da TecJustiça que trabalham em sequência: o OCR TecJustiça, que transforma o PDF dos autos em texto limpo, e o tj-mapa, que transforma esse texto num índice navegável.

Onde o dinheiro vaza

O problema nasce antes da IA entrar em cena. Um processo chega como PDF: centenas de páginas escaneadas, com carimbo, assinatura digital, peça torta. Pra IA fazer qualquer coisa com isso, o PDF precisa virar texto primeiro. É um OCR.

A maioria erra logo aí, de duas formas ao mesmo tempo. Primeiro usando um OCR genérico que embaralha página, perde a numeração de folha ou come carimbo, então o texto já sai torto. Depois jogando esse texto inteiro, do começo ao fim, dentro do modelo. Aí a IA relê o processo todo a cada passo do raciocínio, e você paga por cada token relido. É como pedir pra um estagiário reler as oitocentas folhas antes de responder cada pergunta, mesmo que a resposta esteja numa cláusula da página 12.

Ninguém costuma reparar nisso porque a resposta sai parecendo certa. A conta é que não.

O teste

Peguei um processo real já passado pra texto, com 34.251 linhas (cerca de 1,2 MB de Markdown), e dei pro Claude Sonnet 4.6 uma tarefa de propósito pesada: análise jurídica completa, varrendo partes, cronologia, pedidos, decisões, provas e pontos controvertidos, com a página de cada informação citada.

Rodei a mesma tarefa, no mesmo modelo, de dois jeitos. No primeiro, o agente recebeu o processo inteiro e respondeu direto. No segundo, antes da análise, o tj-mapa gerou um índice do processo (tipo, página e resumo de cada peça) e o agente foi consultando esse índice pra ir direto ao trecho certo.

A telemetria saiu assim:

A última linha é a que me convenceu. A análise entregue ficou praticamente do mesmo tamanho nos dois casos, com a mesma profundidade e as mesmas citações de página. Não perdi qualidade. Só gastei muito menos pra chegar lá.

Aquele cacheCreation que disparou na primeira coluna é o custo de carregar texto na memória de trabalho do modelo. No cenário cru, as 34 mil linhas entram nessa memória a cada chamada, dezoito vezes mais volume que no cenário com mapa. É de longe a maior fatia da conta, e é justo o que o índice enxuga.

Por que os dois passos andam juntos

A economia não vem de um truque isolado. Vem de dois passos encadeados, e se você tira qualquer um deles o resultado quebra.

O primeiro passo é o OCR. O OCR TecJustiça pega o PDF dos autos e devolve um Markdown limpo, com a paginação no lugar certo. Pode parecer detalhe, mas não é: se o OCR errou a folha, todo o resto desanda, inclusive o mapa, que vai acabar apontando pra página errada. OCR genérico até dá conta de documento comum, só que processo judicial é outra praia, com carimbo sobreposto, assinatura digital no meio do texto, folha fora de padrão, peça escaneada de lado, despacho manuscrito na margem. O OCR da TecJustiça é afinado pra esse tipo de documento, com os autos que de fato circulam no Judiciário.

O segundo passo é o mapeamento, e é aqui que mora a diferença entre fazer certo e fazer do jeito “óbvio”. O óbvio seria montar um workflow de agentes, com LangGraph ou parecido, que lê o processo e cospe o índice. É fácil de montar, mas sai caro e, pior, sai errado. Caro porque o workflow relê tudo a cada passo e gasta dólares. Errado porque, quando você pergunta em que folha está a sentença, o LLM chuta. Às vezes diz página 142 quando a sentença está na 148. Pra qualquer outra área isso é um errinho. No nosso caso é grave, porque análise com folha errada não serve pra peticionar, despachar nem decidir.

O tj-mapa foi pelo caminho contrário. O trabalho de achar onde cada peça começa e termina é feito por um algoritmo compilado em Go, que roda local em milissegundos e é determinístico, ou seja, dá sempre o mesmo resultado. A página e a linha de cada peça são calculadas por código, não inventadas pelo modelo. A IA só é chamada no ponto que pede julgamento de verdade, como classificar e resumir a peça, e recebe pedaços pequenos de texto de cada vez. Por isso o custo do mapa fica na casa dos centavos.

No fim das contas o fluxo é esse:

PDF dos autos  →  OCR TecJustiça  →  Markdown limpo  →  tj-mapa  →  índice  →  o agente vai direto ao ponto

Tira o OCR e o mapa nasce torto. Tira o mapa e a IA volta a reler o processo inteiro, devagar e caro. Os dois juntos é que fazem a conta cair pra um quarto sem abrir mão da citação de página confiável.

Como começar

O ponto de partida é gerar um texto confiável dos autos no OCR TecJustiça. Sem texto fiel, nada que você construir em cima vai ser confiável de verdade.

Com o Markdown em mãos, o tj-mapa faz o resto, e ele é gratuito. Não é demonstração nem versão de teste: é um binário que você baixa e usa, com versões pra Windows e pra Linux/WSL na página de releases, além de uma skill pronta pro Claude Code. A instalação é por usuário, sem precisar de admin. Você configura uma chave do OpenRouter e roda:

tj-mapa -in processo.md -formato ambos

Saem dois arquivos, o mapa.json pro agente consumir e o mapa.md numa tabela legível. Se o processo for grande, é só subir a concorrência (algo entre -concorrencia 18 e 24) que o mapa fica pronto em segundos. O repositório completo está em github.com/marcosmarf27/tj-mapa-cli.

A ideia é simples: o OCR prepara o texto, o tj-mapa deixa ele navegável, e o seu agente de IA para de pagar pra reler o processo inteiro toda hora.

_{Metodologia: mesma tarefa e mesmo modelo (Claude Sonnet 4.6) nos dois cenários; processo de cerca de 34.251 linhas (~1,2 MB de Markdown depois do OCR); telemetria pelo OpenTelemetry, medida no Prometheus e Grafana (custo e tokens pelo último valor real do contador, sem extrapolar). O mapeamento foi feito pela CLI tj-mapa, e o custo de gerá-lo não entrou na comparação porque roda em modelos baratos. O teste usou concorrência padrão; com concorrência alta o tempo de mapeamento cai bastante. É uma rodada controlada, então os números podem variar conforme o processo, o modelo e a tarefa.}

TL;DR

O Google lançou o Colab CLI — uma ferramenta de terminal que provisiona GPU/TPU do Colab e roda seu código remotamente com meia dúzia de comandos (colab new --gpu T4, colab exec, colab download, colab stop). O detalhe que muda o jogo: ela foi desenhada para ser pilotada por agentes. Ou seja, você descreve a tarefa em português, o Claude Code traduz para os comandos, e o trabalho pesado roda numa máquina do Google que você nem precisa abrir.

Pra mim isso fecha um ciclo que começou lá atrás, com o SPEED100DIAS e a ferramenta de análise de depoimentos — projetos bons que morreram na configuração. O que matava não era a IA. Era o notebook.

O início: a ideia certa, no encanamento errado

Quem me acompanha desde o tempo do “JusMarTech” lembra de dois projetos.

O primeiro foi a ferramenta de análise de depoimentos em vídeo: subia os vídeos, ela transcrevia com timestamp, processava em lote e devolvia os pontos relevantes. Tudo em Python, tudo no Google Colab, “sem precisar de infraestrutura local”. O segundo foi o SPEED100DIAS — OCR e análise em massa de processos, priorização de prazos, aquela pegada de mutirão.

A ideia era óbvia e continua certa: o servidor não tem GPU na mesa, mas o Colab empresta uma de graça. Por que não usar a nuvem do Google como motor pra rodar OCR e transcrição em cima do acervo?

O problema apareceu na hora de colocar na mão de outra pessoa.

Pra você, que programa, abrir um notebook, instalar as libs e ajustar o runtime é trivial. Pra o colega da vara ao lado, é um abismo. Cada célula que dava erro era um chamado no WhatsApp. E aí veio o golpe que resume tudo: em março de 2025, uma atualização do Colab trocou o kernel e quebrou os scripts de OCR de uma vez só. Tive que lançar correção de emergência (o tal do SPEED100DIAS 9.0) só pra coisa voltar a rodar.

Foi aí que a ficha caiu. O gargalo nunca foi a inteligência artificial. Era o encanamento: configuração manual num ambiente que muda quando o Google quer e não avisa ninguém. Um técnico sem background de dev não tinha a menor chance de manter aquilo de pé.

Então eu enterrei.

O que mudou: o Colab ganhou uma linha de comando

Dia 5 de junho de 2026, o Google anunciou o Colab CLI. Em uma frase: é uma ponte entre o seu terminal local e um runtime do Colab lá na nuvem.

Conceito novo — CLI (Command-Line Interface): é o jeito de operar um programa digitando comandos no terminal, em vez de clicar em botões. Pensa na diferença entre pilotar um drone com controle remoto (a CLI: comandos curtos, à distância) e entrar na cabine de um avião (o notebook: você precisa estar lá dentro, mexendo em cada instrumento). A CLI te deixa comandar a máquina de longe, sem abrir a interface.

O fluxo cabe num cartão de visita:

colab new --gpu T4          # provisiona uma sessão com GPU
colab install transformers  # instala o que precisar (usa uv, com fallback pra pip)
colab exec -f meu_script.py # roda seu script LOCAL na máquina remota
colab download modelo.bin . # traz o resultado de volta
colab stop                  # desliga a VM (e para de consumir)

Repara em dois detalhes que valem ouro.

O primeiro: o colab exec lê o arquivo da sua máquina e manda o conteúdo pro runtime. Você edita local, roda remoto. Sem ficar fazendo upload de notebook a cada ajuste. O atrito que matou meus projetos antigos simplesmente... sumiu.

O segundo: a VM é efêmera. O que você sobe pra ela vive ali só enquanto a sessão existe — no colab stop, a máquina é destruída e o que estava nela some junto. Nada fica “esquecido” num disco a não ser que você salve de propósito (num colab download ou montando o Drive). É descartável por construção: liga, processa, baixa o resultado, desliga.

O pulo do gato: o Claude Code como maestro

Aqui é onde isso deixa de ser “mais uma ferramenta de dev” e vira algo que interessa ao Judiciário.

O próprio Google deixou claro no anúncio: o Colab CLI foi pensado pra ser usado por agentes — Claude Code, Codex, o que for. Eles até embarcaram um arquivo de skill no repositório pra dar ao agente o contexto de como usar a CLI sozinho.

Junta as peças:

• Você fala em português: “transcreve esses três depoimentos e me devolve um relatório com timestamps”.

• O Claude Code traduz isso na sequência de comandos colab new → colab install → colab exec → colab download → colab stop.

• A GPU do Google faz o serviço.

• O servidor nunca abre um notebook.

Isso é exatamente a tese que eu venho martelando aqui: construa a ponte, não a IA. Eu não preciso treinar modelo nenhum nem manter notebook nenhum. Eu conecto o que já existe — o Colab, com sua GPU barata — a um agente que sabe operar terminal. A inteligência é do Claude; o músculo é do Colab; a cola entre os dois é uma CLI de código aberto (Apache-2.0). Cada peça é substituível.

E o melhor: o mesmo padrão que eu uso pra orquestrar MCP e Skills no Claude Code agora alcança compute sob demanda. O agente que já lê o processo agora também pode ligar uma GPU pra processá-lo.

As possibilidades que isso destrava

Aqui a brincadeira fica séria. Com uma GPU a um comando de distância e um agente pilotando, dá pra montar coisas que antes exigiam servidor dedicado:

1. Rodar modelos pequenos sob demanda. Um Gemma de 1B ou 4B roda liso numa T4. Classificar movimentações, etiquetar peças, extrair entidades de um lote de textos — você pede ao Claude Code, ele provisiona, roda o modelo aberto e devolve as etiquetas. Modelo open, na GPU emprestada, sem manter nada de pé entre uma execução e outra.

2. Transcrição de áudio em escala. Aquele WhisperX que eu rodo no RTX 3050 e às vezes engasga voa numa T4/L4. O agente sobe o áudio, roda transcrição com diarização de quem-falou-o-quê, baixa o .txt/.srt e mata a VM. O que demorava a tarde inteira local vira minutos na nuvem.

3. OCR de lote sem montar infraestrutura. O velho sonho do SPEED100DIAS, agora sem o servidor configurar nada. PaddleOCR ou o que for, numa GPU de verdade, comandado por linguagem natural.

4. Fine-tuning real de modelo pequeno. O próprio Google mostrou no anúncio um QLoRA de Gemma 3 1B rodando de ponta a ponta com cinco comandos. Quer um modelinho que escreve no seu estilo de relatório, ou que classifica peças do seu acervo? Dá pra ajustar um modelo aberto numa T4 e baixar só o adaptador pro seu lado.

5. Embeddings e indexação pesada. Gerar embedding de um acervo inteiro pra busca semântica é trabalho de GPU. Liga a máquina, processa o lote, baixa os vetores, desliga. Pague pelos minutos, não pelo servidor parado.

O fio condutor de tudo: músculo descartável, sob comando de linguagem natural. Você não provisiona, não configura, não mantém. Você descreve — e o agente acende a GPU só pelo tempo do serviço.

A ponte, de novo

O que me empolga não é só “rodar barato”. É que o obstáculo que enterrou meus projetos — o ser humano ter que configurar o notebook — virou trabalho de agente. O Claude Code configura, roda, baixa e desliga. O servidor só descreve o que quer.

Isso reabre uma porta inteira pro Judiciário: compute sob demanda, comandado por linguagem natural, com o mínimo de fricção técnica. A GPU deixa de ser um privilégio de quem tem máquina parruda na mesa e vira um recurso que qualquer um aciona com uma frase.

Vou desenterrar a ferramenta de depoimentos e reconstruir ela em cima dessa CLI, fazendo o Claude Code de maestro. Quando estiver de pé, conto aqui o que funcionou e o que quebrou (porque sempre quebra alguma coisa).

Se você quer acompanhar essa reconstrução em primeira mão — e os tombos no caminho —, assina a TecJustiça. É de graça, e não depende de cota de GPU. 😉

TecJustiça — tecnologia para quem faz o Judiciário funcionar por dentro.

Olá, comunidade TecJustiça!

Sei que muitos aqui têm enorme interesse em aproveitar todo o poder do Claude Code nas rotinas do tribunal, mas sentem aquele receio natural de operar diretamente na tela preta do terminal. Pensando em democratizar esse acesso e focar na usabilidade, desenvolvi uma nova ferramenta para Windows Desktop: o TecJustiça Studio.

Ele funciona como uma camada visual e intuitiva por cima do Claude Code. Ou seja, você tem toda a inteligência e automação da IA, mas em uma interface limpa, amigável e projetada para quem não quer lidar com linhas de código.

Agentes Pré-Configurados a um Clique

O sistema já vem pronto para o trabalho jurídico. Em vez de criar prompts complexos do zero, você simplesmente seleciona o perfil do agente que precisa para a tarefa:

• 🔍 Explorador: Responsável por ler os autos, mapear as partes, identificar os pedidos e montar a cronologia do processo.

• 📚 Pesquisador: Integrado ao nosso MCP TecJustiça, ele busca jurisprudência, precedentes e súmulas de forma autônoma.

• 📝 Redator: Estrutura e produz os rascunhos de peças e despachos.

• ✅ Revisor: Faz o pente-fino, conferindo fundamentação, prazos e a linha de defesa.

Você delega a missão e a IA executa, gerando os relatórios estruturados (como o de status do processo) e salvando tudo automaticamente na sua pasta de trabalho.

Evolução Orientada por Vocês: A Chegada das Abas

No recurso anterior, tínhamos o modo “Canvas”, onde os cards de análise ficavam espalhados pela tela de forma mais livre. Ouvindo o feedback direto de vocês para melhorar a experiência, introduzi a visualização em Abas.

Agora, se você tem um Explorador analisando um processo e um Pesquisador buscando jurisprudência ao mesmo tempo, cada um fica isolado e organizado em sua própria aba no topo da tela. Fica muito mais fácil alternar entre as tarefas, acompanhar o que cada agente está fazendo e consultar as notas e arquivos gerados sem poluição visual.

O objetivo do TecJustiça Studio é colocar ferramentas de ponta na mão de todo servidor, de forma segura e fácil. Assistam ao vídeo demonstrativo para ver na prática como a dinâmica das abas funciona e como é simples delegar o trabalho.

Me contem nos comentários o que acharam dessa nova organização!

Quem acompanha o projeto já conhece o caminho: o TecJustiça deixa a inteligência artificial conversar, em português, com os sistemas do Judiciário — consultar processo, ler peça, ver as partes, buscar precedente, achar suas intimações. Tudo sem abrir dez abas nem copiar número de um canto pro outro.

Hoje a gente sai da leitura dos autos e entra na conta. Acabamos de adicionar uma ferramenta nova: cálculo de correção monetária — com juros, multa e honorários, em cima de dados oficiais do Banco Central.

O que ela faz

Você pede em linguagem natural, do jeito que pediria pra um estagiário de confiança:

• “Corrija R$ 10.000 pelo INPC de janeiro/2022 a dezembro/2024.”

• “Atualiza esse valor pela SELIC e soma 1% de juros ao mês.”

• “Quanto dá R$ 5.000 corrigidos pelo IPCA, com juros compostos, multa de 10% e honorários de 20%?”

E a resposta vem mastigada: o fator de correção acumulado, o percentual do período, o valor corrigido e — quando você pede — juros (simples ou compostos), multa e honorários, fechando no valor total.

Os índices saem direto da base de dados aberta do BACEN (as séries do SGS), a mesma fonte da Calculadora do Cidadão. Nada de tabela colada à mão, nada de planilha herdada de origem duvidosa.

Os índices que ela cobre

IPCA, IPCA-E, INPC, IGP-M, IGP-DI, INCC-M, TR, SELIC, CDI e Poupança. Datas no formato dia/mês/ano (01/01/2024). Você diz o índice pelo nome — o resto é com a ferramenta.

Um cuidado importante (e honesto)

Dois avisos que andam de mãos dadas com o cálculo:

• A correção só considera os meses já divulgados pelo BACEN. Se o período termina num mês que ainda não fechou, esse mês pode não entrar — não é erro, é a fonte sendo fiel à realidade.

• A ferramenta entrega o cálculo transparente (fator, percentual, valor mês a mês), mas não substitui a conferência de quem conhece o caso. Índice de correção, marco inicial, tipo de juros — isso é decisão jurídica, e continua sendo sua.

Como na busca de intimações, a gente prefere uma ferramenta honesta a uma que finge certeza onde a responsabilidade é do operador.

Como usar

Se você já configurou o TecJustiça no seu assistente, não precisa fazer nada diferente: é só pedir a conta. O assistente reconhece o pedido e aciona a ferramenta sozinho — e ainda explica o resultado em texto, sem você decorar nome de índice nem formato de data.

Por que isso importa

O TecJustiça é um projeto de pesquisa independente, sem fins lucrativos, mantido pelo apoio voluntário de quem acredita na ideia. Cada ferramenta nova nasce de uma dor real — e cálculo de correção é das mais comuns: planilha herdada, índice trocado, conta refeita três vezes antes de bater.

A meta continua a mesma de sempre: tirar o atrito da tarefa repetitiva pra sobrar tempo pro que exige cabeça de jurista.

Se você já apoia o projeto, obrigado — foi o seu apoio que tornou isso possível. Se ainda não e quiser acompanhar de perto, fica por aqui: vem mais coisa.

Até a próxima.

Vou dissecar com você um workflow real, que lê uma fila de processos do PJe e gera um relatório por processo. Ele serve de mapa para entender a feature — e para ver, na prática, por que “mover o plano para dentro do código” muda tudo em relação a um subagente ou a uma skill.

A cena de segunda-feira

Você é servidor de uma vara e tem sessenta processos na pauta. Para cada um: abrir os autos, ver quem foi intimado, conferir quem já foi ouvido, anotar o que falta. Ler os sessenta, um a um, é trabalho de dias.

Eu resolvi isso com um workflow dinâmico do Claude Code — uma feature nova que deixa você comandar dezenas de agentes a partir de um roteiro escrito uma única vez. Construí um de verdade, chamado analise-processos-pje, e é ele que vou abrir aqui linha a linha. Não para você decorar JavaScript — você não escreve isso, você descreve em português e o Claude escreve. Mas porque entender a anatomia é o que te faz confiar na máquina, auditá-la, e enxergar por que ela é diferente de tudo que veio antes.

As três primitivas: quem segura o plano

Antes de abrir o código, a distinção que organiza tudo. O Claude Code tem três formas de rodar uma tarefa de vários passos, e a diferença entre elas é uma só pergunta: quem segura o plano?

Guarde essa tabela. Vou voltar a cada linha dela depois de abrir o workflow — porque é aí que a diferença deixa de ser abstrata e vira concreta.

Anatomia de um workflow real

O analise-processos-pje faz o seguinte: recebe uma lista de processos, e para cada um dispara um agente que lê os autos via um servidor MCP (pje-mni, que conecta o Claude ao acervo do PJe), diagnostica o status — fase, pendências, alertas, próximo ato — e gera um relatório Word por processo. Vamos pelas peças.

1. A capa (meta)

export const meta = {
  name: 'analise-processos-pje',
  description: 'Analisa processos (CNJ) via PJe/MNI e gera um relatório DOCX por processo',
  phases: [
    { title: 'Analisar',   detail: 'Um agente por processo coleta e analisa via MCP' },
    { title: 'Gerar DOCX', detail: 'Renderiza o relatório Word (determinístico)' },
  ],
}

É o cartão de identidade. O name vira o comando /analise-processos-pje. As phases são as etapas que aparecem na tela de acompanhamento. Simples assim.

2. O pré-processamento — e aqui já mora a primeira diferença

Antes de qualquer agente de IA entrar em cena, o script faz trabalho de programação pura: extrai os números CNJ do texto de entrada (com expressão regular), normaliza para o formato oficial, remove duplicados e descarta o que não tem 20 dígitos. Tudo isso é instantâneo, gratuito e determinístico — sem gastar um único token de IA:

function normalizar(cnj) {
  const d = String(cnj).replace(/\D/g, '')
  if (d.length !== 20) return null            // formato CNJ inválido: fora
  // ...monta a máscara NNNNNNN-DD.AAAA.J.TT.OOOO
}

const vistos = new Set()
for (const c of entradaProcessos) {
  const n = normalizar(c)
  if (!n) { invalidos.push(c); continue }
  if (vistos.has(n.digitos)) continue          // dedup
  vistos.add(n.digitos)
  processosValidos.push(n)
}

Repare no que isso significa: o workflow executa código de verdade. Validar CNJ, deduplicar, contar — é lógica exata, e ela roda como lógica exata. Uma skill “pediria” ao Claude para validar os números, e o Claude poderia escorregar. O workflow não pede; ele executa.

3. O formulário (schema)

Cada agente de análise é obrigado a devolver um objeto num formato fixo — e o runtime valida; se o modelo erra o formato, ele tenta de novo. É o equivalente, no mundo dos agentes, ao Pydantic na fronteira de uma API:

const ANALISE_SCHEMA = {
  type: 'object',
  properties: {
    numero_cnj:    { type: 'string' },
    fase_processual: { type: 'string' },     // instrução? concluso p/ sentença?
    pendencias:    { type: 'array', items: { type: 'string' } },
    alertas:       { type: 'array', items: { type: 'string' } }, // prescrição, réu preso...
    tipo_pronunciamento_sugerido: { type: 'string' },
    proximos_passos: { type: 'array', items: { type: 'string' } },
    // ...partes, valor da causa, últimos atos, etc.
  },
  required: ['numero_cnj', 'fase_processual', 'tipo_pronunciamento_sugerido', 'proximos_passos'],
}

Você recebe um objeto JS pronto, sem ficar fazendo parse de texto solto. Sessenta processos, sessenta objetos no mesmo formato.

4. O coração: o pipeline de dois estágios

phase('Analisar')
const resultados = await pipeline(
  processosValidos,
  // ESTÁGIO 1 — lê os autos via MCP e analisa (modelo escolhido por etapa)
  (proc) => agent(promptAnalise(proc, profundidade), {
    label: `analise:${proc.curto}`, schema: ANALISE_SCHEMA, model: 'sonnet',
  }),
  // ESTÁGIO 2 — gera o DOCX (passo determinístico: roda um script Python)
  (analise, proc) => agent(promptRender(analise, proc), {
    label: `docx:${proc.curto}`, schema: DOCX_SCHEMA, model: 'sonnet',
  }).then(docx => ({ proc, analise, docx })),
)

Três coisas acontecem aqui que valem ouro. Primeiro, pipeline é uma esteira: o processo A já está sendo renderizado em Word enquanto o processo B ainda está sendo analisado — ninguém espera o lote inteiro. Segundo, você escolhe o modelo por etapa — a análise pode ir num modelo mais econômico para segurar custo, reservando o mais forte só onde precisa de mais cabeça. Terceiro, e mais elegante: o estágio 2 não pede para a IA “fazer” um Word (frágil); ele manda o agente escrever os dados num arquivo e rodar um render_relatorio.py determinístico. Análise é trabalho de IA; renderização é trabalho de código. Cada um no seu lugar.

5. O retorno — e a segunda grande diferença

return {
  total_concluidos: relatorios.filter(r => r.docx_ok).length,
  saida_dir: saidaDir,
  relatorios,   // resumo compacto: processo, prioridade, fase, caminho do .docx
}

Os sessenta objetos de análise completos — cada um com partes, movimentações, alertas, próximos passos — ficaram morando na variável resultados. Só este resumo enxuto (umas poucas linhas por processo) volta para a conversa. Segure essa imagem; ela é a chave da próxima seção.

Por que isso NÃO é um subagente

Imagine fazer a mesma tarefa com subagentes “normais”. O Claude vira o maestro turno a turno: ele dispara um agente, lê o resultado dentro do contexto dele, decide o próximo, e por aí vai. Agora faça a conta. Cada processo do PJe traz dezenas de páginas de autos; uma análise carrega facilmente mais de 100 mil tokens. Sessenta deles no contexto do Claude estouram a janela por volta do oitavo. O maestro satura — exatamente como você saturaria tentando lembrar de cor o conteúdo de sessenta processos ao mesmo tempo.

No workflow isso não acontece, e a razão está naquele return: os sessenta objetos vivem em resultados, uma variável do script, fora do contexto do Claude. A conversa só recebe o resumo. É a linha “onde ficam os resultados parciais” da tabela, virando concreta.

Tem mais. Aquele pipeline(...) é o plano, escrito em código. Num subagente, esse laço estaria na cabeça do Claude, improvisado a cada turno — e ele perderia o fio. E se você interromper no meio: o subagente reinicia o turno do zero; o workflow retoma de onde parou, reaproveitando do cache os processos já analisados.

Por que isso NÃO é uma skill

Uma skill é um conjunto de instruções que o Claude segue — no contexto dele. Ela é repetível como texto: “para cada processo, faça A, B, C”. Mas a orquestração não é código. O Claude re-improvisa a coordenação a cada vez, os resultados intermediários continuam enchendo o contexto dele, e não existe um pipeline de verdade rodando dezesseis agentes em paralelo como uma unidade retomável.

Volte ao pré-processamento (peça 2). A skill pediria ao Claude para validar os CNJs e deduplicar; o workflow executa isso como JavaScript — regex, Set, contagem — sem margem para escorregão. Volte à renderização (peça 4): a skill provavelmente mandaria a IA montar o Word, e a IA tropeça em formatação; o workflow chama um script Python determinístico. A skill diz o que fazer; o workflow codifica como e roda por conta própria, em segundo plano, enquanto sua sessão fica livre.

Em uma frase: a skill é uma receita que o Claude lê e tenta seguir; o workflow é a receita transformada em máquina que executa sozinha.

O que só um workflow deixa você codificar

A consequência de o plano virar código não é só “rodar mais agentes”. É poder embutir padrões de qualidade repetíveis. O exemplo que mais importa no Direito: a verificação adversarial. Depois de buscar um precedente, você pode disparar três agentes independentes para tentar derrubá-lo — “esse acórdão existe mesmo? localize o original; se não confirmar, marque suspeito” — e só aceitar os que sobrevivem. Isso não é firula: o TJ-PR já rejeitou um recurso com 43 julgados inventados por IA, e um juiz do TRF-1 foi investigado pelo CNJ por citar precedentes inexistentes do STJ. O improviso alucina; o rito, codificado, verifica.

Some a isso o modelo escolhido por etapa, a execução em paralelo com até 16 agentes, o resultado intermediário fora do contexto e a capacidade de retomar — e você tem um patamar que nem o subagente nem a skill alcançam, porque os dois dependem de o Claude segurar o plano na própria cabeça.

O fecho

A diferença entre ler sessenta processos à mão e escrever (uma vez) um roteiro que lê os sessenta em paralelo não é de esforço — é de alavanca. E é por isso que a feature importa tanto: o plano sair da cabeça do Claude e virar código é o que permite a uma única pessoa comandar uma equipe inteira de agentes, com método e rastro, sem time de TI e sem hospedar nada.

Uma ressalva, e só uma: o workflow não decide — ele prepara. A Resolução CNJ 615/2025 exige supervisão humana, e é justamente isso que faz de você o multiplicador, e não um carimbador. A máquina levanta o material; a leitura, o convencimento e a caneta continuam seus.

E tudo começa com uma frase em português dita ao computador: “crie um workflow que…”.

Fontes

• Claude Code — Orchestrate subagents at scale with dynamic workflows: https://code.claude.com/docs/en/workflows

• Claude Code — Create custom subagents: https://code.claude.com/docs/en/sub-agents

• Migalhas — TJ-PR rejeita recurso feito por IA que inventou 43 jurisprudências: https://www.migalhas.com.br/quentes/429134/tj-pr-rejeita-recurso-feito-por-ia-que-inventou-43-jurisprudencias

• ConJur — CNJ vai investigar juiz que usou tese inventada pelo ChatGPT (TRF-1): https://www.conjur.com.br/2023-nov-12/cnj-vai-investigar-juiz-que-usou-tese-inventada-pelo-chatgpt-para-escrever-decisao/

Toda vez que peço a uma IA para “analisar esse processo”, recebo um relatório bonito, bem escrito, que cobre vários pontos — e que, em metade das vezes, não responde a pergunta que eu tinha. A IA leu o que achou importante. Eu queria saber outra coisa.

Quem trabalha em vara — assessor, servidor, magistrado — conhece essa frustração. E não é problema da IA. É problema de contexto.

O insight veio do code review

Esta semana saiu um post no blog da Claude sobre como a CodeRabbit — plataforma de revisão de código com IA, que processa 2 milhões de pull requests por semana — reestruturou seu agente de geração de código: How CodeRabbit Used Claude to Build an Agent Orchestration System.

O que eles descobriram: o modo de falha mais comum de código gerado por IA não é código quebrado. É código que compila, passa nos testes, e não faz o que o time queria. A causa: o desenvolvedor experiente tem contexto na cabeça (regras de negócio, decisões prévias, padrões internos) que ele não escreve no prompt porque para ele é óbvio. A IA preenche os buracos com algo plausível. Plausível raramente é certo.

A solução foi inserir uma camada de planejamento estruturada antes da geração de código. Em vez de a IA sair codando, ela primeiro produz um plano — um documento curto que diz o que vai fazer, com que premissas, e que limites. O time revisa o plano em segundos. Só então o código começa a ser gerado.

A tese deles, em uma linha: a qualidade do plano determina a qualidade do output, e quanto mais barato gerar resultado fica, mais caro é caminhar na direção errada.

O paralelo cai como luva na análise processual

Trocar “código” por “minuta”, “pull request” por “processo” e “desenvolvedor” por “assessor”, e o problema é literalmente o mesmo. Quando peço a uma IA para analisar um processo:

• Eu tenho na cabeça que essa vara já viu esse banco fazendo essa fraude três vezes. Eu não digo. A IA não sabe.

• Eu sei que o juiz prefere sentença enxuta, sem prolixidade. Eu não digo. A IA produz três páginas de fundamentação.

• Eu sei que o ponto-chave deste processo é prescrição, não o mérito. Eu não digo. A IA analisa o mérito em detalhe e menciona prescrição num parágrafo no final.

O contexto que faz a análise certa mora na cabeça de quem trabalha na vara há anos. A IA não tem como adivinhar — e a gente, na pressa, esquece de contar.

Duas skills em vez de uma

Comecei a separar minha análise processual em duas skills do Claude. A divisão funciona tanto para quem usa o TecJustiça MCP como fonte de dados, quanto para quem extrai os autos por OCR a partir de um PDF do PJe, ou quem faz upload direto dos arquivos no Claude.ai.

Skill 1 — planejar-analise

Custa quase nada. Lê apenas os metadados do processo e a última peça relevante (a denúncia, a contestação, a manifestação recente). Não baixa o processo inteiro. Não gasta tokens lendo tudo. Pode rodar com um modelo barato — Haiku resolve.

Output: um plano em Markdown com cinco campos:

1. Tipo de demanda identificado (ação penal por roubo, revisional de consignado, execução fiscal…).

2. Teses ou pontos centrais prováveis.

3. Documentos prioritários a ler — e quais ignorar.

4. Riscos e peculiaridades desse caso específico.

5. Formato de saída esperado (relatório pré-sentença? minuta de despacho? voto?).

Esse plano fica salvo como plano-analise-{numero-cnj}.md.

Skill 2 — executar-analise

Recebe o plano aprovado. Só agora baixa os documentos relevantes (ou processa o PDF com OCR), gasta os tokens do modelo grande, e produz a peça final.

Entre as duas skills, eu reviso o plano em trinta segundos. Acrescento o contexto que estava na minha cabeça e que a IA não tinha como saber: “também verifica prescrição”, “ignora os mero impulso”, “o juiz quer mais objetividade”, “olha se a vítima se retratou em juízo”.

Como fica na prática — dois exemplos da Vara de Ocara

Exemplo 1 — Ação penal por violência doméstica (Lei Maria da Penha):

A skill planejar-analise lê só a denúncia e os metadados. Devolve algo assim:

Tipo: ação penal — Lei 11.340 (Maria da Penha). Indícios de lesão corporal em contexto doméstico. Pontos a verificar: materialidade (laudo pericial, prontuário), autoria (declarações da vítima, oitivas de testemunhas), aplicação prévia de medidas protetivas, eventual descumprimento de medida, antecedentes do réu. Documentos a priorizar: denúncia, laudo de lesão corporal, boletim de ocorrência, depoimento da vítima em sede policial e em juízo. Documentos a ignorar: intimações, certidões cartorárias, juntadas de procuração. Formato esperado: relatório pré-sentença, com tópicos objetivos para cada elemento do tipo penal.

Em trinta segundos eu valido ou ajusto. Posso acrescentar: “verifica eventual retratação da vítima em juízo — é comum nesses casos e muda a estratégia de fundamentação”.

Aí sim a skill executar-analise faz o trabalho pesado, focada, sem se perder em peças que não importam.

Exemplo 2 — Revisional de contrato bancário:

O plano identifica o tipo de contrato (consignado, cartão, cheque especial), lista as teses prováveis (juros abusivos, capitalização indevida, onerosidade excessiva), aponta os documentos críticos (contrato, demonstrativo de débito, extrato de margem). Eu valido. A execução só lê o que interessa. Acabou o relatório de seis páginas que reconta a história do processo e ignora a tese central.

Por que isso vale tanto para MCP quanto para OCR

O ponto que mais me animou nesse desenho: a divisão é arquitetural, não tecnológica. Não importa de onde vêm os dados do processo.

• Via MCP (caso de quem usa o TecJustiça MCP Lite, conectado ao DataLake do PDPJ/CNJ): a skill planejar-analise consome as tools de metadados; a executar-analise consome as tools de leitura de documento.

• Via OCR de PDF (PJe baixado, autos físicos digitalizados, processos administrativos): a planejar-analise recebe o sumário e a peça mais recente; a executar-analise processa o restante.

• Via upload direto no Claude.ai (escritório de advocacia que sobe os autos no chat): mesma lógica — primeiro o plano, depois a execução.

O ganho de qualidade vem da arquitetura de duas etapas com humano no meio, não da fonte de dados. Quem está construindo ferramenta jurídica com IA hoje, em qualquer pilha, pode aplicar isso já amanhã.

O plano vira memória da vara

Tem um efeito secundário que a CodeRabbit destaca e que faz ainda mais sentido no judiciário: o plano é um artefato persistente.

• Daqui a três meses, quando o processo volta concluso, abro o plano antigo e recupero o contexto em dez segundos.

• Quando um servidor novo chega à vara, lê os planos antigos e absorve o padrão decisório da unidade.

• Quando alguém pergunta “por que essa análise focou em prescrição?”, a resposta está no plano.

No judiciário, isso é memória institucional que hoje some quando o servidor é removido. Ter os planos salvos cria um ativo da unidade — uma camada de conhecimento que sobrevive à rotatividade.

Experimento mínimo

Estou pilotando essa divisão na Vara Única de Ocara, principalmente em processos penais (que são a maioria por aqui) e em ações revisionais bancárias. Os primeiros sinais são bons: menos retrabalho, análises mais cirúrgicas, e — talvez o mais importante — menos tokens gastos lendo o que não importa.

Se você usa IA na sua vara ou no seu escritório, recomendo o experimento mais simples possível: na próxima análise que pedir ao Claude (ou a qualquer outro modelo), pare antes de mandar ele ler tudo. Peça primeiro um plano de análise. Revise. Acrescente o contexto que está na sua cabeça. Aí libera a execução.

Você vai notar a diferença na primeira tentativa.

Inspiração: How CodeRabbit Used Claude to Build an Agent Orchestration System — blog da Claude, maio de 2026.

O TecJustiça MCP é o servidor que conecta Claude e outras IAs ao DataLake do PDPJ/CNJ para consulta de processos judiciais brasileiros.