---
title: Proteggi il tuo deployment di Managed Agents
url: https://platform.claude.com/docs/it/managed-agents/secure-deployment
description: Le impostazioni che limitano ciò che i tuoi agenti possono raggiungere e fare, a partire dalle più importanti.
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
Questa guida elenca le impostazioni che limitano ciò che un agente su Claude Managed Agents può raggiungere e fare, a partire dalle più importanti. Ogni sezione rimanda alla pagina che tratta l'impostazione in modo completo.
| Sezione | Impostazione o decisione | Consigliato |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [Scegli dove viene eseguito l'agente](https://platform.claude.com/docs/it/managed-agents/secure-deployment#choose-where-the-agent-runs) | Sandbox cloud o self-hosted | Cloud, a meno che gli strumenti non debbano essere eseguiti su un'infrastruttura che controlli |
| [Limita la rete](https://platform.claude.com/docs/it/managed-agents/secure-deployment#limit-the-network) | `networking.type` dell'ambiente | `limited`, con solo gli host di cui l'agente ha bisogno |
| [Conserva le credenziali nei vault](https://platform.claude.com/docs/it/managed-agents/secure-deployment#keep-credentials-in-vaults) | `injection_location` e `networking` su ogni credenziale di tipo variabile d'ambiente | Solo header della richiesta, e networking `limited` con solo gli host a cui è destinata la chiave |
| [Limita web search e web fetch](https://platform.claude.com/docs/it/managed-agents/secure-deployment#restrict-web-search-and-web-fetch) | `allowed_domains` su ogni strumento web | Una allowlist su ogni strumento. Su `web_fetch`, elenca solo i siti di cui l'agente ha bisogno. Su `web_search`, elenca i siti da cui vuoi ottenere risultati |
| [Approva le azioni rischiose](https://platform.claude.com/docs/it/managed-agents/secure-deployment#approve-risky-actions) | `permission_policy` su ogni strumento | `auto` su `bash`, `write`, `edit`, `web_fetch` e sugli strumenti MCP che leggono solo dati. `always_ask` invece su uno strumento se non puoi annullare le sue modifiche al di fuori della sandbox, o se il solo testo dell'utente finale inoltrato non dovrebbe farlo eseguire |
| [Dai all'agente il set di strumenti più ridotto](https://platform.claude.com/docs/it/managed-agents/secure-deployment#give-the-agent-the-smallest-tool-set) | `default_config.enabled` sul toolset dell'agente | `false`, poi abilita gli strumenti di cui l'agente ha bisogno |
| [Tieni l'input non attendibile lontano dagli strumenti potenti](https://platform.claude.com/docs/it/managed-agents/secure-deployment#keep-untrusted-input-away-from-powerful-tools) | Quali strumenti e credenziali possiede un agente quando legge input non attendibile | Nessun agente che legge input non attendibile ha su `always_allow` uno strumento che scrive file, esegue comandi o modifica record |
| [Imposta limiti e un modo per fermare l'agente](https://platform.claude.com/docs/it/managed-agents/secure-deployment#set-limits-and-a-way-to-stop) | `budget` su ogni sessione e deployment | Un tetto dimensionato in base a quanto prevedi che costi un'esecuzione |
| [Facoltativamente, fai leggere ogni trascrizione a un revisore offline](https://platform.claude.com/docs/it/managed-agents/secure-deployment-monitoring#optionally-have-an-offline-reviewer-read-every-transcript) | Un job di revisione offline che esegui tu e che legge gli eventi di ogni sessione | Facoltativo. Una revisione pianificata di ogni sessione che è diventata inattiva o è terminata |
| [Monitora le sessioni e rivedi la conservazione](https://platform.claude.com/docs/it/managed-agents/secure-deployment-monitoring#monitor-sessions-and-review-retention) | Webhook ed eliminazione delle sessioni | Un avviso quando una sessione diventa inattiva, raggiunge il suo budget o termina, e una verifica del motivo per cui è diventata inattiva. Archivia nei tuoi log gli eventi che vuoi conservare ed elimina le sessioni che non ti servono più |
[Rischi per la sicurezza e limiti della sandbox](https://platform.claude.com/docs/it/managed-agents/secure-deployment-risks) spiega perché queste impostazioni sono importanti e da cosa non proteggono. Per rivedere e monitorare le sessioni, consulta [Rivedere e monitorare le sessioni degli agenti](https://platform.claude.com/docs/it/managed-agents/secure-deployment-monitoring).
## Scegli dove viene eseguito l'agente
Il luogo in cui vengono eseguiti gli strumenti dell'agente determina chi protegge la "sandbox" (ambiente isolato): Anthropic, con un ambiente cloud, oppure tu, con una sandbox self-hosted. Per scegliere tra le due opzioni e sapere cosa raggiunge Anthropic con ciascuna, consulta [Scegliere un ambiente per l'agente](https://platform.claude.com/docs/it/managed-agents/choosing-an-environment).
Se usi una [sandbox self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes), tieni presenti questi quattro punti:
* **Rete:** [Limita la rete](https://platform.claude.com/docs/it/managed-agents/secure-deployment#limit-the-network) si applica agli ambienti cloud. Per una sandbox self-hosted, imposta limiti equivalenti sul suo traffico nel tuo firewall. Il tuo firewall non limita i server MCP dichiarati da un agente, quindi rivedili, insieme a quelli che la tua applicazione imposta per una sessione.
* **Strumenti web:** Gli strumenti web vengono eseguiti sui server di Anthropic, quindi il tuo firewall non li limita. Limitali con i loro elenchi di domini. Consulta [Limita web search e web fetch](https://platform.claude.com/docs/it/managed-agents/secure-deployment#restrict-web-search-and-web-fetch).
* **Credenziali:** Le credenziali di tipo variabile d'ambiente non sono ancora supportate con le sandbox self-hosted.
* **Isolamento e hardening:** Sei responsabile di entrambi. Consulta il [Modello di sicurezza](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes-security).
Nessuna delle due opzioni modifica la copertura di conformità di Managed Agents né la durata di conservazione della cronologia delle sessioni. Consulta [Monitora le sessioni e rivedi la conservazione](https://platform.claude.com/docs/it/managed-agents/secure-deployment-monitoring#monitor-sessions-and-review-retention).
## Limita la rete
Imposta `networking.type` su `limited` ed elenca in `allowed_hosts` solo gli host di cui l'agente ha bisogno. Una richiesta di creazione di un ambiente che omette `networking` potrebbe ottenere `unrestricted`, quindi imposta `networking` in ogni richiesta di creazione. Consulta [Rischi del networking senza restrizioni](https://platform.claude.com/docs/it/managed-agents/environments#risks-of-unrestricted-networking).
I file, i memory store e i repository GitHub che colleghi restano disponibili per l'agente indipendentemente da `allowed_hosts`.
Gli esempi in questa pagina usano un agente di supporto. Legge il ticket di un cliente, cerca l'ordine, legge il tuo centro assistenza e redige una risposta. La ricerca dell'ordine viene eseguita dalla tua applicazione e non richiede alcun host, quindi questo ambiente consente un solo host, il centro assistenza, per `web_fetch`:
```bash cURL
curl -fsS https://api.anthropic.com/v1/environments \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"name": "support-agent",
"config": {
"type": "cloud",
"networking": {
"type": "limited",
"allowed_hosts": ["help.example.com"]
}
}
}'
```
```bash CLI
ant apply environment.yaml
```
```yaml
# yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
name: support-agent
config:
type: cloud
networking:
type: limited
allowed_hosts:
- help.example.com
```
```python Python
environment = client.beta.environments.create(
name="support-agent",
config={
"type": "cloud",
"networking": {
"type": "limited",
"allowed_hosts": ["help.example.com"],
},
},
)
```
```typescript TypeScript
const environment = await client.beta.environments.create({
name: "support-agent",
config: {
type: "cloud",
networking: {
type: "limited",
allowed_hosts: ["help.example.com"]
}
}
});
```
```csharp C#
using Anthropic.Models.Beta.Environments;
var environment = await client.Beta.Environments.Create(new()
{
Name = "support-agent",
Config = new BetaCloudConfigParams
{
Networking = new BetaLimitedNetworkParams
{
AllowedHosts = ["help.example.com"],
},
},
});
```
```go Go
environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
Name: "support-agent",
Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
OfCloud: &anthropic.BetaCloudConfigParams{
Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
OfLimited: &anthropic.BetaLimitedNetworkParams{
AllowedHosts: []string{"help.example.com"},
},
},
},
},
})
if err != nil {
panic(err)
}
_ = environment
```
```java Java
import com.anthropic.models.beta.environments.*;
import java.util.List;
var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
.name("support-agent")
.config(BetaCloudConfigParams.builder()
.networking(BetaLimitedNetworkParams.builder()
.allowedHosts(List.of("help.example.com"))
.build())
.build())
.build());
```
```php PHP
$environment = $client->beta->environments->create(
name: 'support-agent',
config: [
'type' => 'cloud',
'networking' => [
'type' => 'limited',
'allowed_hosts' => ['help.example.com'],
],
],
);
```
```ruby Ruby
environment = client.beta.environments.create(
name: "support-agent",
config: {
type: "cloud",
networking: {
type: "limited",
allowed_hosts: ["help.example.com"]
}
}
)
```
Un ambiente `limited` ha tre impostazioni di networking:
| Impostazione | Cosa apre al codice nella sandbox | Consigliato |
| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `allowed_hosts` | Gli host che elenchi, per qualsiasi richiesta | Solo gli host di cui l'agente ha bisogno, incluso l'host di ogni server MCP che gestisci o di cui ti fidi |
| `allow_package_managers` | Gli [host dei gestori di pacchetti](https://platform.claude.com/docs/it/managed-agents/environments#package-manager-hosts). Includono ogni repository e percorso su `github.com`, `gitlab.com` e `bitbucket.org`, dove chiunque può pubblicare contenuti e dove il codice nella sandbox può caricare file | `false`, a meno che l'impostazione `packages` dell'ambiente non elenchi pacchetti, il che richiede `true`. Se l'agente installa pacchetti durante l'esecuzione, elenca invece in `allowed_hosts` solo gli host dei registry di cui ha bisogno |
| `allow_mcp_servers` | Nessun host. Managed Agents si connette ai server MCP dai server di Anthropic | `false`, con l'host di ogni server MCP che gestisci o di cui ti fidi elencato in `allowed_hosts` |
Le impostazioni `allow_package_managers` e `allow_mcp_servers` non aggiungono host per web search e web fetch.
Lascia `allow_mcp_servers` disattivato, che è il valore predefinito, ed elenca in `allowed_hosts` l'host di ogni server MCP che gestisci o di cui ti fidi. Ogni host che elenchi è aperto anche al codice nella sandbox. Con `allow_mcp_servers` disattivato, un controllo alla creazione della sessione rifiuta la richiesta se l'host di un server MCP non è elencato. Consulta [Fornisci l'autenticazione alla creazione della sessione](https://platform.claude.com/docs/it/managed-agents/mcp-connector#provide-authentication-at-session-creation). Lo stesso controllo viene eseguito quando un aggiornamento della sessione modifica `mcp_servers`.
L'accesso alla rete viene concesso per ogni host, non per ogni operazione. La sandbox può inviare qualsiasi richiesta a un host consentito, inclusi caricamenti come `git push` e la pubblicazione di pacchetti. Può anche usare qualsiasi credenziale fornita dal comando, anche una che qualcuno ha nascosto nel testo letto dall'agente.
Quando scegli gli host per `allowed_hosts`, segui queste due regole:
* Elenca solo host che gestisci o di cui ti fidi.
* Evita i wildcard `*.` e i domini di hosting condiviso dove chiunque può pubblicare contenuti.
Se l'agente mantiene `bash`, imposta la [policy di autorizzazione](https://platform.claude.com/docs/it/managed-agents/permission-policies) dello strumento `bash` come descritto in [Approva le azioni rischiose](https://platform.claude.com/docs/it/managed-agents/secure-deployment#approve-risky-actions).
Dopo aver reso più restrittivo un ambiente, avvia nuove sessioni e ferma quelle già in esecuzione. Una sessione già in esecuzione può mantenere i vecchi limiti fino al suo termine. Consulta [Imposta limiti e un modo per fermare l'agente](https://platform.claude.com/docs/it/managed-agents/secure-deployment#set-limits-and-a-way-to-stop).
Consulta [Configurazione dell'ambiente cloud](https://platform.claude.com/docs/it/managed-agents/environments#networking) per tutte le impostazioni di networking.
## Conserva le credenziali nei vault
Archivia ogni segreto in un "vault" (cassaforte per credenziali). Per ogni credenziale di tipo variabile d'ambiente, imposta la posizione di iniezione solo sugli header della richiesta ed elenca solo gli host a cui è destinato il segreto. Il codice nella sandbox vede un segnaposto al posto del segreto. Managed Agents sostituisce il segnaposto con il segreto reale solo nelle richieste HTTPS in uscita verso gli host consentiti dalla credenziale. In questo modo il segreto resta fuori dalla portata diretta del modello, a meno che un servizio non lo rimandi indietro, come un endpoint che restituisce gli header della richiesta. Se il `networking` della credenziale è `unrestricted`, Managed Agents sostituisce il segnaposto con il segreto reale nelle richieste verso qualsiasi host che l'ambiente consente alla sandbox di raggiungere. Per usare un vault, passa il suo ID in `vault_ids` quando crei la sessione o il deployment.
| Impostazione | Impostala su | Perché | Cosa non fa |
| ----------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `injection_location` | `{"header": true, "body": false}`, dopo aver verificato che il servizio legga la chiave da un header | I corpi delle richieste sono spesso costruiti a partire dal contenuto letto dall'agente, quindi una chiave in un corpo è più esposta. Specifica entrambi i campi: una richiesta di creazione che omette l'oggetto abilita entrambe le posizioni, e un aggiornamento modifica solo i campi che invii | Il codice può comunque usare la chiave su ogni host consentito dalla credenziale. Un servizio che si aspetta la chiave nel corpo riceve il segnaposto e rifiuta la richiesta |
| `networking` sulla credenziale | `limited`, con gli host esatti a cui è destinata la chiave | Le risposte raggiungono la sandbox senza oscuramento, quindi evita wildcard, domini di hosting condiviso e host che restituiscono gli header della richiesta | Non apre l'host. Anche l'ambiente deve consentirlo |
| I permessi della chiave, presso il servizio che l'ha emessa | Solo i permessi di cui l'agente ha bisogno | L'agente può fare tutto ciò che la chiave consente | Non applicabile |
| Il token GitHub di un repository montato | Un [token fine-grained](https://platform.claude.com/docs/it/managed-agents/github#token-permissions) con i permessi minimi | Il codice nella sandbox può usarlo per eseguire fetch e push sul repository montato per l'intera sessione. Concedi l'accesso in scrittura solo se l'agente deve eseguire push | Non applicabile |
L'agente di supporto non ha bisogno di alcuna credenziale nel vault, perché la chiave API per la tua API degli ordini è detenuta dalla tua applicazione. Se il tuo agente detiene una credenziale nel vault, consulta [Aggiungi una credenziale](https://platform.claude.com/docs/it/managed-agents/vaults#add-a-credential) per la richiesta in ogni linguaggio.
Tieni le chiavi fuori dai prompt di sistema, dalle definizioni degli agenti e dai messaggi. Non dare all'agente una chiave API di Claude. Anche quando una chiave API di Claude si trova in un vault, il codice nella sandbox può usarla per chiamare direttamente la Claude API. Può fare tutto ciò che quella chiave consente, come avviare o eliminare sessioni, o usare web search e web fetch. Le impostazioni degli strumenti dell'agente, le approvazioni e il budget non si applicano a quelle chiamate. In un ambiente `limited`, il codice può effettuare queste chiamate solo se `allowed_hosts` consente alla sandbox di raggiungere `api.anthropic.com`.
Recupera tu stesso i token e archiviali nel vault, perché un token che il codice nella sandbox recupera con un segreto archiviato torna indietro senza oscuramento.
Tieni i vault per carichi di lavoro con livelli di attendibilità diversi in [workspace](https://platform.claude.com/docs/it/manage-claude/workspaces) separati, perché qualsiasi chiave API con accesso a un workspace può fare riferimento ai suoi vault. Usa chiavi API limitate a un solo workspace.
Consulta [Autenticazione con i vault](https://platform.claude.com/docs/it/managed-agents/vaults) per le credenziali MCP e la rotazione.
## Limita web search e web fetch
Imposta `allowed_domains` su `web_fetch` con i siti di cui l'agente ha bisogno. Qualsiasi URL recuperato dall'agente può trasportare dati verso il sito a cui punta, quindi questo elenco è un controllo di sicurezza. Su `web_search`, imposta `allowed_domains` con i siti da cui vuoi ottenere risultati, in modo che i risultati provengano solo da siti che ritieni accurati. L'elenco non impedisce alla query di ricerca di raggiungere il provider di ricerca. I risultati di ricerca includono testo delle pagine, quindi l'elenco limita anche i siti il cui testo raggiunge l'agente. Imposta `allowed_domains` su entrambi gli strumenti per ogni tipo di ambiente.
Un elenco `blocked_domains` blocca gli host che elenchi e i loro sottodomini, e nessun altro host. Lo stesso contenuto può comunque raggiungere l'agente da archivi web, cache, mirror o domini correlati che non hai elencato. Non fare affidamento su `blocked_domains` per la sicurezza. Usa `allowed_domains` e indica gli host di cui ti fidi.
In un ambiente `limited`, l'elenco `allowed_hosts` di [Limita la rete](https://platform.claude.com/docs/it/managed-agents/secure-deployment#limit-the-network) limita anche gli strumenti web. Un ambiente `unrestricted` o una sandbox self-hosted non limita gli strumenti web.
| In un ambiente `limited` | Risultato |
| ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Una voce `allowed_domains` su uno strumento web abilitato è al di fuori di `allowed_hosts` | La creazione di una sessione fallisce con un errore 400, così come un aggiornamento della sessione che aggiunge una voce di questo tipo. Una sessione avviata da un deployment, secondo la sua pianificazione o tramite un'esecuzione manuale, viene creata comunque. Lo strumento poi non restituisce nulla dagli host al di fuori di `allowed_hosts` |
| Uno strumento web non ha un proprio elenco | Lo strumento restituisce pagine e risultati solo dagli host in `allowed_hosts`. Imposta anche `allowed_domains` sullo strumento |
| `allowed_hosts` non ha voci | Nessuno dei due strumenti web restituisce una pagina o un risultato di ricerca |
| Aggiungi un host ad `allowed_hosts` per uno strumento web | L'host è aperto anche al codice nella sandbox |
I due elenchi confrontano gli host in modo diverso:
| Elenco | Voce | Corrisponde a | Non corrisponde a |
| --------------------------------- | --------------- | --------------------------------- | ----------------- |
| `allowed_hosts` (ambiente) | `example.com` | `example.com` | `www.example.com` |
| `allowed_hosts` (ambiente) | `*.example.com` | Ogni sottodominio | `example.com` |
| `allowed_domains` (strumento web) | `example.com` | `example.com` e ogni sottodominio | Altri domini |
Se l'agente ha bisogno di un sito e di tutti i suoi sottodomini, elenca sia `example.com` sia `*.example.com` in `allowed_hosts`, altrimenti elenca host esatti. Se uno strumento elenca `example.com` e `allowed_hosts` elenca solo `*.example.com`, la sessione viene creata. Il controllo alla creazione della sessione considera `example.com` come compreso in `*.example.com`, ma lo strumento non restituisce nulla da `example.com` stesso. Consulta [Impostare elenchi di domini su un agente](https://platform.claude.com/docs/it/managed-agents/tools-web-restrictions#set-domain-lists-on-an-agent) per sapere come vengono confrontati i due elenchi.
Lo strumento `web_fetch` apre inoltre solo URL che sono già comparsi nella sessione:
| Dove compare l'URL | `web_fetch` può aprirlo |
| ------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| Il testo di un messaggio utente, incluso il testo dell'utente finale che inoltri | Sì |
| La descrizione di un evento `user.define_outcome` | Sì |
| L'indirizzo di un risultato di ricerca web | Sì |
| Il testo di una pagina restituita in precedenza da `web_fetch` (non un PDF), in cui è mostrato l'URL completo | Sì |
| Il testo del risultato di uno strumento personalizzato, quando Claude ha chiamato lo strumento direttamente | Sì, a meno che il risultato non sia contrassegnato con `is_error: true` |
| Il prompt di sistema | No |
| La configurazione dell'agente, incluse le voci di `allowed_domains` | No |
| L'output di Claude stesso | No |
| L'output di `bash` e degli altri strumenti della sandbox | No |
| Il risultato di uno strumento MCP | No |
| Un file allegato a un messaggio utente | No |
In una sessione multiagente, `web_fetch` apre un URL proveniente da un altro agente solo se ha raggiunto quell'agente tramite una fonte contrassegnata con Sì. Il risultato di uno strumento personalizzato da una chiamata diretta conta come fonte contrassegnata con Sì. Questo vale anche se il testo è stato scritto da Claude, ad esempio quando lo strumento ripete il proprio input. Un URL può essere valido anche quando è scritto senza `https://`, come `example.com/docs`. Lo strumento `web_fetch` non sempre riesce ad aprire un link che mostra parole invece del suo URL, come "Contatta l'assistenza". Se l'agente deve recuperare un URL che non è comparso nella sessione, invialo in un messaggio utente.
Questa regola riduce la probabilità che un testo iniettato costruisca un URL che trasporta dati privati. Il testo dell'utente finale, i risultati di ricerca, le pagine recuperate e i risultati degli strumenti personalizzati possono comunque aggiungere URL, quindi mantieni impostato `allowed_domains`. La Messages API applica una regola simile con un elenco di fonti diverso. Consulta [Validazione degli URL](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#url-validation).
Un elenco di domini su `web_fetch` non limita lo strumento `bash`. [Limita la rete](https://platform.claude.com/docs/it/managed-agents/secure-deployment#limit-the-network) anche in questo caso. Consulta [Regole degli elenchi di domini](https://platform.claude.com/docs/it/managed-agents/tools-web-restrictions#domain-list-rules).
## Approva le azioni rischiose
Imposta `auto` su `bash`, `write`, `edit` e `web_fetch`, e sugli strumenti MCP che leggono solo dati. Usa invece `always_ask` su uno strumento se non puoi annullare le sue modifiche al di fuori della sandbox. Usalo anche su uno strumento che non dovrebbe essere eseguito solo perché lo richiede il testo dell'utente finale che inoltri. Una [policy di autorizzazione](https://platform.claude.com/docs/it/managed-agents/permission-policies) determina se una chiamata a uno strumento viene eseguita, attende la tua approvazione o viene valutata dal server.
| Strumento | Policy consigliata | Perché |
| ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `read`, `glob`, `grep` | `always_allow` | Leggono file nella sandbox e non modificano nulla |
| `bash`, `write`, `edit` | `auto`. Usa `always_ask` su uno strumento se non puoi annullare le sue modifiche al di fuori della sandbox. Usa `always_ask` su `bash` se inoltri testo dell'utente finale | Il valore predefinito del toolset dell'agente è `always_allow`, che esegue ogni chiamata senza approvazione |
| `web_fetch` | `auto` | Un URL recuperato dall'agente può trasportare dati verso il sito a cui punta |
| `web_search` | `always_ask` se l'agente gestisce dati che non vorresti inviare in una query di ricerca. Altrimenti `always_allow` | `allowed_domains` limita i siti da cui provengono i risultati, non il contenuto della query |
| Strumenti MCP che leggono solo dati | `auto`, impostato per ogni strumento nei `configs` del toolset | Il valore predefinito del toolset resta `always_ask`, quindi uno strumento aggiunto in seguito dal server MCP attende comunque l'approvazione |
| Strumenti MCP che modificano dati | `always_ask` | È il valore predefinito del toolset MCP. Mantienilo |
| Strumenti personalizzati | Il tuo codice decide se ogni chiamata viene eseguita | Le policy di autorizzazione non si applicano |
Il toolset in [Dai all'agente il set di strumenti più ridotto](https://platform.claude.com/docs/it/managed-agents/secure-deployment#give-the-agent-the-smallest-tool-set) applica queste policy.
La [policy `auto`](https://platform.claude.com/docs/it/managed-agents/permission-policies#let-the-server-evaluate-each-call-with-auto) consente al server di eseguire una chiamata, negarla o mettersi in pausa in attesa di approvazione. Una persona non può approvare ogni chiamata in un'esecuzione lunga, quindi è il server a controllarle una per una. Abbina `auto` a un networking limitato, a una chiave con permessi ristretti, a un budget e a un avviso sulle sessioni inattive. `auto` non è un punto di controllo umano, quindi se una persona deve rivedere le chiamate a uno strumento prima che vengano eseguite, configura `always_ask` su quello strumento.
`auto` tratta il testo negli eventi `user.message` e la descrizione in un evento `user.define_outcome` come tue istruzioni, incluso il testo dell'utente finale che inoltri.
Una sessione in pausa attende indefinitamente, quindi una sessione non presidiata ha bisogno di un client che risponda alle chiamate in pausa o interrompa la sessione.
Rivedi ogni chiamata in pausa prima di consentirla. Un client che consente ogni chiamata senza mostrarla a una persona equivale a `always_allow`. Consulta [Rispondere alle richieste di conferma](https://platform.claude.com/docs/it/managed-agents/permission-policies#respond-to-confirmation-requests) e [Vedere come è stata valutata ogni chiamata](https://platform.claude.com/docs/it/managed-agents/permission-policies#see-how-each-call-was-evaluated).
## Dai all'agente il set di strumenti più ridotto
Imposta `default_config.enabled` su `false` e [abilita solo gli strumenti di cui l'agente ha bisogno](https://platform.claude.com/docs/it/managed-agents/tools#enabling-only-specific-tools). Il toolset dell'agente abilita per impostazione predefinita tutti e otto gli strumenti integrati.
| Strumento | Cosa fa |
| ------------------------- | ---------------------------------------------------------------------------------- |
| `bash` | Esegue qualsiasi comando, incluse le richieste agli host consentiti |
| `write`, `edit` | Modificano file nella sandbox |
| `read`, `glob`, `grep` | Leggono file nella sandbox |
| `web_fetch`, `web_search` | Restituiscono pagine e risultati di ricerca dal web, tramite i server di Anthropic |
L'agente di supporto ha bisogno di tre strumenti integrati: `read` e `write` per la sua bozza, e `web_fetch` per il centro assistenza. Cerca gli ordini tramite uno [strumento personalizzato](https://platform.claude.com/docs/it/managed-agents/tools#custom-tools), `lookup_order`, eseguito dalla tua applicazione. La chiave API per la tua API degli ordini è detenuta dalla tua applicazione, quindi l'agente non ha bisogno né di `bash` né di una credenziale.
L'esempio seguente limita `web_fetch` a `help.example.com` con `allowed_domains`. Imposta `auto` su `write` e `web_fetch`, come raccomandato in [Approva le azioni rischiose](https://platform.claude.com/docs/it/managed-agents/secure-deployment#approve-risky-actions). Se il ticket di un cliente induce l'agente a usare questi strumenti, l'agente può solo modificare file nella sandbox o aprire pagine del centro assistenza. Ecco perché nessuno dei due strumenti ha bisogno di `always_ask`. L'esempio imposta anche `always_ask` in `default_config`, così uno strumento che abiliti in seguito senza una propria policy usa `always_ask`:
```bash cURL
tools='[
{
"type": "agent_toolset_20260401",
"default_config": {
"enabled": false,
"permission_policy": {"type": "always_ask"}
},
"configs": [
{"name": "read", "enabled": true, "permission_policy": {"type": "always_allow"}},
{"name": "write", "enabled": true, "permission_policy": {"type": "auto"}},
{
"name": "web_fetch",
"enabled": true,
"allowed_domains": ["help.example.com"],
"permission_policy": {"type": "auto"}
}
]
},
{
"type": "custom",
"name": "lookup_order",
"description": "Look up one order by its ID. Returns the status, the items, and the delivery date.",
"input_schema": {
"type": "object",
"properties": {
"order_id": {"type": "string", "description": "The order ID from the ticket"}
},
"required": ["order_id"]
}
}
]'
```
```bash CLI
ant apply agent.md
```
```markdown
---
name: Support Agent
model: claude-opus-5-5
tools:
- type: agent_toolset_20260401
default_config:
enabled: false
permission_policy:
type: always_ask
configs:
- name: read
enabled: true
permission_policy:
type: always_allow
- name: write
enabled: true
permission_policy:
type: auto
- name: web_fetch
enabled: true
allowed_domains: [help.example.com]
permission_policy:
type: auto
- type: custom
name: lookup_order
description: Look up one order by its ID. Returns the status, the items, and the delivery date.
input_schema:
type: object
properties:
order_id:
type: string
description: The order ID from the ticket
required:
- order_id
---
```
```python Python
tools = [
{
"type": "agent_toolset_20260401",
"default_config": {
"enabled": False,
"permission_policy": {"type": "always_ask"},
},
"configs": [
{
"name": "read",
"enabled": True,
"permission_policy": {"type": "always_allow"},
},
{
"name": "write",
"enabled": True,
"permission_policy": {"type": "auto"},
},
{
"name": "web_fetch",
"enabled": True,
"allowed_domains": ["help.example.com"],
"permission_policy": {"type": "auto"},
},
],
},
{
"type": "custom",
"name": "lookup_order",
"description": "Look up one order by its ID. Returns the status, the items, and the delivery date.",
"input_schema": {
"type": "object",
"properties": {
"order_id": {
"type": "string",
"description": "The order ID from the ticket",
},
},
"required": ["order_id"],
},
},
]
```
```typescript TypeScript
const tools = [
{
type: "agent_toolset_20260401",
default_config: {
enabled: false,
permission_policy: { type: "always_ask" }
},
configs: [
{
name: "read",
enabled: true,
permission_policy: { type: "always_allow" }
},
{
name: "write",
enabled: true,
permission_policy: { type: "auto" }
},
{
name: "web_fetch",
enabled: true,
allowed_domains: ["help.example.com"],
permission_policy: { type: "auto" }
}
]
},
{
type: "custom",
name: "lookup_order",
description:
"Look up one order by its ID. Returns the status, the items, and the delivery date.",
input_schema: {
type: "object",
properties: {
order_id: { type: "string", description: "The order ID from the ticket" }
},
required: ["order_id"]
}
}
] satisfies Anthropic.Beta.AgentCreateParams["tools"];
```
```csharp C#
using System.Text.Json;
using Anthropic.Models.Beta.Agents;
using Tool = Anthropic.Models.Beta.Agents.Tool;
Tool[] tools =
[
new BetaManagedAgentsAgentToolset20260401Params
{
Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401,
DefaultConfig = new()
{
Enabled = false,
PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy { Type = "always_ask" },
},
Configs =
[
new BetaManagedAgentsReadToolConfigParams
{
Enabled = true,
PermissionPolicy = new BetaManagedAgentsAlwaysAllowPolicy { Type = "always_allow" },
},
new BetaManagedAgentsWriteToolConfigParams
{
Enabled = true,
PermissionPolicy = new BetaManagedAgentsAutoPolicy(),
},
new BetaManagedAgentsWebFetchToolConfigParams
{
Enabled = true,
AllowedDomains = ["help.example.com"],
PermissionPolicy = new BetaManagedAgentsAutoPolicy(),
},
],
},
new BetaManagedAgentsCustomToolParams
{
Type = "custom",
Name = "lookup_order",
Description = "Look up one order by its ID. Returns the status, the items, and the delivery date.",
InputSchema = new()
{
Properties = new Dictionary
{
["order_id"] = JsonSerializer.SerializeToElement(
new { type = "string", description = "The order ID from the ticket" }
),
},
Required = ["order_id"],
},
},
];
```
```go Go
tools := []anthropic.BetaAgentNewParamsToolUnion{{
OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
Enabled: anthropic.Bool(false),
PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{
Type: anthropic.BetaManagedAgentsAlwaysAskPolicyTypeAlwaysAsk,
},
},
},
Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{
{OfRead: &anthropic.BetaManagedAgentsReadToolConfigParams{
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsReadToolConfigParamsPermissionPolicyUnion{
OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{
Type: anthropic.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow,
},
},
}},
{OfWrite: &anthropic.BetaManagedAgentsWriteToolConfigParams{
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsWriteToolConfigParamsPermissionPolicyUnion{
OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
},
}},
{OfWebFetch: &anthropic.BetaManagedAgentsWebFetchToolConfigParams{
AllowedDomains: []string{"help.example.com"},
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsWebFetchToolConfigParamsPermissionPolicyUnion{
OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
},
}},
},
},
}, {
OfCustom: &anthropic.BetaManagedAgentsCustomToolParams{
Type: anthropic.BetaManagedAgentsCustomToolParamsTypeCustom,
Name: "lookup_order",
Description: "Look up one order by its ID. Returns the status, the items, and the delivery date.",
InputSchema: anthropic.BetaManagedAgentsCustomToolInputSchemaParam{
Properties: map[string]any{
"order_id": map[string]any{
"type": "string",
"description": "The order ID from the ticket",
},
},
Required: []string{"order_id"},
},
},
}}
_ = tools
```
```java Java
import com.anthropic.core.JsonValue;
import com.anthropic.models.beta.agents.*;
import java.util.List;
import java.util.Map;
var tools = List.of(
AgentCreateParams.Tool.ofAgentToolset20260401(
BetaManagedAgentsAgentToolset20260401Params.builder()
.type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
.defaultConfig(
BetaManagedAgentsAgentToolsetDefaultConfigParams.builder()
.enabled(false)
.permissionPolicy(
BetaManagedAgentsAlwaysAskPolicy.builder()
.type(BetaManagedAgentsAlwaysAskPolicy.Type.ALWAYS_ASK)
.build()
)
.build()
)
.addConfig(
BetaManagedAgentsReadToolConfigParams.builder()
.enabled(true)
.permissionPolicy(
BetaManagedAgentsAlwaysAllowPolicy.builder()
.type(BetaManagedAgentsAlwaysAllowPolicy.Type.ALWAYS_ALLOW)
.build()
)
.build()
)
.addConfig(
BetaManagedAgentsWriteToolConfigParams.builder()
.enabled(true)
.permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build())
.build()
)
.addConfig(
BetaManagedAgentsWebFetchToolConfigParams.builder()
.enabled(true)
.allowedDomains(List.of("help.example.com"))
.permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build())
.build()
)
.build()
),
AgentCreateParams.Tool.ofCustom(
BetaManagedAgentsCustomToolParams.builder()
.type(BetaManagedAgentsCustomToolParams.Type.CUSTOM)
.name("lookup_order")
.description("Look up one order by its ID. Returns the status, the items, and the delivery date.")
.inputSchema(
BetaManagedAgentsCustomToolInputSchema.builder()
.properties(
BetaManagedAgentsCustomToolInputSchema.Properties.builder()
.putAdditionalProperty("order_id", JsonValue.from(Map.of(
"type", "string",
"description", "The order ID from the ticket")))
.build()
)
.addRequired("order_id")
.build()
)
.build()
)
);
```
```php PHP
use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAllowPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAskPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsAutoPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsCustomToolInputSchema;
use Anthropic\Beta\Agents\BetaManagedAgentsCustomToolParams;
use Anthropic\Beta\Agents\BetaManagedAgentsReadToolConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsWebFetchToolConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsWriteToolConfigParams;
$tools = [
BetaManagedAgentsAgentToolset20260401Params::with(
type: 'agent_toolset_20260401',
defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with(
enabled: false,
permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(type: 'always_ask'),
),
configs: [
BetaManagedAgentsReadToolConfigParams::with(
enabled: true,
permissionPolicy: BetaManagedAgentsAlwaysAllowPolicy::with(type: 'always_allow'),
),
BetaManagedAgentsWriteToolConfigParams::with(
enabled: true,
permissionPolicy: BetaManagedAgentsAutoPolicy::with(),
),
BetaManagedAgentsWebFetchToolConfigParams::with(
allowedDomains: ['help.example.com'],
enabled: true,
permissionPolicy: BetaManagedAgentsAutoPolicy::with(),
),
],
),
BetaManagedAgentsCustomToolParams::with(
type: 'custom',
name: 'lookup_order',
description: 'Look up one order by its ID. Returns the status, the items, and the delivery date.',
inputSchema: BetaManagedAgentsCustomToolInputSchema::with(
properties: ['order_id' => ['type' => 'string', 'description' => 'The order ID from the ticket']],
required: ['order_id'],
),
),
];
```
```ruby Ruby
tools = [
{
type: "agent_toolset_20260401",
default_config: {
enabled: false,
permission_policy: {type: "always_ask"}
},
configs: [
{
name: "read",
enabled: true,
permission_policy: {type: "always_allow"}
},
{
name: "write",
enabled: true,
permission_policy: {type: "auto"}
},
{
name: "web_fetch",
enabled: true,
allowed_domains: ["help.example.com"],
permission_policy: {type: "auto"}
}
]
},
{
type: "custom",
name: "lookup_order",
description: "Look up one order by its ID. Returns the status, the items, and the delivery date.",
input_schema: {
type: "object",
properties: {order_id: {type: "string", description: "The order ID from the ticket"}},
required: ["order_id"]
}
}
]
```
Un [aggiornamento dell'agente](https://platform.claude.com/docs/it/managed-agents/agent-setup#update-semantics) sostituisce l'intero array `tools`, quindi invia ogni voce che vuoi mantenere.
Un aggiornamento dell'agente raggiunge solo le nuove sessioni, quindi controlla anche i deployment, gli agenti che elencano questo agente e le sessioni esistenti:
* Un deployment fissa una versione dell'agente, quindi fai puntare ogni deployment alla nuova versione.
* Un agente che elenca questo in [`subagents.predefined_agents`](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration#list-the-subagents) o in `workflows.predefined_agents` mantiene la versione che ha fissato, quindi aggiorna anche quell'agente.
* Per rendere più restrittiva una sessione già esistente, [aggiorna gli strumenti di quella sessione](https://platform.claude.com/docs/it/managed-agents/session-operations#updating-the-agent-configuration). La sessione deve essere `idle`, e l'aggiornamento sostituisce l'intero array `tools`. In una sessione multiagente, i nuovi elenchi `allowed_domains` e `blocked_domains` sugli strumenti web dell'agente eseguito dalla sessione si applicano anche a tutti gli altri agenti. Si applicano a partire dal turno successivo di ciascun agente. Gli strumenti abilitati e le policy di autorizzazione di quegli agenti non cambiano. Per modificarli, aggiorna ciascun agente, quindi avvia una nuova sessione.
Limita anche i server MCP e gli strumenti personalizzati a ciò di cui l'agente ha bisogno:
* **Server MCP:** Un toolset MCP abilita per impostazione predefinita ogni strumento esposto dal server. Imposta `default_config.enabled` su `false` e abilita gli strumenti per nome, così gli strumenti aggiunti in seguito da un server restano disattivati. Rimuovi i server che l'agente non usa. Consulta [Connettore MCP](https://platform.claude.com/docs/it/managed-agents/mcp-connector#configure-which-mcp-tools-are-available).
* **Strumenti personalizzati:** Li esegue la tua applicazione, e le policy di autorizzazione non si applicano. Convalida l'input di ogni chiamata nella tua applicazione e limita ciò che lo strumento può toccare.
## Tieni l'input non attendibile lontano dagli strumenti potenti
Controlla quali strumenti e credenziali possiede un agente ogni volta che legge input non attendibile, ovvero testo che qualcuno al di fuori del tuo team può scrivere. Questa sezione usa due termini:
* **Input non attendibile:** Pagine web, risultati di ricerca, ticket di supporto, email, file di repository, caricamenti, risultati di server MCP e messaggi dell'utente finale che inoltri.
* **Strumenti potenti:** `bash`, `write`, `edit`, `web_fetch`, `web_search`, strumenti MCP e strumenti personalizzati che scrivono o inviano dati, e qualsiasi strumento che usa una credenziale.
Il testo in un input non attendibile può indicare all'agente di usare uno strumento potente che possiede. L'agente di supporto legge i ticket, quindi raggiunge la tua API degli ordini solo tramite lo strumento personalizzato `lookup_order`. La tua applicazione verifica che l'ordine appartenga al mittente del ticket.
| Input letto dall'agente | Potere che ha anche | Cosa fare |
| ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Ticket, email o caricamenti | `bash` con una credenziale | Sostituisci `bash` con uno strumento personalizzato che fa una sola cosa. Se l'agente deve mantenere `bash`, approva ogni chiamata con `always_ask` |
| Pagine web o risultati di ricerca | Scrittura di file o modifica di record | Disattiva gli strumenti web, oppure limitali a siti che gestisci o di cui ti fidi |
| Risultati MCP o file di repository | Strumenti MCP che scrivono | Mantieni il toolset MCP su `always_ask` e abilita solo gli strumenti di cui l'agente ha bisogno |
| Un repository GitHub montato | Qualsiasi strumento | Monta solo repository di cui ti fidi. Un agente con `read` carica le skill dalla directory `.claude/skills` del repository come istruzioni per l'agente, senza alcuna fase di revisione. Consulta [Carica skill da un repository GitHub](https://platform.claude.com/docs/it/managed-agents/skills#load-skills-from-a-github-repository) |
| Qualsiasi input non attendibile | Scrittura in un [memory store](https://platform.claude.com/docs/it/managed-agents/memory#attach-a-memory-store-to-a-session) | Collega lo store come `read_only` a meno che l'agente non debba scrivere. Il valore predefinito è `read_write`, e le sessioni successive leggono il testo salvato come memoria attendibile |
In un ambiente cloud, la lettura di un file con `read` può anche caricare i file `CLAUDE.md` e `AGENTS.md` come istruzioni. Vengono caricati dalla directory del file e dalle sue directory padre, fino alla directory di lavoro della sandbox. Vengono caricati anche i file a cui fanno riferimento con `@` e un percorso, come `@docs/setup.md`, fino a cinque livelli di riferimento. Un riferimento può puntare a qualsiasi punto della sandbox, ad esempio `@/etc/hosts`. Nessuna impostazione disattiva questo comportamento tranne la disabilitazione di `read`, quindi tratta come input non attendibile un repository, un pacchetto o un archivio che qualcuno al di fuori del tuo team può scrivere.
Quando un agente deve leggere input non attendibile e anche agire, questa guida raccomanda uno di tre design:
* **Separa la lettura dall'azione.** In una sessione multiagente, un [agente principale](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration#list-the-subagents) assegna compiti a un fetcher, che legge il web, e a un writer, che modifica file o record.
* **Dai all'agente un unico strumento personalizzato ristretto.** La tua applicazione esegue lo strumento, ne controlla l'input e detiene la credenziale. L'agente di supporto usa questo design, non la separazione. Consulta [Rispondere alle chiamate agli strumenti che mettono in pausa la sessione](https://platform.claude.com/docs/it/managed-agents/events-and-streaming#answer-tool-calls-that-pause-the-session).
* **Mantieni una persona nel ciclo.** Usa `always_ask` sullo strumento potente in modo che una persona approvi ogni chiamata.
La separazione usa tre agenti:
| Agente | Legge | Possiede | Trasmette |
| --------------------------------------------- | --------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
| Principale (l'agente eseguito dalla sessione) | Il tuo messaggio e ciò che gli altri agenti restituiscono | Nessuno strumento integrato. Il suo elenco `subagents.predefined_agents` indica il fetcher e il writer | Un compito a ciascun agente |
| Fetcher | Pagine web e risultati di ricerca | Solo `web_fetch` e `web_search`, ciascuno con `allowed_domains` | Risultati brevi, in un formato che richiedi nel suo prompt di sistema |
| Writer | Il compito dall'agente principale | Gli strumenti che scrivono file, eseguono comandi o modificano record, su `auto` o `always_ask`. Nessuno strumento web | Il suo risultato |
I risultati del fetcher sono costruiti a partire da pagine non attendibili, e l'agente principale può trasmetterne il testo al writer. Mantieni `auto` o `always_ask` sugli strumenti del writer. Il fetcher può comunque inviare parte di ciò che legge ai siti del suo elenco `web_fetch`, e al provider di ricerca nelle sue query.
Gli agenti in una sessione multiagente [condividono la sandbox](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration#how-it-works), i suoi file e le credenziali del vault, quindi questa separazione divide solo i loro strumenti e le loro conversazioni. Per una separazione più forte, usa due sessioni con ambienti e vault separati. Fai in modo che la tua applicazione trasmetta tra le due sessioni solo campi fissi, come un ID ordine.
## Imposta limiti e un modo per fermare l'agente
Imposta un budget quando crei ogni sessione e decidi in anticipo come fermare un agente.
| Controllo | Cosa fa |
| ---------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Budget della sessione | Un tetto alla spesa ai prezzi di listino pubblici. Al raggiungimento del tetto, la sessione e ogni [thread](https://platform.claude.com/docs/it/managed-agents/session-threads) vanno in pausa. Le richieste in corso possono terminare e le loro chiamate agli strumenti vengono comunque eseguite, quindi la spesa può superare il tetto. Consulta [Quando una sessione raggiunge il proprio budget](https://platform.claude.com/docs/it/managed-agents/budgets#when-a-session-reaches-its-budget) |
| Budget del deployment | Lo stesso tetto, applicato a ogni sessione avviata da un deployment |
| [Evento `user.interrupt`](https://platform.claude.com/docs/it/managed-agents/events-and-streaming#interrupt-the-agent) | Ferma immediatamente la risposta del modello. Una chiamata a uno strumento in esecuzione può terminare prima. La sessione passa a `idle`, a meno che un'esecuzione di workflow non la mantenga `running`, e riprende al tuo messaggio successivo. Un'interruzione non termina alcuna esecuzione di workflow |
| Archiviare o eliminare una sessione | L'archiviazione conserva la cronologia e blocca i nuovi eventi. L'eliminazione rimuove il record, gli eventi e la sandbox |
| Mettere in pausa o archiviare un deployment | La pausa ferma le nuove esecuzioni pianificate ma consente ancora le esecuzioni manuali. L'archiviazione termina la pianificazione in modo permanente. Le sessioni già in esecuzione continuano a essere eseguite |
| Archiviare o eliminare un vault o una credenziale | Rimuove il segreto dalle sessioni in esecuzione senza un riavvio. Prevedi un ritardo. Le sessioni continuano a essere eseguite, quindi interrompi anche quelle. Un token che l'agente ha già recuperato con il segreto resta nella sandbox |
Per fermare un agente in esecuzione, segui questi passaggi:
1. Invia `user.interrupt` da solo.
2. Per un agente pianificato, metti anche in pausa il deployment in modo che non venga avviata alcuna nuova esecuzione pianificata. Per terminare la pianificazione in modo permanente, archivia il deployment.
3. Se una chiave potrebbe essere esposta, ruotala presso il servizio che l'ha emessa.
4. Se l'agente ha esecuzioni di workflow aperte, invia anche un `user.message` che gli chieda di fermarle, perché un'interruzione non termina alcuna esecuzione. Consulta [Interrompere una sessione con esecuzioni aperte](https://platform.claude.com/docs/it/managed-agents/workflow-runs#interrupt-a-session-with-runs-open) per le chiamate agli strumenti da annullare prima.
5. Attendi che la sessione passi a `idle`. Una sessione in esecuzione non può essere archiviata né eliminata.
6. Archivia la sessione per conservarne la cronologia. Eliminala quando la cronologia non ti serve più.
Un'interruzione non annulla ciò che l'agente ha già fatto o inviato. L'archiviazione di un agente non ferma le sue sessioni in esecuzione.
Il valore `max_list_cost.amount` di un budget è un numero intero di centesimi di dollaro USA scritto come stringa, quindi `"125"` significa $1,25. Consulta [Imposta un budget alla creazione della sessione](https://platform.claude.com/docs/it/managed-agents/budgets#set-a-budget-at-session-creation).
Non puoi aggiungere un budget a una sessione creata senza. Per modificare o rimuovere un tetto, consulta [Riprendi una sessione che ha raggiunto il budget](https://platform.claude.com/docs/it/managed-agents/budgets#resume-a-session-at-its-budget). Dopo aver rimosso il tetto di una sessione, non puoi impostarne uno nuovo.
Un budget limita la spesa, ma non limita ciò che l'agente fa prima di raggiungere il tetto. Per tenere separati carichi di lavoro con livelli di attendibilità diversi, usa [workspace](https://platform.claude.com/docs/it/manage-claude/workspaces) separati. Assegna a ogni carico di lavoro una chiave API limitata a un solo workspace, perché una chiave che può raggiungere più workspace può agire in ognuno di essi.
Consulta [Budget di sessione](https://platform.claude.com/docs/it/managed-agents/budgets), [Operazioni sulle sessioni](https://platform.claude.com/docs/it/managed-agents/session-operations#archiving-a-session) e [Deployment pianificati](https://platform.claude.com/docs/it/managed-agents/scheduled-deployments#managing-deployment-lifecycle).
## Passaggi successivi
Modalità di networking, host consentiti e gestori di pacchetti.
Policy di approvazione e richieste di conferma.
Tipi di credenziali, posizioni di iniezione e rotazione.
Tetti di spesa, ripresa al raggiungimento del budget e budget sui deployment.