Rode o Gemma 4 26B na Sua Máquina com o Antigravity SDK Agente de Código 100% Offline

Olha só isso: agente de código rodando 100% offline

Sabe quando você quer usar um agente de IA pra mexer no seu código, mas não pode mandar auth.py e billing.py pra nuvem de jeito nenhum? Pois é, o Antigravity SDK do Google agora suporta execução local de modelos, começando pelo Gemma 4 26B A4B rodando via LiteRT, o runtime de edge do Google AI Edge. Traduzindo: seu agente lê arquivos, escreve scripts e roda testes sem um único byte sair da sua máquina. 🔒

O preço da liberdade? Você precisa de mais de 24GB de VRAM ou memória unificada, e a inferência local é mais lenta que a nuvem. Mas pra quem trabalha com código sensível, vale cada segundo. Se você curte entender como o contexto é montado pra agentes que rodam em background, dá uma olhada no nosso guia de context engineering para agentes de código em background.

Vamos lá, mão na massa! 👇

Passo 1: Ambiente e download do modelo

Comece com um venv limpo. O CLI litert-lm baixa o modelo direto do Hugging Face pra você.

# Cria e ativa o ambiente isolado
python3 -m venv .venv
source .venv/bin/activate

# Instala o SDK e o runtime LiteRT-LM
pip install google-antigravity litert-lm

# Importa o Gemma 4 26B A4B (build otimizado pra GPU)
litert-lm import \
  --from-huggingface-repo=litert-community/gemma-4-26B-A4B-it-litert-lm \
  gemma-4-26B-A4B-it-gpu.litertlm \
  gemma4-26b

Passo 2: Seu primeiro agente offline

Cria um arquivo agy_sample.py e cola isso aqui. Repara no lightweight() — ele enxuga o conjunto de ferramentas pra deixar o boot local mais rápido.

import asyncio
import os
from google.antigravity import Agent, LiteRTAgentConfig
from google.antigravity.hooks import policy

# Aponta pro modelo que você importou no Passo 1
MODEL_PATH = os.path.expanduser("~/.litert-lm/models/gemma4-26b/model.litertlm")

async def main():
    print(f"Usando modelo LiteRT local: {MODEL_PATH}. A inferência local pode demorar alguns minutos.")
    config = LiteRTAgentConfig(model_path=MODEL_PATH).lightweight()
    async with Agent(config) as agent:
        response = await agent.chat("Quais arquivos estão no diretório atual?")
        async for token in response:
            print(token, end="", flush=True)

if __name__ == "__main__":
    asyncio.run(main())

Roda com python agy_sample.py. A primeira inferência vai ser lenta — o modelo precisa carregar na VRAM — mas depois é voo.

Passo 3: Deixa o agente construir a própria ferramenta

Aqui é onde a mágica acontece. Dá um workspace pro agente e deixa ele escrever arquivos. Esse exemplo pede pro Gemma 4 26B criar um monitor de recursos em tempo real usando psutil e rich, gerar o requirements.txt e testar tudo sozinho.

import asyncio
import os
from google.antigravity import Agent, LiteRTAgentConfig
from google.antigravity.hooks import policy

PROMPT = (
    "Construa uma CLI usando psutil e rich que exiba um dashboard "
    "em tempo real no terminal, mostrando uso de CPU, memória e os top 5 "
    "processos que mais consomem memória. Salve como 'monitor.py', crie um "
    "requirements.txt e teste se funciona."
)

MODEL_PATH = os.path.expanduser("~/.litert-lm/models/gemma4-26b/model.litertlm")
WORKING_DIR = os.path.expanduser("~/agy-test")
os.makedirs(WORKING_DIR, exist_ok=True)
os.chdir(WORKING_DIR)

