Patente da Mistral sobre tool calling por código: o que ela cobre

No dia 30 de junho de 2026 o USPTO concedeu à Mistral AI a patente US 12.670.045 B1. Título: "Code implemented tool calls". Passou batido por seis semanas. Aí, no dia 10 de agosto, o documento caiu no Hacker News e juntou 223 pontos em algumas horas.

O que a patente descreve: o LLM escreve um bloco de código que chama as ferramentas, o servidor executa esse código num sandbox, pausa quando bate numa tool call, manda a chamada pro cliente executar, recebe o resultado de volta e retoma de onde parou. Se soa familiar, é porque é. É o programmatic tool calling da Anthropic. É o Code Mode da Cloudflare. É o CodeAct que saiu no arXiv em fevereiro de 2024.

Eu li a patente na fonte. As 20 reivindicações, a descrição inteira, a lista de referências que o examinador considerou. Não o resumo do HN. Este post é o que dá pra afirmar com o documento na mão: o que a patente da Mistral sobre tool calling realmente cobre, onde ela para, qual é o prior art e qual é o risco real pra quem constrói agente. Adianto: é menor do que a manchete sugere. Mas não é zero.

TL;DR

O que é: patente US 12.670.045 B1, "Code implemented tool calls", concedida à Mistral AI em 30/06/2026 (depositada em 04/03/2026, pedido 19/557.103, inventor Gabriel Vergnaud).
O mecanismo: LLM gera um bloco de código (TypeScript, na descrição) → servidor executa em sandbox → pausa na tool call pendente → cliente executa a tool → sandbox retoma substituindo o resultado → só a saída final volta pro modelo.
Prior art óbvio: CodeAct (fev/2024), smolagents, Code Mode da Cloudflare (set/2025), code execution with MCP e programmatic tool calling da Anthropic (nov/2025).
Risco pra você: territorial e baixo. Patente americana vale nos EUA. No Brasil, "programa de computador em si" nem sequer é considerado invenção.
Fonte primária: Official Gazette do USPTO e o texto integral com as 20 claims.

O que a patente da Mistral sobre tool calling diz, na letra

Reivindicação independente número 1, direto do gazette do USPTO:

A method, comprising: receiving, at a server, a user request for execution of one or more tool calls; generating, by a large language model (LLM), a code block in a programming language, the code block configured to encapsulate the one or more tool calls; executing, by the server, the code block in a sandbox; in response to obtaining a pending tool call, pausing execution of the code block; transmitting the pending tool call to a client for execution; receiving, from the client, a first result of the pending tool call; resuming execution of the code block and substituting the first result of the pending tool call for the pending tool call in the code block; and returning a second result of the executed code block to the LLM.

Traduzindo para oito passos, porque é assim que uma claim funciona — cada vírgula é uma trava:

Um servidor recebe um pedido do usuário.
Um LLM gera um bloco de código numa linguagem de programação.
Esse bloco encapsula uma ou mais chamadas de ferramenta.
O servidor executa o bloco num sandbox.
Ao encontrar uma tool call pendente, pausa.
Transmite a chamada pro cliente executar.
Recebe o resultado e retoma, substituindo a chamada pelo valor.
Devolve o resultado final pro LLM.

Na descrição, a Mistral é específica: o bloco é gerado "in a programming language, such as TypeScript", o paralelismo sai com Promise.all e o sequenciamento com await. O sandbox é descrito como "resumable" — retomável.

Na prática, o código que o modelo emite é isto aqui:

// Não é JSON de tool call. É código que chama as tools como funções.
const funcionarios = await listarFuncionarios({ time: "engenharia" });

const estouros = await Promise.all(
  funcionarios.map(async (f) => {
    const despesas = await buscarDespesas({ id: f.id, trimestre: "Q3" });
    const total = despesas.reduce((soma, d) => soma + d.valor, 0);
    return total > f.limite ? { nome: f.nome, total } : null;
  })
);

// Só isso volta pro contexto do modelo. As 20 respostas cruas, não.
return estouros.filter(Boolean);

Cada await buscarDespesas(...) é uma tool call pendente: o sandbox congela, a chamada viaja até o cliente, o cliente executa contra o banco dele, devolve, o sandbox descongela. Vinte lookups, zero round-trips pelo modelo.

Isso não é exótico. É o padrão da indústria

Aqui está o detalhe que faz o post existir. Abra a documentação de programmatic tool calling da Anthropic e leia a seção "How programmatic tool calling works":

