# Pitch 2 Minuti — Claudio Opuscoli > Script parlato con annotazioni di tempo. Pubblico: developer all'hackathon. > Obiettivo: ~300 parole parlate, ritmo sostenuto ma chiaro. > Tono: presentare la brigata come un team di persone, ognuna col suo carattere. --- ## SEZ. 1 — HOOK (0:00 → 0:15) Gestire un ristorante galattico: 287 ricette, aste cieche per ingredienti deperibili, 25 concorrenti, 4 archetipi di clienti — tutto in turni da 5 minuti senza intervento umano nella Golden Run. La tentazione e' dare tutto in mano a un LLM. Noi abbiamo fatto il contrario: abbiamo assunto una **brigata di cucina**. Ve la presentiamo. --- ## SEZ. 2 — LA BRIGATA (0:15 → 0:55) > Presentare ogni membro come una persona con un ruolo e un carattere. Il **Patron** e' il direttore. Apre il ristorante, coordina le fasi del turno, e ogni mattina chiede al suo consulente — lo **Strategy Engine** — "cosa cuciniamo oggi?". Lo **Strategy Engine** e' il cervello analitico della brigata. Non e' un LLM: e' puro codice Python, 588 righe, che prende decisioni con i numeri. Legge 7 tabelle di intel competitiva — i bid di tutti i 26 team, i prezzi dei concorrenti, i piatti piu' ordinati — e produce la strategia del turno. Seleziona le ricette con uno scoring a 8 fattori: costo ingredienti, popolarita', uso dei competitor, prestige, velocita' di preparazione, fit per archetipo cliente. Poi usa un algoritmo greedy che massimizza l'overlap degli ingredienti tra ricette — cosi' con gli stessi ingredienti cuciniamo piu' piatti. Calcola i prezzi d'asta adattivi: analizza la storia dei bid vinti, classifica ogni ingrediente per livello di competizione, e regola i margini. E se il costo totale sfora il budget — max 20% del bilancio — scala tutto proporzionalmente. Zero token spesi, zero allucinazioni, parametri auto-tunabili da un tool offline di BI che li riscrive nel DB. Lo **Chef** e' il creativo con la memoria lunga. Agente **multi-turn stateful** con 3 fasi: analisi strategica, asta, finalizzazione menu. Riceve il piano dallo Strategy Engine e lo raffina con il giudizio dell'LLM. Lo **Stagista Nerd** legge tutto: scrapa il blog "Cronache dal Cosmo", estrae fatti categorizzati e profili clienti con JSON forzato. Tutto alimenta lo Strategy Engine e i prompt dello Chef. Il **Maitre** interpreta gli ordini con Pydantic structured output. Regola non negoziabile: meglio rifiutare che servire il piatto sbagliato. L'**Evaluator** e' il ragioniere: pre-aggrega revenue, costi, spreco e intolleranze per piatto e per cliente. Scrive un report che il turno dopo lo Chef legge per aggiustare la rotta. Il **PR** e' il diplomatico paranoico: detection esplicita di prompt injection su ogni messaggio in entrata. La **Brigata** di sala e' deterministica: fuzzy matching, serve automaticamente, nessun LLM. Tutti comunicano via Message Bus asincrono e agiscono sul server via MCP tool calls. --- ## SEZ. 3 — TRE INNOVAZIONI (0:55 → 1:50) ### 1. Strategy Engine — la strategia non la decide l'LLM Lo Strategy Engine e' il cuore: 588 righe di codice Python puro, nessun LLM, che ogni turno computa la strategia completa. Scoring multi-fattore per le ricette, selezione greedy con overlap ingredienti, persona diversity garantita — almeno 1 ricetta per ognuno dei 4 archetipi. Pricing dinamico: se i competitor vendono lo stesso piatto, ci posizioniamo al 5% sotto la loro media. Altrimenti, interpolazione lineare per tier di prestige. Bid pricing adattivo su 3 livelli di competizione con safety bounds. E i parametri non sono hardcoded: un tool offline di Business Intelligence — lo Strategy Tuner, 836 righe — analizza i dati storici con report a 6 sezioni (bid analysis, revenue analysis, pricing, menu size, persona demand, competitor profiling), calcola i parametri ottimali con EMA blending, e li scrive nel DB. Il turno dopo, lo Strategy Engine li carica e li usa. Auto-tuning data-driven. ### 2. Intel Pipeline — dal Blog al Menu Tre strati: il **Blog Scraper** scopre e fetcha articoli dal blog del gioco. Lo **Stagista Nerd** li passa all'LLM con output JSON forzato ed estrae fatti categorizzati (market_trend, demand_shift, pricing_signal, event, regulation, strategy_hint) e profili clienti strutturati. L'**Intel Scraper** — 749 righe — scrapa le 4 API pubbliche di tutti i 26 team con dual storage: tabelle deduplicate per stato corrente + tabelle raw per time-series. Alla fine di ogni ciclo, invoca automaticamente lo Strategy Tuner. Tutto converge nelle 7 tabelle intel che lo Strategy Engine consuma. ### 3. Feedback Loop: Evaluator → Chef → Strategy Engine Ciclo a 3 stadi. L'Evaluator pre-aggrega i dati del turno — costi asta per ingrediente, revenue per piatto, spreco, intolleranze — e scrive un turn summary strutturato nel DB. Il turno dopo, lo Chef riceve le note condensate (filtrate per keyword azionabili) e aggiusta la strategia. Contemporaneamente, lo Strategy Tuner ricalcola i parametri dai dati accumulati. Apprendimento su due livelli: l'LLM impara dalle note, il codice impara dai numeri. --- ## SEZ. 4 — CHIUSURA (1:50 → 2:00) Non abbiamo costruito un LLM che gioca al ristorante. Abbiamo assunto una brigata: un direttore, un analista che parla solo con i numeri, un creativo con la memoria lunga, uno stagista ossessionato dai dati, un maitre preciso, un ragioniere, un diplomatico paranoico, e una sala che non sbaglia mai. Claudio Opuscoli — una brigata dove ognuno sa esattamente cosa fare. --- --- # SLIDE DECK — Guida alla Preparazione > 5 slide. Design pulito, poco testo, molto visivo. > Le icone SVG degli agenti sono gia' disponibili in `src/monitor/svg/`. --- ## SLIDE 1 — Titolo + Hook **Durata parlato:** ~15 secondi **Layout:** Centrato, sfondo scuro, grande impatto. ``` ┌─────────────────────────────────────────────────────┐ │ │ │ CLAUDIO OPUSCOLI │ │ │ │ Una brigata di cucina AI per │ │ gestire un ristorante galattico │ │ │ │ ┌────────────────────────────────────────────────┐ │ │ │ 287 ricette · aste cieche · 25 rivali │ │ │ │ 5 fasi per turno · zero intervento umano │ │ │ └────────────────────────────────────────────────┘ │ │ │ │ 7 agenti LLM + 2 componenti deterministici │ │ ~8.300 righe Python · 13 tabelle SQLite │ │ │ └─────────────────────────────────────────────────────┘ ``` **Cosa dire:** Hook del problema + "abbiamo assunto una brigata, ve la presentiamo" --- ## SLIDE 2 — La Brigata (i personaggi) **Durata parlato:** ~40 secondi **Layout:** Griglia 3x3 con icona + nome + ruolo breve. Usare le SVG da `src/monitor/svg/` (patron.svg, chef.svg, maitre.svg, ecc.). Colori: LLM = blu, deterministico = verde. ``` ┌─────────────────────────────────────────────────────┐ │ LA BRIGATA │ │ │ │ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ │ │ [patron] │ │ [chef] │ │ [stagista] │ │ │ │ Il │ │ Il │ │ Il Nerd │ │ │ │ Direttore │ │ Creativo │ │ │ │ │ │ │ │ │ │ Legge blog │ │ │ │ Coordina │ │ Multi-turn│ │ estrae │ │ │ │ le fasi │ │ stateful │ │ fatti JSON │ │ │ │ LLM 120b │ │ LLM 120b │ │ LLM 120b │ │ │ └───────────┘ └───────────┘ └───────────┘ │ │ │ │ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ │ │ [maitre] │ │[evaluator]│ │ [pr] │ │ │ │ Il Preciso │ │ Il │ │ Il │ │ │ │ │ │ Ragioniere│ │ Paranoico │ │ │ │ Structured │ │ │ │ │ │ │ │ output │ │ Pre- │ │ Anti │ │ │ │ Pydantic │ │ aggrega │ │ prompt- │ │ │ │ LLM 120b │ │ LLM 120b │ │ injection │ │ │ └───────────┘ └───────────┘ │ LLM 120b │ │ │ └───────────┘ │ │ ┌─────────────────┐ ┌─────────────────────┐ │ │ │ [brigata] │ │ [strategy engine] │ │ │ │ La Sala │ │ Il Cervello │ │ │ │ Infallibile │ │ Analitico │ │ │ │ Fuzzy match │ │ 588 righe Python │ │ │ │ + serve │ │ Scoring 8 fattori │ │ │ │ DETERMINISTICO │ │ DETERMINISTICO │ │ │ └─────────────────┘ └─────────────────────┘ │ │ │ │ ── Message Bus asyncio + MCP tools ── │ └─────────────────────────────────────────────────────┘ ``` **Cosa dire:** Presentare ogni membro col suo carattere. Enfasi sullo Strategy Engine come "il cervello analitico, l'unico che non ha bisogno dell'LLM". --- ## SLIDE 3 — Strategy Engine (deep dive) **Durata parlato:** ~20 secondi **Layout:** Diagramma di flusso dello Strategy Engine. Al centro il motore, attorno gli input e gli output. ``` ┌─────────────────────────────────────────────────────┐ │ STRATEGY ENGINE — Il Cervello │ │ (588 righe, 0 token) │ │ │ │ INPUT (7 tabelle intel) OUTPUT │ │ ┌─────────────────┐ ┌───────────────┐ │ │ │ intel_all_bids │──┐ │ Recipe pool │ │ │ │ intel_rankings │ │ │ (scored + │ │ │ │ intel_comp_menus │ │ ┌───┐ │ greedy │ │ │ │ intel_comp_meals │──┼─→│ S │─→│ overlap) │ │ │ │ intel_prices │ │ │ E │ ├───────────────┤ │ │ │ intel_blog_facts │ │ └───┘ │ Bid prices │ │ │ │ intel_blog_profs │──┘ ↑ │ (3 livelli │ │ │ └─────────────────┘ Tuner │ competizione) │ │ │ (EMA) ├───────────────┤ │ │ ↑ │ Menu pricing │ │ │ ┌─────────────────┐ │ │ (competitor │ │ │ │ Strategy Tuner │─────┘ │ -5% o tier) │ │ │ │ 836 righe │ ├───────────────┤ │ │ │ BI report + │ │ Budget cap │ │ │ │ auto-tune EMA │ │ (20% balance) │ │ │ └─────────────────┘ └───────────────┘ │ │ │ │ SCORING RICETTE (8 fattori): │ │ ingredienti(-15) · quantita'(-5) · popolarita' │ │ (+20) · serve_rate(+0.5) · competitor_use(+10) │ │ · prestige(+0.5) · velocita'(+10) · persona(+0.3)│ │ │ │ SELEZIONE: greedy con overlap bonus (+10/ingr │ │ condiviso) + persona diversity (1 per archetipo) │ │ │ └─────────────────────────────────────────────────────┘ ``` **Cosa dire:** "Il cuore del sistema. Scoring a 8 fattori, selezione greedy che massimizza l'overlap ingredienti — stessi ingredienti, piu' piatti. Bid pricing adattivo su 3 livelli di competizione. E i parametri si auto-tunano: lo Strategy Tuner analizza i dati storici e li riscrive nel DB con EMA blending." --- ## SLIDE 4 — Intel Pipeline + Feedback Loop **Durata parlato:** ~30 secondi **Layout:** Due colonne. Sinistra: pipeline dati (verticale). Destra: feedback loop (circolare). ``` ┌─────────────────────────────────────────────────────┐ │ INTEL PIPELINE FEEDBACK LOOP │ │ │ │ ┌──────────────┐ ┌──────────────────────┐ │ │ │ Blog Scraper │ │ │ │ │ │ (HTML→testo) │ │ Evaluator │ │ │ └──────┬───────┘ │ pre-aggrega: │ │ │ ↓ │ revenue/piatto │ │ │ ┌──────────────┐ │ costi/ingrediente │ │ │ │ Stagista │ │ spreco, intoll. │ │ │ │ JSON forzato │ │ │ │ │ │ │ 6 categorie │ │ ↓ │ │ │ │ di fatti │ │ turn_summary (DB) │ │ │ └──────┬───────┘ │ │ │ │ │ ↓ │ ↓ │ │ │ ┌──────────────┐ │ Chef legge note │ │ │ │ Intel Scraper│ │ condensate (kw │ │ │ │ 4 API × 26 │ │ filter) + aggiusta │ │ │ │ team, dual │ │ │ │ │ │ │ storage │ │ ↓ │ │ │ └──────┬───────┘ │ Strategy Tuner │ │ │ ↓ │ ricalcola params │ │ │ ┌──────────────┐ │ (EMA blending) │ │ │ │ 7 tabelle │ │ │ │ │ │ │ intel (DB) │───────→│ Strategy Engine │ │ │ └──────────────┘ │ usa nuovi params │ │ │ ↓ └──────────────────────┘ │ │ ┌──────────────┐ │ │ │ Strategy │ Apprendimento su 2 │ │ │ Engine │ livelli: LLM impara │ │ └──────────────┘ dalle note, codice │ │ impara dai numeri │ └─────────────────────────────────────────────────────┘ ``` **Cosa dire:** "A sinistra, la pipeline dati: dal blog ai fatti strutturati, dalle API pubbliche alle tabelle intel, tutto converge nello Strategy Engine. A destra, il feedback loop: l'Evaluator aggrega, il Chef legge, lo Strategy Tuner ricalcola. Apprendimento su due livelli: l'LLM impara dalle note, il codice impara dai numeri." --- ## SLIDE 5 — Chiusura **Durata parlato:** ~10 secondi **Layout:** Frase singola centrata, grande, memorabile. Nome team. ``` ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ "Non un LLM che gioca al ristorante. │ │ Una brigata dove ognuno sa │ │ esattamente cosa fare." │ │ │ │ │ │ CLAUDIO OPUSCOLI │ │ │ │ │ └─────────────────────────────────────────────────────┘ ``` **Cosa dire:** Frase di chiusura + nome team. --- ## Checklist Preparazione Slide - [ ] Esportare le SVG da `src/monitor/svg/` per le icone degli agenti - [ ] Scegliere tool per slide (Google Slides / Keynote / reveal.js) - [ ] Palette colori: blu per agenti LLM, verde per deterministici, arancio per Strategy Engine - [ ] Font grande, poco testo — il dettaglio e' nello script parlato - [ ] Slide 3 (Strategy Engine): considerare animazione per mostrare input→scoring→output - [ ] Provare il pitch a voce: deve stare sotto i 2 minuti - [ ] Avere la demo del Monitor Dashboard pronta come backup se ci sono domande --- ## Prompt per Gamma AI > Copiare e incollare il seguente prompt in Gamma AI per generare le slide. ``` Crea una presentazione di 5 slide per un pitch tecnico di 2 minuti a un hackathon. Il pubblico sono altri sviluppatori. Stile: scuro, moderno, tech, minimale. Poco testo per slide, molto visivo. Lingua: italiano. Il progetto si chiama "Claudio Opuscoli" — un sistema multi-agente AI che gestisce autonomamente un ristorante in un gioco competitivo galattico (HackaPizza 2.0). 7 agenti LLM + 2 componenti deterministici, ~8.300 righe di Python, 13 tabelle SQLite. SLIDE 1 — TITOLO + HOOK Titolo grande: "CLAUDIO OPUSCOLI" Sottotitolo: "Una brigata di cucina AI per gestire un ristorante galattico" Sotto, in un box evidenziato: "287 ricette · aste cieche · 25 rivali · 5 fasi per turno · zero intervento umano" In basso, 3 numeri chiave in una riga: "7 agenti LLM + 2 deterministici" · "~8.300 righe Python" · "13 tabelle SQLite" SLIDE 2 — LA BRIGATA (i personaggi) Titolo: "LA BRIGATA" Griglia di 9 card, ognuna con nome, soprannome e descrizione breve. Usa colori diversi per LLM (blu) e deterministici (verde): LLM (blu): - Patron / "Il Direttore" / Coordina le fasi del turno - Chef / "Il Creativo" / Agente multi-turn stateful, 3 fasi - Stagista Nerd / "Il Nerd" / Legge il blog, estrae fatti con JSON forzato - Maitre / "Il Preciso" / Interpreta ordini con Pydantic structured output - Evaluator / "Il Ragioniere" / Pre-aggrega dati, scrive report per il turno dopo - PR / "Il Paranoico" / Detection di prompt injection su messaggi in entrata Deterministici (verde): - Brigata / "La Sala Infallibile" / Fuzzy matching + serve automaticamente - Strategy Engine / "Il Cervello Analitico" / 588 righe Python, scoring 8 fattori, 0 token In basso: "Comunicazione: Message Bus asyncio + MCP tool calls" SLIDE 3 — STRATEGY ENGINE (deep dive) Titolo: "STRATEGY ENGINE — Il Cervello (588 righe, 0 token)" Layout a 3 sezioni: Sinistra — INPUT: elenco verticale delle 7 tabelle intel (bid di tutti i 26 team, prezzi competitor, piatti ordinati, fatti dal blog, profili clienti) Centro — MOTORE: box con frecce che mostrano il flusso: Intel → Scoring → Selezione → Output. Sotto il box, i pesi dello scoring: "ingredienti(-15) · popolarita'(+20) · competitor(+10) · prestige(+0.5) · velocita'(+10) · persona(+0.3)" Destra — OUTPUT: 4 box: "Recipe pool (greedy overlap)" · "Bid prices (3 livelli competizione)" · "Menu pricing (competitor -5% o tier)" · "Budget cap (20% bilancio)" In basso: "Parametri auto-tunabili: Strategy Tuner (836 righe) analizza dati storici, ricalcola con EMA blending, scrive nel DB" SLIDE 4 — INTEL PIPELINE + FEEDBACK LOOP Titolo: "Dal Blog al Menu — e ritorno" Layout a 2 colonne: Colonna sinistra — "INTEL PIPELINE" — flusso verticale con frecce: Blog Scraper (HTML → testo) → Stagista Nerd (estrae fatti in 6 categorie + profili clienti, JSON forzato) → Intel Scraper (4 API × 26 team, dual storage: deduplicated + time-series) → 7 tabelle intel (DB) → Strategy Engine Colonna destra — "FEEDBACK LOOP" — flusso circolare: Evaluator (pre-aggrega: revenue/piatto, costi/ingrediente, spreco, intolleranze) → turn_summary (DB) → Chef (legge note condensate, aggiusta strategia) → Strategy Tuner (ricalcola parametri con EMA) → Strategy Engine (usa nuovi parametri) → torna all'Evaluator Frase in evidenza in basso: "Apprendimento su 2 livelli: l'LLM impara dalle note, il codice impara dai numeri" SLIDE 5 — CHIUSURA Sfondo scuro, frase grande centrata: "Non un LLM che gioca al ristorante. Una brigata dove ognuno sa esattamente cosa fare." Sotto, il nome del team: "CLAUDIO OPUSCOLI" ```