Qwen 3.6 31B: il primo vero salto di qualità

Il modello che per me ha segnato la svolta è Qwen 3.6 31B. Non è la potenza bruta in sé a colpire, quanto la qualità delle rielaborazioni che la community ha saputo tirarne fuori.

Due versioni GGUF mi hanno impressionato particolarmente:

• La build di Unsloth (Qwen3.6-35B-A3B-GGUF), solida e ben ottimizzata per l’inferenza locale.
• La versione di ByteShape (Qwen3.6-35B-A3B-MTP-GGUF), che sfrutta il Multi-Token Prediction con risultati sorprendenti.

Nei miei test di coding e debug, entrambe le versioni si comportano molto bene, specialmente se abbinate all’harness ufficiale Qwen Code (qwen.ai/qwencode). La combinazione modello-tooling fa davvero la differenza: non basta un buon modello, serve un ecosistema che lo sappia sfruttare.

Agent A1: quando il locale sfida (davvero) il cloud

Se Qwen 3.6 mi aveva già convinto, oggi ho provato qualcosa che alza ulteriormente l’asticella: Agent A1 di InternScience (huggingface.co/InternScience/Agents-A1). I benchmark che presenta lo pongono a un livello paragonabile a modelli closed source molto più grandi, e non è la prima volta che vedo un modello “piccolo” (in senso relativo) tenere testa a giganti da centinaia di miliardi di parametri.

È il tipo di risultato che ti fa fermare un attimo e chiederti: dove sta andando davvero questo settore?

La domanda da un milione (di dollari, letteralmente)

Questo mi porta alla domanda che mi frulla in testa da settimane: chi vincerà, alla fine, tra cloud e inferenza locale?

Da una parte, il cloud closed source vive ancora una fase “dorata” grazie ai capitali enormi investiti da attori come OpenAI, Anthropic e compagnia. Questo ha reso possibile offrire inferenza a prezzi vantaggiosi, spesso sussidiati, pur di conquistare quote di mercato. È un classico schema da economia digitale: brucia cassa oggi, guadagna posizione domani.

Dall’altra parte, l’inferenza locale sta crescendo a una velocità sorprendente, ma per motivi completamente diversi: non capitali enormi, bensì ottimizzazione pura. Quantizzazione, tecniche come MTP, architetture MoE sempre più efficienti: tutto questo sta permettendo a hardware consumer di fare cose impensabili solo un paio di anni fa.

Al momento, il cloud vince ancora, e probabilmente vincerà ancora per un po’. Ma la vera domanda è cosa succederà quando il mercato selezionerà un vincitore (o pochi vincitori) tra i provider closed source. In quel momento, chi resterà in piedi dovrà necessariamente far pagare l’inferenza a un prezzo che rifletta davvero i costi (e gli investimenti da recuperare). È lì che si aprirà la vera partita.

Se a quel punto l’hardware consumer sarà abbastanza potente, e i modelli open abbastanza ottimizzati, avremo finalmente un’alternativa concreta e sostenibile al cloud a pagamento. Non lo so con certezza, ma spero che il ritmo di miglioramento dei modelli open continui così: non tanto per “battere” il cloud, quanto per garantire che un’alternativa esista sempre. Perché in un mercato senza alternative, alla fine, a pagare il conto siamo sempre noi.

Chi se lo ricorda sa di cosa parlo: un modo semplice per salvare i segnalibri, taggarli, e condividerli con altri. Quando Delicious ha chiuso i battenti, ho passato anni a provare alternative — estensioni, servizi cloud, note app riadattate — senza trovare niente che replicasse quel flusso naturale: trovo un sito interessante, lo salvo con un click, lo condivido con chi mi segue. Alla fine ho deciso di risolvere il problema alla vecchia maniera: scrivendomi l’alternativa da solo.

È nato così BookmarkFox, un’estensione per Firefox che comunica con un backend web per pubblicare i segnalibri. Niente di rivoluzionario nell’idea, ma è esattamente quello che mi serviva — e visto che non esisteva, l’ho costruito.

Il problema: nessuna vera alternativa a Delicious

Le opzioni moderne per gestire segnalibri condivisibili sono o troppo pesanti (servizi enterprise di bookmarking/knowledge management) o troppo chiuse in un ecosistema (salvataggi legati a un singolo social o browser). Mancava qualcosa di leggero, personale, e soprattutto self-hosted: un’estensione che facesse una cosa sola, bene, e che mi lasciasse controllo pieno sui dati.

BookmarkFox nasce da questa esigenza precisa: un’estensione Firefox minimale che pubblica i segnalibri su un backend che gestisco io, raggiungibile su bookmarkfox.b0sh.net.

Come ho lavorato: SpecKit invece del solito “vibe coding”

