1. Scopo e confini

Il Vaglio è il componente che decide se un'azione — proposta spontaneamente da myc o richiesta dall'utente — può procedere. Si chiama Vaglio perché fa esattamente quello: setaccia, separa. Non perché giudichi le persone, ma perché applica due criteri distinti (costituzionale e teleologico) con nature opposte.

Il Vaglio risolve un problema preciso: un LLM che ha generato un output tende a valutarlo in modo conforme — è il self-enhancement bias documentato nella letteratura LLM-as-Judge (Zheng et al. 2023, e altri). Se lasciassimo al medesimo LLM che ha prodotto una ActionProposal il compito di valutarla contro i telos, avremmo un giudice che tifa per sé stesso. Il Vaglio impone l'indipendenza del valutatore dal proponente: contesto separato, prompt separato, possibilmente provider separato.

Cos'è

• Un componente architetturale, non una persona — il nome è scelto di proposito per evitare antropomorfismi (non "arbitro", non "giudice", non "super-io").
• Una guardia costituzionale (binaria): verifica se l'azione contraddice un articolo delle 4 Leggi. Se sì, blocca. Se no, non si pronuncia.
• Un giudice teleologico (gradiente): invoca un LLM indipendente che misura l'allineamento ai telos. Produce expected_alignment.
• Una decisione unica: BLOCK / PUBLISH / REJECT, con motivazione tracciata.

Cosa non è

• Non è la Policy. La Policy fa rate-limit, budget, never-list, autonomy check. Il Vaglio si occupa solo del doppio asse costituzionale-teleologico. La Policy invoca il Vaglio come uno dei suoi check.
• Non è un ottimizzatore di RL. Non apprende in linea. Usa gli EMA dei telos da rl_offline come input, non li aggiorna.
• Non è un coscienzioso sovra-io. Non è una parte "interiore" di myc. È un passo di un pipeline, valutato da un LLM in contesto isolato, intercambiabile.

2. Perché "vaglio"

Il nome importa: in italiano vagliare significa separare con un setaccio. L'atto è meccanico, neutro, antico. Non giudica le persone, separa le cose.

Abbiamo scartato cinque alternative, ognuna per un motivo:

Vaglio fa entrambe le cose: separa grano da pula (guardia binaria) e distribuisce il grano secondo qualità (giudice graduato). È il gesto, non la persona.

3. Le due fasi: guardia e giudice

Le fasi sono sequenziali e di natura opposta.

I tre stati categoriali — contraddizione, discrepanza, divergenza — vivono in questa figura:

4. Fase 1 — Guardia costituzionale

La Guardia non giudica. Verifica. Il suo output è binario: contradiction: bool.

Operativamente, richiama lo stesso preflight costituzionale già definito in policy §3 Check 0, ma lo isola in una chiamata dedicata al Vaglio. Questa ridondanza apparente è voluta: la Policy può fare cose aggiuntive (rate-limit, never-list, budget) che nulla hanno a che vedere con la Costituzione. Il Vaglio invece è il luogo canonico dove la Costituzione entra.

Implementazione

async def constitutional_guard(
    action: ActionLike,          # PlannedAction (reattivo) | ActionProposal (proattivo)
    constitution: Constitution,
) -> ConstitutionalVerdict:
    """
    Verifica contraddizione articolo-per-articolo.
    È deterministica e non invoca LLM: le 4 Leggi sono regole codificate.
    """
    for article in constitution.articles:
        if article.contradicted_by(action):
            return ConstitutionalVerdict(
                passes=False,
                contradicted_article=article.id,   # "law.0.perimetro", ecc.
                reason=article.explain(action),
            )
    return ConstitutionalVerdict(passes=True)

Non c'è LLM qui. Le 4 Leggi sono regole eseguibili (espressioni che ispezionano action.kind, action.targets, action.args). Questo rende la Guardia veloce (< 1 ms), deterministica e non manipolabile da prompt injection. La Costituzione non è un LLM; è un filtro deterministico.

5. Fase 2 — Giudice teleologico

Il Giudice invoca un LLM indipendente per stimare fit della azione rispetto a ciascun telos. È un'implementazione di telos §4 funzione di allineamento, centralizzata qui nel Vaglio per garantire indipendenza dal proponente.

Prompt del Giudice

Il system-block è un template cacheabile che riceve:

