Personal AI - OfficinaTurini

Cascina (PI) 19 Giugno 2026

L’argomento non è certamente di facile accesso per il grande pubblico. L’intelligenza artificiale moderna sembra spesso qualcosa di enorme, distante e quasi inafferrabile: grandi data center, consumi energetici imponenti, modelli con miliardi di parametri, aziende gigantesche, linguaggi tecnici difficili da penetrare. Vista da fuori, l’AI appare come una scatola chiusa: si inserisce una domanda, esce una risposta, ma ciò che accade nel mezzo resta nascosto.

Yet, as often happens in the history of technology, the most profound changes aren't born solely from big announcements. Sometimes they're triggered by seemingly small tools, libraries, quietly released projects, or cleverly written code offered to the community. It's those less visible steps that, over time, transform a technology from something reserved for specialists into a tool truly usable by many.

It is in this context that Georgi Gerganov enters the scene—a name still unknown to the general public, yet highly significant for those currently working with locally run AI models. Gerganov is the author and primary driving force behind open-source projects such as GGML, llama.cpp, and whisper.cpp. These are tools written predominantly in C/C++, designed to enable the execution of AI models on hardware that is far more common than the typical infrastructure used in large-scale labs. The llama.cpp project explicitly states its goal: the inference of language models with minimal setup and high performance across a wide variety of local hardware.

The key point is this: Gerganov did not invent transformers, he did not train the most powerful language models from scratch, nor did he build the entire theoretical edifice of modern AI. His contribution is of a different, yet decisive, nature: he brought those models closer to the hands of programmers, experimenters, and, indirectly, end users.

In other words, he helped shift AI from the remote world of servers to the computer on the desk.

This difference is enormous. As long as a model can only be used via the cloud, it remains, in some sense, external: powerful, certainly, but distant. It depends on a connection, a service, recurring costs, corporate policies, and externally imposed limits. When a model can run locally—even in a reduced or quantized form—the relationship with the technology changes. AI ceases to be merely a remote service and also becomes a personal tool: installable, studyable, and integrable into one's own programs.

This is where open source shows its full strength.

A locally executed model can be used more privately, because the data doesn't necessarily have to leave your computer. It can be integrated into artisanal, industrial, scientific, educational, or creative software. It can be modified, automated, encapsulated in a GUI, connected to measuring instruments, used in a laboratory, a workshop, an image archive, an embedded system, or a simple home program. This doesn't mean that every PC can run any model at the maximum possible quality; it does mean, however, that the boundary has shifted. What just a few years ago seemed reserved for specialized infrastructure can now be experimented with on common machines, with reasonable trade-offs.

One of the technical elements that made this leap possible is quantization. Put very simply, an AI model is composed of a vast quantity of numbers. These numbers represent the internal connections of the neural network—i.e., what the model "learned" during training. Usually, the more precisely these numbers are represented, the more memory they occupy. Quantization consists of representing them with fewer bits, reducing the model's size and making it easier to run on limited hardware. The price to pay may be a loss of precision, but often this loss is surprisingly contained compared to the gain in terms of memory and speed. Indeed, recent studies continue to analyze precisely the various quantization strategies used in the llama.cpp ecosystem, confirming their practical importance for local model execution.

This idea can be conveyed with a simple comparison. Imagine a large geographical atlas printed on luxury paper, enormous and highly detailed. It is beautiful, but difficult to carry around. Quantization is like creating a more compact version of that atlas: it won't have every minute detail of the original, but it will be precise enough to allow us to navigate, travel, and make decisions. It doesn't always replace the original, but it makes it usable in contexts where it would have been impossible before.

With GGML and llama.cpp, this philosophy has become concrete. The code is relatively lightweight, portable, compilable, and close to the metal. It is not merely a convenience for expert programmers: it is an architectural choice that has enabled the birth of an entire ecosystem. From these projects have sprung tools, graphical interfaces, local servers, wrappers for other languages, desktop applications, and integrations in the most diverse contexts. Not all users directly see GGML or llama.cpp, but countless tools that use local models owe something to that work.

