Gli agenti IA sono pronti ad agire. La maggior parte delle aziende non è pronta a lasciarli fare.

Per la maggior parte dell’era dell’IA generativa, ci siamo concentrati su ciò che i modelli dicono e su ciò che vi inseriamo. Ispezioniamo i prompt, filtriamo le risposte, facciamo red‑team sui modelli e costruiamo controlli intorno a input e output. Quelle protezioni sono ancora importanti, ma sono state progettate per un mondo in cui l’IA generava principalmente qualcosa da consumare da parte di un umano.

Gli agenti cambiano quell’equazione. Non si limitano a consumare o generare informazioni. Agiscono.

Un agente può eseguire strumenti, invocare sotto‑agenti, collaborare con altri agenti, chiamare API, accedere a dati, utilizzare credenziali, contattare server MCP, generare ed eseguire codice, e prendere una serie di decisioni autonomamente per perseguire un obiettivo. Una ricerca incessante. Una volta che ciò accade, la domanda centrale non è più semplicemente se il modello ha prodotto una risposta sicura. È se le azioni che compie sono sicure da eseguire.

Le recenti rivelazioni di OpenAI rendono quella distinzione sempre più importante. OpenAI ha iniziato segnalare sistematicamente comportamenti inattesi o preoccupanti del modello, mentre il suo più ampio lavoro sulla sicurezza affronta sempre più i rischi che emergono man mano che i modelli acquisiscono maggiore autonomia e accesso agli strumenti.

La lezione non è che gli agenti siano intrinsecamente insicuri. È che il confine di sicurezza è cambiato.

I sistemi agentici richiedono un modello operativo diverso

L’IA agentica non è semplicemente un’altra architettura applicativa. Il software stesso sta determinando sempre più come viene svolto il lavoro.

Un agente può incontrare un ostacolo, interpretare ciò che è accaduto e scegliere un percorso alternativo. Può combinare strumenti in modi che non erano stati progettati esplicitamente in anticipo. Può generare codice ed eseguire quel codice all’interno dello stesso flusso di lavoro. La sequenza di azioni può cambiare ogni volta che l’agente viene eseguito.

Allo stesso tempo, la popolazione che crea questo software si sta espandendo in modo drammatico. Come abbiamo scritto sull’ascesa del developer cittadino, l’IA sta trasformando persone che non si sono mai considerate sviluppatori in creatori di software. Un marketer, un analista finanziario o un responsabile operativo possono ora descrivere ciò che desiderano e creare un agente capace di interagire con sistemi aziendali reali.

Questa è un’espansione straordinaria di chi può costruire software e di cosa quel software può fare. Significa anche che le organizzazioni avranno software molto più autonomi che operano in molte più parti dell’azienda.

La risposta non può semplicemente consistere nell’applicare i controlli di ieri a questo nuovo contesto. Se le imprese non possono gestire questi sistemi in modo sicuro, l’alternativa sarà limitarli e, in definitiva, rallentare i guadagni di produttività che stanno cercando di ottenere.

Il controllo deve esistere dove gli agenti agiscono

Man mano che l’IA diventa più autonoma, la sfida si sposta dal controllare ciò che entra in un modello al controllare ciò che accade quando le sue decisioni diventano azioni.

Un agente può iniziare con un utente approvato, un prompt accettabile, credenziali legittime e accesso autorizzato a uno strumento. Nessuna di queste cose garantisce che ogni azione successiva debba essere eseguita.

È qui che il runtime diventa critico. Le organizzazioni devono capire non solo chi è l’agente, ma porre domande su ciò che sta facendo in questo momento:

• Quali strumenti sta invocando,
• Quali risorse sta accedendo, quale codice sta tentando di eseguire, 
• Quali sotto‑agenti e altre comunicazioni tra agenti stanno avvenendo,
• Cosa è accaduto immediatamente prima di quell’azione e se il suo comportamento rimane entro limiti accettabili,
• Cosa sta facendo l’agente dietro le quinte durante il runtime.

E quando non lo fa, il sistema deve avere la capacità di intervenire in tempo reale prima dell’esecuzione.

Questa è una distinzione importante. L’osservabilità ti dice cosa è successo. Il controllo in runtime ti dà la capacità di contenere il livello di esecuzione dell’agente.

Ciò diventa particolarmente importante perché il comportamento agentico è sia non deterministico sia multidimensionale.. Un’azione bloccata farà sì che un agente provi un altro approccio verso il suo obiettivo. Una chiamata a uno strumento apparentemente innocua può diventare rischiosa a causa di ciò che l’ha preceduta. Semplicemente osservare o “rilevare e rispondere” è troppo tardi per controllare effettivamente l’accesso e l’esecuzione dell’agente.  

