# Flint di Recursive: il modello da coding con pesi aperti che gira sul Mac, benchmark e requisiti

_Un MoE da 40 miliardi di parametri, 2,5 attivi per token, licenza Apache 2.0 e oltre 125 token al secondo su MacBook Pro secondo l'azienda_

Fonte: https://andreapirazzini.it/blog/recursive-flint-modello-coding-pesi-aperti-mac · 22 ottobre 2026

> Articolo redatto da un sistema di AI a partire da fonti ufficiali: https://recursive.com/updates/introducing-recursive-flint.

## In breve

- Flint è il primo modello di Recursive: 39,8 miliardi di parametri, circa 2,5 miliardi attivi per token, pesi aperti con licenza Apache 2.0.
- Su SWE-bench Verified Recursive dichiara il 74,2%, sopra il MoE Qwen3.6 35B ma sotto il denso Qwen3.8 27B (75,6%).
- Nel grafico ufficiale corre a 131 token al secondo su un MacBook Pro M4 Pro, contro 13 del denso Qwen3.8 27B.
- Il motore rec richiede un Mac M4 Pro, M4 Max, M5 Pro o M5 Max con almeno 48 GB di memoria unificata; con Ollama il file pesa 23 GB.
- L'API è per ora riservata a partner selezionati; il modello si prova gratis anche su OpenCode.

## Perché se ne parla

Il 21 ottobre 2026 Recursive, la startup di Richard Socher (cofondatore e CEO, già chief scientist di Salesforce e CEO di You.com), ha presentato **Flint**, il suo primo modello. È un modello da programmazione con i **pesi aperti** su Hugging Face e licenza **Apache 2.0**, pensato per girare in locale su un portatile. Secondo Recursive è stato costruito da zero in meno di quattro mesi con la «Eureka Machine», il sistema di ricerca automatizzata dell'azienda.

Per chi sviluppa software per i clienti la notizia conta per un motivo semplice: un modello che gira sul proprio computer non manda il codice a un servizio esterno.

- **40 mld** Parametri in tutto (39,8 mld)
- **2,5 mld** Parametri attivi per ogni token
- **125+** Token al secondo su MacBook Pro M4 Pro
- **Apache 2.0** Licenza dei pesi, uso commerciale consentito

_Fonte: Recursive, annuncio ufficiale e model card Hugging Face_

## Come funziona Flint

Flint è un **mixture-of-experts** (MoE): il modello intero ha 39,8 miliardi di parametri, ma per ogni token ne usa circa 2,5 miliardi. Ogni strato ha 256 «esperti» e per ciascun token ne vengono scelti 6, più uno condiviso. Gli strati sono 49 (2 densi e 47 MoE).

In parole semplici: il modello è grande, ma a ogni passo lavora solo una piccola parte, circa il 6% dei parametri. Per questo è più leggero e più veloce di un modello «denso» di qualità simile, dove ogni token attraversa tutti i parametri.

