Seu navegador já roda IA local. Você só não sabia.

Se alguém te dissesse, dois anos atrás, que daria pra rodar um modelo de linguagem direto no Chrome, sem backend, sem API key, sem pagar um centavo, você provavelmente riria. Eu riria. Mas o fato é que em 2026 isso não é experimento de fim de semana: é uma stack de produção.

O projeto MicroLLM Lab explodiu no Hacker News essa semana com uma proposta simples: coloque 7 modelos pequenos (de 25 milhões a 360 milhões de parâmetros) pra rodar direto no navegador, com aceleração de GPU via WebGPU, quantização Q4 e fallback pra WebAssembly. Tudo local. Tudo privado. Tudo grátis.

E isso é só a ponta do iceberg. WebLLM, Transformers.js v4 e uma nova geração de modelos compactos como SmolLM2 estão transformando o navegador no novo runtime de IA. Vamos entender como isso funciona na prática, o que dá pra fazer e onde isso faz sentido (spoiler: mais lugares do que você imagina).

WebGPU: a peça que faltava

Antes de falar dos modelos, preciso falar da tecnologia que viabilizou tudo isso: WebGPU.

WebGPU é o padrão W3C que substitui o velho WebGL como API de acesso à GPU no navegador. Diferente do WebGL (que foi projetado pra renderizar triângulos em jogos), o WebGPU foi pensado desde o início pra compute shaders, ou seja, computação paralela de propósito geral. Exatamente o que inferência de modelos de IA precisa.

Em setembro de 2026, o suporte a WebGPU está em aproximadamente 82,7% dos navegadores globais:

Isso significa que a maioria esmagadora dos seus usuários já tem hardware acceleration pra IA disponível no navegador. E quando WebGPU não está disponível? Os frameworks fazem fallback automático pra WebAssembly (mais lento, mas funcional).

MicroLLM Lab: 7 modelos, zero servidor

O MicroLLM Lab é um projeto open source que empacota 7 modelos pequenos pra rodar inteiramente no navegador. O fluxo é direto:

1. Carrega o modelo: o download fica cacheado no IndexedDB do navegador (não precisa baixar de novo)
2. Chat local: conversa com o modelo numa interface dedicada, tudo rodando no device
3. Benchmark: testa velocidade e acurácia de cada modelo com métricas objetivas

Os modelos variam de 25M a 360M parâmetros e usam quantização Q4 (4 bits), o que reduz o uso de memória em 75% comparado com pesos em ponto flutuante. O pacote completo de todos os modelos pesa 589 MB.

Pra que servem modelos tão pequenos? Mais do que você imagina:

• Triagem e roteamento de tarefas: classificar a intenção do usuário antes de mandar pro modelo grande
• Filtro de spam: detectar conteúdo indesejado sem chamar API externa
• Autocomplete inteligente: sugestões em tempo real com latência abaixo de 10ms pro primeiro token
• Extração de entidades: puxar nomes, datas, valores de texto não estruturado

A real é que nem toda tarefa de IA precisa de um GPT-4. Às vezes, um modelo de 135 milhões de parâmetros rodando em 8ms resolve o problema que você estava pagando $0.03 por chamada de API pra resolver.

WebLLM: a artilharia pesada no navegador

Se o MicroLLM Lab é o canivete suíço dos modelos pequenos, o WebLLM é o tanque de guerra. Desenvolvido pelo time do MLC (Machine Learning Compilation), o WebLLM é um engine de inferência que roda modelos de até 13 bilhões de parâmetros direto no navegador.

Sim, 13B. No navegador.

Na versão 0.2.85 (setembro de 2026), o WebLLM oferece 163 modelos pré-compilados, incluindo:

O diferencial do WebLLM é que a API é 100% compatível com a OpenAI. Isso significa que você pode trocar uma chamada de API cloud por inferência local mudando literalmente duas linhas de código:

// Antes: chamada pra API da OpenAI
import OpenAI from "openai";
const client = new OpenAI({ apiKey: "sk-..." });

// Depois: inferência local com WebLLM
import { CreateMLCEngine } from "@mlc-ai/web-llm";
const engine = await CreateMLCEngine("Llama-3.2-1B-Instruct-q4f16_1-MLC");

// A interface é IDÊNTICA
const response = await engine.chat.completions.create({
  messages: [{ role: "user", content: "Explique WebGPU em 3 frases" }],
  stream: true,
});