La parte che mi interessa raccontare di più, però, non è il “cosa” ma il “come”. Negli ultimi tempi ho sviluppato diversi progettini con l’aiuto di modelli AI locali o via API, e il pattern tipico è quello del prompt libero seguito da iterazioni a ruota libera. Funziona, ma con progetti che superano una certa complessità il modello perde il filo, e tu perdi tempo a rispiegare il contesto ogni volta.

Per BookmarkFox ho voluto provare un approccio più strutturato, usando GitHub SpecKit insieme a OpenCode. L’idea di SpecKit è semplice ma efficace:

• Si parte da un prompt utente ad alto livello (l’idea del progetto).
• SpecKit guida una fase di analisi dettagliata, trasformando l’idea grezza in una specifica vera e propria.
• C’è una fase di clarification: il sistema pone domande specifiche per chiarire ambiguità prima di scrivere codice, invece di assumere e sbagliare.
• Solo dopo la specifica viene suddivisa in task ben definiti, ognuno con un perimetro chiaro.

Il vantaggio pratico? Un modello non enorme — nel mio caso DeepSeek V4 Flash, con 250k di contesto — riesce a lavorare bene su singole task senza dover tenere “in mente” tutta l’architettura del progetto contemporaneamente. Ogni task è autoconclusiva, con contesto sufficiente ma non eccessivo. Il risultato è un workflow più prevedibile, meno “allucinazioni” da perdita di contesto, e codice più coerente con l’architettura pensata a monte.

È un cambio di paradigma interessante: non si tratta di usare un modello più potente, ma di strutturare meglio il problema perché anche un modello più leggero possa affrontarlo con efficacia. Per chi lavora con LLM locali o con budget di context window limitati, è una lezione che vale la pena portarsi a casa.

Il risultato

BookmarkFox oggi è operativo:

• L’estensione è scaricabile dalle release su GitHub.
• Il backend che gestisce la pubblicazione dei segnalibri è live su bookmarkfox.b0sh.net.
• Il codice è open source, disponibile per chiunque voglia guardare sotto il cofano, contribuire, o semplicemente farsi un’idea di come è stato strutturato il progetto con SpecKit.

Non è (ancora) Delicious 2.0, ma è già quello che mi serviva: un modo veloce per salvare e condividere i siti interessanti che trovo in giro, senza dipendere da un servizio terzo che può chiudere domani.

Cosa mi porto a casa

Al di là del progetto in sé, l’esperienza con SpecKit mi ha convinto che il futuro dell’AI-assisted coding per progetti non banali passa da qui: meno prompt-e-spera, più analisi-chiarifica-scomponi. È un investimento di tempo iniziale che si ripaga abbondantemente quando il progetto cresce oltre le due-tre funzioni.

Se usi Firefox e ti manca un modo semplice per salvare e condividere segnalibri, dai un’occhiata a BookmarkFox. E se sei curioso di provare tu stesso il workflow SpecKit + LLM locale, è un ottimo punto di partenza per progetti di dimensioni simili.

Da allora ho lavorato molto sul progetto, aggiungendo funzionalità, migliorando la stabilità e rendendo tutto più facile da usare.

Da Ollama a Ollama e LM Studio

Una delle richiesta più comuni che ho visto in giro per progetti simili è la possibilità di usare backend diversi. Nel primo post parlavo solo di Ollama come backend AI. Ora lo strumento supporta anche LM Studio, con API OpenAI-compatibili.

Che significa, in pratica? Se desideri avere più controllo e scelta di modelli, puoi usare LM Studio senza cambiare nulla nel flusso di lavoro. Nell’interfaccia web e nella CLI il passaggio è trasparente: basta cambiare il backend nei parametri e puntare all’URL del server corretto.

Deduplicazione tempo e spazio, non solo semantica

Nel post originale parlavo di clustering semantico: le foto venivano raggruppate per similarità di descrizione e poi selezionate a rotazione per evitare ripetizioni. Funzionava, ma a volte finivo comunque con foto troppo simili, scattate nello stesso istante e nella stessa posizione.

Ho aggiunto un secondo livello di deduplicazione temporale e geografica. Dopo la selezione iniziale, lo strumento rimuove automaticamente le foto che sono entro 30 secondi e 100 metri l’una dall’altra, tenendo sempre quella con il ranking estetico migliore.

Il risultato è un album più vario, con meno “serie di foto quasi identiche” e più momenti distinti.

Logging professionale con Logback

Il primo prototipo scriveva log in modo un po’ artigianale, spesso su stdout o in file senza gestione. Per un tool che può girare automaticamente su grandi archivi, serve qualcosa di più robusto.

Ora il progetto usa Logback con:

