OpenCode e le balene

Come sto usando i modelli forniti da opencode (free e non) paragonandoli ai modelli di frontiera

Data: 26 ott 2026 · 6 min di lettura

OpenCode e le balene

OpenCode: una settimana dopo, non me l'aspettavo

Uso agenti AI per programmare da un bel po' — ne ho provati parecchi, e onestamente pensavo di aver già visto tutto. Poi ho installato OpenCode per curiosità e, niente, dopo più di una settimana è ancora lì aperto nel mio terminale. Non scrivo spesso post del genere, ma quando un tool ti sorprende così vale la pena raccontarlo.

Cos'è

OpenCode è un agente di coding AI open source (licenza MIT). Il codice sta tutto su GitHub, e puoi usarlo in tre modi:

  • TUI — dentro il terminale, ed è la mia modalità preferita;
  • Desktop — app grafica nativa;
  • Web — tramite opencode pair.

La cosa che mi ha colpito subito è che non è un wrapper attorno a un singolo modello. È un client che si collega a qualsiasi provider ti pare: Anthropic, OpenAI, Google, Grok, modelli locali via Ollama, e una marea di altri. Tu porti le tue API key (o un modello locale gratuito), e lui fa il resto.

Come funziona

Qui c'è il punto che, secondo me, spiega perché la TUI mi sembra così "leggera": OpenCode è costruito come client-server.

flowchart LR
    subgraph client["Client (quello che vedi)"]
        TUI["TUI<br/>(terminale)"]
        DESK["Desktop"]
        WEB["Web"]
    end

    subgraph server["Servizio OpenCode (background)"]
        SESSIONS["Sessioni"]
        CONF["Config<br/>opencode.json"]
        PERM["Permessi"]
        TOOLS["Tool<br/>file · bash · grep · LSP"]
        MCP["Server MCP"]
    end

    PROVIDERS["Provider LLM<br/>Anthropic · OpenAI ·<br/>Google · Ollama · ..."]

    TUI -- "API HTTP" --> server
    DESK --> server
    WEB --> server
    TOOLS --> PROVIDERS
    server -- "richieste LLM" --> PROVIDERS

Quando avvii opencode, in realtà parte un servizio in background che si tiene tutto il lavoro pesante: sessioni, configurazione, plugin, permessi ed esecuzione dei tool. Le interfacce (TUI, desktop, web) sono solo client che parlano con quel servizio tramite una API HTTP. Le conseguenze pratiche sono tre:

  1. Puoi aprire la stessa sessione da più client, o staccarti e riprenderla dopo.
  2. La TUI resta reattiva anche mentre l'agente macina: non è lei a fare il lavoro.
  3. Puoi automatizzare tutto con opencode api o con l'SDK TypeScript ufficiale, visto che è solo HTTP.

Il ciclo di una richiesta

Quando gli scrivo qualcosa, succede questo:

  1. Il prompt va al modello configurato.
  2. L'agente decide se rispondere direttamente o usare i tool: leggere e modificare file, eseguire comandi, cercare nel codice, usare server MCP esterni.
  3. Le azioni "sensibili" passano dalle permissions: puoi fargli chiedere conferma prima di ogni comando, oppure dargli carta bianca. La decisione è tua.
  4. Il risultato dei tool torna al modello, che continua finché non ha finito davvero — non si ferma al primo punto "ragionevole" come tanti altri.

E tutto gira sul tuo filesystem locale: niente indexing del repo in cloud, lavora direttamente dove stai già lavorando tu. Il bello è che quasi ogni cosa è configurabile in un opencode.json ricaricato a caldo (agenti custom, comandi, plugin, skill, MCP) senza riavviare niente.

Free vs Go (la parte che tutti chiedono)

OpenCode di per sé è gratis e open source. Punto. Lo scarichi, ci metti le tue API key (o un modello locale via Ollama) e funziona. Non c'è nessun paywall dietro le funzioni base.

Poi c'è OpenCode Go, che è una cosa opzionale:

