Edge0 35B testado: 0 tokens em uma 4090, 187 tokens/s do jeito convencional

Autoria: Prompt Engineer · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Edge0 35B Tested: 0 Tokens on a 4090, 187 tok/s the Normal Way · Canal: Prompt Engineer · 11:17 · Assistir no YouTube

Tópicos: Avaliação e benchmarks de IA, Engenharia de prompts e contexto, Inferência e otimização de modelos, Modelos locais e open source

Resumo

O vídeo testa o Edge0, uma versão quantizada do Qwen 3.6 35B A3B que usa streaming de experts a partir do SSD para reduzir o uso de memória. Na RTX 4090, quatro tentativas de executar o framework falham antes de gerar qualquer token, em linha com a limitação documentada de suporte atual ao Apple Silicon. Em contraste, o modelo-base quantizado executado com llama.cpp chega a cerca de 187 tokens/s e passa por testes de contexto longo, código e tool calling. O autor considera o Edge0 útil para Macs com pouca memória, mas recomenda que usuários de Nvidia usem o modelo-base pelo método convencional por enquanto.

Pontos-chave

O Edge0 quantiza o Qwen 3.6 35B A3B para 4 bits e usa streaming de experts do SSD, além de um pre-outer para antecipar o carregamento de experts.
O projeto é voltado atualmente ao Apple Silicon; as tentativas de execução em uma RTX 4090 falharam com quatro erros diferentes e não geraram tokens.
Os números de qualidade são autorrelatados, sem validação independente encontrada pelo autor, e mostram quedas maiores em matemática e código.
O código do Edge0 usa top k igual a 4, enquanto a configuração do modelo-base indica 8 experts por token.
O modelo-base quantizado executado com llama.cpp alcançou 187,47 tokens/s na RTX 4090, cerca de 12 vezes a velocidade citada para o Edge0 no Mac Mini.
A janela de contexto completa de 262.144 tokens coube na placa de 24 GB, e o teste de busca em contexto longo encontrou a informação escondida.
O modelo-base passou nos seis testes da função de merge intervals e chamou duas ferramentas em paralelo em uma única rodada.
O autor recomenda o Edge0 para Macs com pouca memória, mas sugere que usuários de Nvidia com 24 GB prefiram o modelo-base com llama.cpp.

Capítulos

Início	Capítulo	Resumo
00:00	O que é o Edge0 e como promete economizar memória	O vídeo apresenta o modelo, sua arquitetura de streaming de experts e os números de qualidade e velocidade divulgados pela equipe.
02:43	Benchmarks e tentativas de execução na RTX 4090	O autor questiona a falta de validação independente e testa o framework na RTX 4090, mas encontra erros em todas as tentativas.
06:21	Desempenho do modelo-base com llama.cpp	O modelo-base quantizado chega a cerca de 187 tokens/s, cabe na placa de 24 GB com contexto longo e passa por testes práticos.
09:39	Limitações e veredito	O autor resume os pontos fortes e fracos do Edge0 e recomenda caminhos diferentes conforme o hardware disponível.

Citações

Este é um modelo de 35 bilhões de parâmetros rodando em um iPhone 16 Pro. — 00:00

Todas as execuções falharam durante o prefill. Pico de VRAM: 3,9 GB, pico de RAM: cerca de 10 GB e zero tokens gerados. — 05:49

Geração a 128 tokens: 187,47 tokens por segundo, com variação de mais ou menos 1,28. — 06:56

Se você tem um Mac com Apple Silicon e pouca memória para uma quantização de 17 GB, vale a pena testar o Edge0 hoje. — 10:43

Conceitos e entidades

Edge0 (modelo): Versão quantizada do Qwen 3.6 35B A3B que transmite experts do SSD para reduzir o uso de memória.
Edge Zero AI (empresa): Equipe responsável pelo Edge0 e pelo framework apresentado no vídeo.
Qwen3.6 35B A3B (modelo): Modelo-base de mistura de experts com 35 bilhões de parâmetros no total e cerca de 3 bilhões usados por token.
RTX 4090 (ferramenta): GPU Nvidia de 24 GB usada para testar o Edge0 e executar o modelo-base.
RunPod (empresa): Serviço em que o autor alugou uma máquina com RTX 4090 para realizar os testes.
MLX (ferramenta): Framework de machine learning da Apple, voltado ao Apple Silicon no contexto do teste.
MLX-CUDA (ferramenta): Backend que permite executar MLX em GPUs CUDA, mas que apresentou incompatibilidades com o framework do Edge0 durante o teste.
llama.cpp (repo): Projeto usado para executar o modelo-base quantizado na RTX 4090 e medir desempenho e contexto.
Apache License 2.0 (conceito): Licença indicada para o Edge0.