• logging su file (logs/photoprism-ai.log)
• rotazione giornaliera
• retention di 7 giorni
• nessun output su stdout, tranne barre di progresso essenziali

Nel log trovi:

• prompt di clustering (DEBUG)
• rimozioni per dedup temporale/spaziale (INFO)
• nomi dei cluster finali (INFO)

Prompt emozionale e descrizioni più ricche

Uno dei problemi iniziali era che il modello multimodale produceva descrizioni troppo brevi o generiche, il che rendeva il clustering meno efficace.

Ho:

• aumentato la descrizione a 30 parole per ogni foto
• introdotto un prompt emozionale più ricco, per spingere il modello a valutare anche composizione, originalità e “atmosfera”, non solo要素 tecnici

Il clustering ne beneficia molto: le categorie sono più pulite e coerenti.

Batch, thread e performance

Nel primo post parlavo di timeout e latenza come principali colli di bottiglia. Ho fatto diversi affini:

• batch da 30 richieste per il clustering
• 3 thread per il processing parallelo
• caching più intelligente di takenAt, titolo, coordinate e luogo
• retry automatico 3× per le chiamate AI in caso di errore

Questi cambiamenti hanno reso il tool più stabile e veloce, soprattutto su archivi grandi.

Barra di progresso e Web UI

La CLI funziona bene, ma per molti utenti un’interfaccia visuale è più comoda. Ho quindi sviluppato una Web UI leggera con:

• Javalin come server embedded
• HTMX per dinamicità senza scrivere JavaScript complesso
• una barra di progresso per il clustering, con conteggio batch in tempo reale

La Web UI permette di:

• scegliere mese singolo o anno intero
• specificare quante foto selezionare
• personalizzare il prompt di valutazione
• scegliere il nome dell’album

Il form è semplice, ma copre tutti i casi d’uso principali.

Modalità anno intero

Nel post originale parlavo solo di selezione per mese. Ora c’è anche una modalità anno intero: lo strumento processa tutti i 12 mesi in sequenza, accumulando le foto migliori di ogni mese in un unico album annuale.

È utile per creare album tipo “Best of 2025” o “Viaggi 2025” senza dover lanciare manualmente 12 selezioni separate.

Cache arricchita e pool temporaneo

La cache (ai-cache.json) ora conserva per ogni foto:

• score estetico
• descrizione generata dall’AI
• cluster assegnato
• titolo, coordinate, takenAt, placeLabel, placeCity, placeState, placeCountry

Il pool temporaneo pre-dedup viene salvato in {albumName}.json, utile per debug e analisi.

CLI più flessibile

Oltre alla Web UI, la CLI è più potente:

bash# Mese singolo
java -jar target/photoprism-ai-curator-1.0.1.jar \
  --no-web --mode month --month 1 --year 2026 \
  --count 20 --album "Mia Selezione"

# Anno intero
java -jar target/photoprism-ai-curator-1.0.1.jar \
  --no-web --mode year --year 2026 \
  --count 20 --album "Best of 2026"

# Prompt personalizzato
java -jar target/photoprism-ai-curator-1.0.1.jar \
  --no-web --mode month --month 1 --year 2026 \
  --count 20 \
  --prompt "Rate composition and originality"

Sono disponibili flag per:

• percorso del config file
• forzatura modalità CLI
• modalità mese/anno
• mese, anno, conteggio foto
• nome album
• prompt di valutazione

Struttura del progetto

Il progetto è ora più maturo e meglio organizzato:

• AiBackend come interfaccia comune per rating e clustering
• OllamaClient e LmStudioClient come implementazioni separate
• PhotoFetcher, AISelector, AlbumManager, ImageHasher come servizi puliti
• WebServer con Javalin + HTMX
• JobContext per lo stato thread-safe dei job

Tutto il codice è in Java 17+, con Maven, JUnit 5 e Mockito per i test.

Perché questi aggiornamenti contano

Per me, il punto non è solo automatizzare una classifica di bellezza. Il vero valore sta nel:

• combinare giudizio estetico, varietà narrativa e vincoli pratici
• gestire cache, timeout e costi computazionali in modo intelligente
• offrire un’alternativa locale e controllabile ai servizi cloud per la selezione foto

Con LM Studio, dedup tempo/spazio, Logback, Web UI e modalità anno intero, ritengo che il progetto sia oggi molto più pronto per l’uso quotidiano.

Tutti i dettagli tecnici, commit e modifiche sono disponibili su GitHub.
La commit history è qui: https://github.com/b0sh-net/photoprism-ai-curator/commits/master/.