Piano Prezzo Cosa dà
— (base) gratuito tutto OpenCode, con le tue key o modelli locali
Go $10/mese accesso a un catalogo di modelli open, con limiti mensili
Go Plus $40/mese stessi modelli, limiti più alti

Go non è "il modello proprietario di OpenCode". È una curatela: il team testa un gruppo di modelli open (roba come GLM-5.3, DeepSeek V4, Kimi K3, Qwen3.8, GPT 6 Luna, Claude Haiku, Gemini 4 Argon...) e te li serve tramite un unico endpoint, con un prezzo unico e un limite mensile per modello. In pratica risolvi il problema di "quale provider è affidabile oggi?" delegandolo a loro.

Il setup è identico a qualsiasi provider: ti abboni dalla console, copi la API key, e poi:

/connect
# seleziona OpenCode Go, incolla la key
/models

Due dettagli che apprezzo: la maggior parte dei modelli ha zero data retention (ZDR), cioè i tuoi prompt non vengono usati per training; e se superi il limite mensile non ti bloccano, puoi continuare con i modelli free o attivare il pay-as-you-go. La lista dei modelli cambia man mano che ne testano di nuovi, quindi vale la pena dare un'occhiata alla guida Go ogni tanto.

Come l'ho usato io: reverse engineering + patch con Morphe

Finora ho parlato di "coding", ma il motivo per cui OpenCode mi ha convinto è un altro: l'ho usato per un flusso di reverse engineering di un'app Android (un'app Unity, quindi codice nativo il2cpp), fino ad arrivare a patcharla.

Prima di OpenCode quel flusso era una sequenza lunga e noiosa di comandi separati. Con OpenCode è diventato: gli descrivo l'obiettivo in linguaggio naturale, e lui guida l'intera pipeline:

  1. Recupero e merge dell'APK — le app moderne sono split APK (base + moduli per ABI); serve unire tutto e togliere la firma per poterci lavorare.
  2. Dump dei metadati il2cpp — da libil2cpp.so + global-metadata.dat si estraggono firme leggibili e indirizzi virtuali, con tool tipo Il2CppDumper o Il2CppInspector.
  3. Localizzazione — cercare nomi tipo Subscribed, Paywall, Feature nel dump.
  4. Disassembly ARM64 — smontare i metodi sospetti e risolvere il grafo delle chiamate (chi chiama cosa).
  5. Patch — applicare la modifica con Morphe, firmare l'APK e installarlo.

Il punto non è che "fa tutto da solo": il punto è che il lavoro meccanico (merge, dump, grep, disassembly, risoluzione dei chiamanti) viene svolto in batch e in modo coerente, mentre io mi concentro solo sulle decisioni vere — capire cosa protegge un guard, come è fatta una state machine.

Morphe, per chi non lo conoscesse, è un patcher di app Android in stile ReVanced: prendi un APK, applichi delle patch (scritte in Kotlin) e ne esce una versione modificata. I pezzi interessanti:

L'APK patchato esce non firmato, quindi l'ultimo passaggio è sempre firmarlo (apksigner o uber-apk-signer) prima di installarlo. È il tipo di dettaglio che da solo ti fa perdere mezz'ora se non lo sai, e che OpenCode non si dimentica mai di ricordarti.

Per chiudere

OpenCode non ha reinventato nulla di radicale: è un client-server ben fatto, con una configurazione sensata e un ecosistema di provider già pronto. Ma è esattamente quel "ben fatto" che fa la differenza — la sensazione è che il tool stia al tuo servizio e sparisca, invece di intromettersi. Se fate coding con un agente AI, o se vi intriga l'idea di usarlo per roba un po' meno convenzionale come il reverse engineering, vale assolutamente una settimana di prova.

Link raccolti

Daniele lovaion Avolio

Sviluppatore e amante del mondo dei videogiochi 🎮 e della cultura pop giapponese 🗾

LinkedInxGitHub

Daniele Avolio © 2026 · RSS