Tradução completa (pt-BR)

00:00 Este é um modelo de 35 bilhões de parâmetros rodando em um iPhone 16 Pro. 8 GB de RAM, modo avião ativado, e a sobreposição mostra um pico de 1,8 GB de memória. Esse clipe vem da equipe Edge Zero. Ele está bem ali na página deles no Hugging Face. Então aluguei uma RTX 4090 na RunPod, instalei o framework deles exatamente como diz o README e apontei para o modelo. A instalação terminou com código de saída zero. Aí o primeiro comando falhou com “libmx.2: não foi possível abrir o arquivo de objeto compartilhado”. Tentei três soluções diferentes depois disso. Todas falharam em um ponto diferente. Ao final deste vídeo, você vai saber o que o Edge0 faz

00:33 e quais dos números dele se confirmam, por que ele não rodou em uma placa Nvidia de 24 GB e o que o mesmo modelo-base faz nessa placa quando você o executa do jeito normal. A resposta para essa última pergunta é 187 tokens por segundo. Então, o que é o Edge0? É uma versão de prévia de uma equipe chamada Edge Zero AI, publicada em 8 de setembro. A base é o Qwen 3.6 35B A3B. Esse é o modelo de mistura de especialistas da Alibaba, com 35 bilhões de parâmetros no total e cerca de 3 bilhões usados por token. Ele já tem 3,6 milhões de downloads por conta própria. O Edge Zero pega

01:06 esse modelo, comprime-o para inteiros de 4 bits e adiciona dois pequenos arquivos de adaptador, um LoRA e algo que eles chamam de pre-router. A pasta inteira tem 19,7 GB. Licença Apache 2.0. Em 6 dias, recebeu 1.6424 curtidas e 809 downloads. Essa proporção é excepcionalmente alta, e faz sentido quando você vê quem consegue realmente rodá-lo. O truque tem três partes. A primeira é o descarregamento dos especialistas para o SSD. Um modelo de mistura de especialistas tem 256 pequenas redes especialistas em cada camada, e cada token passa por apenas algumas delas. Então o Edge Zero deixa os

01:39 especialistas no disco. Ele mapeia os arquivos na memória e lê um especialista somente quando o roteador o seleciona. A RAM mantém as partes ativas, e o resto fica esperando no SSD. A segunda parte é o pre-router. Ler do disco é lento. Então eles treinaram uma pequena camada de saída que prevê de quais especialistas a próxima etapa vai precisar e começa a carregá-los enquanto a etapa atual ainda está sendo calculada. O README diz que isso pode proporcionar até 59% a mais de velocidade de decodificação. Não há uma tabela que sustente esse número. A terceira parte é o Recover LoRA. Quantizar para 4 bits reduz a qualidade. Então eles congelaram a base de 4 bits e treinaram o LoRA para imitar o modelo de precisão total.

02:12 É assim que eles alegam ficar a até 3,9 pontos do original. E veja só: a tabela de modelos do README diz “256 dividido por 4K = 4”. O config.json no mesmo repo diz “num experts per token 8”. Consultei o código-fonte para verificar, e a configuração da categoria Edge Dur 35B define top_k = 4. Então o Edge usa metade dos especialistas roteados para os quais o modelo-base foi treinado. Isso traz um ganho real de velocidade e memória, mas o destaque nunca menciona isso. Para ser justo com eles, os números de qualidade foram medidos nesse pipeline. Portanto, esse custo já deve estar incluído

02:43 na diferença de 3,9 pontos. Agora, os benchmarks: cinco testes, Edge Zero em int4 contra Qwen em fp16: AIME 2026, 86 contra 92,7; HumanEval, 90,9 contra 95,1; GPQA Diamond, 79,8 contra 81,8; MM Pro, 81 contra 84,6; IFBench, 57,9 contra 61,7; média, 79,2 contra 83,2. Dois pontos sobre essa tabela. A média esconde uma

