> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devinenterprise.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Automazioni

> Configura le automazioni di Devin: flussi di lavoro basati su eventi che avviano sessioni di Devin da Slack, GitHub, Linear, pianificazioni e webhook.

Le automazioni ti permettono di collegare eventi esterni — messaggi Slack, webhook GitHub, aggiornamenti dei ticket Linear, pianificazioni e webhook personalizzati — a sessione Devin che si avviano automaticamente. Invece di taggare manualmente Devin ogni volta che viene segnalato un bug o che un controllo CI fallisce, definisci il trigger una sola volta e Devin gestisce ogni evento non appena arriva. Puoi anche gestire le automazioni in modo dichiarativo con il [provider Terraform](https://docs.devinenterprise.com/it/api-reference/terraform-provider.md). Per una guida video con quattro esempi, consulta il [tutorial sulle automazioni di Devin](https://docs.devinenterprise.com/it/tutorial-library/automations.md).

## Concetti fondamentali

Un'automazione è composta da un trigger e da azioni, con condizioni e un controllo Preflight facoltativi:

| Parte | Cosa fa |
| - | - |
| **Trigger** | L'evento che attiva l'automazione (ad es. un messaggio su Slack in `#bugs`, un fallimento della CI su GitHub, una modifica di etichetta in Linear) |
| **Condizioni** | Filtri facoltativi che restringono il trigger (ad es. attivarla solo quando l'etichetta è `bug`, solo per una repo specifica) |
| **Controllo Preflight** | Un filtro LLM o uno script facoltativo che viene eseguito dopo che un evento soddisfa i criteri e prima delle azioni. Può ignorare l'evento oppure lasciarlo passare; uno script può inoltre generare elementi di lavoro separati. |
| **Azione** | Cosa fa Devin quando il trigger si attiva: avvia una nuova sessione, invia un messaggio a una sessione esistente oppure agisce come monitor di triage |

### Tipi di azione

| Azione | Descrizione |
| - | - |
| **Avvia sessione** | Crea una nuova sessione Devin con il prompt che definisci. Il payload dell'evento viene incluso automaticamente come contesto. |
| **Invia messaggio alla sessione** | Invia un messaggio a una sessione Devin esistente e persistente — utile per inviare eventi a una sessione che mantiene lo stato. |
| **Triage Devin** | Un Devin persistente che monitora un canale Slack. Analizza ogni messaggio in arrivo, decide cosa richiede attenzione e avvia sub-Devin per gli elementi che richiedono approfondimenti. Per maggiori dettagli, vedi [Auto-triage](https://docs.devinenterprise.com/it/product-guides/auto-triage.md). Per avvisi, incidenti e bug report, usa [Devin Oncall](https://docs.devinenterprise.com/it/product-guides/devin-oncall.md). |
| **Notifica email** | Ti invia un'email quando viene eseguita l'automazione — a ogni esecuzione, solo in caso di errori o solo in caso di esito positivo. |

### Fonti di attivazione

| Source | Event types | Example use case |
| - | - | - |
| **Slack** | Nuovo messaggio, reazione aggiunta | Fai triage delle segnalazioni di bug in `#incidents`, aggiungi la reazione 🚨 per avviare un'indagine |
| **GitHub** | Issue, commento su issue, PR aperta/aggiornata, revisione PR, check run (CI), push | Correggi automaticamente i fallimenti della CI, rispondi ai commenti `/devin` sulle issue |
| **GitLab** | Merge request, commento sulla MR, issue, commento su issue, push, pipeline | Correggi automaticamente le pipeline fallite, rispondi ai commenti sulle merge request |
| **Linear** | Issue creata, etichetta aggiunta, stato modificato, priorità modificata, assegnata, spostata in un team | Fai triage dei bug quando viene aggiunta un'etichetta, implementa i ticket quando vengono assegnati a Devin |
| **Jira** | Issue creata, issue aggiornata, etichetta aggiunta, stato modificato, assegnata, commentata | Implementa i ticket quando vengono assegnati a Devin, tieni traccia delle modifiche di stato |
| **Pylon** | Issue creata, tag aggiunto, stato modificato | Fai triage dei ticket di bug dei clienti aperti in Pylon. Vedi l'[integrazione Pylon](https://docs.devinenterprise.com/it/integrations/pylon.md) |
| **PagerDuty** | Incident attivato, preso in carico, risolto, aggiornato | Indaga sugli incident ad alta urgenza non appena si verificano. Vedi l'[integrazione PagerDuty](https://docs.devinenterprise.com/it/integrations/pagerduty.md) |
| **Pianificazione** | Ricorrente (basata su cron) o una tantum (eseguita una volta) | Controlli quotidiani degli errori in Sentry, Aggiornamenti settimanali delle dipendenze, smoke test notturni o un'attività una tantum eseguita in un momento futuro specifico |
| **Webhook** | Richiesta HTTP in ingresso | Collega qualsiasi sistema esterno (PagerDuty, Datadog, Sentry, strumenti personalizzati) a Devin tramite un URL webhook |

Le fonti diverse dalla pianificazione compaiono nel picker dei trigger una volta collegata la relativa integrazione in **Settings > Connections**.

Una singola automazione può avere **più trigger**: si combinano con logica OR, quindi l'automazione si attiva quando corrisponde uno qualsiasi dei trigger. Per esempio, puoi avere un'automazione che si attiva sia in caso di fallimento della CI su GitHub sia con una reazione su Slack.

## Creare un'automazione

### Dalla pagina delle automazioni

1. Vai su **automazione** nella barra laterale
2. Fai clic su **Crea automazione** e scegli **Create** per aprire un editor vuoto (se non hai ancora alcuna automazione, fai invece clic su **Create manually** nella pagina iniziale). Lo stesso menu offre anche **Template** (apre la galleria dei template) e **Generate with Devin** (avvia una sessione che crea l'automazione insieme a te)
3. Configura il trigger, le condizioni e l'action
4. Fai clic su **Crea automazione**

### Da un template

1. Vai a **Automazioni** nella barra laterale
2. Fai clic su **Crea automazione** > **Template** (se non hai ancora alcuna automazione, fai invece clic su **Crea da template** nella pagina iniziale), oppure vai direttamente a `/automations/templates`
3. Sfoglia la galleria dei template: ogni template è un'automazione preconfigurata per un flusso di lavoro comune
4. Fai clic su un template per precompilare l'editor con il trigger, l'action e i limiti consigliati
5. Personalizza la configurazione (ad es. seleziona il canale Slack o la repo) e fai clic su **Crea automazione**

### Uso del linguaggio naturale

Nella pagina delle automazioni, fai clic su **Crea automazione** > **Generate with Devin** (se non hai ancora alcuna automazione, fai invece clic sulla scheda **Generate with Devin** nella pagina iniziale). Devin apre una nuova sessione per aiutarti a creare l'automazione. Descrivi ciò che vuoi fare — ad esempio: "Quando un controllo CI fallisce su my-org/my-repo, fai in modo che Devin lo corregga ed esegua il push sullo stesso branch." Devin genererà per te la configurazione dell'automazione, che potrai esaminare e creare.

## Configurazione dei trigger

### Trigger Slack

I trigger Slack si attivano quando viene pubblicato un messaggio o viene aggiunta una reazione in un canale a cui Devin è stato invitato.

* **Messaggio Slack**: Si attiva alla pubblicazione di nuovi messaggi. Per default viene aggiunta una condizione sul canale; puoi rimuoverla per intercettare i messaggi di più canali, ma in tal caso ogni gruppo di condizioni necessita di almeno un altro filtro (ad esempio il testo del messaggio o il tipo di mittente — **Include thread replies** da solo non è sufficiente).
* **Gruppo di utenti menzionato**: Si attiva quando viene menzionato un gruppo di utenti Slack (ad esempio `@oncall`). Seleziona il gruppo o inserisci il suo ID Slack (inizia con `S`) e, facoltativamente, limitalo a canali specifici.
* **Reazione Slack**: Si attiva quando a un messaggio viene aggiunta una specifica reazione emoji (ad es. 🚨 per gli incidenti). Puoi filtrare in base al nome della reazione e al canale.

> [!NOTE]
>
> Per i trigger con ambito su un canale, Devin deve essere invitato nel canale Slack. Devi anche aver collegato il tuo account Slack personale in **Settings > Connections > Slack**.

### Trigger di GitHub

I trigger di GitHub si attivano in risposta agli eventi del repository. Devi selezionare un repository specifico per ogni trigger.

* **Issue**: Si attiva sugli eventi della issue (apertura, chiusura, riapertura, modifica, aggiunta di label).
* **Commento su issue**: Si attiva quando viene pubblicato un commento su una issue di GitHub. In genere viene usato con una condizione `starts_with "/devin"`, così gli utenti possono digitare `/devin` su qualsiasi issue per attivare Devin.
* **Pull request**: Si attiva sugli eventi della PR (apertura, sincronizzazione, ecc.).
* **Review della pull request**: Si attiva quando viene inviata una review su una PR.
* **Commento di review della pull request**: Si attiva sui singoli commenti di review.
* **Check run (CI)**: Si attiva quando un controllo CI viene completato. Filtra per `conclusion = failure` per correggere automaticamente le build non riuscite.
* **Push**: Si attiva quando viene eseguito un push su un branch.

> [!NOTE]
>
> Per impostazione predefinita, le automazioni GitHub si attivano solo sui repository privati. Un Admin può abilitare una singola connessione GitHub per i repository pubblici: in [Settings → Connections → GitHub](https://app.devin.ai/settings/connections/github), apri il menu della connessione e imposta **Ambito dell'automazione** su **Tutti i repo installati**. Chiunque su Internet può commentare o aprire una PR su un repo pubblico, quindi i trigger dei repository pubblici comportano un rischio maggiore di prompt injection: abilitali consapevolmente e mantieni restrittive le condizioni dei trigger.

### Trigger GitLab

I trigger GitLab si attivano in base agli eventi di progetto nella tua istanza GitLab collegata:

* **Merge request**: si attiva sulle azioni relative alle MR (aperta, chiusa, merged, riaperta, approvata, aggiornata).
* **Commento MR**: si attiva quando viene pubblicato un commento (nota) su una merge request, inclusi i thread di review dei diff.
* **Issue**: si attiva sulle azioni relative alle issue (aperta, chiusa, riaperta, aggiornata).
* **commento su issue**: si attiva quando viene pubblicato un commento su una issue.
* **Push**: si attiva sui push verso un branch.
* **Pipeline**: si attiva quando una pipeline raggiunge un determinato status: filtra per status (ad es. `failed`) per correggere automaticamente le pipeline non riuscite.

### Trigger di Linear

I trigger di Linear si attivano in risposta agli eventi relativi alle issue nel tuo workspace Linear connesso. Devi selezionare un team per ogni trigger.

* **Issue creata**: Si attiva quando viene creata una nuova issue nel team selezionato.
* **etichetta aggiunta**: Si attiva quando una label viene applicata a un'issue (ad es. `bug`, `devin`).
* **Stato modificato**: Si attiva quando cambia lo stato di un'issue (ad es. viene spostata in "In Progress").
* **Priorità modificata**: Si attiva quando cambia la priorità di un'issue.
* **Assegnata**: Si attiva quando un'issue viene assegnata a qualcuno.
* **Issue spostata**: Si attiva quando un'issue viene spostata in un altro team: il filtro per team del trigger corrisponde al team di destinazione.

### Trigger Jira

I trigger Jira si attivano in base agli eventi sulle issue nel sito Jira collegato. Puoi filtrare per progetto, label, status, assegnatario ed epic:

* **Issue creata**: si attiva alla creazione di una nuova issue.
* **issue aggiornata**: si attiva quando cambiano i campi di una issue.
* **etichetta aggiunta**: si attiva quando una label viene applicata a una issue.
* **stato modificato**: si attiva quando cambia lo status di una issue.
* **assegnata**: si attiva quando una issue viene assegnata a qualcuno.
* **Comment created or edited**: si attiva quando un commento viene aggiunto o modificato su una issue.

### Trigger di pianificazione

I trigger di pianificazione si attivano in base a una pianificazione temporale, ricorrente oppure come singola run una tantum. Nel menu a discesa dei trigger, espandi **Pianificazione** e scegli **Ogni ora**, **Ogni giorno**, **Ogni settimana**, **Esegui una volta** oppure **Pianificazione personalizzata**.

* **Ricorrente**: imposta la frequenza (oraria, giornaliera, settimanale) e l'ora. Dietro le quinte, le pianificazioni usano il formato RRULE di iCalendar. Scegli **Pianificazione personalizzata** per creare una ricorrenza personalizzata (ripeti ogni N minuti/ore/giorni/settimane/mesi) oppure inserisci direttamente una stringa RRULE grezza (ad es. `FREQ=WEEKLY;BYDAY=MO;BYHOUR=9;BYMINUTE=0`) per cadenze più complesse.
* **Esegui una volta**: si attiva una sola volta a una data e ora future specifiche, poi si disattiva automaticamente. Utile per attività differite una tantum, ad es. "sveglia Devin tra 12 ore per eseguire un'attività". Scegli la data e l'ora (per impostazione predefinita è un'ora da adesso); devono essere nel futuro.

> [!TIP]
>
> Ogni pianificazione ha un proprio fuso orario, che per impostazione predefinita corrisponde a quello del tuo browser e può essere modificato nell'editor della pianificazione. La pianificazione viene eseguita all'ora locale impostata, anche in caso di passaggio all'ora legale o solare.

### Trigger webhook

I trigger webhook consentono di collegare qualsiasi sistema esterno a Devin tramite un endpoint HTTPS univoco.

1. Crea un'automazione con un trigger **Webhook**
2. Copia l'URL del webhook e il segreto mostrati nella configurazione del trigger
3. Configura il tuo sistema esterno (PagerDuty, Datadog, Sentry o qualsiasi strumento personalizzato) in modo che invii richieste HTTP POST a questo URL
4. Facoltativamente aggiungi un **filtro del payload** — un pattern regex a cui il corpo della richiesta deve corrispondere affinché l'automazione si attivi

Trasmetti il segreto del webhook in uno dei seguenti modi:

* header `X-Webhook-Secret: <secret>`
* header `Authorization: Bearer <secret>`
* parametro di query `?secret=<secret>`

Preferisci un header: le stringhe di query vengono spesso acquisite nei log di accesso di proxy, CDN e server.

Il payload del webhook viene incluso nel prompt della sessione di Devin come contesto. I payload di dimensioni superiori a 200 KB vengono troncati automaticamente.

#### Segreto del webhook

Ogni trigger webhook dispone di un segreto che autentica le richieste in arrivo: le chiamate prive del segreto corretto vengono rifiutate. Il segreto viene generato automaticamente e visualizzato quando aggiungi il trigger webhook nell'editor di automazione.

> [!NOTE]
>
> Copia il segreto quando viene visualizzato: non verrà più mostrato. Se lo perdi, non potrai recuperarlo; rigeneralo.

Ogni richiesta deve includere il segreto nell'header HTTP `X-Webhook-Secret`. Ad esempio, per eseguire un test con curl:

```bash theme={null}
curl -X POST '<webhook-url>' \
  -H 'Content-Type: application/json' \
  -H 'X-Webhook-Secret: <secret>' \
  -d '{"test": true}'
```

Se perdi il segreto o devi ruotarlo, apri il trigger webhook nell'editor di automazione e rigeneralo. Il vecchio segreto smette subito di funzionare, quindi aggiorna il sistema esterno con il nuovo valore.

## Controlli Preflight

Un **controllo Preflight** è un passaggio facoltativo che viene eseguito tra l'attivazione del trigger e le azioni dell'automazione. Un'automazione può averne di due tipi:

| Tipo | Cosa fa |
| - | - |
| **Filtro LLM** | Un modello decisionale analizza ogni evento corrispondente e scarta quelli che non soddisfano la tua descrizione in linguaggio naturale. Rapido ed economico. |
| **Script** | È il tuo codice Python, Node o Bash a decidere cosa succede: chiamare un servizio esterno, mantenere lo stato tra un run e l'altro o avviare una sessione per ogni nuovo elemento. |

Per aggiungerne uno, fai clic su **Add a step before the agent runs** sotto la sezione del trigger e scegli **filtro LLM** o **Run a script**.

> [!NOTE]
>
> Gli script Preflight sono in fase di rilascio graduale. Se l'opzione **Run a script** non è disponibile, gli script non sono ancora abilitati per la tua organizzazione.

> [!WARNING]
>
> Il pulsante **Run now** dell'automazione salta il controllo Preflight ed esegue direttamente le azioni configurate.

### Filtro LLM

Seleziona **filtro LLM** e descrivi quali eventi includere o escludere. Ad esempio: «PRs relative al servizio di autenticazione» oppure «messaggi Slack sulla cena».

Un modello decisionale leggero legge l'intero evento. L'agente viene eseguito solo per gli eventi corrispondenti.

### Configurare e testare uno script Preflight

Lo script viene eseguito in una macchina virtuale (VM) separata e di breve durata, non all'interno della sessione Devin che potrebbe avviare. Può leggere l'evento, conservare una piccola quantità di stato tra una run e l'altra e decidere quale lavoro far arrivare alle azioni configurate.

1. Crea un'automazione o modificane una esistente, quindi configurane i trigger e le condizioni.
2. Fai clic su **Add a step before the agent runs** sotto la sezione dei trigger e seleziona **Run a script** nella scheda **Before the agent runs**.
3. Fai clic su **Edit script**, scegli **Python**, **Node** (JavaScript) o **Bash** nel selettore del runtime e modifica lo script iniziale.
4. Se necessario, usa **Select secrets** nell'editor degli script per associare i segreti dell'organizzazione. Vengono iniettati come variabili d'ambiente solo i segreti selezionati. Per salvare o testare uno script con segreti associati è necessaria l'autorizzazione a gestire i segreti dell'organizzazione.
5. Imposta **Timeout (seconds)** nella scheda: il valore predefinito è 60 secondi e l'intervallo consentito va da 1 a 300 secondi. Per impostazione predefinita, lo script usa il **Minimal environment**; se sono disponibili snapshot della macchina, il selettore **Environment** consente anche di scegliere uno snapshot dell'organizzazione che includa le tue dipendenze.
6. Nell'editor degli script, scegli un evento in **Test against** e fai clic su **Run**. Puoi testare lo script non salvato su un evento di esempio di un trigger configurato oppure su un evento recente di un'automazione esistente. Esamina il risultato, i log e, per gli elementi emessi, l'anteprima di quanti verrebbero eseguiti, risulterebbero duplicati o verrebbero rinviati.
7. Fai clic su **Save script** per applicare le modifiche apportate nell'editor, quindi su **Crea automazione** oppure salva l'automazione per rendere persistente la configurazione.

Le run di test eseguono lo script, ma non eseguono le azioni dell'automazione, non salvano modifiche al suo stato e non contrassegnano gli elementi emessi come gestiti. Le eventuali richieste esterne o gli effetti collaterali prodotti dallo script sono invece reali. Ad esempio, se testi uno script che scrive su un servizio esterno, la scrittura verrà eseguita comunque.

### Input e output dello script

Lo script riceve queste variabili d'ambiente. Ognuna contiene un percorso di file, non i dati JSON veri e propri:

| Variabile | Contenuto |
| - | - |
| `EVENT_FILE` | Evento JSON in sola lettura con `event_type`, `source`, `payload` e `received_at`. La struttura di `payload` dipende dal trigger. |
| `STATE_FILE` | Un oggetto JSON in lettura/scrittura, conservato tra un run live riuscito e l'altro, fino a 64 KiB. Usalo per un cursore di polling, non come database. |
| `LAST_RUN_FILE` | Feedback in sola lettura sugli elementi emessi in precedenza: `key`, `status` e, se presente, `session_id`. Contiene al massimo i 200 elementi più recenti e un indicatore `truncated`. |
| `OUTPUT_FILE` | La decisione in JSON che lo script deve scrivere prima di terminare correttamente. |

Scrivi in `OUTPUT_FILE` esattamente uno tra `run` e `items`, facoltativamente con una stringa `reason`:

| Output | Comportamento |
| - | - |
| `{"run": true}` | Esegue le azioni configurate una sola volta, con l'evento originale. |
| `{"run": false, "reason": "Alert already resolved"}` | Salta l'evento senza eseguirne le azioni. |
| `{"items": [{"id": "INC-1", "title": "Investigate error spike"}]}` | Esegue le azioni configurate separatamente per ogni elemento accettato. Con **Avvia sessione**, avvia una sessione per ciascun elemento; ogni sessione riceve l'evento originale e, come contesto aggiuntivo, l'elemento corrispondente. |
| `{"items": []}` | Salta l'evento perché non c'è nulla da fare. |

Ad esempio, questo script Python lascia passare un messaggio Slack solo se il testo contiene `urgent`:

```python theme={null}
import json
import os

with open(os.environ["EVENT_FILE"]) as f:
    event = json.load(f)

text = event.get("payload", {}).get("text", "")
should_run = "urgent" in text.lower()

with open(os.environ["OUTPUT_FILE"], "w") as f:
    json.dump({"run": should_run, "reason": "Urgency filter"}, f)
```

Seleziona un messaggio Slack di esempio o un messaggio Slack recente in **Test against** per esaminare il risultato. Non basta stampare una decisione sullo standard output: lo script deve scrivere un JSON valido in `OUTPUT_FILE` e terminare con codice di uscita 0.

### Elementi dello script, stato e limiti

* **Prevenzione dei duplicati:** l'`id` di un elemento identifica un'unità di lavoro all'interno di questa automazione, non semplicemente un'entità. `{"id": "INC-1"}` viene gestito una sola volta; per elaborare una nuova occorrenza dello stesso incidente, aggiungi una `version`, ad esempio il timestamp dell'ultimo aggiornamento nel sistema di origine. Senza un `id`, Preflight identifica l'elemento tramite un hash del suo contenuto, quindi modificarne il contenuto può causare un'altra run.
* **Limite di elementi per run:** per impostazione predefinita, vengono inviati al massimo 10 nuovi elementi per run; il limite massimo consentito dal sistema è 50. Gli elementi che superano il limite non vengono gestiti né pianificati automaticamente: la run successiva dello script dovrà emetterli di nuovo. Non far avanzare un cursore oltre il lavoro rinviato solo perché è comparso nel tuo output.
* **Esiti precedenti:** usa `LAST_RUN_FILE` per distinguere il lavoro in esecuzione, completato, non riuscito o saltato. Un elemento la cui run non riesce viene rilasciato, in modo che una run successiva dello script possa emetterlo di nuovo.
* **Stato persistente:** le run live dello script di un'automazione vengono eseguite una alla volta. Gli script non riusciti non fanno avanzare lo stato salvato né contrassegnano gli elementi come gestiti. **Clear state** cancella sia lo stato JSON salvato sia la cronologia degli elementi già gestiti; dopo questa reimpostazione, gli elementi gestiti in precedenza possono essere eseguiti di nuovo.
* **Limiti di dimensione:** il sorgente e l'output dello script sono limitati a 256 KiB ciascuno, lo stato salvato a 64 KiB e i log acquisiti a 1 MiB.
* **Errori:** un codice di uscita diverso da zero, un timeout, un output o uno stato non validi o un errore dell'infrastruttura interrompono l'evento prima che vengano eseguite le relative azioni. Lo script non viene ritentato automaticamente per quell'evento; un trigger successivo può eseguirlo di nuovo.
* **Accesso alla rete:** la VM dello script rispetta le restrizioni di rete dell'automazione e il [profilo di sicurezza](https://docs.devinenterprise.com/it/product-guides/security-profiles.md) applicabile. Ad esempio, per interrogare periodicamente un servizio di avvisi esterno, il relativo host deve essere consentito. Associare un segreto non concede l'accesso alla rete.

## Configurare le actions

### Avvia sessione

L'azione più comune. Quando il trigger si attiva, Devin avvia una nuova sessione con il tuo prompt. Il payload dell'evento (ad es. il testo del messaggio di Slack, il corpo del webhook di GitHub o i dettagli del ticket di Linear) viene aggiunto automaticamente al prompt, in modo che Devin abbia il contesto completo.

Opzioni:

* **Prompt**: Le istruzioni che Devin segue. Scrivilo come faresti con un normale prompt per Devin.
* **Playbook** (facoltativo): Usa `@playbook-name` nel tuo prompt per includere un [playbook](https://docs.devinenterprise.com/it/product-guides/using-playbooks.md) con istruzioni aggiuntive.
* **Tag** (facoltativo): Aggiungi tag alle sessioni create da questa automazione per facilitare il filtraggio.

### Invia un messaggio a una sessione

Invia un messaggio a una sessione Devin esistente e di lunga durata. Utile quando vuoi che un'unica sessione persistente elabori gli eventi nel tempo, invece di avviare una nuova sessione per ciascun evento.

Devi selezionare la sessione di destinazione durante la configurazione di questa action.

### Triage con Devin (monitor)

Crea una sessione persistente di Devin che monitora un canale Slack. Per tutti i dettagli su questo tipo di action, consulta la [guida all'auto-triage](https://docs.devinenterprise.com/it/product-guides/auto-triage.md).

### Notifica email

Invia una notifica email quando viene eseguita l'automazione. Scegli quando inviare la notifica:

* **Sempre** — a ogni esecuzione
* **In caso di errore** — solo quando la sessione non riesce o si verifica un errore
* **In caso di successo** — solo quando la sessione si completa correttamente

## Limiti e protezioni

Le automazioni includono controlli integrati per evitare un utilizzo incontrollato:

### Limite di ACU

Imposta un budget massimo di ACU (Agent Compute Unit) per ogni sessione avviata da questa automazione. Se Devin raggiunge il limite, la sessione si arresta. In questo modo, una singola esecuzione non può consumare risorse eccessive.

### Limite di invocazione

Imposta un limite al numero di volte in cui l'automazione può attivarsi entro un intervallo di tempo. Ad esempio, "al massimo 10 invocazioni all'ora" impedisce che un canale Slack particolarmente attivo o una raffica di fallimenti della CI generino decine di sessioni.

Entrambi i campi sono facoltativi — se vengono svuotati, l'automazione viene eseguita senza quel limite. Le nuove automazioni partono senza limite di ACU e con un **limite di frequenza** di 50 run all'ora (150 all'ora per le automazioni di triage che monitorano canali Slack); i template applicano gli stessi valori predefiniti.

### Accodamento

Per impostazione predefinita, ogni evento corrispondente avvia subito un run. Attiva **Enable queueing** nell'editor di automazione per limitare il numero di run eseguiti contemporaneamente:

* **Concurrent runs**: il numero massimo di run simultanei di questa automazione. Gli eventi in eccesso restano in coda. Un run smette di essere conteggiato ai fini del limite non appena la sua sessione termina e resta in attesa di nuove istruzioni.
* **Queue depth**: il numero massimo di eventi che possono restare in coda. Gli eventi che arrivano quando la coda è piena vengono scartati.

I run in coda vengono visualizzati con lo stato **Queued** nell'attività dell'automazione.

### Policy di rete

Puoi abilitare una policy di rete per limitare gli host esterni a cui possono accedere le sessioni dell'automazione. Questo è particolarmente importante per le automazioni che elaborano input utente non attendibile (ad es. messaggi Slack, payload di webhook). Puoi aggiungere domini specifici all'allowlist se Devin deve raggiungere servizi esterni. La policy di rete di un'automazione può solo limitare l'accesso: viene intersecata con il [profilo di sicurezza](https://docs.devinenterprise.com/it/product-guides/security-profiles.md) che regola le sessioni dell'automazione.

## Integrazioni MCP

> [!TIP]
>
> Collegare le integrazioni MCP è vivamente consigliato: migliorano notevolmente la qualità delle automazioni, perché consentono a Devin di accedere a dati di runtime come logs, metriche e dettagli sugli errori.

Le automazioni usano le [integrazioni MCP](https://docs.devinenterprise.com/it/work-with-devin/mcp.md) per consentire a Devin di accedere a strumenti esterni. Quando crei un'automazione, la sezione **Connessioni** mostra quali server MCP sono consigliati e il loro stato di connessione.

Ad esempio, il template "Fix Sentry Errors Daily" consiglia Sentry MCP, così Devin può recuperare da Sentry gli errori non risolti. Il template "Investigate Alerts Triggered" consiglia Datadog MCP per recuperare metriche e tracce.

Abilita i server MCP nella tab **Settings → Connections → MCPs** (oppure installa i relativi plugin dal marketplace dei plugin) prima di creare automazioni che ne hanno bisogno.

## Accesso agli strumenti di Slack

Per impostazione predefinita, le sessioni di automazione possono leggere e scrivere nei canali Slack coinvolti nel trigger. Puoi concedere l'accesso ad altri canali Slack nella sezione **strumenti di Slack** dell'editor di automazione. Questa opzione è utile quando Devin deve leggere più canali oltre a quello che ha attivato l'automazione.

## Attività e monitoraggio

Ogni automazione tiene traccia della cronologia delle proprie invocazioni. Nella pagina dei dettagli dell'automazione, la scheda **Activity** mostra:

* Invocazioni recenti con timestamp
* Se ogni invocazione è riuscita o è stata ignorata
* Collegamenti alle sessioni Devin create
* Messaggi di errore per le invocazioni non riuscite

La pagina dell'elenco delle automazioni mostra uno sparkline per ogni automazione, fornendo una panoramica visiva dell'attività degli ultimi 30 giorni.

## Attivazione e disattivazione

Attiva o disattiva un’automazione in qualsiasi momento dall’elenco delle automazioni o dalla pagina di dettaglio. Le automazioni disattivate smettono di elaborare gli eventi, ma mantengono la configurazione. Quando riattivi un’automazione, l’elaborazione degli eventi riprende immediatamente.

## Template

Devin include una libreria di template di automazione predefiniti per i flussi di lavoro più comuni:

| Template | Categoria | Cosa fa |
| - | - | - |
| Triage Bug Reports | Monitoring & Triage | Monitora un canale Slack in cerca di segnalazioni di bug — Devin esegue il triage di ciascuna, indaga sulla causa principale e risponde nel thread |
| Triage Support Requests | Monitoring & Triage | Monitora un canale di supporto — Devin redige una risposta accurata nel thread e segnala tutto ciò che richiede un'escalation |
| Triage Customer Bug Tickets | Monitoring & Triage | Quando un cliente apre una issue in Pylon, Devin riproduce il bug, indaga nella codebase e riporta i risultati al team di supporto |
| Investigate Support Escalations | Monitoring & Triage | Quando il supporto contrassegna una issue Pylon per il team di ingegneria, Devin individua la causa principale, la riproduce, propone una soluzione e riferisce nel thread Slack interno — taggando il probabile owner e aprendo un ticket Linear se è lì che vengono gestite le escalation |
| Investigate Alerts Triggered | Monitoring & Triage | Quando un avviso arriva nel canale Slack degli avvisi, Devin usa il Datadog MCP per recuperare metriche, log e tracce, poi pubblica un'analisi della causa principale nel thread |
| Fix Sentry Errors Daily | Monitoring & Triage | Ogni mattina recupera i principali errori Sentry non risolti, indaga su ciascuno e apre PR di soluzione |
| Daily Error Report | Monitoring & Triage | Ogni mattina analizza Datadog alla ricerca di errori nuovi e in aumento nei tuoi servizi e pubblica un report conciso su Slack |
| Recurring Capacity Planning | Monitoring & Triage | Secondo una pianificazione, esamina l'utilizzo e le tendenze di impiego delle risorse per prevedere il fabbisogno di capacità e segnalare i servizi prossimi ai propri limiti |
| Fix CI Failures | CI/CD & Release | Corregge automaticamente i check CI falliti sulle PR non create da Devin — legge i log di build, individua la causa principale, applica una soluzione e verifica che i check passino |
| /devin Issue Fix | CI/CD & Release | Quando qualcuno commenta `/devin` su una issue GitHub, Devin indaga nella codebase e apre una PR di soluzione |
| Weekly Dependency Update | CI/CD & Release | Ogni lunedì cerca pacchetti obsoleti, esamina i changelog per individuare modifiche non retrocompatibili e apre PR di aggiornamento raggruppate per livello di rischio |
| Weekly Changelog | CI/CD & Release | Ogni venerdì raccoglie le PR unite in un changelog suddiviso per categorie e apre una PR che aggiorna CHANGELOG.md |
| Stale PR Cleanup | CI/CD & Release | Scansione settimanale delle PR non aggiornate da oltre una settimana — verifica la presenza di conflitti di merge e pubblica un promemoria cordiale |
| Dependency Vulnerability Scanner | Sicurezza | Scansione giornaliera alla ricerca di CVE note nelle tue dipendenze, con priorità in base alla severità e PR di soluzione |
| Secret Scanner | Sicurezza | Scansione giornaliera alla ricerca di credenziali, API key e token esposti — sostituisce i segreti scritti nel codice con riferimenti a variabili d'ambiente e apre PR di soluzione |
| Verifica dei pattern di codice | Sicurezza | Confronto settimanale del tuo repo con un repository di riferimento, con apertura di PR di allineamento per le deviazioni |
| OWASP Security Hardening | Sicurezza | Scansione settimanale delle vulnerabilità OWASP Top 10 — falle di injection, XSS, controlli di autenticazione mancanti, configurazioni predefinite insicure — con PR di soluzione |
| Cloudflare Security Audit | Sicurezza | Revisione settimanale dei log di audit di Cloudflare per segnalare attività sospette, modifiche di configurazione e potenziali problemi di sicurezza |
| Weekly Status Digest | Project Management | Ogni lunedì raccoglie le PR unite nella settimana precedente in un aggiornamento di stato conciso e lo pubblica su Notion |
| Sprint Progress Report | Project Management | Un riepilogo giornaliero di standup da Asana — recupera lo stato delle attività nei vari progetti e pubblica un aggiornamento sui progressi su Slack |
| Backlog Cleanup | Project Management | Una revisione settimanale del tuo backlog Linear — chiude le issue inattive e duplicate, segnala quelle senza triage e completa etichette, priorità e stime mancanti |

Per sfogliare tutti i template, apri la pagina **automazione** nell'app Devin e clicca su **Crea automazione** > **Template** (oppure vai direttamente su `/automations/templates`).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.