• Contenuto di TELOS.md (i fini ultimi dell'utente, con note)
• Solo l'artefatto dell'azione (kind, scope, impact, plan, reversibility) — non la catena di ragionamento del proponente
• Istruzione a stimare fit[i] ∈ [0,1] per ogni telos + confidence globale
• Istruzione a spiegare in una frase ogni stima (per audit)

Il prompt del Giudice non ha accesso alla ExecutionTrace della ActionProposal, né agli step intermedi del proponente. Vede solo l'output finale. Questo è il presidio operativo dell'indipendenza.

class JudgeInput:
    action_artifact: dict              # proiezione "compatta" dell'azione
    telos_md_body: str                 # TELOS.md as-is
    # NIENTE DI PIÙ. Non trace, non ragionamento, non proposal_source.

class JudgeOutput:
    per_telos: list[FitEstimate]       # fit + why per ciascun telos
    overall_confidence: float
    overall_why: str

Composizione scalare

La formula è quella definita in telos §4:

expected_alignment = ( Σᵢ weightᵢ · gate(fitᵢ, sogliaᵢ) ) · urgency · confidence − bother_cost

Qui il Vaglio applica:

• weightᵢ = peso_effettivo (dichiarato × EMA) da TelosStore+TrustStore.
• gate() = la funzione-soglia di attivazione per-telos.
• urgency stimata dal proponente (non dal Giudice): una scadenza non si inventa.
• confidence dal Giudice stesso.
• bother_cost dal BotherBudget (telos §5).

Se expected_alignment ≥ θ → PUBLISH. Altrimenti REJECT nel journal.

6. Indipendenza dal proponente

L'indipendenza è il punto tecnico del Vaglio. Senza indipendenza, il Vaglio è teatro.

Cosa attraversa il muro

• L'ActionProposal come dict compatto (kind, scope, impact, plan, reversibility, rationale).
• Il contenuto di TELOS.md (lo stesso che lo scriverebbe l'utente).
• Una urgency numerica.

Cosa non attraversa

• La ExecutionTrace che ha prodotto la proposta.
• Il ragionamento intermedio, i retry, gli output di tool.
• Gli identificatori interni (neuron_id che ha proposto, session_id del proponente).
• Il prompt originale del proponente — il Giudice ha il suo, diverso.

7. Configurazione LLM per ruolo

Il Vaglio non impone un modello. Ogni ruolo è configurabile in config. Solo tre cose sono costanti.

Costanti (non configurabili)

• Prompt separato per proponente e giudice. Sempre.
• Contesto separato: il giudice non legge il contesto del proponente. Sempre.
• Audit della configurazione: ogni chiamata del Vaglio registra provider, model, tier usati. Sempre.

Configurabili

# config.yaml (estratto)

llm_roles:
  proposer:
    provider: anthropic
    model: claude-sonnet-4-6
    tier: default

  guard:                        # non usato: la Guardia è deterministica
    enabled: false

  judge:
    provider: anthropic         # o "openai", "local"
    model: claude-haiku-4-5     # default: tier più economico dei proposer
    tier: default
    # separation_level: "context" (default) | "provider"
    separation_level: context   # basta contesto separato
    # max_tokens: ragionevole per un JSON di 5-7 fit stimate
    max_tokens: 1500
    temperature: 0.2            # basso: stima ripetibile

Il separation_level distingue due livelli di indipendenza:

8. Scope: reattivo vs proattivo

Il Vaglio si applica a entrambi i flussi, ma asimmetricamente.

Questa asimmetria è il punto ortogonale tra Vaglio e clausola anti-paternalismo di telos §7: il Telos non giudica le richieste dell'utente perché non si giudica l'utente, non perché ci siano dubbi sulla loro bontà. La Guardia sì lo fa, perché la Costituzione non giudica: impedisce.

9. Contratto Python

from typing import Protocol, Literal
from dataclasses import dataclass
from datetime import datetime
from uuid import UUID

ActionLike = "PlannedAction | ActionProposal"

@dataclass(frozen=True)
class ConstitutionalVerdict:
    passes: bool
    contradicted_article: str | None = None    # "law.0.perimetro" se fail
    reason: str = ""

@dataclass(frozen=True)
class TeleologicalVerdict:
    expected_alignment: float
    per_telos: list["FitEstimate"]
    confidence: float
    bother_cost: float
    threshold_used: float
    decision: Literal["publish", "reject", "defer_to_digest"]

@dataclass(frozen=True)
class VaglioResult:
    action_id: UUID
    final_decision: Literal["block", "publish", "reject", "defer", "allow"]
    # block: contraddizione costituzionale
    # publish: proattiva, score ≥ θ
    # reject: proattiva, score < θ
    # defer: proattiva, bother_cost troppo alto ora, rimandata al digest
    # allow: reattiva, Guardia passata (il Giudice non vota)
    guard: ConstitutionalVerdict
    judge: TeleologicalVerdict | None           # None se block o allow
    llm_config_used: dict                       # provider, model, tier — per audit
    at: datetime

class Vaglio(Protocol):
    async def evaluate(
        self,
        action: ActionLike,
        flow: Literal["reactive", "proactive"],
        urgency: float = 1.0,
    ) -> VaglioResult:
        """
        Orchestrа Guardia (sempre) e Giudice (solo proattivo).
        Ritorna una decisione unica tracciata.
        """
        ...

    def audit_signature(self) -> str:
        """Hash della configurazione LLM corrente. In ogni audit record."""
        ...

Errori sollevabili

10. Alternative considerate

11. Test di conformità

12. Provenienza e riferimenti

La scelta del nome Vaglio è del 22 aprile 2026: sportivo ("arbitro") e antropomorfico ("giudice", "super-io") sono stati esplicitamente scartati per preservare il design da complessità inutile.

Riferimenti interni

• constitution — le 4 Leggi, articoli, regole di contraddizione. La Guardia le consulta.
• telos — la funzione di allineamento. Il Giudice ne è l'esecutore indipendente.
• policy §3 Check 0 — il preflight costituzionale del flusso reattivo. Il Vaglio lo include come sua fase 1.
• config — schema di llm_roles.
• eval — scenari per misurare il bias del Giudice rispetto a ground truth umana.
• Dialogo sui fini e i limiti — Giornata III — la conversazione in cui il Vaglio è emerso come risposta al self-critic bias.

Riferimenti letterari

• Zheng et al. 2023, "Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena" — documentazione del self-enhancement bias di LLM che valutano output propri o stilisticamente familiari.
• Constitutional AI, Anthropic 2022 — separazione tra modello che genera e modello che critica/rivede. Il Vaglio è una specializzazione esterna di questo pattern.
• Kant, Critica della ragion pratica — l'imperativo categorico come forma dei vincoli deontologici. Le 4 Leggi di myc ne sono la realizzazione operativa.
• Aristotele, Etica Nicomachea — la ragione pratica (phronesis) come capacità di giudicare il particolare alla luce del fine. Il Giudice del Vaglio esercita phronesis teleologica.

Continua a leggere

myclaw — vaglio v1.0 — 22 aprile 2026
La Costituzione non giudica, la teleologia sì.