03:13 queda desigual. O GPQA perde dois pontos, enquanto matemática perde 6,1 e código perde 4,2. Essas são as duas tarefas que as pessoas mais costumam executar localmente, e a página diz isso com clareza. Todos os benchmarks foram executados por eles. Procurei uma verificação independente no Artificial Analysis, no LiveBench e no LMArena e não encontrei nada. A publicação do blog sobre esse modelo repete a tabela do fornecedor. Ninguém independente o mediu ainda. Os números de velocidade vêm de uma máquina, um Mac Mini M4 Pro com 24 GB: 14,9 a 17,7 tokens por segundo e 2,9 GB de pico de memória ativa, com uma nota de rodapé

03:45 dizendo que os contextos eram curtos. A configuração de categoria do próprio framework reserva 3.400 megabytes para este modelo. Um pouco acima do valor destacado, o checkpoint completo de 19,7 GB ainda precisa ficar em um disco rápido, e o sistema operacional vai usar alegremente a RAM livre como cache de páginas enquanto lê. Agora, a parte que eu realmente queria testar. O README tem uma frase que decide tudo para a maioria das pessoas que estão assistindo. O backend MLX atualmente tem como alvo o Apple Silicon. O repo do GitHub é mais direto: o backend CUDA está no roteiro. MLX é o framework de

04:15 machine learning da Apple. Eu não tenho um Mac, e a maioria das pessoas que executa modelos localmente tem uma placa Nvidia. Então aluguei uma RTX 4090 na RunPod. Secure Cloud, 74 centavos por hora, 24.564 MB de VRAM, Ubuntu 22.04. Segui o guia de início rápido linha por linha: clonar, criar ambiente, instalar com pip. Ele baixou o wheel Linux do mlx 0.30.6 e exibiu “instalado com sucesso”, código de saída zero. Então digitei edge0 –help e recebi um erro de importação: “libmlx.so: não foi possível abrir o arquivo de objeto compartilhado”.

04:47 O wheel MLX simples para Linux vem sem a biblioteca de que precisa. Verifiquei a árvore do código-fonte. Há uma pasta backends com exatamente uma coisa dentro: MLX. A pasta CUDA, que o README chama de reservada, não existe. O MLX já tem uma versão oficial para CUDA. Então a solução número um foi instalar o MLX CUDA. Mesma versão, 0.30.6. Essa funcionou por si só. O dispositivo padrão era a GPU zero, e uma multiplicação de matrizes de teste retornou o resultado correto. Então apontei o Edge Zero para os pesos. Ele carregou, ocupando 690 MB de VRAM, e um minuto depois

05:18 falhou na primeira camada de mistura de especialistas com o erro de execução “QMM NYI”. QMM significa multiplicação de matrizes quantizada. NYI significa “ainda não implementado”. O backend CUDA nessa versão do MLX não consegue executar um especialista de 4 bits. A solução número dois foi instalar a versão mais recente do MLX, 0.32.2. Ela passou do erro QMM, rodou por 3 minutos e 14 segundos e depois parou com uma mensagem dizendo para aumentar o tamanho do cache de gráficos do MLX CUDA para mais de 400. Então a solução número três foi fazer exatamente isso. Defini o valor como 4.000 e executei novamente o benchmark

05:49 e três conversas com o pre-router ativado e desativado. Todas as execuções falharam durante o prefill com erro de índice: “vetor pequeno fora do intervalo”. O pico de VRAM foi de 3,9 GB, o pico de RAM foi de cerca de 10 GB e não saiu nenhum token. Solução número quatro: esquecer a GPU. O MLX também tem uma versão para CPU, e esse pod tem 128 núcleos. Deixei de lado a placa de vídeo e executei o benchmark oficial na CPU com MLX. Ele se arrastou por 9 minutos e 38 segundos, chegou a 9,9 GB de RAM e depois falhou dentro da camada de streaming de especialistas. Erro de tempo de execução: “não há stream CPU 36 na thread atual”.

