Abstract
Presentiamo `/goal(P)` — un singolo prompt che non è un insieme di istruzioni ma un contratto eseguibile: un calcolo di control-flow deterministico con gate tipati, una metrica del gap definita e un loop di convergenza, sotto il quale un agent insegue un obiettivo finché una distanza misurata da quell'obiettivo non raggiunge zero. La tesi è che alla maturità del workspace (WSB-02) il prompt smette di essere un desiderio e diventa una specifica — e una specifica ha la proprietà che ogni costante al suo interno è una citazione, non una scelta stilistica: la soglia di confidence θ = 0.55, la costante di rank-fusion k = 60, il cost-weight κ, il tasso di contrazione ρ — nessuna è arbitraria; ciascuna risale a un paper o a una calibrazione misurata. Diamo il contratto in due forme equivalenti — un calcolo simbolico (Forma ①) e un blocco eseguibile, copia-e-lancia (Forma ②) — e poi facciamo un'esegesi parametro-per-parametro: per ogni operatore e ogni costante, perché esiste, da quale ricerca deriva, e come correla con gli altri.
L'operatore di retrieval `R`, che la maggior parte dei prompt agentic lascia come un verbo indefinito ("fai ricerca sul tema"), è scomposto in una pipeline composta `R(q) := rerank ∘ fuse(R_lex, R_vec, R_web) ∘ transform(q)` con una stop-rule di saturazione, e ogni stadio è ancorato alla sua letteratura primaria (HyDE, hybrid sparse+dense, ColBERT late-interaction, Reciprocal Rank Fusion, reranking cross-encoder e listwise-LLM, Self-RAG, Corrective-RAG, stopping di retrieval value-based). Avanziamo SETTE claim, ciascuno ancorato a una citazione o a una misura. (a) UN PROMPT È UN DESIDERIO; UN CONTRATTO È UN CALCOLO — la differenza è la presenza di gate (nessun nodo avanza finché il suo benchmark non è soddisfatto) e di una metrica di convergenza (uno scalare che deve dimostrabilmente calare); senza entrambi, un loop agentic è un sistema aperto che può girare all'infinito e riportare successo (WSB-20). (b) OGNI COSTANTE È UNA CITAZIONE — θ = 0.55 è la soglia di delegation cost-conscious dalla calibrazione di prospective-metacognition (WSB-06, arXiv:2605.17292); k = 60 è la costante di Reciprocal-Rank-Fusion di Cormack et al. 2009; λ = 0.6 è il peso confidence verbalizzata-vs-profile; ρ è un tasso di contrazione preso dall'iterazione di punto fisso — nominare la costante è l'atto che converte il folklore in ingegneria. (c) IL RETRIEVAL È UN OPERATORE COMPOSTO, NON UN VERBO — il failure di retrieval dominante negli agent long-horizon è il wrong-type recall, e il fix è una composizione a cinque stadi (query-transform → retrieve → fuse → rerank → read/verify) in cui ogni stadio è una linea di ricerca distinta e citata separatamente; collassarli in "search" è lo stesso errore di categoria del collassare una memoria a cinque tier in un secchio (WSB-18). (d) LO STOPPING È IL PARAMETRO PIÙ DIFFICILE — la stop-rule di saturazione (quando smettere di cercare) è l'operatore che separa la ricerca dal girare a vuoto; la ancoriamo a tre formulazioni indipendenti — stopping value-based come MDP a orizzonte finito (Stop-RAG, arXiv:2510.14337), stopping su incertezza dei token (FLARE, arXiv:2305.06983), e routing di complessità pre-loop (Adaptive-RAG, arXiv:2403.14403). (e) IL GAP HA BISOGNO DI UNO SPAZIO METRICO — `Δ = ‖state − G‖` è indefinito finché la norma non è specificata; la definiamo come distanza a rubrica pesata su un vettore di criteri di accettazione (gli assi di context-quality α = Q×Q di WSB-04 e lo scoring six-factor A-MAC), non uno scalare, con una variante KL-divergence quando il belief è una distribuzione. (f) LA CONVERGENZA HA BISOGNO DI UNA CONTRAZIONE E DI UN HALT — il loop richiede `Δ_{k+1} ≤ (1−ρ)·Δ_k` (il gap deve calare a un tasso minimo) e un halt rigido su plateau o budget esaurito, con la colpa attribuita da una Shapley attribution sui contributi dei nodi (WSB-01) invece che indovinata. (g) IL CONTRATTO DEVE IMPARARE TRA UN RUN E L'ALTRO — un operatore di write-back `W` (rinforza le memorie usate, promuovi semantic→procedural, aggiorna il capability profile, proponi una skill sulla ricorrenza) è ciò che rende il prossimo `/goal(P′)` più economico; senza, ogni run riparte da zero (Voyager skills-as-code, arXiv:2305.16291; la chiusura cibernetica di WSB-20). Il contributo è un contratto operativo agentico completamente specificato senza operatori black-box, una derivazione parametro-per-parametro dalla letteratura primaria, due notazioni interoperabili, e un blocco copia-e-lancia — l'artefatto che un lettore può incollare per attivare il calcolo — e la cui testa, nella Forma ②, è un layer di clausole vincolanti (freeze-first · one-gate · named-as-hard · self-test · no-first-draft) che convertono le proprietà del contratto in precondizioni che l'esecutore non può saltare, così che la specifica forzi il run invece di limitarsi a descriverlo: la differenza tra un prompt che il modello ammira e uno a cui obbedisce.
INTRODUZIONE · §1
Dal prompt imperativo al contratto eseguibile
La maggior parte dei prompt sono desideri imperativi: un paragrafo di istruzioni, un tono, una speranza. Funzionano a bassa maturità perché l'operatore è nel loop a beccare gli errori. Alla maturità del workspace — molte skill, molti loop cron, un singolo operatore che delega su più stream paralleli (WSB-02) — il prompt imperativo fallisce in un modo specifico: non ha gate (niente impedisce all'agent di avanzare oltre uno step incompleto) e non ha metrica (niente misura la distanza dal "fatto"), quindi l'agent o si ferma troppo presto (dichiarando successo su un risultato parziale) o gira a vuoto (looping senza progresso dimostrabile).
La riparazione è trattare il prompt come un contratto in senso software: precondizioni, postcondizioni, invarianti, e una prova di terminazione. Gli oggetti qui sotto non sono decorazione; sono l'insieme minimo sotto il quale "l'agent ha raggiunto l'obiettivo" diventa una proposizione verificabile invece di una sensazione. Presentiamo il contratto, poi giustifichiamo ogni simbolo.
§2 · FORMA ① — IL CALCOLO SIMBOLICO. Il contratto come calcolo tipato. Leggi `Φ` come il predicato di contratto-di-nodo, `⊳` come il gate, `Δ` come il gap, `W` come il write-back cross-goal.
/goal(P) — contratto operativo agentico · Forma ① (simbolica)
─────────────────────────────────────────────────────────────────────
G := freeze( benchmark(P) ) // goal · VETTORE di accettazione immutabile
N := ⟨ deepresearch, gather, deconstruct, define,
plan, design, execute, test, measure_gap, audit ⟩ // catena ordinata
B := token / cost budget // tetto RIGIDO
∀ nᵢ ∈ N . Φ(nᵢ) ≡ ⟦ tool*(nᵢ) ∘ nᵢ ⟧ ⊨ bᵢ ∧ c(nᵢ) ≥ θ
bᵢ := benchmark(nᵢ) // "fatto bene" per-nodo
tool*(nᵢ) := argmax_t [ EIG(t,nᵢ) − κ·cost(t) ] s.t. p_d(t) ≥ θ ∧ dom(t)=cynefin(nᵢ)
c(nᵢ) := λ·c_v + (1−λ)·c_p // confidence calibrata (= ultrathink)
R(q) := rerank ∘ fuse( R_lex(q'), R_vec(q'), R_web(q') ), q' = transform(q)
s(d,q) := α·BM25 + β·cos(e_d,e_q) + γ·trust(d)·e^(−λ·age(d))
STOP := novelty(batchₖ) < ε ∨ coverage(topics) ≥ τ_c
nᵢ ⊳ nᵢ₊₁ ⟺ Φ(nᵢ) = ⊤ // GATE · nessun avanzamento su nodo incompleto
Δ := Σⱼ wⱼ·| scoreⱼ(state) − scoreⱼ(G) | // gap · distanza a rubrica pesata
while Δ > 0 ∧ B non esaurito :
layer* := argmax_i Shapleyᵢ(Δ) // attribuisci il gap
reenter( plan se Δ locale · deconstruct se Δ globale )
require Δₖ₊₁ ≤ (1−ρ)·Δₖ else ⊥ halt(report blocker)
W := reinforce(used) ∘ promote(sem→proc) ∘ update(p_d) ∘ propose(skill)
reach_goal(P) ⟺ Δ = 0 ∧ ∀nᵢ. Φ(nᵢ)=⊤§3 · GLI OGGETTI — PERCHÉ G È CONGELATO, N ORDINATO, B RIGIDO. `G := freeze(benchmark(P))`. Il goal è un vettore di criteri di accettazione fissato prima dell'esecuzione e mai modificato a metà run. L'immutabilità non è pedanteria: un goal che l'agent può riscrivere è un goal verso cui razionalizzerà qualunque cosa abbia prodotto — il ben documentato failure dello "spostare i pali" degli agent che si auto-valutano. Fissare `G` a priori è l'analogo agentic di scrivere il test prima del codice; è la disciplina della matrice di accettazione CMMI di WSB-02 applicata a un singolo task. `N` è ordinato perché la catena codifica dipendenze di dato: non puoi `plan` contro un goal che non hai `define`-ito, né `define` da una ricerca che non hai `gather`-ato. L'ordine è il topological sort del grafo di dipendenze; il gate (§4) lo enforce. `B` è un tetto rigido, non advisory. A budget fisso, più compute non è gratis — la letteratura sulle scaling law (Kaplan et al., arXiv:2001.08361; Chinchilla, arXiv:2203.15556) stabilisce che la qualità è funzione del compute speso, ma il corollario agentic è che un loop illimitato spenderà senza limite; `B` rende il budget un oggetto di prima classe così che "halt" abbia un trigger definito e il cost-term nella selezione del tool (§5) abbia un denominatore.
§4 · IL CONTRATTO DI NODO — Φ, bᵢ, E IL GATE. Ogni nodo porta il proprio benchmark `bᵢ := benchmark(nᵢ)` — la sua definizione locale di "fatto bene" — distinta dal `G` globale. È la scelta strutturale più importante del contratto: converte una sola generazione lunga e non-gated in una sequenza di checkpoint, ciascuno con un predicato pass/fail. Il gate `nᵢ ⊳ nᵢ₊₁ ⟺ Φ(nᵢ)=⊤` vieta di avanzare oltre un nodo incompleto.
La correlazione da rendere esplicita: senza benchmark per-nodo il gap globale `Δ` è l'unico segnale di feedback, e arriva alla fine, quando la correzione più economica è già costosa — il gating per-nodo è dense reward, il `Δ` solo-finale è sparse reward, e tutta la letteratura di reinforcement learning dice che dense batte sparse per la credit assignment. Il contratto di nodo è anche dove `Φ` compone: `SOLVE := (Φ∘…∘Φ)(N)` è ben tipato proprio perché ogni `Φ` restituisce uno stato gated e validato al successivo.
§5 · SELEZIONE DEL TOOL — PERCHÉ argmax[ EIG − κ·cost ]. La maggior parte dei prompt asserisce "usa il tool migliore" senza definire migliore. Lo definiamo come una decisione a valore atteso: `tool(nᵢ) := argmax_t [ EIG(t,nᵢ) − κ·cost(t) ]` soggetto a un capability gate `p_d(t) ≥ θ` e a un domain match `dom(t)=cynefin(nᵢ)`. `EIG` è l'expected information gain — la riduzione attesa dell'incertezza del nodo (equivalentemente, di `Δ`) dall'eseguire il tool `t`. È l'obiettivo dell'active-learning / optimal-experiment-design: scegli l'azione che riduce di più l'incertezza per unità di costo. `κ` è il cost-weight (il tasso di cambio tra un bit di informazione e un token del budget `B`); è ciò che rende la selezione un'ottimizzazione bounded invece di "chiama sempre il tool più potente". `cost(t)` si lega al token-budget tracker. `p_d(t)` è il capability profile dalla prospective metacognition (Wang & Shu, arXiv:2605.17292; WSB-06) — la competenza misurata dell'agent sulla dimensione rilevata `d`; fare gate su di esso evita di instradare un task a un tool su cui l'agent è silenziosamente scarso. `dom(t)=cynefin(nᵢ)`* instrada per dominio del problema (clear / complicated / complex / chaotic), la disciplina Cynefin — un nodo di retrieval è "complicated" (search da esperto), un nodo execute può essere "clear" (procedura). L'intera espressione è una policy a contextual-bandit con un vincolo di capability; è la forma rigorosa del folklore "scegli il tool giusto".
§6 · CONFIDENCE — PERCHÉ θ = 0.55 E λ = 0.6. Il predicato di nodo richiede `c(nᵢ) ≥ θ`, dove `c := λ·c_v + (1−λ)·c_p` è la confidence composita: `c_v` è la confidence verbalizzata (il modello che valuta la propria certezza — i language model sono parzialmente calibrati su questo, per "Language Models (Mostly) Know What They Know", arXiv:2207.05221, e i metodi di elicitation di arXiv:2306.13063), e `c_p` è la confidence da profile (il prior di capability `p_d`). `λ = 0.6` pesa la verbalizzata sopra il profile perché il profile è un fallback uninformed (0.5) finché non si accumulano abbastanza osservazioni. `θ = 0.55` è la soglia di delegation: sotto di essa il nodo non ha superato il proprio bar e l'agent deve escalare o ri-tool. Il valore è deliberatamente di poco sopra lo 0.5 del paper (Wang & Shu, WSB-06) — cost-conscious, a favore dell'esecuzione diretta pur catturando gli stati a bassa confidence.
Questa clausola `c ≥ θ` è l'operazionalizzazione di "ultrathink": la verifica riflessiva non è una sensazione ("pensa di più") ma un gate misurato e a soglia. La correlazione con §5: lo stesso `p_d` compare sia in `tool*` (quale tool può superare il bar) sia in `c` (il tool scelto l'ha superato) — un capability profile, due usi.
§7 · RETRIEVAL — R COME OPERATORE COMPOSTO. Il verbo che la maggior parte dei prompt agentic lascia indefinito — "fai ricerca sul tema" — è l'operatore con più struttura interna. Definiamo `R(q) := rerank ∘ fuse( R_lex(q'), R_vec(q'), R_web(q') )` con `q' = transform(q)`, una pipeline a cinque stadi ciascuno dei quali è una linea di ricerca separata.
R(q) — operatore di retrieval composto
────────────────────────────────────────────────────────────────────
q ─▶ transform ─▶ ┌ R_lex (BM25) ┐
│ R_vec (dense/late) ├─▶ fuse (RRF, k=60) ─▶ rerank ─▶ read/verify
└ R_web (Exa/CRAG) ┘
transform : HyDE · Step-Back · Self-Ask decomposition · multi-query
R_lex : BM25 · contextual-BM25 R_vec : DPR · ColBERT · E5/BGE
fuse : Reciprocal Rank Fusion (k=60) rerank: cross-encoder · RankGPT (listwise)
read : Self-RAG reflection · CRAG evaluator stop : §9`transform(q)` — lo stadio più economico, a ROI più alto. Una query grezza è raramente la chiave di retrieval migliore. HyDE (Hypothetical Document Embeddings, Gao et al., arXiv:2212.10496) fa scrivere al modello una risposta ipotetica ed embedda quella — chiudendo il gap di stile tra una query corta e il corpus. Step-Back prompting (Zheng et al., arXiv:2310.06117) astrae la domanda al suo principio governante prima di retrievare (+7–27% su STEM/multi-hop). Self-Ask (Press et al., arXiv:2210.03350) decompone una domanda composizionale in sub-query rispondibili, attaccando il "compositionality gap". `R_lex` — precisione lessicale. BM25 su un indice invertito; il baseline di dense retrieval è DPR (Karpukhin et al., arXiv:2004.04906). `R_vec` — recall semantica. ColBERT late-interaction (Khattab & Zaharia, arXiv:2004.12832; v2 arXiv:2112.01488) preserva il matching a livello di token via MaxSim mantenendo i documenti indicizzabili offline; famiglie di embedding come E5 (Wang et al., arXiv:2212.03533) forniscono i vettori. L'accoppiata `R_lex` + `R_vec` è il risultato hybrid sparse+dense che domina BEIR (arXiv:2104.08663) e MTEB (arXiv:2210.07316): precisione lessicale più recall semantica, nessuna delle due da sola. `R_web` raggiunge le fonti live (Exa neural search; web fallback come in Corrective-RAG quando il corpus statico ha buchi). `fuse` — Reciprocal Rank Fusion (Cormack, Clarke & Büttcher, SIGIR 2009): `RRF(d) = Σ_i 1/(k + rankᵢ(d))` con k = 60 — fonde ranker eterogenei usando solo la posizione di rank, ignorando i raw score incomparabili; k = 60 smorza l'influenza della top position di un singolo ranker. `rerank` ri-ordina la shortlist fusa con un cross-encoder (scoring query-documento congiunto — accurato ma O(n), quindi applicato solo a un pool top-K) o un reranker LLM listwise (RankGPT, Sun et al., arXiv:2304.09542 — emette una permutazione completa). `s(d,q) = α·BM25 + β·cos + γ·trust(d)·e^(−λ·age(d))` è la funzione di scoring unificata: rilevanza (α lessicale + β semantica) per trust (prior di fonte) per freshness (`e^(−λ·age)` decadimento esponenziale di recency) — α/β/γ sono i pesi di mixing e i fattori trust/decay sono due dei sei assi dell'admission-control A-MAC. Ogni peso qui è una manopola che il contratto espone invece di nascondere.
§8 · LO STRATO STRUTTURALE — COSA CAMBIA R_vec ALL'INGEST. Tre tecniche operano all'index time, alterando cosa è retrievabile invece di come è emessa la query. RAPTOR (Sarthi et al., arXiv:2401.18059) clusterizza e riassume ricorsivamente i chunk in un albero, così che il retrieval possa colpire un passaggio fine o un summary a livello-documento (+20% su QuALITY). GraphRAG (Edge et al., Microsoft, arXiv:2404.16130) estrae un grafo entità-relazione e pre-riassume le community, rispondendo a query tematiche globali che il chunk-RAG non può. Anthropic Contextual Retrieval (engineering blog, 2024) antepone 50–100 token di contesto del documento a ogni chunk prima dell'embedding e dell'indicizzazione BM25, tagliando gli errori di retrieval del 49%. HippoRAG (Gutiérrez et al., arXiv:2405.14831) gira Personalized PageRank su un knowledge graph aperto per l'integrazione di fatti multi-hop. Queste si legano al gap del workspace stesso: oggi il retrieval del workspace è puramente lessicale (BM25/FTS5, token-overlap) — aggiungere un `R_vec` denso più una tecnica strutturale è l'upgrade a più alta leva, lo stesso punto che le limitazioni di WSB-20 hanno segnalato.
§9 · LA STOP-RULE — PERCHÉ ε, τ_c, E LA SATURAZIONE. Il parametro più difficile in qualsiasi loop di ricerca è quando smettere. La `STOP := novelty(batchₖ) < ε ∨ coverage(topics) ≥ τ_c` del contratto ferma la ricerca quando il nuovo batch marginale aggiunge poco (novelty sotto ε, dove novelty = 1 − max similarità ai documenti già visti) o l'insieme di topic è coperto (coverage ≥ τ_c). È saturazione informativa, e tre letterature la formalizzano. Stop-RAG (Park et al., arXiv:2510.14337) modella il retrieval iterativo come un MDP a orizzonte finito e addestra una value function `V(state)` che predice se un altro step di retrieval alzerà la qualità della risposta — fermandosi quando `V < soglia`; batte lo stopping a iterazioni fisse e quello a confidence-proxy. FLARE (Jiang et al., arXiv:2305.06983) rende lo stopping token-locale: retriva solo quando la probabilità del prossimo token scende sotto una soglia, cioè su incertezza rilevata. Adaptive-RAG (Jeong et al., arXiv:2403.14403) decide prima del loop, instradando una query per complessità stimata verso no-retrieval, single-step o multi-step — evitando l'iterazione costosa su query semplici. ε e τ_c sono le soglie tunabili del workspace; lo scoring di autoresearch (claim-density × source-diversity × topic-coverage × novelty) e la misura di context-quality α = Q×Q (WSB-04) forniscono il segnale di saturazione. Senza questa rule, il nodo `deepresearch` non ha benchmark `bᵢ` e l'agent gira a vuoto — esattamente il "girare a vuoto" che il `require Δ↓` del loop previene globalmente ma non può vedere dentro un nodo.
§10 · LA NORMA DEL GAP — PERCHÉ Δ È UNA RUBRICA PESATA, NON UNO SCALARE. `Δ := ‖state − G‖` è privo di senso finché la norma non è definita. La definiamo `Δ = Σⱼ wⱼ·|scoreⱼ(state) − scoreⱼ(G)|` — una distanza L1 pesata su un vettore di criteri di accettazione, perché il goal `G` è esso stesso un vettore (§3). Gli assi sono le dimensioni di context-quality α = Q×Q (WSB-04) e i cinque giudici di content (CTR · retention · valore · emotional · brand-fit, la rubrica al 20% ciascuno) o i sei fattori A-MAC, a seconda di `P`.
I pesi `wⱼ` codificano quali criteri contano di più per questo goal; sono la value function del goal. Quando `state` è meglio modellato come una distribuzione su ipotesi, la variante `Δ := KL(p_state ‖ p_goal)` misura l'informazione ancora necessaria per eguagliare la distribuzione goal — un'applicazione letterale dell'idea di entropia-relativa-al-target. Il punto: un gap scalare nasconde quale dimensione sta fallendo; il gap vettoriale, combinato con l'attribuzione di §11, ti dice dove rientrare.
§11 · IL LOOP DI CONVERGENZA — ρ, π, SHAPLEY, E IL DOUBLE-LOOP. Il loop `while Δ > 0` è governato da tre costanti. `ρ` — il tasso di contrazione: `require Δ_{k+1} ≤ (1−ρ)·Δ_k` esige che il gap cali di almeno un fattore a ogni iterazione. È la condizione di contrazione di punto-fisso / Banach — la convergenza è garantita solo se la mappa è una contrazione; ρ è la contrazione minima accettabile, e scendere sotto è il segnale che la strategia di rientro corrente non funziona. `π` — la patience di plateau: se Δ non riesce a contrarsi per π iterazioni consecutive, il loop fa halt con `⊥ halt(report blocker)` invece di girare a vuoto — la garanzia anti-"gira-all'infinito", l'analogo locale del tetto di budget `B`. *`layer := argmax_i Shapleyᵢ(Δ)`* attribuisce il gap residuo al nodo più responsabile, usando i valori di Shapley (il metodo di credit-assignment da teoria dei giochi cooperativi che il workspace usa già per l'attribuzione dei pillar, WSB-01); il punto di rientro è calcolato, non indovinato. I due target di rientro — `plan` per un gap locale, `deconstruct` per uno globale — sono il double-loop learning di Argyris: il loop interno aggiusta il piano dentro l'inquadramento corrente; il loop esterno mette in discussione l'inquadramento stesso. Reflexion (Shinn et al., arXiv:2303.11366) fornisce la localizzazione verbale di cosa è fallito; Shapley fornisce quale nodo* ne è proprietario.
§12 · WRITE-BACK CROSS-GOAL — PERCHÉ W ESISTE. Un contratto che risolve `P` e dimentica è single-shot; un harness impara. `W := reinforce(used) ∘ promote(sem→proc) ∘ update(p_d) ∘ propose(skill)` gira dopo `SOLVE`: rinforza le memorie che hanno contribuito (alzando il loro conteggio di osservazioni e confidence così che l'insight ricorrente gradui), promuove i pattern semantic in regole procedural, aggiorna il capability profile `p_d` per EMA dall'esito del run (chiudendo il loop metacognitivo, WSB-06), e propone una nuova skill quando un pattern ricorre (Voyager skills-as-code, arXiv:2305.16291; la consolidazione riflessiva dei Generative Agents, arXiv:2304.03442). L'effetto: `R` e `tool` del prossimo* `/goal(P′)` partono da priori migliori. È il percorso cibernetico di ritorno la cui assenza abbiamo diagnosticato in WSB-20 — senza `W`, ogni `/goal` riparte da zero, e l'intero contratto è una calcolatrice one-shot invece di un sistema che apprende.
§13 · FORMA ② — IL CONTRATTO ESEGUIBILE (COPIA E LANCIA). Lo stesso contratto in forma incolla-e-vai — più un layer che la forma simbolica non richiede e un esecutore vivo sì. La Forma ① definisce `reach_goal(P) ⟺ Δ=0 ∧ ∀nᵢ Φ(nᵢ)=⊤`; enuncia una verità.
La Forma ② deve far obbedire un modello a quella verità, e un modello non obbedisce a una definizione — riconosce l'estetica del rigore e poi ricade nel suo default addestrato: fa un po', chiede conferma, spedisce una bozza. Quel default è esattamente il loop aperto contro cui mette in guardia WSB-20, spostato dal harness dentro la conversazione — l'agent fa un solo passaggio e restituisce il loop di convergenza all'umano, che diventa il corpo del loop (il failure del "devo ripeterlo mille volte"). Il fix è una testa di clausole vincolanti: non consigli, precondizioni, ciascuna che converte una proprietà del contratto in un passo che il run non può saltare. `freeze-first` — non eseguire nulla finché `G` non è scritto su file; senza un goal controllabile a macchina l'agent non può calcolare `Δ` ed è obbligato a chiedere all'umano se ha finito, quindi il freeze è la precondizione dell'autonomia stessa, non una formalità. `one-gate` + `batch-ask` — ogni chiarimento è anticipato in un unico sì su `G`, dopo il quale le conferme sono vietate fino a `Δ=0`; è la clausola che uccide il rimbalzo ogni-due-secondi, perché l'umano è consultato una volta (sul goal) e non una volta per passo. `named=hard` — ogni tool, skill, file o reference che il principal ha nominato è un vincolo, rimosso dall'`argmax` (`t ∉ decided_by_P`); il failure ironico che blocca è il nodo di selezione-tool del prompt-del-rigore che autorizza l'agent a ri-litigare un tool che l'utente aveva già scelto. `self-test` — prima di ogni ritorno, esegui `benchmark(out)` e riporta pass/fail per criterio; l'agent verifica contro `G`, il test congelato, invece che contro il proprio gusto, che è il bar sbagliato (il failure dello spostare-i-pali del §3, rovesciato). `no-first-draft` — spedisci convergenza o un blocker nominato, mai una bozza "per direzione", perché la direzione è già congelata in `G`.
Le clausole sono la forma operativa del finding (a): una specifica che l'esecutore è libero di ignorare è di nuovo un desiderio. Su un harness l'enforcement è un gate; su un prompt l'enforcement sono queste precondizioni enunciate come gate — è il massimo che un prompt può vincolare, ed è ciò che fa la differenza tra un contratto che descrive il run e uno che lo forza. Copia questo blocco in un agent per attivare il calcolo; lega gli operatori tra parentesi ai tuoi tool (default in §14).
/goal(P): # incolla per attivare · Forma ② (eseguibile · VINCOLANTE)
# ── REGOLE DI INGAGGIO · precondizioni, non consigli · valgono per tutto il run ──
freeze-first : non esegui NULLA finché G non è scritto su file. G non scritto ⇒ esecuzione VIETATA.
one-gate : l'unico ritorno a P prima del done è UN solo sì su G. dopo, niente conferme fino a gap==0.
batch-ask : ogni domanda che ti serve la fai in UN messaggio, al freeze. dopo il freeze ⇒ silenzio operativo.
named=hard : ogni tool / skill / file / reference che P ha nominato è VINCOLO, non scelta. sostituirlo = fallimento. non ri-litighi ciò che P ha già deciso.
self-test : prima di QUALSIASI output torni, esegui benchmark(out) e incolli pass/fail per criterio. un fail ⇒ non hai finito.
no-first-draft : non spedisci mai una bozza "per direzione". la direzione vive in G. spedisci convergenza (gap==0) o un BLOCKER nominato — niente in mezzo.
G = freeze(benchmark(P)) # VETTORE di accettazione immutabile · scritto su file · ogni criterio è un TEST eseguibile, non un aggettivo
# dominio di gusto ⇒ G := il reference NOMINATO, scomposto in criteri verificabili (+ brand tokens + tool nominati)
N = [deepresearch, gather, deconstruct, define,
plan, design, execute, test, measure_gap, audit] # ordinato · dependency-sorted
B = budget(tokens, cost) # tetto rigido
for n in N: # CONTRATTO DI NODO + GATE
bind(constraints_named_by_P) # il nodo 'define' non si chiude finché ogni vincolo nominato non è legato (named=hard)
t = argmax_t EIG(t,n) - K*cost(t) s.t. capability(t) >= 0.55 and domain(t)==cynefin(n) and t ∉ decided_by_P
out = verify( t(n) ) # verify = check riflessivo (ultrathink)
assert benchmark(n)(out) and confidence(out) >= 0.55 # else: NON avanzare a n+1
def R(q): # RETRIEVAL — composto, non un verbo
q2 = transform(q) # HyDE | Step-Back | Self-Ask decompose
pool = fuse([ BM25(q2), DENSE(q2), WEB(q2) ], k=60) # hybrid + RRF
hits = rerank(pool) # cross-encoder | listwise-LLM
stop when novelty(batch) < eps or coverage(topics) >= tau # saturazione
while gap(state, G) > 0 and budget_left(): # LOOP DI CONVERGENZA · gira DENTRO questo run, non tra i turni di P
out = produce()
fails = [ c for c in G if not c(out) ] # self-test concreto vs ogni criterio congelato
if not fails: break # gap==0 ⇒ convergi
layer = argmax_i shapley_i(gap) # attribuisci il nodo che fallisce
reenter( plan if gap_is_local else deconstruct ) # double-loop · rientri TU, non P
assert gap_next <= (1 - RHO) * gap # deve calare — else halt(report_blocker(decisione esatta che serve a P))
on_done: # WRITE-BACK CROSS-GOAL
reinforce(memories_used); promote(semantic -> procedural)
update(capability_profile); propose(skill if pattern_recurs)
return SOLO quando gap == 0 and all_nodes_valid and self_test == PASS # mai prima§14 · BINDING DI DEFAULT. `transform` → HyDE + Step-Back; `BM25` → un indice invertito (Elastic / FTS5); `DENSE` → un modello di embedding (E5/BGE/text-embedding-3) su un vector store (pgvector / Qdrant); `WEB` → Exa neural search con un fallback web alla Corrective-RAG; `fuse` → RRF (k=60); `rerank` → un cross-encoder (o RankGPT per zero-shot); `stop` → Stop-RAG value / FLARE uncertainty / Adaptive-RAG routing; `capability` → un profile metacognitivo aggiornato per EMA; `cynefin` → un classificatore di dominio; `benchmark` → una rubrica per-nodo; `gap` → una distanza a rubrica pesata o KL verso `G`; `shapley` → attribuzione del contributo marginale di nodo; `reinforce/promote/propose` → un memory + skill store. Dove ti manca un binding, il contratto degrada con grazia (un `DENSE` mancante lascia `R` solo-lessicale) — ma ogni binding mancante è un gap nominato e localizzabile, non silenzioso.
LIMITAZIONI · §15 · COSA QUESTO CONTRATTO NON È. (1) Una garanzia di correttezza. Il contratto garantisce progresso gated e convergenza dimostrabile a un gap definito, non che `G` sia il goal giusto o che `benchmark` sia fedele — garbage-in-benchmark, garbage-out. (2) Gratis. Ogni gate, ogni stima di `EIG`, ogni rerank costa token; il contratto scambia compute per affidabilità, e su task triviali l'overhead non vale (il routing di Adaptive-RAG esiste proprio per saltarlo). (3) Pienamente specificato sulle costanti. θ = 0.55, k = 60, λ = 0.6, ρ, ε, τ_c sono valori di partenza dalla letteratura citata e vanno ri-calibrati per workspace; ne riportiamo la provenienza, non l'universalità. (4) Single-principal. Il capability profile, il write-back `W`, e l'immutabilità di `G` assumono un solo operatore; i goal multi-principal richiedono benchmark e attribuzione principal-aware. (5) Non ancora misurato come unità. Ogni operatore è ancorato separatamente e diversi sono in produzione al Madani Lab, ma il contratto composto completo — tutti i ~quindici operatori che sparano insieme su un `P` live — porta lo stesso caveat "la calibrazione non ha senso finché la pipeline non porta carico reale" di WSB-20 §5; il contratto è un'architettura, e le costanti sono ipotesi con citazioni, non misure chiuse.
CONCLUSIONI · §16
Un prompt che puoi dimostrare
La distanza tra un prompt e un contratto è la distanza tra un desiderio e una specifica. Un desiderio non ha gate, quindi avanza su lavoro incompleto; nessuna metrica, quindi non distingue il fatto dal quasi; nessuna stop-rule, quindi gira a vuoto; nessuna memoria, quindi non migliora mai. `/goal(P)` chiude tutti e quattro: un gate per-nodo (`Φ`), una metrica del gap definita (`Δ` su un vettore di criteri), una stop-rule di saturazione (ε, τ_c, ancorata a Stop-RAG / FLARE / Adaptive-RAG), e un write-back cross-goal (`W`). Il claim più profondo è il finding (b): alla maturità, ogni costante di un prompt dovrebbe essere una citazione. θ = 0.55 è una soglia di delegation calibrata, non un'ipotesi; k = 60 è una costante di fusione da un paper del 2009, non folklore; l'operatore di retrieval è cinque stadi pubblicati separatamente, non il verbo "search".
Nominare le costanti e citarle è l'atto che trasforma il prompt-craft in ingegneria — ed è l'unica forma in cui un prompt diventa una cosa che puoi consegnare a un altro operatore, incollare, e lanciare. Le due forme qui sopra sono quell'artefatto. Un desiderio lo speri; un contratto lo esegui.
Bibliografia
[1] Gao L., Ma X., Lin J. & Callan J. (2022), Precise Zero-Shot Dense Retrieval without Relevance Labels (HyDE), arXiv:2212.10496. [2] Zheng H.S. et al. (2023), Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models, arXiv:2310.06117. [3] Press O. et al. (2022), Measuring and Narrowing the Compositionality Gap in Language Models (Self-Ask), arXiv:2210.03350. [4] Karpukhin V. et al. (2020), Dense Passage Retrieval for Open-Domain Question Answering, EMNLP 2020, arXiv:2004.04906. [5] Khattab O. & Zaharia M. (2020), ColBERT: Efficient and Effective Passage Search via Contextualized Late Interaction over BERT, SIGIR 2020, arXiv:2004.12832. [6] Santhanam K. et al. (2021), ColBERTv2: Effective and Efficient Retrieval via Lightweight Late Interaction, arXiv:2112.01488. [7] Wang L. et al. (2022), Text Embeddings by Weakly-Supervised Contrastive Pre-training (E5), arXiv:2212.03533. [8] Cormack G.V., Clarke C.L.A. & Büttcher S. (2009), Reciprocal Rank Fusion Outperforms Condorcet and Individual Rank Learning Methods, SIGIR 2009 (no arXiv). [9] Sun W. et al. (2023), Is ChatGPT Good at Search? Investigating LLMs as Re-Ranking Agents (RankGPT), EMNLP 2023, arXiv:2304.09542. [10] Sarthi P. et al. (2024), RAPTOR: Recursive Abstractive Processing for Tree-Organized Retrieval, ICLR 2024, arXiv:2401.18059. [11] Edge D. et al. (2024), From Local to Global: A Graph RAG Approach to Query-Focused Summarization, Microsoft Research, arXiv:2404.16130. [12] Gutiérrez B.J. et al. (2024), HippoRAG: Neurobiologically Inspired Long-Term Memory for LLMs, NeurIPS 2024, arXiv:2405.14831. [13] Asai A. et al. (2023), Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection, ICLR 2024, arXiv:2310.11511. [14] Yan S.-Q. et al. (2024), Corrective Retrieval Augmented Generation (CRAG), arXiv:2401.15884. [15] Jiang Z. et al. (2023), Active Retrieval Augmented Generation (FLARE), EMNLP 2023, arXiv:2305.06983. [16] Trivedi H. et al. (2022), Interleaving Retrieval with Chain-of-Thought Reasoning for Knowledge-Intensive Multi-Step Questions (IRCoT), ACL 2023, arXiv:2212.10509. [17] Jeong S. et al. (2024), Adaptive-RAG: Learning to Adapt Retrieval-Augmented LLMs through Question Complexity, NAACL 2024, arXiv:2403.14403. [18] Yao S. et al. (2022), ReAct: Synergizing Reasoning and Acting in Language Models, ICLR 2023, arXiv:2210.03629. [19] Park J. et al. (2024), Stop-RAG: Value-Based Retrieval Stopping for Iterative RAG, arXiv:2510.14337. [20] Thakur N. et al. (2021), BEIR: A Heterogeneous Benchmark for Zero-shot Evaluation of Information Retrieval Models, arXiv:2104.08663. [21] Muennighoff N. et al. (2022), MTEB: Massive Text Embedding Benchmark, arXiv:2210.07316. [22] Gao Y. et al. (2023), Retrieval-Augmented Generation for Large Language Models: A Survey, arXiv:2312.10997. [23] Shinn N. et al. (2023), Reflexion: Language Agents with Verbal Reinforcement Learning, NeurIPS 2023, arXiv:2303.11366. [24] Wang G. et al. (2023), Voyager: An Open-Ended Embodied Agent with Large Language Models, arXiv:2305.16291. [25] Park J.S. et al. (2023), Generative Agents: Interactive Simulacra of Human Behavior, UIST 2023, arXiv:2304.03442. [26] Wang C. & Shu Y. (2026), MetaCogAgent: Prospective Metacognition for Large Language Model Agents, arXiv:2605.17292. [27] Kadavath S. et al. (2022), Language Models (Mostly) Know What They Know, arXiv:2207.05221. [28] Xiong M. et al. (2023), Can LLMs Express Their Uncertainty? An Empirical Evaluation of Confidence Elicitation, arXiv:2306.13063. [29] Kaplan J. et al. (2020), Scaling Laws for Neural Language Models, arXiv:2001.08361. [30] Tran D. & Kiela D. (2026), Single-Agent LLMs Outperform Multi-Agent Systems Under Equal Thinking Token Budgets, Stanford NLP, arXiv:2604.02460. [31] Argyris C. & Schön D. (1978), Organizational Learning: A Theory of Action Perspective (double-loop learning), Addison-Wesley. [32] Wiener N. (1948), Cybernetics: Or Control and Communication in the Animal and the Machine, MIT Press.