The same applies to whisper.cpp, a C/C++ adaptation of the Whisper model for speech recognition. Here too, the idea is not just "transcribing audio," but making the technology more portable and more easily integrable. The whisper.cpp project states that the core implementation is contained in a few central files and relies on GGML as its computation library—a choice that highlights its philosophy: simplicity, control, portability. OpenAI had released Whisper as a multilingual speech recognition system trained on a large amount of audio data, but its transformation into a compact, local, and easily compilable tool opened the way to a vast array of practical applications.

Naturally, none of this is born in a vacuum. Modern AI is the result of an immense chain of contributions: academic research, large datasets, GPUs, training frameworks, neural architectures, industrial work, and the open-source community. It would be wrong to attribute the entire revolution to a single person. But it would be equally wrong to ignore those who built one of the most important bridges between research and everyday use.

Gerganov's value lies precisely in this bridge.

On one side are the large models, often developed by companies or research centers with enormous resources. On the other are the everyday programmers, advanced hobbyists, teachers, independent developers, small laboratories, and curious individuals. In between, something was needed to make those models less monumental and more manageable. A tool was needed that could say: "You don't necessarily need a data center. You can start here, from your computer."

This is technological democratization in the most concrete sense of the term.

It does not mean that everyone suddenly becomes an expert in neural networks. It does not mean that a small PC can compete with the largest commercial systems. It does mean, however, that many more people can try, understand, integrate, make mistakes, correct, and build. And it is precisely this way that a technology often becomes truly mature: not when it remains perfect and distant, but when it falls into the hands of those who use it to solve real problems.

Personal AI is thus born from two complementary movements. The first is that of large models, which require research, data, computational power, and enormous investments. The second is that of the tools that make them accessible, reducing the distance between the model and the user. Without the first movement, we wouldn't have modern artificial intelligence; without the second, we risk having it only as a closed service, controlled by a few.

In this perspective, open source is not a romantic detail. It is a cultural and technical infrastructure. It is the place where a discovery ceases to be merely the property of its creator and becomes building material for others. It is the workbench where an idea is taken apart, understood, reassembled, and carried elsewhere.

For this reason, Georgi Gerganov's work deserves attention. Not because he made AI magically simple, but because he made it closer. He helped transform it from a remote object into a software component, from an external service into a local possibility, from a technology endured into a technology that can be explored.

And perhaps this is the most important shift: when a technology becomes personal, it changes its nature. It is no longer just something we use. It becomes something we can build with.

Local AI will not necessarily replace the cloud, just as the personal computer did not erase large central systems. But, as happened back then, it shifts the center of gravity. It brings a portion of that power into the user's hands. It makes it possible to experiment without asking for permission. And it returns to the programmer, the technician, the tinkerer, and the independent researcher that creative freedom which is often the true engine of innovation.

Ultimately, the history of computer science has shown this many times: when a technology steps down from its pedestal and arrives on the workbench, the revolution truly begins.

È in questo contesto che entra in scena Georgi Gerganov, un nome ancora sconosciuto al grande pubblico, ma molto importante per chi oggi lavora con modelli di intelligenza artificiale eseguiti localmente. Gerganov è l’autore e il principale promotore di progetti open source come GGML, llama.cpp e whisper.cpp, strumenti scritti prevalentemente in C/C++ e pensati per rendere possibile l’esecuzione di modelli AI su hardware molto più comune rispetto alle infrastrutture tipiche dei grandi laboratori. Il progetto llama.cpp dichiara esplicitamente come obiettivo l’inferenza di modelli linguistici con configurazione minima e alte prestazioni su un’ampia varietà di hardware locale.