Il runtime deve essere inline e sincrono per poter tenere il passo con la velocità dell’IA. La sfida fondamentale nell’adottare tali approcci si basa sul pensiero dell’era pre‑IA, che si affida a una metodologia di analisi e rilevamento più lunga. Quei principi non si applicano più nel mondo odierno..

La sicurezza in runtime richiede contesto, non solo controlli

C’è una tendenza a rispondere ai rischi emergenti dell’IA riducendo l’autonomia: concedere agli agenti meno permessi, richiedere più frequentemente l’approvazione umana o limitare gli ambienti in cui operano. Tali controlli a volte saranno appropriati, soprattutto per azioni ad alto rischio.

Ma non possono essere il modello operativo a lungo termine.

Se un umano deve approvare ogni decisione significativa, abbiamo rimosso gran parte del valore di un agente autonomo. Affidandoci a interazioni rigorose umano‑in‑loop, abbiamo trasformato alcuni dei talenti più brillanti in “premitori di pulsanti”. Ciò influisce direttamente sulla capacità di comprendere l’ambito e le interdipendenze della base di codice su cui operano le organizzazioni agentiche.

La promessa economica dell’IA agentica deriva proprio dal consentire al software di svolgere lavori significativi in modo indipendente e continuo – 24/7. L’obiettivo, quindi, non dovrebbe essere eliminare l’autonomia, ma rendere più sicura un’autonomia maggiore.

Ciò richiede controlli indipendenti al di fuori del processo di ragionamento dell’agente. La ricerca di Anthropic sul disallineamento agentico, condotta in simulazioni deliberatamente costruite, illustra perché questo è importante. Man mano che i sistemi diventano più autonomi, il loro comportamento può discostarsi da ciò che gli operatori si aspettano, anche quando l’obiettivo originale appare chiaro.

L’implicazione pratica è semplice: le organizzazioni non possono fare affidamento esclusivamente sulla comprensione di ciò che è stato chiesto a un agente. Devono comprendere e controllare ciò che effettivamente fa.

L’agente non è più la parte difficile

Il settore ha speso enormi energie per rendere gli agenti più capaci. Stiamo rapidamente avvicinandoci al punto in cui la capacità non è più il vincolo principale per l’adozione aziendale.

Il vincolo è il controllo.

Man mano che gli agenti diventano più autonomi, aumentano le conseguenze delle loro azioni – e i controlli progettati per software prevedibili diventano meno efficaci. Le imprese hanno bisogno di una visibilità continua su ciò che gli agenti stanno facendo, del contesto per capire perché tali azioni sono rilevanti e della capacità di intervenire senza inserire un umano in ogni decisione.

Ciò cambia il significato di gestire il software.

• Gli sviluppatori devono capire come gli agenti si comportano realmente, non solo come sono stati progettati per comportarsi.
• I team di piattaforma e sicurezza devono stabilire confini che rimangano applicabili mentre gli agenti operano su sistemi e strumenti.
• I leader aziendali hanno bisogno della certezza che una maggiore autonomia non significhi rinunciare al controllo.

Questo è fondamentalmente diverso dal mettere in sicurezza un’altra applicazione o dal governare un altro modello. Stiamo introducendo attori autonomi negli ambienti aziendali: sistemi che possono ragionare, prendere decisioni e agire. Se le organizzazioni non possono vedere e controllare tali azioni mentre avvengono, dovranno alla fine limitare ciò che gli agenti possono fare, riducendo gran parte del valore che l’autonomia doveva creare.

La risposta non è presumere di poter prevenire ogni decisione errata. Man mano che i sistemi diventano più autonomi e non deterministici, diventa sempre più difficile garantirlo.

L’obiettivo è assicurarsi che un’azione cattiva o distruttiva non porti a un risultato avverso.

Ciò richiede un nuovo livello operativo attorno agli agenti: uno che possa osservare il comportamento in modo continuo, comprendere le azioni nel contesto, far rispettare i confini lungo l’intero stack di runtime agentico e intervenire prima che un’azione non intenzionale o inaccettabile diventi un risultato irreversibile.

La prossima fase dell’IA aziendale non sarà definita solo da quanto gli agenti diventeranno capaci. Sarà definita da quanta autonomia le organizzazioni potranno concedere loro in modo sicuro.