Un post su The Beach mostra un agente completo scritto in 100 righe di Common Lisp: loop ricorsivo, chiamata al modello, esecuzione dei tool. Niente dipendenze oltre HTTP e JSON. Il loop intero sta in 8 righe: base case (il modello risponde), recursive case (vuole tool, li esegue, richiama). Lo stato dell’agente è solo l’argomento che scorre attraverso la ricorsione.

Perché ti riguarda: se hai seguito le lezioni del corso sul primo agente o hai scaricato gli scaffolding minimi, questa implementazione è lo scheletro nudo di quello che c’è sotto. Il tool è uno solo: eval. Il modello scrive codice Lisp come stringa, l’agente lo esegue e restituisce il risultato. Niente catalogo di tool, niente framework: il linguaggio stesso diventa l’interfaccia. Per Fibonacci(30), il modello ha scritto la funzione ricorsiva, l’ha eseguita con eval, e ha tornato 832040. Due chiamate, zero prompt preconfezionati.

È un esperimento da sandbox (eval aperto è un rischio di sicurezza chiaro), ma l’idea è istruttiva: Lisp è homoiconico (il codice è fatto della stessa struttura dati del programma), quindi un programma può costruire e modificare altro codice come se fosse una lista della spesa. È la proprietà che 25 anni fa rendeva Lisp “il linguaggio dell’AI simbolica”. Oggi quella promessa si materializza diversamente: il modello genera il codice, Lisp lo esegue, e il loop ricorsivo tiene tutto insieme. 114 punti su Hacker News dicono che l’idea ha colpito.

Nel dettaglio

Il contesto

Intorno al 2000, Lisp era considerato il linguaggio dell’intelligenza artificiale simbolica: sistemi esperti, dimostratori di teoremi, programmi che manipolavano simboli e regole. Poi i metodi statistici hanno vinto, il deep learning li ha sepolti, e Lisp è rimasto una curiosità storica per la maggior parte degli sviluppatori. L’autore del post racconta di aver imparato Lisp in un corso di AI all’Università di Guelph, senza mai vederlo usare dopo.

Oggi costruisce una piattaforma di agenti AI e si chiede: potrebbe Lisp essere ancora utile per un agent loop? La risposta è sì, ma per ragioni diverse da quelle del 2000.

L’anatomia dell’agente

L’implementazione completa (disponibile su The Beach) usa SBCL (Steel Bank Common Lisp), due librerie (dexador per HTTP, shasht per JSON), e nient’altro. Il loop ricorsivo:

lisp (defun agent-loop (messages) (let* ((message (ref (call-model messages) choices 0 message)) (tool-calls (gethash tool_calls message))) (if (and tool-calls (plusp (length tool-calls))) (agent-loop (append messages (list message) (map list # execute tool-calls))) (append messages (list message)))))

Otto righe. Se il modello risponde, torna la storia. Se chiede tool, li esegue, appende i risultati, e richiama sé stesso. Lo stato è solo la lista di messaggi che scorre attraverso la ricorsione. Niente state machine, niente variabili globali.

Il trucco: eval come unico tool

La maggior parte degli agenti ha un catalogo di tool (web search, file read, python exec). Questo agente ha un solo tool: eval. Il modello scrive una form Lisp come stringa, l’agente la legge (read-from-string), la esegue (eval), e torna il risultato stampato.

lisp (defun lisp-eval (form-string) (handler-case (format nil “~s” (eval (read-from-string form-string))) (error (e) (format nil “ERROR: ~a” e))))

Questo è possibile perché Lisp è homoiconico: il codice è scritto nella stessa struttura dati (liste) che il linguaggio manipola. Un programma Lisp può costruire e modificare altro codice Lisp con la stessa facilità con cui costruisce una lista della spesa. Nel transcript del post, l’agente ha calcolato Fibonacci(30) in due passi: prima ha definito la funzione nel runtime, poi l’ha chiamata.

Limiti dichiarati

L’autore lo dice chiaramente: eval aperto è un rischio di sicurezza. Il modello esegue codice arbitrario sulla macchina. Questo è un esperimento da sandbox, non una ricetta per produzione. L’autore stesso lo ha fatto girare solo in un container Docker locale.

Ma l’idea regge come strumento didattico: mostra cosa c’è sotto un agente senza framework, senza astrazioni, senza dipendenze. È l’equivalente di scrivere un server HTTP in 50 righe per capire cosa fa Express o Flask dietro le quinte.

Perché oggi

La promessa originale di Lisp era “programmi che manipolano programmi”. Nel 2000 significava regole simboliche scritte a mano. Nel 2026 significa: il modello scrive il codice, Lisp fornisce il substrato dove quel codice gira, e il loop ricorsivo tiene tutto insieme. Il lavoro simbolico è stato outsourced al modello, ma la proprietà homoiconica di Lisp rende l’esecuzione immediata.

Se stai costruendo agenti o stai seguendo il percorso builder del corso, questo post vale la lettura: è un’anatomia pulita, senza orpelli, di come funziona un loop. E se hai mai pensato “vorrei capire cosa c’è davvero sotto prima di usare un framework”, questo è il tipo di codice che te lo mostra.