Il punto fondamentale è questo: Gerganov non ha inventato i transformer, non ha addestrato da zero i modelli linguistici più potenti e non ha costruito l’intero edificio teorico dell’AI moderna. Il suo contributo è stato di natura diversa, ma decisivo: ha reso quei modelli più vicini alle mani dei programmatori, degli sperimentatori e, indirettamente, degli utenti finali.

In altre parole, ha contribuito a spostare l’AI dal mondo remoto dei server al computer sulla scrivania.

Questa differenza è enorme. Finché un modello può essere usato soltanto tramite cloud, esso resta in qualche modo esterno: potente, certo, ma distante. Dipende da una connessione, da un servizio, da costi ricorrenti, da politiche aziendali, da limiti imposti dall’esterno. Quando invece un modello può girare localmente, anche solo in forma ridotta o quantizzata, cambia il rapporto con la tecnologia. L’AI smette di essere soltanto un servizio remoto e diventa anche uno strumento personale, installabile, studiabile, integrabile nei propri programmi.

È qui che l’open source mostra tutta la sua forza.

Un modello eseguito in locale può essere usato in modo più privato, perché i dati non devono necessariamente uscire dal proprio computer. Può essere integrato in software artigianali, industriali, scientifici, didattici o creativi. Può essere modificato, automatizzato, incapsulato in una GUI, collegato a strumenti di misura, usato in laboratorio, in officina, in un archivio di immagini, in un sistema embedded o in un semplice programma domestico. Questo non significa che ogni PC possa eseguire qualunque modello alla massima qualità possibile; significa però che il confine si è spostato. Ciò che pochi anni fa sembrava riservato a infrastrutture specialistiche oggi può essere sperimentato anche su macchine comuni, con compromessi ragionevoli.

Uno degli elementi tecnici che ha reso possibile questo salto è la quantizzazione. Detto in modo molto semplice, un modello AI è composto da un’enorme quantità di numeri. Questi numeri rappresentano le connessioni interne della rete neurale, cioè ciò che il modello ha “imparato” durante l’addestramento. Normalmente, più questi numeri sono rappresentati con precisione, più memoria occupano. La quantizzazione consiste nel rappresentarli con meno bit, riducendo la dimensione del modello e rendendone più facile l’esecuzione su hardware limitato. Il prezzo da pagare può essere una perdita di precisione, ma spesso questa perdita è sorprendentemente contenuta rispetto al vantaggio ottenuto in termini di memoria e velocità. Studi recenti continuano infatti ad analizzare proprio le diverse strategie di quantizzazione usate nell’ecosistema llama.cpp, a conferma della loro importanza pratica per l’esecuzione locale dei modelli.

Questa idea può essere resa con un paragone semplice. Immaginiamo un grande atlante geografico stampato su carta di lusso, enorme e dettagliatissimo. È bellissimo, ma difficile da portare con sé. La quantizzazione è come creare una versione più compatta di quell’atlante: non avrà ogni minimo dettaglio della versione originale, ma sarà abbastanza precisa da permetterci di orientarci, viaggiare e prendere decisioni. Non sostituisce sempre l’originale, ma lo rende utilizzabile in contesti dove prima sarebbe stato impossibile.

Con GGML e llama.cpp, questa filosofia è diventata concreta. Il codice è relativamente leggero, portabile, compilabile, vicino al metallo. Non è soltanto una comodità per programmatori esperti: è una scelta architetturale che ha permesso la nascita di un intero ecosistema. Da questi progetti sono derivati strumenti, interfacce grafiche, server locali, wrapper per altri linguaggi, applicazioni desktop e integrazioni nei contesti più diversi. Non tutti gli utenti vedono direttamente GGML o llama.cpp, ma moltissimi strumenti che usano modelli locali devono qualcosa a quel lavoro.