for await (const chunk of response) {
  console.log(chunk.choices[0]?.delta?.content || "");
}

Streaming, JSON mode, function calling: tudo funciona. Se você já usa a SDK da OpenAI, a migração é quase copiar e colar.

Requisitos de hardware

Antes de sair rodando Llama 13B no navegador, uma dose de realismo. Um Llama 3.2 1B quantizado em 4 bits precisa de aproximadamente 880 MB de memória de GPU. Um modelo de 3B pede cerca de 2.5 GB. O 13B? Uns 8 GB, o que exige uma GPU dedicada decente.

Na prática, pra aplicações web voltadas ao público geral, fique com modelos de 1B a 3B. Modelos maiores fazem sentido pra ferramentas internas, aplicações desktop ou cenários onde você sabe que o hardware do usuário aguenta.

Transformers.js v4: muito além de chat

Enquanto o WebLLM foca em modelos de linguagem (LLMs), o Transformers.js v4 é o canivete suíço multimodal. A versão 4, lançada em fevereiro de 2026, reescreveu o runtime em C++ e trouxe um backend WebGPU que entrega speedups de 3x a 10x comparado com a v3.

Os números impressionam:

• 60 tokens por segundo com Llama 3.2 3B
• 200+ arquiteturas de modelo suportadas
• 1.200+ modelos convertidos e prontos pra uso
• Roda em browsers, Node.js, Deno e Bun com o mesmo código

E não é só geração de texto. O Transformers.js v4 suporta:

• Embeddings: pra busca semântica local
• ASR (Speech Recognition): transcrição de áudio no navegador
• Visão computacional: classificação de imagens, detecção de objetos
• Classificação de texto: sentimento, intenção, spam

import { pipeline } from "@huggingface/transformers";

// Classificação de sentimento, rodando 100% local
const classifier = await pipeline(
  "sentiment-analysis",
  "Xenova/distilbert-base-uncased-finetuned-sst-2-english",
  { device: "webgpu" }
);

const result = await classifier("I love running AI in the browser!");
// [{ label: "POSITIVE", score: 0.9998 }]

WebGPU vs WebAssembly: quando usar cada um?

O Transformers.js faz essa decisão ficar simples:

SmolLM2: o modelo que cabe em qualquer lugar

Eu já mencionei o SmolLM2 algumas vezes, mas ele merece um destaque. Criado pelo time de pesquisa da Hugging Face, o SmolLM2 vem em três tamanhos:

• 135M: cabe em qualquer dispositivo, ideal pra classificação e triagem
• 360M: o sweet spot pra chat básico e extração de informação
• 1.7B: surpreendentemente capaz pra seu tamanho

Os benchmarks do SmolLM2-1.7B mostram que um modelo “pequeno” pode ser bem competente:

Pra rodar no navegador, a versão quantizada em Q4 do SmolLM2-360M pesa menos de 200 MB. E com WebGPU, a latência pro primeiro token fica abaixo de 10ms. É rápido o suficiente pra autocomplete em tempo real.

Casos de uso que já fazem sentido em produção

Eu já vi equipes implementando essas soluções em produção. Não é teoria. Esses são os cenários onde IA no navegador já ganha da API cloud:

1. Ferramentas de produtividade com dados sensíveis

Imagine um editor de texto corporativo que sugere completions, corrige gramática e resume documentos. Se os dados são sensíveis (contratos, prontuários, dados financeiros), mandar tudo pra uma API externa é um pesadelo de compliance. Com inferência local, os dados nunca saem do dispositivo.

2. Aplicações offline-first

Apps que precisam funcionar sem internet: ferramentas de campo, apps de inspeção, assistentes de manutenção. O modelo fica cacheado no IndexedDB e roda normalmente offline.

3. Roteamento inteligente de requests

Use um modelo pequeno no browser pra classificar a complexidade da pergunta do usuário. Perguntas simples (“qual o horário de funcionamento?”) são respondidas localmente em milissegundos. Só as complexas vão pro modelo grande na nuvem. Resultado: 60 a 80% menos chamadas de API.

4. Personalização em tempo real

Modelos de embedding rodando no navegador permitem busca semântica local, recomendações personalizadas e organização automática de conteúdo sem mandar dados do usuário pra servidor nenhum.