Da qui è nata l’idea di un selezionatore AI: una piccola applicazione Java che usa PhotoPrism per recuperare le miniature delle immagini e Ollama per far lavorare due modelli AI, uno multimodale per assegnare un punteggio estetico e produrre una descrizione oggettiva, e un secondo modello testuale per raggruppare semanticamente le foto e selezionarle con più equilibrio.

Il problema vero non era la qualità

Il primo prototipo faceva una cosa molto semplice: prendere le foto da PhotoPrism, inviarle a un modello multimodale su Ollama e chiedere un voto estetico da 1 a 100 insieme a una breve descrizione. Sulla carta sembrava sufficiente, ma in pratica produceva una selezione monotona: immagini molto belle singolarmente, ma spesso troppo simili tra loro.

Era il classico caso in cui un ranking puro ottimizza la qualità locale ma non la copertura narrativa. Se cinque foto dello stesso scorcio o dello stesso momento ricevono voti alti, un algoritmo ingenuo tende a sceglierle tutte. Per costruire un album da condividere, invece, non basta premiare le immagini migliori: bisogna anche evitare la ripetizione.

Dalla classifica ai cluster

La seconda iterazione ha quindi cambiato approccio. Invece di trattare il problema come una semplice classifica, il tool ha iniziato a ragionare per gruppi: ogni foto riceve una descrizione oggettiva dal modello visivo, e queste descrizioni vengono poi analizzate da un secondo modello text-only per creare cluster di immagini semanticamente simili.

In questo modo la selezione finale non è più dominata da un unico soggetto o da una sola scena. Il sistema sceglie a rotazione le migliori foto da cluster diversi, così da conservare un livello qualitativo alto senza sacrificare la varietà. È un cambiamento piccolo da spiegare, ma sostanziale nel risultato: da “le più belle” a “le più belle che, insieme, raccontano meglio il viaggio”.

Il collo di bottiglia era la latenza

La parte più difficile non è stata immaginare la pipeline, ma farla funzionare in tempi accettabili. Creare i cluster su un numero elevato di immagini si è rivelato più costoso del previsto, soprattutto per il tempo necessario a far processare le descrizioni dal modello. Per questo la pipeline è stata spezzata in blocchi parziali, poi riunificati in una fase finale di merge, così da ridurre il costo operativo del clustering su un set grande.

Anche così, però, i timeout continuavano a essere un problema reale. La svolta è arrivata intervenendo direttamente sulle chiamate verso Ollama: per il modello dedicato al clustering è stata disabilitata la fase di thinking, usando richieste batch con think:false, così da evitare lunghi passaggi riflessivi non necessari per questo tipo di compito. È stata la scelta risolutiva, soprattutto con i modelli Qwen, che tendono ad avere una fase riflessiva di default piuttosto lunga.

Cosa fa la prima beta

La prima beta, pubblicata come PhotoPrism AI Curator, automatizza l’intero flusso: scarica le miniature delle foto da PhotoPrism, invia ciascuna miniatura a Ollama con un modello multimodale per ottenere un punteggio estetico e una descrizione, raggruppa le immagini per similarità semantica tramite un secondo modello text-only, seleziona a rotazione le migliori da ciascun gruppo e crea infine un album direttamente in PhotoPrism. Questa architettura è coerente con le capacità offerte da PhotoPrism per organizzazione, persone e label, e con il ruolo di Ollama come runtime locale per modelli diversi nello stesso workflow.

Il progetto include anche una modalità “anno intero”, che processa tutti i dodici mesi in sequenza e accumula le migliori foto mensili in un unico album annuale. È una funzione semplice da descrivere ma molto pratica per chi usa PhotoPrism come archivio personale continuo e non vuole lavorare manualmente mese per mese.

Stack e funzionamento

Dal punto di vista tecnico, il progetto richiede Java 17+, Maven, un’istanza PhotoPrism con API attiva e Ollama con almeno due modelli: uno multimodale per l’analisi visiva, come minicpm-v, llava o moondream, e uno text-only per il clustering delle descrizioni, come qwen3.5:4b o llama3.2:3b. In alternativa è possibile usare un solo modello capace di gestire sia input visivi sia generazione testuale pura, ma l’architettura pensata per la beta separa chiaramente valutazione estetica e clustering semantico.

L’applicazione si compila con Maven, legge la configurazione da config.properties e consente di impostare URL e token di PhotoPrism, endpoint Ollama, modelli da usare, prompt di valutazione, file di cache e timeout per connessione, rating e clustering. Il fatto di mantenere una cache locale delle valutazioni in ai-cache.json è importante, perché evita di ripetere inferenze costose su immagini già processate e rende molto più sopportabile l’uso iterativo durante i test.

Web UI invece di solo CLI

