Stefan VaskevichFerramentas usadas neste artigo
Da última vez, o Claude construiu um mundo dentro da Unreal Engine 5.8 por meio do novo MCP nativo - e o comentário em destaque naquele vídeo foi, de longe: “Beleza, mas você consegue fazer isso com uma IA local, gratuita e de código aberto?” Pergunta justa. O Claude é brilhante, até o momento em que você olha a conta.
Então, desta vez: sem nuvem, sem chave de API, sem assinatura. Qwen3.6-27B - 27 bilhões de parâmetros, cerca de dezessete gigabytes em uma GPU de uso doméstico - conectado diretamente ao Unreal Editor em execução por meio do mesmo MCP nativo. Dezessete prompts, e cada um deles é um chat novo: o modelo não lembra de nada entre as etapas. O modo de pensamento está desativado. E cada tarefa no histórico do Cline termina com o mesmo número no canto: $0.00.
A verdadeira pergunta nunca foi “ele consegue abrir o editor?”. Era saber se um modelo local consegue sobreviver a um projeto real: criar os Blueprints, construir uma HUD de 28 widgets, conectar um sistema de entrada e caçar seu próprio bug nas entranhas da engine - ou desmoronar na primeira chamada de ferramenta. Até onde sabemos, ninguém tinha publicado uma build bem-sucedida com LLM local por meio do MCP nativo da UE antes desta; a única tentativa pública que encontramos acabou em fracasso no dia do lançamento. Aqui está a configuração exata, o que ele construiu e o veredito sincero.
1. O modelo: Qwen3.6-27B e o hardware de que ele realmente precisa
A escolha é o Qwen3.6-27B - um modelo denso de pesos abertos que atualmente fica perto do topo dos benchmarks de programação agêntica entre os modelos abertos, com melhorias de chamadas de ferramentas integradas nesta geração. A build exata usada aqui é a do repositório GGUF da unsloth com a quantização UD-Q4_K_XL (UD = Unsloth Dynamic) - cerca de 17 GB de pesos.
2. Disponibilize o modelo localmente com o llama.cpp (as flags são o segredo de tudo)
Instale o llama.cpp com um único comando - no Windows, é winget install llama.cpp - e inicie o servidor. A flag -hf baixa a quantização exata diretamente do Hugging Face na primeira execução, então não há uma etapa separada de download:
winget install llama.cpp # macOS/Linux: curl -LsSf https://llama.app/install.sh | sh
llama serve -hf unsloth/Qwen3.6-27B-GGUF:UD-Q4_K_XL -a Qwen3.6-27B \
--host 127.0.0.1 --port 1235 \
-ngl 99 -fa on -c 40960 \
--cache-type-k q8_0 --cache-type-v q8_0 \
--jinja --reasoning off \
--temp 0.7 --top-p 0.80 --top-k 20 --min-p 0.0 \
--presence-penalty 1.5 --repeat-penalty 1.0O que cada bloco faz, porque cada um deles conquistou seu lugar:
-ngl 99 coloca todas as camadas na GPU (99 significa apenas “todas elas”). -fa on ativa o flash attention. -c 40960 é o contexto máximo nativo do Qwen3 - diminua se a VRAM estiver apertada. As flags de cache K/V q8_0 comprimem o cache de atenção para 8 bits: a memória quase cai pela metade, e a qualidade quase não muda.-a Qwen3.6-27B nomeia o modelo na API - a string exata que você vai digitar no Cline mais tarde. --reasoning off desativa o modo de pensamento: o loop de um agente precisa de uma chamada de ferramenta rápida por turno, não de um monólogo - menor latência, sem tokens desperdiçados.--repeat-penalty 1.0, o que significa desativado. O llama.cpp define como padrão 1.1, e essa penalidade antiga prejudica o Qwen.--jinja força o llama.cpp a usar o template de chat nativo do modelo. Sem ela, o servidor não consegue processar as tags que o Qwen usa para formatar as chamadas de ferramentas - e o Cline nunca verá uma única chamada de ferramenta. O modelo parece vivo, conversa alegremente e não faz absolutamente nada no seu editor. Se o seu agente local “fala, mas nunca age”, essa flag é a primeira coisa a verificar.
3. Aponte o Cline para o seu próprio servidor
O Cline é o harness do agente - uma extensão gratuita e de código aberto para o VS Code. O llama-server expõe um endpoint compatível com a OpenAI, então o Cline se comunica com a sua GPU exatamente como se fosse uma API na nuvem:
API Configuration
Provider OpenAI Compatible; Base URL http://127.0.0.1:1235/v1 (o caminho /v1 é obrigatório); Model Qwen3.6-27B - deve coincidir exatamente com a flag -a; API Key - qualquer string não vazia (o servidor nunca a verifica, mas o Cline exige o campo). Context Window 40960, mantido em sincronia com o servidor. Reasoning Effort None, correspondendo a --reasoning off.
Recursos que importam para um agente do Unreal
Native Tool Call ON - use o formato real de chamadas de ferramentas do modelo em vez de truques de prompt. Parallel Tool Calling OFF - você não consegue trabalhar no Unreal Editor em paralelo de qualquer forma; é uma operação por vez. Auto Compact OFF - aqui, um chat é uma tarefa, então nunca há um histórico longo para compactar.
Yolo Mode ON (opcional, mas a ideia é essa)
O Yolo Mode aprova automaticamente cada chamada de ferramenta - o equivalente local de bypass-permissions. Com um agente na nuvem, cada “proceed?” custa atenção e dinheiro; aqui o modelo é seu, então deixe rodar.
4. Faça a ponte com o Unreal Engine 5.8
Do lado do Unreal, é o mesmo servidor MCP nativo que abordamos no capítulo anterior - ative o plugin, ligue o Auto Start Server e o editor passa a escutar em http://127.0.0.1:8000/mcp. (O plugin do MCP ainda está marcado como Experimental, e às vezes isso fica evidente - falaremos mais sobre isso abaixo.) A única parte nova é avisar o Cline sobre isso, em cline_mcp_settings.json:
{
"mcpServers": {
"unreal-mcp": {
"type": "streamableHttp",
"url": "http://127.0.0.1:8000/mcp"
}
}
}Primeira tarefa, em um novo chat: “verificar a conexão MCP com o Unreal Engine.” A primeiríssima chamada de execute_python_code falhou com um AttributeError - uma chamada incorreta da API do Python. E esse foi o primeiro momento genuinamente animador: o modelo leu o traceback, concluiu por conta própria que a conexão estava perfeita e apenas o código dele estava errado, e tentou novamente com o código corrigido. Oito milissegundos depois: “MCP connection to Unreal Engine: SUCCESSFUL.”
Para um modelo local sem memória entre as tarefas, o arquivo de regras é decisivo. Este aqui - BurgerTower_SystemPrompt.md - traz as convenções do projeto, as notas sobre a API do editor, a disciplina de compilação e as armadilhas da engine que, de outro modo, consumiriam um prompt cada (floats devem ser declarados como tipo real ou viram ints sem aviso; um sistema por chamada de ferramenta; compile duas vezes para eliminar o aviso de valor padrão). Coloque o arquivo no seu projeto e adapte.
5. O teste de estresse: um jogo completo em 17 prompts
O projeto é o BurgerTower - um jogo arcade de empilhar de um botão só. Um pedaço de comida balança sobre uma torre crescente; toque para soltá-lo. Um pouso limpo garante bônus e um respingo de suco de carne; uma torre inclinada tomba e encerra a partida. A cada andar, a câmera sobe mais alto - cidade, nuvens, estratosfera, espaço. O projeto vem com apenas arte: oito malhas de comida, uma textura panorâmica, um mapa de estúdio vazio. Cabe ao modelo criar cada Blueprint, grafo, widget, asset de entrada, material e efeito diretamente no editor, via Python.
E uma regra que torna isso um benchmark real em vez de uma demo: cada prompt é uma tarefa totalmente nova no Cline, com contexto limpo. O modelo não se lembra de nada entre as etapas - os próprios prompts carregam a continuidade, como encomendas entregues a um prestador de serviços que acorda com amnésia toda manhã. Dezessete encomendas no total.
Prompts 1-6: todo o esqueleto, sem apertar Play uma única vez
Os primeiros seis prompts constroem cada parte separadamente e verificam apenas por compilação: o actor da peça que cai com seu perfil de física e pool de malhas (a malha DEVE ser o componente raiz - a física simula a raiz, e uma malha pendurada sob uma raiz vazia se desprende no momento em que a simulação física é ativada); seu grafo de eventos, onde um evento Hit com filtro triplo transforma um contato físico em exatamente um sinal de “pousei”; um burst do Niagara duplicado de um template da engine; o pawn de câmera com 19 variáveis de estado; e o HUD.
O HUD merece uma frase à parte: 28 widgets - placar, uma pílula dourada de BEST, avisos de PERFECT!/COMBO, um medidor de altitude com marcações CITY/CLOUDS/STRATOSPHERE/SPACE e uma tela de derrota completa com um botão RETRY - posicionados, ancorados, coloridos e estilizados inteiramente em código, em duas chamadas de ferramenta, sem um único clique no designer do UMG. A segunda chamada foi um bloco de código contínuo que o modelo local transmitiu por cerca de dois minutos e meio. Compilou sem erros.
Prompts 7-13: conectando tudo, primeiro Play, primeiro game over
O segundo episódio conecta as partes na ordem de dependência: primeiro o receptor de aterrissagem no pawn, depois o ciclo do Tick (senoide do balanço, subida suave da câmera, atualizações do HUD a cada frame, uma verificação de falha controlada pela física), os assets do Enhanced Input, a inicialização no BeginPlay e o game mode - incluindo a sutil armadilha de que, após definir o pawn padrão, o game mode precisa ser recompilado, senão o Play continua gerando o pawn padrão da engine. O modelo recompilou e releu o valor para confirmar. O primeiro Play de toda a série acontece só depois do prompt 11: o pawn é gerado, o HUD surge zerado, uma peça balança sobre o pão da base.
O prompt 12 é o botão de soltar - avaliar o perfect no momento em que é pressionado, ativar a física da peça, subir a câmera passo a passo, gerar a próxima peça - e o maior bloco de código da série: cerca de três minutos de streaming e, depois, três minutos e meio com a engine compilando o grafo. No meio da tarefa, o endpoint do MCP encerrou a sessão; o Cline reenviou exatamente a mesma chamada sozinho e a compilação continuou. Falhas de entrega como essa aconteceram três vezes ao longo do projeto, e o agente se recuperou sozinho de cada uma delas diante da câmera. Depois: Play, primeira queda, uma sequência de “PERFECT! x4”, uma torre inclinada, um tombo aos 5,316 metros, GAME OVER, RETRY - todo o loop do jogo funciona. O prompt 13 é o clássico ajuste de sensação: ampliar o balanço, acelerá-lo, abrir o FOV de 70 para 80.
Prompts 14-15: um shader criado a partir de uma fórmula e, depois, a etapa de lançamento
O prompt 14 é a demonstração de força: criar o material de fundo em código - cerca de 18 nós de material via MaterialEditingLibrary - mapeando uma textura panorâmica vertical no espaço de tela, com a janela visível deslizando para cima em sincronia com a subida da câmera. Pura matemática de shaders, ditada como uma fórmula no prompt e convertida em conexões de nós pelo modelo. Essa tarefa também gerou o único obstáculo real da série: uma resposta se perdeu no caminho, a nova tentativa colidiu com o asset que a primeira chamada já havia criado, e a Unreal exibiu caixas de diálogo de sobrescrita. O modelo não entrou em loop - concluiu que o material já existia e passou para a parte dois. O prompt 15 é a etapa de lançamento: conectar o único fio de execução que havia sido deixado deliberadamente desconectado desde o prompt 7 (a explosão de acerto perfeito, deixada em espera atrás de seu gate), mudar a cor do efeito para um tom marrom de caldo de carne e fazer uma verificação geral - oito assets, todos compilando sem erros.
Prompt 16: o bug real - e o momento que responde ao título
Após a etapa de lançamento, o splash de acerto perfeito ainda aparecia em branco no jogo - embora os relatórios da ferramenta estivessem verdes e os valores de cor estivessem comprovadamente no asset. O prompt 16 entrega o mistério ao modelo: descobrir por que a cor nunca chegou à tela. O diagnóstico apresentado por ele é o momento mais brilhante de todo o projeto: o Niagara compila sistemas em segundo plano, e o jogo esteve reproduzindo a cópia antiga compilada do efeito o tempo todo. A correção proposta: redefinir a cor em todos os três emissores, salvar e forçar uma recompilação abrindo o sistema no editor. No Play seguinte: dois perfects, splashes marrom-escuros com faíscas. Isso não é reconhecimento de padrões de um tutorial - é raciocínio sobre o pipeline de assets da engine.
O prompt 17 é a sobremesa: importar um novo panorama - uma cabeça gigante mastigando sobre uma cidade de hambúrgueres - e redirecionar o sampler do material para a nova textura. Uma importação, um redirecionamento; a matemática de deslocamento fica em parâmetros escalares que nunca tocam na textura, de modo que o fundo mudou em tempo real na viewport, no meio da sessão.
6. O veredito sincero
- Ele sobreviveu a um projeto real. Dezessete prompts de contexto limpo, todos os sistemas compilando sem erros, um bug autêntico de nível de engine diagnosticado e corrigido. A estrutura do jogo foi construída sem apertar Play uma única vez.
- É mais lento que um modelo de ponta na nuvem. Os grandes blocos de código levam de dois a três minutos para serem gerados em uma única GPU convencional, e o grafo mais pesado exigiu outros ~3.4 minutos de compilação da engine. Reserve uma noite tranquila, não o intervalo de almoço.
- O harness faz parte do trabalho. O Cline reenviou chamadas perdidas do MCP três vezes; o modelo se recuperou de sua própria chamada de API incorreta e de uma nova tentativa que causou uma colisão de assets. Espere que o endpoint de nível Experimental do MCP dê umas engasgadas - e que o loop consiga lidar com elas.
- Os prompts carregam a inteligência pela qual você não está pagando. Instruções precisas, um sistema por vez, somadas a um arquivo de regras, são o que faz um modelo local sem memória agir como um profissional sênior. Prompts vagos não vão funcionar na prática.
- Ele substitui o Claude? Em um projeto estruturado como este, sinceramente, ele deu conta do recado com $0.00 em custos de API. Para tarefas confusas e abertas, um modelo de ponta ainda oferece uma margem de folga que um modelo local de 27B não tem. Escolha de acordo com o projeto, não com a ideologia.
E sim, a numerologia bate: 17 prompts, um modelo de ~17 GB e uma torre final de 17.7 quilômetros de altura - além do limite do espaço, dentro da boca aberta de um gigante, com uma tela de game over de verdade. Todas as etapas custaram $0.00.
O que você realmente recebe
Esse é o pipeline completo: um comando do llama.cpp, uma página de configurações do Cline, uma entrada de MCP - e um modelo local controlando o mesmo editor que os agentes na nuvem controlam. As ferramentas de geração que alimentam projetos como este vivem mudando; quando ferramentas novas chegam, elas vão direto para a Arena para que você possa compará-las às cegas antes de escolher uma. Para os capítulos anteriores desta história, veja Unreal Engine 5.8 Native MCP + Claude e Claude Code + Unreal Engine 5.
Assista à criação completa
Toda a configuração e todos os 17 prompts, do início ao fim, no YouTube.