06:21 Quatro tentativas, quatro erros diferentes e ainda zero tokens. Quero ser justo quanto ao que isso demonstra. O Edge0 diz no próprio README que tem como alvo o Apple Silicon, e eu o executei em outra coisa. Nenhuma dessas falhas ou erros refuta as alegações. Mas elas mostram para quem esta versão é voltada hoje: donos de Mac. A demonstração no iPhone está ainda mais fora de alcance, porque o repo não contém um app para iOS nem instruções para criar um. Então, o que o mesmo modelo-base faz nessa placa quando você o executa do jeito comum? Compilei o llama.cpp a partir do código-fonte, no commit 41 ABBFD, com CUDA para a 4090, e baixei a quantização IQ4 XS do Anslo

06:56 do Qwen 3.6 35B A3B, também em 4 bits: 17,7 GB no disco e 16,5 GB carregados. Llama-bench, duas repetições: processamento do prompt com 512 tokens, 6.983 tokens por segundo; geração com 128 tokens, 187,47 tokens por segundo, mais ou menos 1,28. Pico de VRAM: 17 GB. Para comparar, o número do próprio Edge0 em um Mac Mini é cerca de 15. Isso é aproximadamente 12 vezes mais rápido. O preço é 16,5 GB de memória de vídeo, exatamente aquilo que o Edge0 foi criado para evitar gastar.

07:30 Agora, o contexto. Antes de executar qualquer coisa, fiz as contas a partir do config.json. Apenas 10 das 40 camadas usam atenção completa. Uma a cada quatro; as outras 30 usam atenção linear com um estado pequeno e fixo. Com duas cabeças de chave e valor e um tamanho de cabeça de 256, o cache KV custa cerca de 2 kilobytes por token por camada completa. De 8K a 131K tokens, isso prevê um aumento de cerca de 2.400 megabytes. Medido na 4090 com o Llama server: 17.360 megabytes em 8K, 17.864

08:01 em 32K, 18.536 em 65K, 19.880 em 131K. Isso representa um aumento de 2.520 megabytes, dentro de 5% da previsão. E, com a context window completa de 262.144 tokens, 22.568 megabytes: todo o contexto nativo cabe em uma placa de 24 GB. Esse design de atenção híbrida merece crédito e também ajuda a memória de contexto longo do Edge Zero. Mas uma context window que você consegue alocar ainda precisa ser uma janela que o modelo consiga usar. Então montei uma pilha de 6.218 frases banais sobre trancas de armazém, com 460.129

08:36 caracteres e escondi uma linha a 46% do texto. O código mestre de substituição do depósito de Kolkata é Indigo Pengalin 77. Depois, pedi o código no final. 106.663 tokens de prompt pré-preenchidos a 5.368 tokens por segundo. 20 segundos de tempo real. A resposta foi Indigo Pengolin 77. Exatamente. Agora, os prompts do vídeo do iPhone da Edge0ero, no modelo base: o What Is On-Device AI retornou 567 tokens a 167,9 tokens por segundo em 3,6

09:06 segundos. A pergunta sobre Xangai, em chinês: 847 tokens a 167,5. A pergunta sobre anime, em japonês: 966 tokens a 169,4. As três respostas ficaram claras em seus idiomas. Para código, pedi uma função de mesclagem de intervalos e executei seis testes nela, incluindo uma lista vazia e intervalos adjacentes. Ela gerou cerca de 18.000 caracteres, escreveu 5.536 tokens em 33 segundos e passou nos seis testes. Para ferramentas, dei a ela duas funções: clima e calendário. Em uma frase, pedi para verificar o clima em Kolkata e colocar a revisão na minha reunião das

09:39 16h de amanhã no calendário. Em uma única interação, ela chamou as duas ferramentas em paralelo. Converteu 16h para 1600 e amanhã para 15 de setembro, sem que eu especificasse o formato. Depois, elaborou a resposta com base nos resultados simulados e não fez chamadas extras. O README da Edge Zero diz que o uso de ferramentas é fraco na versão de prévia, e não consegui testar a compilação deles. Portanto, este é apenas o modelo base. Um erro. Pedi a linha da Edge Zero para a RTX 4090 na tabela oficial de benchmarks. Uma linha que não existe. Ela disse corretamente que não conhecia o modelo. Depois, sugeriu uma faixa típica de 30 a 70 tokens por segundo para essa classe de