async def main():
    print(f"Usando modelo LiteRT local: {MODEL_PATH}. Aguarde a inferência local.")
    config = LiteRTAgentConfig(
        model_path=MODEL_PATH,
        workspaces=[WORKING_DIR],
        policies=[policy.allow_all()],
    ).lightweight()
    async with Agent(config) as agent:
        response = await agent.chat(PROMPT)
        async for token in response:
            print(token, end="", flush=True)

if __name__ == "__main__":
    asyncio.run(main())

Passo 4: Padrão Architect-Builder (modo híbrido)

Você não precisa escolher entre nuvem e local. O padrão que funciona muito bem na prática é usar um modelo na nuvem como arquiteto (planejador, maestro) enquanto um enxame local de instâncias Gemma 4 26B faz o trabalho pesado. Assim o código sensível fica no dispositivo, mas você ainda aproveita o raciocínio de escala da nuvem pro planejamento.

Exemplo concreto: auditar e corrigir três módulos vulneráveis (auth.py, billing.py, database.py). O arquiteto na nuvem planeja a auditoria; o enxame local lê cada arquivo, propõe patches e roda testes — sem o código-fonte sair da máquina. O custo de tokens despenca porque o modelo caro só vê planos, não conteúdo de arquivo.

Passo 5: Plug-and-play com backends OpenAI-compatible

Se você já roda Ollama, LM Studio ou vLLM, dá pra trocar o backend sem mexer no código do agente. Usa LocalOpenAIAgentConfig no lugar de LiteRTAgentConfig e aponta pro seu servidor local. Ferramentas, hooks e orquestração continuam idênticos — só o motor de inferência muda.

Limitações e cuidados (importante!)

• O piso de hardware é real. 24GB de VRAM é bastante. Num notebook de 16GB você vai sofrer com swap. Considere modelos quantizados menores ou o caminho OpenAI-compatible com servidor remoto.
• Latência de cold start. Carregar um modelo de 26B na VRAM leva minutos. Mantenha o processo quente pra trabalho iterativo.
• Confiabilidade das ferramentas cai. Modelos locais menores erram mais em tool calls do que modelos frontier. Sempre cerque políticas allow_all() com um workspace em sandbox — nunca aponte o agente pra sua home.
• Janela de contexto é mais apertada. Sessões longas batem no limite mais rápido que na nuvem. Fatie suas tarefas.
• Sem almoço grátis na qualidade. O Gemma 4 26B é impressionante pro tamanho, mas não é um Gemini 3.8 Flash. Reserve execução local pra jobs críticos de privacidade ou custo.

Pra onde ir agora

1. Meça seu throughput. Faça benchmark de tokens/segundo no seu hardware antes de fechar um workflow. Se ficar abaixo de ~15 tok/s, o padrão híbrido Architect-Builder é o único caminho sensato.
2. Monte uma biblioteca de ferramentas. O agente é tão bom quanto as ferramentas que você expõe. Comece com filesystem, shell e test runners — depois adicione ferramentas de domínio.
3. Leia o README do SDK pra ver a lista completa de hooks e policies, e abre issue no GitHub quando algo quebrar.
4. Estude otimização em nível de sistema. Se você tá empurrando throughput de inferência em aceleradores, nosso playbook de engenharia de sistemas pra servir modelos MoE grandes em escala cobre os truques de hardware que valem também pra inferência local.

Resumo da ópera

O suporte a modelos locais do Antigravity SDK não é brinquedo. Com o Gemma 4 26B A4B via LiteRT, você tem um agente offline de verdade que audita código, escreve scripts e roda testes sem vazar uma linha pra nuvem. O padrão Architect-Builder deixa o esperto na nuvem e o sensível no dispositivo.

Comece pelo script de exemplo, depois vá pro exemplo que escreve arquivos. Quando estiver confortável, pluga no seu workflow real — e mantém o workspace em sandbox, sempre.

Fonte: Introducing support for local AI models in the Antigravity SDK

Leituras recomendadas:

• Context Engineering para Agentes de Código em Background
• Servindo um Modelo MoE de 397B com 4.7x de Speedup