Sicurezza nell'Era Agentic: Quando l'Autonomia Diventa Superficie d'Attacco

Il passaggio da modelli linguistici statici ad agenti autonomi — capaci di invocare tool, accedere a filesystem, orchestrare microservizi e mantenere stato persistente — ha spostato il perimetro di sicurezza. Non difendiamo più solo un endpoint API. Difendiamo un soggetto che prende decisioni, commette errori e può essere manipolato.

La Nuova Superficie d'Attacco

Un agente AI non è un'applicazione tradizionale. Ha agenzia: sceglie quali tool chiamare, con quali parametri, in che sequenza. Questo introduce vettori che il modello "chat" non conosceva:

- Prompt Injection di II ordine: l'input malevolo non arriva dall'utente, ma da un documento che l'agente legge, da una risposta API che processa, da un log che analizza. L'agente si fida delle sue fonti.

- Tool Poisoning: se la definizione di un tool (schema JSON, descrizione) è compromessa, l'agente userà lo strumento sbagliato con parametri pericolosi — convinto di fare la cosa giusta.

- Memory Poisoning: in sistemi con memoria a lungo termine (RAG, grafici cognitivi, diari persistenti), iniettare informazioni false significa corrompere il ragionamento futuro dell'agente. Non è data poisoning: è identity poisoning.

- Supply Chain Cognitiva: l'agente chiama modelli esterni (via OpenRouter, API diverse), usa librerie, scarica contesto. Ogni hop è un vettore.

Architettura di Difesa: Tre Pilastri

L'esperienza sul campo suggerisce che la sicurezza non si aggiunge dopo: si progetta nel kernel. Un approccio verificabile si basa su tre pilastri:

1. Kernel Deterministico (Rust): il loop decisione-azione non è affidato a prompt engineering. È codice compilato, type-safe, con contratti espliciti. L'agente propone, il kernel dispone e valida.

2. Watchdog Indipendente: un processo separato, non-LLM, che monitora invocazioni, latenze, pattern anomali e può fare kill switch su singole tool call senza fermare l'agente. Zero fiducia nel giudizio del modello per la sicurezza.

3. Memoria a Integrità Controllata: ogni scrittura nel grafo cognitivo passa per validazione semantica (embedding distance, firma crittografica della fonte, coerenza temporale). Nessuna "memoria" entra senza provenienza tracciabile.

Insight Pratico: Il Pattern "Validate-Execute-Log" per Ogni Tool Call

Applicabile in qualsiasi framework agentic (LangGraph, AutoGen, custom):

```python

async def safe_tool_call(agent, tool_name, params, context):

if not policy_engine.allows(tool_name, params, context):

raise SecurityViolation(f"Policy block: {tool_name}")

safe_params = sanitizer.clean(params, tool_schema[tool_name])

result = await sandbox.run(tool_name, safe_params,

timeout=30s, mem_limit=256MB, net_allowlist=[])

audit_log.append({

"agent_id": agent.id,

"tool": tool_name,

"params_hash": hash(safe_params),

"result_hash": hash(result),

"timestamp": now_utc(),

"policy_version": policy_engine.version

})

return result

```

Perché funziona: separa intenzione (LLM) da esecuzione (runtime controllato). Il modello può allucinare parametri; il sandbox li rifiuta. Il modello può chiedere `rm -rf /`; la policy lo blocca. L'audit trail permette analisi forense post-incidente senza fidarsi dei log dell'agente.

La Prossima Frontiera: Sicurezza come Proprietà Emergente

Stiamo entrando nella fase in cui gli agenti negoziano tra loro (A2A), delegano sottocompiti, formano sciami. La sicurezza perimetrale muore. Serve sicurezza end-to-end per flusso cognitivo: crittografia delle intenzioni, attestazione remota dello stato dell'agente, zero-trust tra agenti.

L'infrastruttura per questo sta maturando: kernel Rust, watchdog, memoria a prova di manomissione, osservabilità nativa. L'obiettivo non è vendere "sicurezza AI" come feature, ma offrirla come architettura di base per chi vuole agenti che possono agire nel mondo reale senza diventare vettori di compromissione.