10:10 modelo em uma 4090. Eu tinha acabado de medir 187 nessa placa. Ela chutou, e o palpite errou por quase um fator de três. Agora, os problemas, em ordem de importância. Primeiro, só funciona em Apple silicon. Em uma placa Nvidia, tive três falhas diferentes e zero tokens. Segundo, os números de qualidade são autorrelatados, com as maiores quedas em matemática e código. Terceiro, o número de experts roteados cai de 8 para 4 em código, enquanto o destaque fala apenas de memória. Quarto, o framework fixa o mlx-lm 0.31.0, uma versão removida do PyPI. O motivo informado é a contaminação cruzada do cache KV em lotes, e o processamento de lotes é

10:43 um dos casos de uso anunciados por eles. E os pontos positivos são reais. Apache 2.0, zero. Uma seção clara sobre limitações que admite habilidades fracas de agent. Uma arquitetura que transmite experts do disco, em vez de fingir que a RAM é gratuita, para Macs com 8 ou 16 GB, nos quais o Qwen 3.6 35B simplesmente não cabe. Uma versão de 15 tokens por segundo é uma opção real. Então, aqui vai meu veredito. Se você tem um Mac com Apple silicon e pouca memória para uma quantização de 17 GB, vale a pena experimentar a Edge0 hoje; afinal, é por isso que este projeto existe. Se você tem uma placa Nvidia com 24 GB, deixe para depois. Rode o Qwen 3.6

11:17 35B IQ4_XS normal no llama.cpp: 187 tokens por segundo, o contexto completo de 262K, e ele encontrou a agulha. Com 16 GB, você vai precisar de uma quantização menor de 3 bits ou de offload parcial para a CPU, o que não testei aqui. Com 8 GB em uma Nvidia, nenhuma das opções funciona bem ainda. E o backend CUDA que a Edge promete é o que vale a pena acompanhar. Se quiser saber mais, vou deixar o link para a página principal na descrição abaixo. Todos os comandos e números deste vídeo vieram daquela sessão no RunPod, e as transcrições também estão linkadas. Obrigado por assistir.

Transcrição original

[00:00] This is a 35 billion parameter model running on an iPhone 16 Pro. 8 GB of RAM, airplane mode on, and the overlay says 1.8 GB of memory peak. That clip comes from the Edge Zero team. It sits right on their hugging face page. So, I rented an RTX 4090 on RunPod, installed their framework exactly the way the readme says, and pointed it at the model. The install finished with exit code zero. Then, the very first command died with libmx.2. So, cannot open shared object file. I tried three different fixes after that. every one of them crashed in a new place. By the end of this video, you’ll know what Edge0ero

[00:33] does, which of its numbers hold up, why it would not run on a 24 GB Nvidia card, and what the same base model does on that card when you run it in the normal way. The answer to that last one is 187 tokens per second. Now, what is Edge0ero? It’s a preview release from a team called Edge Zero AI, published on September 8th. The base is Quen 3.6 35B A3B. That’s Alibaba’s mixture of experts model with 35 billion parameters in total and about 3 billion used per token. It already has 3.6 million downloads on its own. Edge Zero takes

[01:06] that model, squeezes it to 4-bit integers, and adds two small adapter files, a Laura and something they call a pre-outer. The whole folder is 19.7 GB. Apache 2.0 license. In 6 days, it collected 1,6424 likes against 809 downloads. That ratio is unusually high and it makes sense once you see who can actually run it. The trick has three parts. The first is SSD expert offload. A mixture of experts model has 256 small expert networks in every layer and each token only visits a few of them. So edge zero leaves the

[01:39] experts on disk. Memory maps the files and reads an expert only when the router picks it. RAM holds the active pieces and the rest waits on the SSD. The second part is the pre-outer. Reading from disk is slow. So they trained a small head that guesses which experts the next step will need and starts loading them while the current step is still computing. The readme says that’s worth up to plus 59% decode speed. There is no table behind that number. The third part is recover Laura quantizing to four bits loses quality. So they froze the 4bit base and trained Allora to imitate the full precision model.