Un aspetto interessante della beta è che non si ferma alla linea di comando. Il progetto espone anche una piccola interfaccia web embedded, avviabile direttamente dal JAR, costruita con Javalin lato server e HTMX nel frontend, una scelta leggera ma molto sensata per questo tipo di utility locale. L’interfaccia permette di scegliere se elaborare un mese singolo o l’intero anno, indicare quante foto selezionare, personalizzare il prompt di valutazione e decidere il nome dell’album finale.

Questa parte è importante anche narrativamente, perché mostra che il progetto non è solo una prova tecnica. C’è già il tentativo di trasformare uno script nato per uso personale in uno strumento riutilizzabile, con uno stato di job thread-safe e una UX minima ma concreta.

Struttura del progetto

La struttura del repository rende abbastanza chiara l’evoluzione del tool. I client separano le API di PhotoPrism e Ollama, i service isolano fetch delle foto, logica di selezione, hashing e gestione degli album, mentre il pacchetto web contiene il server e il contesto di esecuzione dei job. È una divisione ordinata che aiuta a leggere il progetto come una pipeline composta da fasi distinte: raccolta, valutazione, raggruppamento, selezione, pubblicazione.

In breve, l’albero principale comprende App.java come entry point, una configurazione dedicata, model per foto e album, client per PhotoPrism e Ollama, service per selezione e gestione operativa, e una web UI HTMX servita da Javalin. Anche la scelta di usare JUnit 5 e Mockito per i test indica che la beta non è soltanto un esperimento estemporaneo, ma un progetto già pensato per crescere.

Perché mi interessava davvero

La cosa più interessante di questo progetto non è tanto aver fatto scegliere delle foto a un’AI. Il punto è aver trasformato un problema quotidiano e noioso — rientrare da un viaggio e dover setacciare centinaia di immagini quasi uguali — in una pipeline locale, controllabile e compatibile con strumenti self-hosted già esistenti.

PhotoPrism sa già dove sono state scattate le foto, chi compare nelle immagini e quali label possono descriverle, ma il salto verso una vera selezione richiede qualcosa in più: un giudizio estetico, una nozione minima di varietà e una serie di compromessi pratici su latenza, timeout e costo computazionale. È proprio in quel punto, tra metadata e gusto, che questo selezionatore AI prova a inserirsi.

Come provarlo

Per compilare la beta basta clonare il repository, copiare config.properties.example in config.properties, inserire i dati della propria istanza PhotoPrism e di Ollama e lanciare mvn clean package. A quel punto si può avviare il JAR in modalità web oppure usare la CLI con il file di configurazione passato esplicitamente.

bashgit clone <url-repo>
cd photoprism-ai-curator
cp config.properties.example config.properties
# modifica config.properties con i tuoi dati
mvn clean package
java -jar target/photoprism-ai-curator-1.0.0.jar

Una volta aperta l’interfaccia web su http://localhost:8080, il flusso è lineare: scegliere il periodo, indicare il numero di foto desiderate, adattare eventualmente il prompt di valutazione e lasciare che il sistema costruisca l’album finale dentro PhotoPrism.

Cosa può diventare

Questa prima beta risolve già il problema più concreto: ridurre una massa di foto a una selezione più pulita, più varia e più condivisibile. Ma lascia intravedere sviluppi interessanti, come criteri di selezione personalizzabili per tipo di viaggio, un bilanciamento più esplicito tra soggetti, luoghi e momenti, oppure un uso più intelligente dei metadata di PhotoPrism per influenzare il clustering e la rotazione finale.

Il progetto è già disponibile in una prima beta su GitHub, qui: b0sh-net/photoprism-ai-curator. Dentro al repository ci sono codice, istruzioni di compilazione, configurazione di PhotoPrism e Ollama, oltre alla piccola interfaccia web che ho costruito per rendere il flusso più comodo da usare.

La prova più interessante non è stata nemmeno il primo avvio fallito su Fedora in VM, ma il confronto tra ambienti diversi. Su una macchina fisica Windows con GPU, OpenHuman parte; appena si entra nel flusso di configurazione, però, emergono subito domande poco rassicuranti: login cloud richiesto, collegamento Gmail mediato da un servizio terzo, e una catena di dipendenze che rende il concetto di “locale” molto più sfumato di quanto il marketing lasci intendere.

Un progetto che promette molto

OpenHuman si presenta come un assistente personale AI locale, capace di integrarsi con servizi esterni, gestire memoria e collegarsi a modelli LLM sia in locale sia in cloud. Il pitch è forte: un agente “human-centric”, pronto a conoscersi in pochi minuti e a diventare parte del flusso di lavoro quotidiano.

Ed è proprio qui che nasce il problema. Più la promessa è ambiziosa, più ci si aspetta che il setup sia semplice, trasparente e affidabile. Invece la mia esperienza è stata l’opposto: ogni passo sembrava introdurre un nuovo livello di complessità, spesso non spiegato bene all’utente.