[Animazione: Come lavora un mixture-of-experts: per ogni token Flint usa 6 dei 256 esperti di ogni strato più uno condiviso, circa 2,5 miliardi di parametri su 39,8. Dati: Recursive. Animazione realizzata per questo articolo; Scheggia non è una mascotte di Recursive.](https://xfzvzyxtnexwldhdjrdj.supabase.co/storage/v1/object/public/blog-media/posts/a790b59a-bd4a-4dcd-a274-b7104fbe5315/6f53fbc6-139a-4914-9a57-d503d2b1f743.mp4)

| Caratteristica | Valore dichiarato |
| --- | --- |
| Parametri totali | 39,8 miliardi |
| Parametri attivi per token | circa 2,5 miliardi |
| Esperti per strato | 256, di cui 6 scelti + 1 condiviso |
| Contesto | fino a 512.000 token, consigliato entro 256.000 |
| Conoscenze | fino a giugno 2026 |
| Licenza | Apache 2.0 |
| Pesi completi (BF16) | circa 80 GB |

![Il simbolo di Flint: un triangolo sfaccettato color terracotta su fondo scuro.](https://xfzvzyxtnexwldhdjrdj.supabase.co/storage/v1/object/public/blog-media/posts/a790b59a-bd4a-4dcd-a274-b7104fbe5315/0780a732-85a4-4277-af4a-4d1e42e4466d.png)
*Il simbolo di Flint. Immagine: Recursive*

## I benchmark: cosa dicono i numeri di Recursive

Recursive presenta Flint come il miglior MoE sotto i 50 miliardi di parametri su tre test di programmazione: Terminal-Bench 2.1, SWE-bench Pro v2 e SWE-bench Verified. Sono **numeri misurati dall'azienda**, anche sui concorrenti: per ora non ci sono test indipendenti.

![Il grafico ufficiale Flint benchmark performance: barre di Flint e di modelli locali simili su sei test.](https://xfzvzyxtnexwldhdjrdj.supabase.co/storage/v1/object/public/blog-media/posts/a790b59a-bd4a-4dcd-a274-b7104fbe5315/a2a66c40-e199-45e2-87d4-69ba1167b569.png)
*Grafico ufficiale dei benchmark. Fonte: Recursive*

**Tre test di programmazione** — Punteggi in percentuale, più alto è meglio

| Voce | Flint (MoE, 2,5 mld attivi) | Qwen3.6 35B (MoE) | Qwen3.8 27B (denso) |
| --- | --- | --- | --- |
| Terminal-Bench 2.1 | 54,9% | 44,9% | 73% |
| SWE-bench Pro v2 | 89,7% | 73,8% | 94,9% |
| SWE-bench Verified | 74,2% | 73,4% | 75,6% |

_Fonte: Recursive, grafico «Flint benchmark performance»; i concorrenti sono misurati da Recursive_

| Test | Flint | Qwen3.6 35B MoE | Qwen3.8 27B denso |
| --- | --- | --- | --- |
| Terminal-Bench 2.1 | 54,9 | 44,9 | **73,0** |
| SWE-bench Pro v2 | 89,7 | 73,8 | **94,9** |
| SWE-bench Verified | 74,2 | 73,4 | **75,6** |

La tabella va letta con attenzione. Flint supera il MoE di taglia simile su tutti e tre i test. Il modello denso Qwen3.8 27B, però, resta sopra su tutti e tre, con il distacco più ampio su Terminal-Bench 2.1. Il vantaggio dichiarato di Flint non è il punteggio assoluto ma il rapporto tra qualità e velocità: secondo Recursive regge il confronto con modelli densi da 25 a 40 miliardi di parametri ed è più di cinque volte più veloce.

## Quanto corre in locale

Recursive dichiara oltre 125 token al secondo su un MacBook Pro M4 Pro e oltre 150 su NVIDIA RTX Spark da 64 GB, con contesti corti. Il grafico ufficiale riporta i valori misurati con un contesto da 1.000 token.

[Animazione: Token al secondo su MacBook Pro M4 Pro da 48 GB, con un contesto da 1.000 token. Dati: Recursive, grafico ufficiale «Flint local inference performance», concorrenti misurati da Recursive. Animazione realizzata per questo articolo.](https://xfzvzyxtnexwldhdjrdj.supabase.co/storage/v1/object/public/blog-media/posts/a790b59a-bd4a-4dcd-a274-b7104fbe5315/02eeb352-693b-44fd-bf92-1490864ff3f2.mp4)

**Velocità su MacBook Pro M4 Pro, 48 GB** — Token al secondo, contesto corto (1K)

| Voce | Token al secondo |
| --- | --- |
| Flint con rec (MLX) | 131,22 token/s |
| Flint con llama.cpp | 87,98 token/s |
| Qwen3.6 35B A3B | 65,55 token/s |
| Gemma 4 26B | 61,89 token/s |
| Qwen3.8 27B (denso) | 13,01 token/s |

_Fonte: Recursive, grafico «Flint local inference performance»_

Sulla RTX Spark da 64 GB, sempre secondo lo stesso grafico, Flint arriva a 155,82 token al secondo nella versione NVFP4, a 96,61 con llama.cpp, mentre Qwen3.6 si ferma a 72,65.

![Il grafico ufficiale Flint local inference performance con i token al secondo su Mac e su RTX Spark.](https://xfzvzyxtnexwldhdjrdj.supabase.co/storage/v1/object/public/blog-media/posts/a790b59a-bd4a-4dcd-a274-b7104fbe5315/4470b48d-01ed-4b9a-b955-ee34f19a2fed.png)
*Grafico ufficiale della velocità in locale. Fonte: Recursive*

![Il grafico ufficiale di Recursive che mette in relazione qualità e velocità dei modelli locali.](https://xfzvzyxtnexwldhdjrdj.supabase.co/storage/v1/object/public/blog-media/posts/a790b59a-bd4a-4dcd-a274-b7104fbe5315/d777367a-c466-4213-8f54-085d0bfcac05.png)
*Qualità e velocità a confronto. Fonte: Recursive*

## Il video di lancio

Il video ufficiale è nel [post di Richard Socher su X](https://x.com/RichardSocher/status/2112944385415426249) del 21 ottobre 2026. La parte centrale mostra la scritta «for running a coding agent on your laptop» e poi scorre i grafici dei benchmark, con la barra di Flint evidenziata in arancione. L'annuncio dell'azienda è anche nel [post di Recursive su X](https://x.com/Recursive_SI/status/2112947469826896151).

## Cosa serve per provarlo

Flint si può usare con diversi strumenti. Recursive cita llama.cpp, Ollama, Unsloth, LM Studio, vLLM e SGLang, più il proprio motore per Mac, **rec**.

| Strumento | Come si installa | Note dalle fonti ufficiali |
| --- | --- | --- |
| rec (Recursive) | dalla documentazione Recursive | solo M4 Pro, M4 Max, M5 Pro o M5 Max con almeno 48 GB di memoria unificata e circa 30 GB liberi |
| Ollama | `ollama run flint` | file da 23 GB, contesto 256K |
| LM Studio | `lms get recursivesi/flint` | dalla documentazione Recursive |
| Hugging Face | repository RecursiveSI/flint | pesi BF16 completi, circa 80 GB |

> **Attenzione:** rec controlla chip e memoria prima di scaricare il modello: su un Mac con un chip non supportato o con meno di 48 GB di memoria unificata non scarica Flint. Per Ollama e LM Studio la documentazione non indica una soglia di memoria precisa, oltre allo spazio per il file da 23 GB.

Chi non vuole installare nulla può provarlo gratis su **OpenCode**, con i limiti del piano gratuito. L'API di Recursive per Flint è aperta per ora solo a partner selezionati.

## Limiti dichiarati

- Recursive consiglia compiti piccoli e istruzioni esplicite: Flint «può richiedere più guida» dei grandi modelli chiusi.
- La model card avverte che il modello può produrre codice sbagliato o chiamate a strumenti non corrette: il codice va testato, e permessi e confini li deve impostare l'applicazione che lo usa.
- Nessuna pagina ufficiale parla del supporto alla lingua italiana: va verificato sul campo.
- Benchmark e velocità sono dati del produttore.

## Cosa cambia in pratica per un'azienda

Per uno studio o una software house che lavora su codice dei clienti, spesso sotto NDA, Flint apre una strada concreta: un assistente di programmazione che gira sul portatile, senza mandare il repository a un servizio cloud e senza costi per token.

Un modo prudente per valutarlo:

1. Verificate la memoria del Mac (menu Apple, Informazioni su questo Mac). Sotto i 48 GB rec non parte; con Ollama o LM Studio servono comunque 23 GB per il file più lo spazio di lavoro.
2. Scegliete un repository che il team conosce bene, non un progetto critico.
3. Assegnate compiti piccoli: spiegare una funzione, scrivere un test, correggere un bug noto.
4. Mettete il diff di Flint accanto a quello del modello che usate oggi, misurando tempi ed errori.
5. Tenete la revisione umana prima di ogni merge.

![L'illustrazione ufficiale della Eureka Machine di Recursive: linee e nodi luminosi su fondo scuro.](https://xfzvzyxtnexwldhdjrdj.supabase.co/storage/v1/object/public/blog-media/posts/a790b59a-bd4a-4dcd-a274-b7104fbe5315/590da798-c7d9-4975-bd9d-fdba1f89eac3.png)
*La Eureka Machine, il sistema di ricerca automatizzata con cui Recursive dice di aver costruito Flint. Immagine: Recursive*

## Chi c'è dietro Recursive

Recursive è uscita dallo stealth a maggio 2026 con 650 milioni di dollari raccolti. Secondo WIRED la società è valutata 4,65 miliardi di dollari e tra gli investitori ci sono GV, Greycroft, Nvidia e AMD Ventures; questi ultimi dati non compaiono sulle pagine di Recursive.

## Domande frequenti

**Flint è gratuito?**

I pesi sono gratuiti e con licenza Apache 2.0, che consente anche l'uso commerciale. Si può provare gratis anche su OpenCode, con i limiti del piano gratuito. L'API di Recursive è per ora riservata a partner selezionati.

**Gira su qualsiasi Mac?**

Con rec, il motore di Recursive, servono un M4 Pro, M4 Max, M5 Pro o M5 Max con almeno 48 GB di memoria unificata. Con Ollama il file pesa 23 GB e la documentazione non indica una soglia di memoria precisa.

**È meglio dei modelli densi?**

Non sui punteggi assoluti: nel grafico di Recursive il denso Qwen3.8 27B resta sopra su Terminal-Bench 2.1, SWE-bench Pro v2 e SWE-bench Verified. Il punto di forza dichiarato è la velocità, più di cinque volte superiore a densi di qualità simile.

**Funziona in italiano?**

Le pagine ufficiali non ne parlano. Conviene provarlo su richieste e commenti in italiano prima di adottarlo.

**Il codice resta sul computer?**

Se il modello gira in locale con rec, Ollama o LM Studio, l'elaborazione avviene sul computer. Permessi e confini dell'agente restano però da configurare nell'applicazione che lo usa, come ricorda la model card.

---

_Articolo scritto con l'aiuto dell'intelligenza artificiale sulla base delle fonti ufficiali indicate, verificate il 21 ottobre 2026. Benchmark e velocità sono dati di Recursive._