[02:12] That’s how they claim to stay within 3.9 points of the original. And get this, the readme’s model table says 256 divide vite 4 k equals 4. The config.json in the same repo says num experts per token 8. I went into the source code to check and the edge dur 35b tier config hardcodes top k equals 4. So edge runs half the routed experts the base model was trained with. That’s a real speed and memory labor and the headline never mentions it. To be fair to them, their quality numbers were measured on this pipeline. So the cost should already sit

[02:43] inside that 3.9 point gap. Now the benchmarks five tests edge zero at int4 against quen at fp16 aime 202686 forces 92.7 human eval 90.9 versus 95.1 GPQA diamond 79.8 versus 81.8 mm pro 81 versus 84.6 if bench 57.9 versus 61.7 average 79.2 versus 83.2 2. Two things about that table. The average hides an

[03:13] uneven drop. GBQA loses two points while math loses 6.1 and code loses 4.2. Those are the two tasks people most often run locally and the page says it plainly. All benchmarks were run by us. I looked for an independent check on artificial analysis livebench and alamarina and found nothing. The blog post covering this model repeat the vendor table. Nobody independent has measured it yet. The speed numbers come from one machine, a Mac Mini M4 Pro with 24 GB 14.9 to 17.7 tokens per second and 2.9 GB of peak active memory with a footnote

[03:45] saying short contexts. The framework’s own tier config budgets 3,400 mgabytes for this model. A little above the headline, the full 19.7 GB checkpoint still has to live on a fast drive and the operating system will happily fill spare RAM with page cache while it reads. Now, the part I actually wanted to test. The Redmi has one sentence that decides everything for most people watching. The MLX backend currently targets Apple Silicon. The GitHub repo is more direct. The CUDA back end is on the road map. MLX is Apple’s machine

[04:15] learning framework. I don’t own a Mac and most people running local models have an Nvidia card. So, I rented an RTX 4090 on RunPod. Secure Cloud 74 cents an hour, 24,564 MGB of VRAM, Ubuntu 2204. I followed the quick start line for line clone create event pip install. It pulled mlx030.6 the Linux wheel and printed successfully installed exit code zero. Then I typed edge0-help import error lib mlx dot so cannot open

[04:47] shared object file. The plain Linux MLX wheel ships without the library it needs. I check the source tree. There’s a backends folder with exactly one thing in it. MLX the CUDA folder the readme calls reserved doesn’t exist. MLX does have an official CUDA build now. So fix number one was installing MLX CUDA. Same version 030.6. That one worked on its own. Default device GPU zero and a test matrix multiply came back correct. So I pointed edge zero at the weights. It loaded set at 690 MGB of VRAM and a minute later

[05:18] died in the first mixture of experts layer runtime error. QMM NYI. QMM is quantized matrix multiply. NYI means not yet implemented. The CUDA backend in that MLX version can run a 4-bit expert. Fix number two was the newest MLX 0.32.2 that got past QMM, ran for 3 minutes and 14 seconds, and then stopped with a message telling me to raise MLX CUDA graph cache size above 400. So fix number three was doing exactly that. I set it to 4,000 and reran the benchmark

[05:49] and three chats with the pre-outer on and off. Every single run crashed during prefill with index error, small vector out of range. Peak VRAM was 3.9 GB and peak RAM about 10 GB and zero tokens came out. Fix number four, forget the GPU. MLX has a CPU built too, and this pod has 128 cores. I hit the graphics card and ran the official benchmark on MLX CPU. It ground away for 9 minutes and 38 seconds, climbed to 9.9 GB of RAM, and then crashed inside the expert streaming layer. Rad time error. There is no stream CPU 36 in current thread.

[06:21] Four attempts, four different errors, and still zero tokens. I want to be fair about what this shows. Edge0 says in its own readme that it targets Apple Silicon, and I ran it on something else. None of these crashes or bugs in the claims. They do tell you who this release is for today, Mac owners. The iPhone demo is further out of reach still because the repo contains no iOS app and no instructions for building one. So, what does the same base model do on this card when you run it the ordinary way? I built llama.cpp CPP from source commit 41 ABBFD with CUDA for the 4090 and downloaded Anslo’s IQ4 XS quant