Fedora in VM: crash, errori e packaging fragile

Il primo test è stato su Fedora in macchina virtuale. Qui OpenHuman ha mostrato subito il suo lato più fragile. L’installazione è partita velocemente, ma all’avvio il programma non è riuscito a completare il bootstrap in modo stabile. I log hanno iniziato a restituire errori diversi a ogni tentativo, e questo è già di per sé un pessimo segnale.

Tra i messaggi più significativi c’erano:

textVMware: No 3D enabled

e soprattutto:

textError initializing NSS with a persistent database
version `NSSUTIL_3.108' not found
FATAL: nss_error=-5925

In pratica, il pacchetto distribuiva librerie incompatibili con quelle presenti sul sistema. Il risultato non era solo un crash, ma un crash dovuto a un conflitto abbastanza banale da sembrare quasi un errore di packaging elementare. Ho provato anche a forzare l’esecuzione con estrazione manuale dell’AppImage, variabili ambientali diverse e disabilitazione della GPU, ma senza successo.

A quel punto il problema non era più il singolo workaround: era il fatto che il software, su una configurazione abbastanza comune come Fedora in VM, falliva in modo ripetuto e poco affidabile.

Windows con GPU: parte, ma non convince

Su una macchina fisica Windows con GPU, OpenHuman si installa e si avvia. Questo però non ha risolto il mio giudizio, anzi lo ha reso più netto. La prima sorpresa è stata la richiesta di un login cloud già al primo avvio, cosa che stride parecchio con l’immagine di applicazione locale e privacy-oriented.

Poi è arrivata la richiesta di collegare Gmail attraverso un target chiamato Composio. Il problema non è solo tecnico, ma concettuale: non viene spiegato chiaramente perché un software che si presenta come locale debba passare da una terza parte esterna per accedere alle mail. Per me questa è una soglia di fiducia importante, e senza una spiegazione trasparente il risultato è un semplice “no”.

Skip sì, utilità poca

C’è un pulsante tipo “skip for now”, quindi in teoria si può andare avanti anche senza concedere tutto subito. In pratica bisogna insistere un po’, ma alla fine si entra davvero nell’app.

Il punto è un altro: se rifiuti di dare accesso a terze parti, OpenHuman resta davvero utile? Questa è la domanda centrale. Perché le funzioni più interessanti sembrano vivere proprio nel punto di incontro tra app locale, account cloud e servizi esterni. Se togli quella parte, resta un guscio molto meno significativo rispetto a quanto il progetto promette.

Ollama, Open WebUI e OpenRouter: altre prove fallite

A questo punto ho provato a portare il tutto sul terreno più favorevole possibile: accesso LLM locale via Ollama, poi Open WebUI come eventuale router/proxy, e infine OpenRouter per testare anche una strada cloud.

Il risultato è stato sempre negativo. Con Ollama non arrivava nessuna risposta in chat e ollama ps non mostrava modelli caricati. Con Open WebUI, usando impostazioni che con altre applicazioni funzionano correttamente, il backend restava silenzioso. Con OpenRouter non è cambiato nulla: le richieste non apparivano neppure nei log.

Questo è stato probabilmente il segnale più chiaro di tutti. Non si tratta di un singolo provider da sistemare o di una configurazione da rifinire. Il problema sembra stare nel modo in cui OpenHuman orchestra il tutto: integrazione, routing, backend, richieste. Se la pipeline non produce neppure tracce nei log, la sensazione è che la superficie sia più avanzata della sostanza.

Perché tante stelline?

La domanda, a questo punto, viene naturale: come fa un software così approssimativo a ottenere tante stelline su GitHub?

La risposta probabilmente non è misteriosa: oggi molti progetti AI vendono prima l’idea e solo dopo il prodotto. Bastano un README convincente, una roadmap ambiziosa, qualche schermata accattivante e un paio di video ben fatti per generare entusiasmo. In molti casi il pubblico non prova davvero il software in scenari normali, oppure lo fa per pochi minuti in condizioni ideali.

OpenHuman mi sembra rientrare proprio in questa categoria: molto forte sul piano narrativo, molto più debole nella prova concreta. E quando il marketing corre parecchio avanti rispetto alla maturità reale del codice, le stelline diventano un indicatore meno affidabile di quanto sembri.

Verdetto attuale

Per ora la valutazione è negativa. Non perché il progetto sia “senza idea”, ma perché l’idea è venduta come se fosse già matura, mentre nella pratica l’esperienza è fragile, poco trasparente e inadatta a un uso sereno.

Il test su Fedora in VM è fallito. Il test su Windows è partito ma ha introdotto dubbi sostanziali sulla privacy e sulle dipendenze cloud. I tentativi con Ollama, Open WebUI e OpenRouter non hanno migliorato il quadro. Il risultato complessivo è un software che promette molto, ma che al momento convince poco.

Disinstallerò OpenHuman e disconnetterò l’account. Per ora, almeno nel mio uso, resta un progetto interessante da osservare, ma non ancora uno strumento davvero affidabile.

Ma ultimamente mi sono fatto una domanda: ha ancora senso usare N8N nel 2026, ora che gli strumenti di codifica AI sono diventati così potenti?

L’esperimento

Avevo un workflow N8N che usavo per trascrivere e sintetizzare registrazioni video — niente di esoterico, ma un processo abbastanza articolato: estrazione audio, chiamata a un modello di trascrizione, sintesi con un LLM, output strutturato. Funzionava, ma con i suoi limiti: dimensione massima dei file in ingresso, dipendenza dall’infrastruttura N8N, e quella sensazione di lavorare “dentro una scatola”.

Ho deciso di provare a riscrivere l’intero flusso come programma standalone. Gli strumenti? Gemini CLI come agente di codifica, il JSON del workflow N8N come specifica di partenza, e un prompt abbastanza dettagliato su cosa volessi ottenere.

Il risultato (che mi ha sorpreso)

In poche decine di minuti avevo un programma funzionante da riga di comando. Non un prototipo traballante: un tool che funziona meglio del workflow N8N originale, senza i limiti sulla dimensione dei file e con un controllo molto più diretto su ogni fase del processo.

Ho scelto deliberatamente la CLI perché l’uso che immagino è locale e sporadico — nessun senso di tirar su un’infrastruttura per qualcosa che uso una volta alla settimana. Ma sarebbe stato altrettanto semplice chiedere a Gemini CLI di generare un’app che espone un webservice: il delta di complessità sarebbe stato minimo.

La cosa che mi ha colpito di più non è tanto la velocità, ma quanto sia stato naturale usare il JSON di N8N come prompt implicito. Il workflow descriveva già la logica del processo in modo strutturato; Gemini ha semplicemente tradotto quella struttura in codice Java coerente e funzionante.

Cosa cambia (e cosa no)

N8N rimane uno strumento valido per certi scenari: team non tecnici, integrazioni con decine di servizi SaaS, processi che devono girare su scheduler senza infrastruttura dedicata. Non sto dicendo che sia morto.

Ma per chi sa usare il terminale e ha accesso a un buon agente di codifica AI, il vantaggio principale di N8N — abbassare la barriera tecnica — si è assottigliato enormemente. Il codice generato è leggibile, manutenibile, e non ha i vincoli architetturali di una piattaforma generalista.

Il codice è pubblico

Ho pubblicato tutto su GitHub: codice sorgente, workflow N8N originale e il prompt iniziale che ho passato a Gemini CLI.

github.com/b0sh-net/VideoToMemo

Se vuoi replicare l’esperimento o adattarlo a un tuo caso d’uso, tutto quello che ti serve è lì. Sono curioso di sapere se anche voi avete fatto ragionamenti simili su N8N o su altri strumenti di automazione visuale — scrivetemi nei commenti.

phone-whisper è un’app Android open source che ho sviluppato a partire da un fork di un progetto esistente, riprogettandola per fare una cosa sola ma fatta bene: trascrivere file audio condivisi direttamente sul dispositivo, in modo completamente locale.

Da dove nasce il progetto

Il punto di partenza è stato un progetto open source che sfruttava il riconoscimento vocale via microfono. L’idea di base mi piaceva, ma quello che mi serviva era diverso: volevo poter condividere un file audio da qualsiasi app — WhatsApp, Files, un registratore vocale — e ottenere la trascrizione in pochi secondi, tutto offline.

Ho quindi forkato il progetto e ho iniziato ad adattarlo, usando strumenti di intelligenza artificiale come Gemini CLI e Qwen Code per accelerare il refactoring e la riscrittura delle funzionalità principali. L’AI è stata preziosa per navigare una codebase che non conoscevo a fondo e per generare rapidamente le modifiche necessarie all’integrazione con il sistema di condivisione di Android.

Il debugging: quando la trascrizione locale non funzionava

Qui le cose si sono fatte interessanti. Il sistema di trascrizione locale del progetto originale non funzionava in modo affidabile — o meglio, non funzionava affatto nel mio caso. Dopo varie sessioni di debug, ho capito che la soluzione più stabile era integrare direttamente sherpa-onnx, una libreria di inferenza vocale offline estremamente performante, sviluppata dal team k2-fsa.

Il problema? Non potevo semplicemente aggiungere la dipendenza tramite Gradle come si farebbe normalmente. Ho dovuto includere la libreria direttamente come file .aar all’interno del progetto, per garantire compatibilità e controllo sulla versione esatta utilizzata.

E proprio le versioni sono state un altro grattacapo: l’ultima release di sherpa-onnx al momento dello sviluppo (la v1.12.39) aveva un’interfaccia pubblica diversa rispetto a quella pensata per il progetto originale. Questo ha richiesto ulteriori modifiche ai metodi di comunicazione tra i componenti, ma alla fine tutto ha trovato il suo posto.

Come funziona oggi

La release 0.4.4 è stabile e funzionante. Il flusso d’uso è semplice:

1. Condividi un file audio da qualsiasi app verso phone-whisper
2. L’app avvia la trascrizione in locale, senza connessione internet
3. Ottieni il testo trascritto direttamente sul dispositivo

Per ottenere i migliori risultati con audio in italiano, consiglio di utilizzare il modello Parakeet 0.6B: offre un ottimo equilibrio tra qualità della trascrizione e dimensioni del modello.

Una cosa importante sull’installazione del modello

Il primo avvio richiede il download e l’installazione del modello linguistico, che può richiedere qualche minuto. Non interrompere il processo: farlo potrebbe corrompere l’installazione e rendere l’app non funzionante. Se dovesse succedere, è necessario cancellare i dati dell’applicazione dalle impostazioni di Android per poter ripetere l’installazione da capo.

Conclusioni e link utili

phone-whisper nasce da un’esigenza reale, da un po’ di debugging ostinato e dall’aiuto — sempre più indispensabile — degli strumenti AI per muoversi velocemente in territorio inesplorato. È un progetto piccolo, ma funziona, è privato by design e gira interamente sul tuo telefono.

• Repository GitHub: github.com/b0sh-net/phone-whisper
• Release 0.4.4: github.com/b0sh-net/phone-whisper/releases/tag/0.4.4
• sherpa-onnx: github.com/k2-fsa/sherpa-onnx

Ho qualche dubbio sull’opportunità di pubblicare sullo store ufficiale … dovrei informarmi su burocrazia e costi.

L’Aero Club d’Italia (AECI) mette a disposizione un’applicazione desktop per simulare l’esame di conseguimento dell’attestato VDS (Volo da Diporto o Sportivo). Utile, certo – ma decisamente più comodo avere qualcosa in tasca, da usare anche lontano dalla scrivania. Non a caso esistono già alcune app per smartphone, tutte però a pagamento.

Ho voluto quindi fare un esperimento: quanto tempo ci vuole per replicare le funzionalità dell’app di AECI in formato mobile, usando un modello AI gratuito come strumento di sviluppo?

Il risultato

In circa una giornata di lavoro ho ottenuto un prototipo sostanzialmente funzionante. Lo strumento usato? Qwen 3 Plus, recentemente disponibile gratuitamente su OpenRouter, abbinato a Claude Code.

La qualità del modello è evidente: rispetto a Nemotron 3 Super rappresenta un netto passo avanti in termini di comprensione del contesto e qualità del codice generato. Poterlo usare gratuitamente sembra quasi troppo bello per essere vero – e probabilmente questa finestra non durerà a lungo. Consiglio di sfruttarla finché c’è.

Prova l’app (è open source)

Il codice è disponibile su GitHub: github.com/b0sh-net/vdsexamapp

Chiunque voglia provarla, migliorarla o creare opere derivate è il benvenuto. Il progetto è aperto a contributi e modifiche di ogni tipo.

Ho voluto quindi riprovare con Nemotron-Cascade-2, ma le sue richieste hardware si sono rivelate eccessive per la mia macchina. Incuriosito comunque dall’ecosistema di modelli NVIDIA, ho scoperto che Nemotron 3 Super è disponibile gratuitamente su OpenRouter — e ho deciso di metterlo alla prova con lo stesso compito.

Quasi 21 milioni di token dopo, e con una spesa effettiva di 0$, l’applicazione non è ancora priva di bug. Eppure, in qualche modo, sembra più vicina a qualcosa di concreto rispetto a quanto ottenuto con Qwen3.5. Il dettaglio più incoraggiante? Non si è ancora bloccato su un errore irrisolvibile. Con qualche altra sessione di test e qualche milione di token in più, potrebbe davvero riuscire a chiudere il lavoro.

Resta però evidente una cosa: siamo ancora molto lontani dall’idea romantica di “mi faccio un’app semplice, senza scrivere una riga di codice, in pochi minuti”. Forse ci proverò anche con Claude Sonnet, se mi avanza qualche credito a fine mese.

Il progetto è pubblico: puoi scaricarlo e testarlo sul repository GitHub.