Claude writes Python code that invokes the tool as a function (...) When a tool function is called, code execution pauses and the API returns a tool_use block (...) You provide the tool result, and code execution continues (intermediate results are not loaded into Claude's context window).

Pausa. Devolve pro cliente. Cliente executa. Retoma. Resultado intermediário não entra no contexto. Isso é a claim 1 inteira, mais a reivindicação dependente 6 ("the LLM receives the second result and does not receive the first result"), escrito em prosa de documentação pública.

E não é só a Anthropic. A Cloudflare publicou o Code Mode em 26 de setembro de 2025, mais de cinco meses antes do depósito. A tese do post é literalmente o título da patente: "Convert the MCP tools into a TypeScript API, and then ask an LLM to write code that calls that API." Mesma linguagem, mesmo sandbox (V8 isolate), mesma conversão de schema em tipos.

Os números por trás disso já foram publicados por quem construiu. A Anthropic mostrou queda de 150 mil para 2 mil tokens num fluxo Google Drive → Salesforce, e média de 43.588 para 27.297 tokens — 37% — em tarefas de pesquisa complexa. Não é firula: é a diferença entre um agente que cabe no orçamento e um que não cabe.

Ou seja: a patente não descreve uma invenção guardada num laboratório francês. Descreve o mecanismo que você provavelmente já tem rodando em produção, se seu agente é minimamente moderno. Continuar rodando esse padrão com segurança exige entender o mecanismo, não a manchete — e é esse tipo de destrinchamento que a gente faz toda semana, ao vivo, na Beer And Code.

Onde a claim 1 para

Patente não se lê por manchete. Se lê pela regra dos elementos: para infringir uma reivindicação, sua implementação precisa ter todos os elementos dela. Falta um, a claim não alcança.

Então vamos ser específicos sobre o que fica de fora:

Seu agente executa a tool no mesmo processo do sandbox? A claim 1 exige "transmitting the pending tool call to a client for execution". Se não existe um cliente separado executando, não lê.
Não tem sandbox? Se o código roda direto no seu worker, sem isolamento, o passo 4 não bate.
O código não pausa e retoma? Se você gera o bloco, resolve tudo de uma vez e só depois monta o resultado, os passos 5 a 7 não existem.
O resultado não volta pro LLM? Se o bloco é a resposta final entregue ao usuário sem novo turno do modelo, o passo 8 não bate.
Rodou local, num agente de dev na sua máquina? Uso privado e não comercial não é a arena em que patente vive.

As dependentes são onde mora a parte tecnicamente interessante — e também a mais vulnerável a prior art:

Claims 4, 5, 10 e 14, 15, 20: retomada por meio de uma "evaluation stack" que reexecuta o bloco desde o início, capturando e reproduzindo resultados de operações não determinísticas, envolvendo essas operações numa função que guarda o valor inicial.
Claim 8: traduzir definições de ferramenta de JSON Schema para definições de tipo na linguagem de programação, antes do modelo gerar o código.
Claim 7: paralelo com construto de paralelismo, sequencial com await.
Claim 6: o modelo recebe só o resultado final, nunca os intermediários.

Repare na claim 4/5/10. É replay determinístico:

// Claim 10: envolver a operação não determinística numa função
// que guarda o valor inicial, para o replay devolver o mesmo valor.
const agora = capturar(() => Date.now());
const id    = capturar(() => crypto.randomUUID());

Guarde essa ideia. Ela vai voltar no próximo tópico.

▪ Clã Beer and Code

Não só acompanhe as novidades — domine. Engenharia de IA na prática, ao vivo, toda semana, na maior comunidade do Brasil.

Entrar no Clã

Prior art: a lista que qualquer dev monta em dez minutos

CodeAct — Executable Code Actions Elicit Better LLM Agents, 1º de fevereiro de 2024. A tese: em vez de o agente emitir JSON, ele gera Python executável como espaço de ação unificado. Dois anos antes do depósito.
smolagents, Hugging Face. A biblioteca inteira é construída em cima do CodeAgent: o agente escreve código, o código roda em sandbox (E2B, Docker, Modal), as tools são funções Python.
Code Mode da Cloudflare, 26 de setembro de 2025. Converte MCP em API TypeScript e pede pro LLM escrever código. Cobre o espírito da claim 8 com data anterior ao depósito.
Code execution with MCP (4/11/2025) e Advanced tool use (24/11/2025), da Anthropic. Pausa, resultado do cliente, retomada, contexto preservado. Tudo público mais de três meses antes do depósito.
Replay determinístico: as claims 4, 5 e 10 descrevem, com outro nome, o que o Temporal faz desde 2019 (e o Cadence antes dele): reexecutar a função do começo, alimentando-a com o histórico gravado em vez de refazer o trabalho, e capturar operações não determinísticas para que o replay produza o mesmo valor. Antes disso, event sourcing já fazia isso há duas décadas.

Agora o detalhe que dói. A folha de rosto da patente lista cinco documentos de patente como referência considerada — e nenhuma literatura não-patentária. Nenhum arXiv. Nenhum blog de engenharia. Nenhuma documentação de API. O examinador avaliou novidade sobre o corpo de conhecimento que menos representa esse campo específico, que é justamente onde o estado da arte de agentes vive: em post de engenharia, paper no arXiv e repositório no GitHub.

Isso não torna a patente inválida por si só. Torna ela frágil.

O risco real para quem constrói agente no Brasil

Vamos separar pânico de engenharia. Não sou advogado, e nada aqui é parecer jurídico — mas três fatos são checáveis e mudam a conversa.

Um: patente é territorial. US 12.670.045 B1 é uma patente dos Estados Unidos. Ela dá à Mistral o direito de impedir terceiros de explorar aquela invenção em território americano. Se você roda um SaaS em São Paulo, atendendo cliente brasileiro, com infra brasileira, essa patente não te alcança. Se você vende para os EUA, a conversa é outra — e aí vale falar com um advogado de PI de verdade.

Dois: no Brasil isso provavelmente nem seria concedido. A Lei 9.279/96, art. 10, inciso V, é explícita: não se considera invenção "programas de computador em si". O INPI examina invenções implementadas por computador, mas exige efeito técnico além do processamento em si. Uma orquestração de chamadas de API em sandbox tem caminho bem estreito por aqui.

Três: na Europa é mais difícil, não impossível. O meme do HN é que "software patent não existe na Europa". Meia verdade. O EPO exclui programas de computador "as such", mas concede invenções implementadas por computador quando há efeito técnico adicional. Reduzir uso de memória e chamadas de rede é o tipo de argumento que já passou lá. Não conte com invalidade automática.

E o mais importante para a leitura do movimento: patente de software grande raramente é arma, é escudo. A Mistral vale uma fração dos rivais americanos. Um portfólio de patentes é o que te dá o que colocar na mesa quando alguém maior aparece cobrando licença. É guerra fria de PI, não caça a startup. O cenário desconfortável não é a Mistral processar você em 2027 — é a patente ser vendida em 2030 para quem litiga por profissão.

Se alguém quiser mesmo derrubar, os caminhos existem: post-grant review nos nove meses após a concessão (janela que se fecha por volta do fim de março de 2027), inter partes review depois disso, reexame ex parte a qualquer momento, e a defesa de matéria não patenteável sob o teste de Alice em eventual litígio. Prior art com data anterior a 4 de março de 2026 é o que não falta.

O que muda na sua arquitetura

Nada. E isso é a parte que precisa ser dita com todas as letras, porque a reação errada a esse tipo de notícia é o dev abandonar um padrão bom por medo de manchete.

O que muda é a higiene em volta:

Continue usando o padrão. Se seu agente chama doze tools por tarefa, escrever código que orquestra as chamadas continua sendo a decisão certa de arquitetura, por token, por latência e por composição. Já destrinchamos o padrão com código em Programmatic tool calling: deixe o agente escrever o código em vez de chamar tool a tool e a comparação de custo e latência em Programmatic Tool Calling: por que executar suas ferramentas em código é o futuro do agente.
Publique o que você inventa. Publicação defensiva é barata: um post de engenharia datado, um repositório público, um ADR versionado. Vira prior art. É o mecanismo mais acessível que um time pequeno tem contra esse jogo.
Documente as datas. Se seu produto já rodava esse padrão antes de março de 2026, tenha commit, changelog e post com data. Isso é ativo.
Se você vende nos EUA, leve para o jurídico. Não para entrar em pânico: para ter a análise de liberdade de operação feita por quem sabe ler claim.

FAQ rápido

Preciso parar de usar programmatic tool calling ou Code Mode? Não. Você usa esses recursos como cliente de uma API da Anthropic ou da Cloudflare — o risco de infração, se existisse, seria delas, não seu. E ambas publicaram o mecanismo antes do depósito da patente.

Meu agente roda a tool no mesmo processo do sandbox. Isso infringe? A claim 1 exige transmitir a chamada pendente a um cliente para execução e receber o resultado de volta. Se não há esse ida e volta entre servidor e cliente, falta um elemento e a reivindicação não alcança sua implementação. Vale para todas as 20 claims, porque as dependentes herdam os elementos da independente.

Isso afeta quem usa MCP? Indiretamente. A claim 8 (traduzir tool definitions de JSON Schema para tipos da linguagem) descreve o que praticamente todo bridge de MCP para código faz. É também exatamente o que a Cloudflare publicou em setembro de 2025, o que dá prior art com data.

Por que a patente saiu tão rápido? Depósito em 4 de março de 2026, concessão em 30 de junho de 2026: menos de quatro meses. Esse tipo de prazo costuma indicar exame acelerado. Combinado com uma folha de rosto sem literatura não-patentária, dá pra imaginar quanto do estado da arte real entrou na análise.

O que fica

A patente da Mistral sobre tool calling por código é um documento tecnicamente competente descrevendo um padrão que a indústria inteira já tinha publicado. A claim 1 é a arquitetura do programmatic tool calling. A claim 8 é o Code Mode. As claims 4, 5 e 10 são replay determinístico de workflow com nome novo. E o processo cita cinco patentes, nenhum paper, nenhum post de engenharia.

O que isso realmente sinaliza não é ameaça à sua stack. É que a fase de "todo mundo publica tudo em blog de engenharia" está sendo atravessada pela fase em que os mesmos padrões viram ativo jurídico. Os dois movimentos vão conviver por um tempo, e quem constrói agente precisa saber ler os dois.

A conclusão prática é chata e correta: continue construindo. Só passe a datar o que você constrói.