[06:56] of Quen 3.635B A3B that’s also 4bit 17.7 GB on disk and 16.5 GB loaded LLBA bench two repetitions prompt processing at 512 tokens 6983 tokens per second generation at 128 tokens 187.47 tokens per second plus or minus 1.28 28. Peak VR RAM 17 GB. For comparison, Edge0’s own number on a Mac Mini is about 15. That’s around 12 times faster. The price is 16 1/2 GB of video memory, which is the exact thing Edge0 was built to avoid spending.

[07:30] Now, context. Before running anything, I did the math from config.json. Only 10 of the 40 layers use full attention. Every fourth one, the other 30 are linear attention with a small fixed state. With two key value heads and a head size of 256, the KV cache costs about 2 kilobytes per token per full layer. From 8K to 131K tokens, that predicts about 2,400 megabytes of growth. Measured on the 4090 with Llama server, 17,360 megabytes at 8K, 17,864

[08:01] at 32K, 18,536 at 65K, 19,880 at 131K. That’s 2520 megabytes of growth within 5% of the prediction. And at the full 262,144 token window, 22,568 mgabytes, the whole native context fits on a 24 GB card. That hybrid attention design deserves credit, and it helps edge zero’s long context memory, too. A window you can allocate still has to be a window the model can use. So, I built a hstack of 6,218 boring warehouse lock sentences, 460,129

[08:36] characters, and hid one line 46% of the way in. The master override code for the Kolkata depot is Indigo Pengalin 77. Then I asked for the code at the very end. 106,63 prompt tokens pre-filled at 5,368 tokens per second. 20 seconds wall clock. It answered Indigo Pengolin 77. Exactly. Now, the prompts from Edge0ero’s iPhone video on the base model, what is on device AI returned 567 tokens at 167.9 tokens per second in 3.6

[09:06] seconds. The Shanghai question in Chinese, 847 tokens at 167.5. The anime question in Japanese, 966 tokens at 169.4. All three read cleanly in their language. For code, I asked for a merge intervals function and ran six tests against it, including an empty list and touching intervals. It fought for about 18,000 characters, wrote 5,536 tokens in 33 seconds, and passed six out of six. For tools, I gave it two functions, weather and calendar. In one sentence, check the weather in Kolkata and put the review on my calendar for my

[09:39] 4 p.m. meeting tomorrow. In one turn, it called both tools in parallel. It turned 4 p.m. into 1600 and tomorrow into September 15th without being told the format. Then it wrote the answer from the fake results and made no extra calls. Edge Zero’s readme says tool uses weak in its preview and I couldn’t test their build. So, this is the base model only. One miss. I asked for edge zero’s RTX490 row from the official benchmark table. A row that doesn’t exist. It correctly said it didn’t know the model. Then it offered a typical range of 30 to 70 tokens per second for this class of

[10:10] model on a 4090. I had just measured 187 on that card. It guessed and the guess was wrong by almost three times. Now, the problems in order of how much they matter. First, it runs on Apple silicon only. On an Nvidia card, I got three different crashes and zero tokens. Second, the quality numbers are self-reported with the biggest drops in math and code. Third, the routed experts are cut from 8 to four in code, while the headline talks about memory only. Fourth, the framework pins MLXLm0.31.0, which is a yanked release on Pi Pi. The listed reason is batched KV cache crosscontamination and batch serving is

[10:43] one of their advertised use cases. And the good parts are real. Apache 2.0, zero. A clear limitation section that admits weak agent skills. An architecture that streams experts from disk instead of pretending RAM is free on a Mac with 8 or 16 GB where Qen 3.635b simply doesn’t fit. A 15 token per second version is a real option. So here’s my verdict. If you have an Apple silicon Mac with too little memory for a 17 GB quant, Edge0 is worth trying today and it’s the reason this project exists. If you have an Nvidia card with 24 GB, skip it for now. Run the regular QN 3.6

[11:17] 6 IQ4XS in llama.cb CBP 187 tokens per second, the full 262K context, and it found the needle. With 16 GB, you’ll want a smaller 3-bit quant or partial CPU offload, which I didn’t test here. With 8 GB on Nvidia, neither path works well yet. And the CUDA backend, Edge, promises is the one to watch. If you’re interested in reading further, I’ll link to this main page in the description below. Every command and every number in this video came from that runpod session, and the transcripts are linked, too. Thanks for watching.