> ## Content Index > Fetch the complete content index at: https://adrianoamalfi.com/llms.txt > Use this file to discover other available public pages before exploring further. # AI agentica open source nel SDLC: dal modello all'integrazione nel ciclo di sviluppo - URL: https://adrianoamalfi.com/tech-scratchpad/agenti-open-source-integrazione-sdlc/ - Published: 2026-10-01T17:32:51.000Z - Updated: 2026-10-19T14:37:48.000Z - Description: Agenti di coding open source nel SDLC: come collegare un LLM (vLLM in casa o un servizio) al ciclo di sviluppo, tra famiglie di strumenti e punti di aggancio. - Author: Adriano Amalfi - Tags: AI Agentica, LLM, Open Source, AI Tools, SDLC, MCP, coding agent, Panorama, #Tech Scratchpad: Appunti avanzati e esperimenti per esperti e amatoriali **Verificato il:** 2026-10-01 Avere a disposizione un LLM non è più il problema. Che sia un modello servito in casa con vLLM o un modello raggiunto via API da OpenAI, Anthropic o un servizio come OpenCode Zen, la capacità di calcolo non è più la parte difficile: la parte difficile è collegarla al lavoro di sviluppo. Il primo pezzo di questa serie ha passato in rassegna gli [strumenti open source che coprono le quattordici fasi dell'SDLC](https://adrianoamalfi.com/tech-scratchpad/sdlc-open-source-strumenti-per-fase/). Questo fa il passo successivo: mostra dove si innesta l'AI agentica open source in quel ciclo, partendo dal presupposto che il modello ci sia già. Nell'integrazione il **modello è un endpoint sostituibile**: cambia con una riga di configurazione. Quello che non è sostituibile è l'impianto che lo circonda, fatto di contesto, permessi e punti di aggancio al ciclo. Chi progetta guardando solo al modello sceglie l'ingrediente; chi progetta guardando all'interfaccia costruisce la cucina. ## Il modello è un endpoint, non l'architettura La fortuna dell'AI agentica open source è che quasi tutti gli strumenti parlano la stessa lingua: l'API compatibile con OpenAI. Un server vLLM espone gli endpoint `/v1/chat/completions`, `/v1/completions`, `/v1/responses` e persino una API in stile Anthropic su `/v1/messages`, con un endpoint `/v1/models` per elencare i modelli caricati ([vLLM](https://docs.vllm.ai/en/stable/serving/online%5Fserving/?ref=adrianoamalfi.com)). Dall'altra parte, i servizi espongono la stessa forma o ne offrono una equivalente. Il risultato è che dal punto di vista dell'agente esistono sempre tre soli parametri: un base URL, una chiave e un identificativo di modello. Da qui nasce la prima scelta di integrazione, che non riguarda il modello ma il modo in cui lo si presenta agli strumenti. Un endpoint unico, locale o remoto, lascia gli agenti agnostici: si passa da un modello self-hosted a uno a noleggio senza toccare il codice dell'agente. È l'esatto contrario dell'incollare ogni strumento a un fornitore. Il self-hosting con vLLM richiede una precisazione che spesso si scopre tardi: servire un modello per chat non equivale a servirlo per un agente. Il tool calling, cioè la capacità del modello di chiedere di eseguire un comando o leggere un file, non è attivo di default. Serve avviare il server con `--enable-auto-tool-choice` e scegliere il parser giusto per la propria famiglia di modelli (`--tool-call-parser`), spesso con un chat template dedicato, come nella configurazione di vLLM per i modelli Llama. Un modello che risponde bene in chat ma non emette tool call in modo affidabile, con un agente, si blocca al primo passo. ```bash vllm serve meta-llama/Llama-3.1-8B-Instruct \ --host 0.0.0.0 --port 8000 \ --api-key mykey \ --enable-auto-tool-choice \ --tool-call-parser llama3_json \ --chat-template examples/tool_chat_template_llama3.1_json.jinja ``` Sul versante servizio la scelta è tra i grandi fornitori (OpenAI, Anthropic) e gli aggregatori che normalizzano l'accesso a più modelli dietro la stessa API. [OpenCode](https://adrianoamalfi.com/tag/opencode/), per esempio, si appoggia all'AI SDK e a Models.dev per coprire oltre 75 provider e i modelli locali, e consente di definire un provider personalizzato compatibile con OpenAI con una manciata di righe ([OpenCode, provider](https://opencode.ai/docs/providers/?ref=adrianoamalfi.com)): ```json { "$schema": "https://opencode.ai/config.json", "provider": { "vllm-locale": { "npm": "@ai-sdk/openai-compatible", "name": "vLLM locale", "options": { "baseURL": "http://127.0.0.1:8000/v1" }, "models": { "Qwen3.6-35B-A3B": { "name": "Qwen 3.6 35B" } } } } } ``` Lo stesso schema ricorre ovunque. Aider si collega a qualunque endpoint compatibile con [OpenAI](https://adrianoamalfi.com/tag/openai/) via `OPENAI_API_BASE` e `OPENAI_API_KEY`, con il modello indicato come `openai/` ([Aider](https://aider.chat/docs/llms/openai-compat.html?ref=adrianoamalfi.com)). OpenHands accetta un modello locale con l'identificativo `openai/` e il base URL del server, e i suoi stessi documenti avvertono che un modello locale debole o con finestra di contesto piccola si comporta da semplice chatbot invece che da agente ([OpenHands, LLM locali](https://docs.openhands.dev/usage/llms/local-llms?ref=adrianoamalfi.com)). Codex CLI definisce i provider in `~/.codex/config.toml`, con `base_url`, `env_key` e `wire_api`, e ha una modalità OSS dedicata per Ollama e LM Studio ([Codex CLI](https://developers.openai.com/codex/config-file/config-advanced?ref=adrianoamalfi.com)). Cambia il file di configurazione, non il concetto. ## Dove gira l'agente: quattro famiglie Scegliere lo strumento giusto è più facile se si separano due domande che spesso si confondono: dove l'agente lavora e quale fase del ciclo tocca. Sul primo asse esistono quattro famiglie, tutte rappresentate da progetti open source maturi. | Famiglia | Esempi open source | Dove lavora | Backend self-hosted | | ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- | ------------------------------- | | Agenti da terminale | [OpenCode](https://github.com/anomalyco/opencode?ref=adrianoamalfi.com) (MIT), [Aider](https://aider.chat/?ref=adrianoamalfi.com) (Apache-2.0), [Codex CLI](https://github.com/openai/codex?ref=adrianoamalfi.com) (Apache-2.0), [goose](https://github.com/block/goose?ref=adrianoamalfi.com) (Apache-2.0) | Shell, repository locale | Sì, endpoint compatibile OpenAI | | Assistenti in IDE | [Continue](https://docs.continue.dev/?ref=adrianoamalfi.com) (Apache-2.0), [Cline](https://docs.cline.bot/?ref=adrianoamalfi.com) (Apache-2.0) | VS Code, JetBrains | Sì, provider locale o custom | | Agenti autonomi in container | [OpenHands](https://github.com/OpenHands/OpenHands?ref=adrianoamalfi.com) (MIT), [SWE-agent](https://github.com/SWE-agent/SWE-agent?ref=adrianoamalfi.com) (MIT) | Sandbox con filesystem e terminale | Sì, via base URL locale | | Protocollo e collante | [MCP](https://modelcontextprotocol.io/docs/getting-started/intro?ref=adrianoamalfi.com) (standard aperto) | Ovunque l'agente sia | Indipendente dal modello | Gli agenti da terminale sono il punto di partenza più naturale: girano nel repository, vedono i file veri e producono diff revisionabili. Aider nasce come pair programming con il controllo di versione al centro e, grazie ai flag `--message` e `--yes`, si presta a essere richiamato da uno script o da una pipeline CI ([Aider, scripting](https://aider.chat/docs/scripting.html?ref=adrianoamalfi.com)). [OpenCode](https://adrianoamalfi.com/tech-scratchpad/opencode-go-guida-abbonamento/) copre il terminale, l'IDE e la modalità server, con regole di progetto in `AGENTS.md` e server MCP configurabili. Codex CLI porta lo stesso modello di esecuzione locale, ma con provider definiti in un file di configurazione e una modalità non interattiva pensata per l'automazione. Gli assistenti in IDE cambiano il punto di contatto: invece di girare nel terminale, vivono nell'editor e affiancano chi scrive. Continue e Cline coprono entrambi VS Code e JetBrains; Cline offre anche una CLI con modalità headless pensata per CI/CD e scripting. La differenza rispetto agli agenti da terminale è il grado di autonomia: l'assistente in IDE tende a proporre e chiedere conferma, l'agente da terminale a eseguire. Gli agenti autonomi in container sono i più potenti e i più esigenti. OpenHands esegue il modello dentro una sandbox con accesso a file e comandi, e per questo chiede modelli capaci e finestre di contesto ampie: i suoi documenti indicano almeno 22.000 token e consigliano 32.000 e più, oltre a un modello ottimizzato per il coding agentico. È la famiglia che rende più evidente perché il modello, da solo, non basta. Il collante che tiene insieme tutto il resto è [MCP](https://adrianoamalfi.com/tag/mcp/), il Model Context Protocol: uno standard aperto per collegare un'applicazione AI a fonti dati, strumenti e workflow esterni, adottato da un numero crescente di client. È il modo con cui un agente legge un issue tracker, interroga un database o consulta la documentazione senza che ogni integrazione venga riscritta da zero. ## Dove si aggancia al ciclo Se le famiglie dicono come lavora l'agente, le fasi dell'SDLC dicono dove aggiunge valore. Il criterio pratico è agganciare l'agente nel punto in cui produce un artefatto verificabile, non in ogni punto in cui potrebbe. 1. Nell'analisi dei requisiti l'agente legge il backlog via MCP e prepara una bozza di specifica o di criteri di accettazione da rivedere. 2. Nella scrittura del codice lavora nel repository, con le convenzioni di progetto dichiarate in un file di contesto come `AGENTS.md`: è lì che si dice all'agente quali pattern seguire, non nel prompt di ogni sessione. 3. Nei test genera casi e li esegue, ma il valore sta nella corsa verde, non nel testo prodotto. 4. Nella revisione del codice l'agente può commentare una pull request, attività che si presta bene a un'esecuzione headless in CI. 5. Nella documentazione e nel rilascio può trasformare un diff in note di rilascio e aggiornare la documentazione insieme al codice. Il filo che unisce questi agganci è sempre lo stesso: la modalità **headless**, cioè la capacità di far girare l'agente senza una persona davanti alla tastiera, e MCP come interfaccia verso il resto del sistema. Sono questi due elementi, non il modello scelto, a determinare se l'integrazione sopravvive al prossimo aggiornamento. Un agente richiamabile da uno script e collegato agli strumenti giusti resta utile anche quando sotto cambia il modello; un agente bloccato in un'interfaccia grafica e cucito a un solo fornitore no. ## Self-hosted o servizio: cosa cambia davvero A parità di endpoint, la scelta del backend è una scelta di compromessi, non di principio. Il modello self-hosted con vLLM tiene il codice dentro il perimetro: nessuna riga lascia la rete dell'organizzazione. In cambio chiede GPU, competenze operative e attenzione alla finestra di contesto e al tool calling, che con modelli piccoli o parser sbagliati diventa il collo di bottiglia dell'intero agente. È il contesto giusto per codice regolato, ambienti air-gapped o team che vogliono la piena sovranità sui dati. Il modello a noleggio non richiede infrastruttura, offre la capacità frontier e si aggiorna da solo, al prezzo di token e di dati che escono dall'organizzazione. È il contesto giusto per chi vuole partire in fretta o per i task che richiedono il massimo ragionamento. La via di mezzo è spesso la più sensata e si vede sempre più spesso nei team reali: un modello locale piccolo per il completamento inline e i task che toccano codice sensibile, un modello più grande, locale o remoto, per i turni agentici lunghi. Poiché l'endpoint è lo stesso, la ripartizione si cambia senza riscrivere gli strumenti. La regola pratica è assegnare il self-hosting dove il dato non può uscire e il servizio dove il ragionamento pesa più della riservatezza. ## Il costo nascosto è il contesto, non il modello Quando l'endpoint è standardizzato, il valore dell'integrazione si sposta su ciò che rende un agente efficace su un repository specifico: le convenzioni di progetto, i server MCP che gli danno accesso agli strumenti giusti, le regole di permesso che decidono cosa può fare senza chiedere, la memoria di sessione che gli evita di ricominciare ogni volta. È un impianto portabile, perché non dipende dal modello, ma non è gratis: va scritto, mantenuto e verificato con la stessa cura del codice. Qui sta il punto che sfugge a chi guarda solo al listino dei modelli. La differenza tra due team che usano lo stesso modello non è quasi mai il modello: è la qualità del contesto e dei permessi. Lo stesso vale per la sicurezza. Il self-hosting protegge la riservatezza dei dati, non l'azione dell'agente: un agente con accesso in scrittura al repository e alla rete è un rischio indipendentemente da dove gira il modello, e va governato con sandbox, approvazioni umane e branch protetti. La leva non è il modello, sono gli strumenti che gli si mettono in mano e i limiti che gli si impongono. Per iniziare, la sequenza che riduce il rischio è lineare: esporre un solo endpoint compatibile con OpenAI, collegarci un agente da terminale, agganciarlo a una fase sola del ciclo, e solo dopo aggiungere IDE, container e automazione in CI. L'AI agentica open source non chiede di riscrivere il processo: chiede un punto di ingresso ben scelto. Il modello, da quel punto in poi, è la parte che si può cambiare. ## Fonti Fonti primarie consultate e ricontrollate il 1 ottobre 2026: - [vLLM, OpenAI-compatible server](https://docs.vllm.ai/en/stable/serving/online%5Fserving/?ref=adrianoamalfi.com) (endpoint, API e Ray Serve LLM) - [vLLM, tool calling](https://docs.vllm.ai/en/latest/features/tool%5Fcalling/?ref=adrianoamalfi.com) (flag `--enable-auto-tool-choice` e `--tool-call-parser`) - [OpenCode, provider](https://opencode.ai/docs/providers/?ref=adrianoamalfi.com) (75+ provider, modelli locali e provider personalizzati) - [Aider, API compatibili con OpenAI](https://aider.chat/docs/llms/openai-compat.html?ref=adrianoamalfi.com) e [scripting](https://aider.chat/docs/scripting.html?ref=adrianoamalfi.com) - [OpenHands, LLM locali](https://docs.openhands.dev/usage/llms/local-llms?ref=adrianoamalfi.com) (vLLM, Ollama, LM Studio, SGLang, contesto minimo) - [Codex CLI, configurazione avanzata](https://developers.openai.com/codex/config-file/config-advanced?ref=adrianoamalfi.com) (provider personalizzati, modalità OSS, esecuzione non interattiva) - [Continue](https://docs.continue.dev/customize/models?ref=adrianoamalfi.com) (modelli, ruoli e provider) e [Cline](https://docs.cline.bot/?ref=adrianoamalfi.com) (IDE, CLI e modalità headless) - [Model Context Protocol, introduzione](https://modelcontextprotocol.io/docs/getting-started/intro?ref=adrianoamalfi.com) (standard aperto, revisione 2026-07-28) - Repository e licenze: [OpenCode](https://github.com/anomalyco/opencode?ref=adrianoamalfi.com) (MIT), [Aider](https://github.com/Aider-AI/aider?ref=adrianoamalfi.com) (Apache-2.0), [Codex CLI](https://github.com/openai/codex?ref=adrianoamalfi.com) (Apache-2.0), [goose](https://github.com/block/goose?ref=adrianoamalfi.com) (Apache-2.0), [Continue](https://github.com/continuedev/continue?ref=adrianoamalfi.com) (Apache-2.0), [Cline](https://github.com/cline/cline?ref=adrianoamalfi.com) (Apache-2.0), [OpenHands](https://github.com/OpenHands/OpenHands?ref=adrianoamalfi.com) (MIT), [SWE-agent](https://github.com/SWE-agent/SWE-agent?ref=adrianoamalfi.com) (MIT), [vLLM](https://github.com/vllm-project/vllm?ref=adrianoamalfi.com) (Apache-2.0)