5. Prototipagem rápida

Quer testar uma ideia com IA antes de montar toda a infra de backend? Coloca um modelo no navegador, valida o conceito e só depois investe em infraestrutura. Feedback loop de minutos, não dias.

Tutorial: rodando seu primeiro LLM no navegador

Chega de teoria. Vamos colocar um modelo pra rodar. Aqui vai o caminho mais rápido usando WebLLM:

Passo 1: Setup do projeto

mkdir browser-llm-demo && cd browser-llm-demo
npm init -y
npm install @mlc-ai/web-llm

Passo 2: HTML mínimo

<!DOCTYPE html>
<html>
<head>
  <title>LLM Local</title>
</head>
<body>
  <div id="output">Carregando modelo...</div>
  <input id="prompt" placeholder="Digite sua pergunta" />
  <button onclick="ask()">Enviar</button>
  <script type="module" src="app.js"></script>
</body>
</html>

Passo 3: JavaScript com WebLLM

// app.js
import { CreateMLCEngine } from "@mlc-ai/web-llm";

const output = document.getElementById("output");
const promptInput = document.getElementById("prompt");

// Callback de progresso do download
const initProgressCallback = (report) => {
  output.textContent = `Baixando: ${report.text}`;
};

// Inicializa o engine com SmolLM2-360M (leve e rápido)
const engine = await CreateMLCEngine(
  "SmolLM2-360M-Instruct-q4f16_1-MLC",
  { initProgressCallback }
);

output.textContent = "Modelo pronto! Digite sua pergunta.";

window.ask = async () => {
  const userMessage = promptInput.value;
  output.textContent = "Pensando...";

  const response = await engine.chat.completions.create({
    messages: [
      { role: "system", content: "Responda de forma concisa em português." },
      { role: "user", content: userMessage }
    ],
    temperature: 0.7,
    max_tokens: 256,
  });

  output.textContent = response.choices[0].message.content;
};

Passo 4: Sirva com qualquer server local

npx serve .

Abra http://localhost:3000 e pronto. Na primeira carga, o modelo é baixado e cacheado. Nas próximas, carrega do cache em segundos.

Os limites que você precisa conhecer

Nem tudo são flores. Antes de sair substituindo toda sua infra de IA por inferência no browser, saiba onde os limites estão:

Memória: modelos grandes comem memória do navegador. Um tab com Llama 3B quantizado ocupa uns 2.5 GB. Em celulares, isso pode travar o dispositivo.

Qualidade vs. tamanho: um modelo de 360M parâmetros não vai escrever um artigo de blog. Ele classifica, triaga, extrai, autocompleta. Pra geração longa e criativa, você ainda precisa de modelos maiores no servidor.

Primeira carga: baixar 500 MB a 2 GB de pesos na primeira visita não é ideal pra sites públicos. Funciona bem pra apps instaláveis (PWA) ou ferramentas internas.

Compatibilidade: 82.7% de cobertura WebGPU significa que 17.3% dos usuários vão cair no fallback WASM, que é significativamente mais lento. Teste ambos os caminhos.

Consumo de bateria: inferência na GPU do celular drena bateria rápido. Use com parcimônia em apps mobile.

O que vem pela frente

O ecossistema de IA no navegador está evoluindo rápido. Alguns sinais do que vem por aí:

O Chrome já está experimentando uma Built-in AI API que vai permitir acessar modelos pré-instalados no navegador, sem nem precisar baixar pesos. Imagine um navigator.ai.createTextSession() que simplesmente funciona, como navigator.geolocation.

Modelos estão ficando menores e mais eficientes a cada mês. O SmolLM2 mostrou que treinamento com curadoria de dados inteligente (data-centric training) compensa mais que simplesmente escalar parâmetros. A tendência é clara: modelos de 1B a 3B vão continuar ficando melhores sem ficar maiores.

E o WebGPU ainda está no começo. Conforme os drivers amadurecem e os navegadores otimizam, a performance só tende a melhorar.

Pra quem trabalha com produto, a mensagem é: comece a pensar em IA local como parte da sua stack. Não como substituto do servidor, mas como complemento. O modelo pequeno no front, o modelo grande no back. O dado sensível nunca sai do device. O request trivial nunca chega na API.

O navegador deixou de ser só uma tela de rendering. Ele virou um runtime de IA. E o melhor: custa zero.