Lo stesso discorso vale per whisper.cpp, adattamento in C/C++ del modello Whisper per il riconoscimento vocale. Anche qui l’idea non è soltanto “trascrivere audio”, ma rendere la tecnologia più portabile e più facilmente integrabile. Il progetto whisper.cpp dichiara che l’implementazione principale è contenuta in pochi file centrali e poggia su GGML come libreria di calcolo, scelta che ne evidenzia la filosofia: semplicità, controllo, portabilità. OpenAI aveva pubblicato Whisper come sistema di riconoscimento vocale multilingua addestrato su una grande quantità di dati audio, ma la trasformazione in uno strumento compatto, locale e facilmente compilabile ha aperto la strada a una quantità enorme di applicazioni pratiche.

Naturalmente, tutto questo non nasce nel vuoto. L’AI moderna è il risultato di una catena immensa di contributi: ricerca accademica, grandi dataset, GPU, framework di addestramento, architetture neurali, lavoro industriale, comunità open source. Sarebbe sbagliato attribuire a una singola persona il merito dell’intera rivoluzione. Ma sarebbe altrettanto sbagliato ignorare chi ha costruito uno dei ponti più importanti tra la ricerca e l’uso quotidiano.

Il valore di Gerganov sta proprio in questo ponte.

Da una parte ci sono i grandi modelli, spesso sviluppati da aziende o centri di ricerca con risorse enormi. Dall’altra ci sono i programmatori comuni, gli hobbisti evoluti, gli insegnanti, gli sviluppatori indipendenti, i piccoli laboratori, le persone curiose. In mezzo serviva qualcosa che rendesse quei modelli meno monumentali e più maneggevoli. Serviva uno strumento capace di dire: “Non devi per forza avere un data center. Puoi iniziare da qui, dal tuo computer”.

Questa è democratizzazione tecnologica nel senso più concreto del termine.

Non significa che tutti diventino improvvisamente esperti di reti neurali. Non significa che un piccolo PC possa competere con i più grandi sistemi commerciali. Significa però che molte più persone possono provare, capire, integrare, sbagliare, correggere, costruire. Ed è proprio così che spesso una tecnologia diventa davvero matura: non quando resta perfetta e distante, ma quando entra nelle mani di chi la usa per risolvere problemi reali.

L’AI personale nasce quindi da due movimenti complementari. Il primo è quello dei grandi modelli, che richiedono ricerca, dati, potenza di calcolo e investimenti enormi. Il secondo è quello degli strumenti che li rendono accessibili, riducendo la distanza tra il modello e l’utente. Senza il primo movimento non avremmo l’intelligenza artificiale moderna; senza il secondo, rischieremmo di averla soltanto come servizio chiuso, controllato da pochi.

In questa prospettiva, l’open source non è un dettaglio romantico. È una infrastruttura culturale e tecnica. È il luogo in cui una scoperta smette di essere soltanto proprietà di chi l’ha prodotta e diventa materiale da costruzione per altri. È il banco da lavoro dove un’idea viene smontata, capita, ricomposta e portata altrove.

Per questo il lavoro di Georgi Gerganov merita attenzione. Non perché abbia reso l’AI magicamente semplice, ma perché l’ha resa più vicina. Ha contribuito a trasformarla da oggetto remoto a componente software, da servizio esterno a possibilità locale, da tecnologia subita a tecnologia esplorabile.

E forse è proprio questo il passaggio più importante: quando una tecnologia diventa personale, cambia natura. Non è più soltanto qualcosa che usiamo. Diventa qualcosa con cui possiamo costruire.

L’AI locale non sostituirà necessariamente il cloud, così come il personal computer non cancellò i grandi sistemi centrali. Ma, come avvenne allora, cambia il baricentro. Porta una parte della potenza nelle mani dell’utente. Rende possibile sperimentare senza chiedere permesso. E restituisce al programmatore, al tecnico, al curioso e al ricercatore indipendente quella libertà creativa che spesso è il vero motore dell’innovazione.

In fondo, la storia dell’informatica lo ha già mostrato molte volte: quando una tecnologia scende dal piedistallo e arriva sul banco di lavoro, comincia davvero la rivoluzione.