Verwenden Sie den Recon Agent in Project Perception

Der Recon Agent in Project Perception bietet Sicherheitsteams und Red-Team-Operatoren einen Blick aus Angreiferperspektive auf eine Azure-Umgebung. Es korreliert Ressourcen, Identitäten, Berechtigungen und Netzwerkexposition, um realistische Angriffspfade, Konfigurationsprobleme und Risikorisiken zu identifizieren, ohne Ressourcen zu ändern.

Verwenden Sie diesen Artikel, um die Funktionen des Recon Agent zu verstehen, seine Voraussetzungen und Berechtigungen zu überprüfen, sie einzurichten, eine Sitzung zu starten und den Bericht zu interpretieren.

Wichtige Funktionen

Der Recon Agent führt in Ihrer Azure Umgebung mehrstufige, KI-orchestrierte Aufklärung durch.

• Schreibgeschützte Bewertung: Liefert eine evidenzbasierte Risikobewertung, ohne Ressourcen zu ändern.
• Eingaben für andere Agents: Stellt Erkenntnisse für andere Agents bereit, einschließlich Untersuchungs-Agents.
• Umgebungsbasierte Analyse: Analysiert nur Daten aus Ihrer Azure Umgebung.

Warum verwenden Sie den Recon Agent?

Microsoft Security Exposure Management identifiziert kontinuierlich Angriffspfade, die von internet verfügbar gemachten Ressourcen, kritischen Ressourcen und vertraulichen Identitäten stammen. Sie überwacht diese markierten Objekte und Identitäten, generiert jedoch keine Angriffspfade aus beliebigen Ausgangspunkten, die diese Kriterien nicht erfüllen.

Der Recon Agent ergänzt Exposure Management und die Analyse angenommener Sicherheitsverletzungen. Analysten können mit jeder Ressource oder Identität in einem Azure-Abonnement beginnen. Ressourcen müssen nicht als kritisch oder im Internet verfügbar gemacht werden, und Identitäten müssen nicht als vertraulich gekennzeichnet werden. Die Analyse beantwortet die Frage: "Wenn ein Angreifer diese Ressource oder Identität bereits kontrolliert hat, wo könnten sie als Nächstes gehen?"

Beispielsweise kann ein Phishingangriff einen Benutzer kompromittieren, der in Defender nicht als vertrauliche Identität gekennzeichnet ist. Die Expositionsverwaltung generiert in der Regel keinen Angriffspfad von diesem Benutzer, es sei denn, der Pfad enthält eine andere markierte Ressource. Der Recon-Agent kann den Nutzer als Ausgangspunkt verwenden, um mögliche Pivot-Punkte für Angreifer aufzudecken. Teams können dann effektive Drosselpunkte identifizieren, bevor diese Pfade zu Vorfällen mit kritischen Ressourcen oder vertraulichen Identitäten führen.

Diese umfassendere Startpunktabdeckung hilft Teams dabei, Angriffspfade in ihrer Azure Umgebung zu identifizieren und kritische Pfade rechtzeitig zu priorisieren, um das SoC-Vorfallvolumen (Security Operations Center) zu reduzieren.

Kurz gesagt: Microsoft Defender Produkte helfen, Expositionen zu erkennen, zu schützen und zu verwalten. Der Recon Agent erklärt, wie ein Angreifer diese Exposition in einer bestimmten Azure Umgebung verwenden kann und welche Aktionen das Risiko am effektivsten reduzieren würden.

Bevor Sie anfangen

Überprüfen Sie die folgenden Produkt- und Berechtigungsanforderungen, bevor Sie den Recon Agent einrichten.

Voraussetzungen

Um den Recon Agent zu verwenden, benötigen Sie Folgendes:

• Microsoft Entra ID P2
• Microsoft Defender XDR
• Microsoft Defender for Cloud mit dem Defender CSPM Plan
• Ein Azure-Abonnement

Erforderliche Berechtigungen

Zusätzliche Berechtigungen erforderlich

Der Recon-Agent erfordert zwei weitere Berechtigungssätze zum Ausführen der Aufklärung. Der Benutzer, der jedem Berechtigungssatz gewährt, benötigt die entsprechende Rolle in der folgenden Tabelle.

Einrichten des Recon-Agents

Führen Sie zum Einrichten dieses Agents die Schritte unter Einrichten eines Agents aus.

Nachdem Sie die Agent-ID des Recon-Agents erstellt haben, verwenden Sie das folgende Skript, um die in "Zusätzlichen Berechtigungen" aufgeführten Berechtigungen zuzuweisen. Die Skriptparameter sind unten aufgeführt.

Erteilen sie Microsoft Graph-API- und Azure RBAC-Berechtigungen:

Führen Sie dieses Skript aus, um den Microsoft Graph Anwendungsberechtigungen und Azure RBAC-Berechtigungen zu erteilen, die der Recon-Agent benötigt. Sie können Graph, Azure oder beide Berechtigungen über die Parameter erteilen.

<#
.SYNOPSIS
    Assigns the Graph API permissions and Azure RBAC roles required by Recon.

.DESCRIPTION
    Assigns the following Graph API application permissions:
      - User.Read.All
      - Organization.Read.All
      - GroupMember.Read.All
      - Application.Read.All
      - DelegatedPermissionGrant.Read.All
      - Policy.Read.All
      - RoleManagement.Read.Directory
      - AuditLog.Read.All

        Assigns the following Azure RBAC roles at subscription scope:
            - Reader
            - Key Vault Reader
            - Log Analytics Reader
            - Security Reader

.PARAMETER TenantId
    The Tenant Id.

.PARAMETER AgentId
    The Entra ID Object ID (principal ID) of the Agent Identity to assign roles to. To get this value,
    1. Go to the Microsoft Defender portal at https://security.microsoft.com/ -> Perception -> Agents
    2. Search for the Recon Agent and click on it to open the agent details page
    3. Copy the value under the "Identity" section

.PARAMETER Permissions
    Permission sets to assign: All, Azure, or Graph. Defaults to All.

.PARAMETER SubscriptionId
    One or more Azure subscriptions to receive the Recon RBAC assignments.
    Values can be comma-delimited, space-delimited, or supplied as an array.
    Required when Permissions is All or Azure.

Example: .\ReconAgent-Permissions.ps1 -TenantId <TenandId> -AgentId <AgentId> -Permissions All -SubscriptionId <SubscriptionId>
Example: .\ReconAgent-Permissions.ps1 -TenantId <TenandId> -AgentId <AgentId> -Permissions Azure -SubscriptionId <SubscriptionId1>, <SubscriptionId2>

#>

[CmdletBinding()]
param(
    [Parameter(Mandatory = $true)]
    [ValidatePattern('^[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}$')]
    [string]$TenantId,

    [Parameter(Mandatory = $true)]
    [ValidatePattern('^[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}$')]
    [string]$AgentId,

    [ValidateSet('All', 'Azure', 'Graph')]
    [string]$Permissions = 'All',

    [string[]]$SubscriptionId,

    [Parameter(ValueFromRemainingArguments = $true, DontShow = $true)]
    [string[]]$AdditionalSubscriptionId
)

$ErrorActionPreference = 'Stop'

$subscriptionIds = @(@($SubscriptionId) + @($AdditionalSubscriptionId) |
    ForEach-Object { $_ -split '[,\s]+' } |
    Where-Object { -not [string]::IsNullOrWhiteSpace($_) } |
    ForEach-Object { $_.Trim() } |
    Sort-Object -Unique)

if ($Permissions -in @('All', 'Azure') -and $subscriptionIds.Count -eq 0) {
    throw '-SubscriptionId requires at least one subscription GUID when -Permissions is All or Azure.'
}

foreach ($id in $subscriptionIds) {
    if ($id -notmatch '^[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}$') {
        throw "Invalid subscription ID '$id'. Supply one or more GUIDs separated by commas or spaces."
    }
}

function Invoke-AzJson {
    param(
        [Parameter(Mandatory)]
        [string[]]$Arguments
    )

    $output = & az @Arguments 2>&1
    if ($LASTEXITCODE -ne 0) {
        throw "az $($Arguments -join ' ') failed: $($output -join [Environment]::NewLine)"
    }

    if (-not $output) {
        return $null
    }

    return ($output -join [Environment]::NewLine) | ConvertFrom-Json
}

function Test-AzureActionAllowed {
    param(
        [Parameter(Mandatory)]
        [string]$Scope,

        [Parameter(Mandatory)]
        [string]$Action
    )

    $permissionsResponse = Invoke-AzJson -Arguments @(
        'rest', '--method', 'GET',
        '--url', "https://management.azure.com$Scope/providers/Microsoft.Authorization/permissions?api-version=2022-04-01",
        '--output', 'json'
    )

    foreach ($permission in @($permissionsResponse.value)) {
        $isAllowed = @($permission.actions | Where-Object {
            $Action -like [string]$_
        }).Count -gt 0
        $isExcluded = @($permission.notActions | Where-Object {
            $Action -like [string]$_
        }).Count -gt 0

        if ($isAllowed -and -not $isExcluded) {
            return $true
        }
    }

    return $false
}

function Write-Section {
    param([string]$Title)

    Write-Host ''
    Write-Host $Title -ForegroundColor Cyan
    Write-Host ('-' * $Title.Length) -ForegroundColor DarkGray
}

function Write-Step {
    param(
        [string]$Message,
        [ValidateSet('Info', 'OK', 'Warn', 'Err', 'Step')]
        [string]$Level = 'Info'
    )

    $color = switch ($Level) {
        'OK' { 'Green' }
        'Warn' { 'Yellow' }
        'Err' { 'Red' }
        'Step' { 'Cyan' }
        default { 'Gray' }
    }
    $prefix = switch ($Level) {
        'OK' { '[ OK ]' }
        'Warn' { '[WARN]' }
        'Err' { '[FAIL]' }
        'Step' { '[STEP]' }
        default { '[ -- ]' }
    }

    if ($Level -eq 'Step') {
        Write-Host ''
    }

    Write-Host (
        '{0} {1} {2}' -f
        (Get-Date -Format 'HH:mm:ss'), $prefix, $Message
    ) -ForegroundColor $color
}

function Write-ConsoleResults {
    param([object[]]$Results)

    Write-Section 'Granular Recon permission assignment'
    Write-Step `
        -Message "Agent: Recon, EntraObjectId: $AgentId" `
        -Level Step

    foreach ($result in @($Results |
        Sort-Object PermissionSet, SubscriptionId, Role)) {
        $category = if ($result.PermissionSet -eq 'Graph') {
            'Microsoft Graph permission'
        }
        else {
            'Azure RBAC'
        }
        $value = if ($result.PermissionSet -eq 'Azure') {
            "{0} ({1})" -f $result.Role, $result.Scope
        }
        else {
            "Graph $($result.Role)"
        }
        $assignmentResult = switch ($result.Status) {
            'Already assigned' { 'Already existed' }
            'Assigned' { 'Added' }
            default { $result.Status }
        }
        $level = if ($result.Status -eq 'Failed') { 'Err' } else { 'OK' }

        Write-Step `
            -Message "$category`: $value - $assignmentResult" `
            -Level $level
        if ($result.Status -eq 'Failed' -and
            -not [string]::IsNullOrWhiteSpace([string]$result.Details)) {
            Write-Host ("       Details:  {0}" -f $result.Details) `
                -ForegroundColor DarkGray
        }
    }
}

if (-not (Get-Command az -ErrorAction SilentlyContinue)) {
    throw 'Azure CLI is required but the az command was not found.'
}

Write-Host ''
Write-Host 'Recon Agent Permission Assignment' -ForegroundColor Cyan
Write-Host 'Assigns required Microsoft Graph and Azure RBAC permissions' `
    -ForegroundColor DarkGray
Write-Host "Permission set: $Permissions"
Write-Host "Tenant: $TenantId"

# Ensure Azure CLI is signed in to the requested tenant.
$account = $null
try {
    $account = Invoke-AzJson -Arguments @('account', 'show', '--output', 'json')
}
catch {
    # No usable cached Azure CLI session.
}

if (-not $account -or [string]$account.tenantId -ne $TenantId) {
    & az login --tenant $TenantId --allow-no-subscriptions | Out-Null
    if ($LASTEXITCODE -ne 0) {
        throw "Azure CLI sign-in to tenant $TenantId failed."
    }
}

$agentServicePrincipal = Invoke-AzJson -Arguments @(
    'rest', '--method', 'GET',
    '--url', "https://graph.microsoft.com/v1.0/servicePrincipals/$AgentId",
    '--output', 'json'
)
if ([string]$agentServicePrincipal.id -ne $AgentId) {
    throw "Agent service principal $AgentId could not be resolved in tenant $TenantId."
}

$results = @()

if ($Permissions -in @('All', 'Graph')) {
    $graphToken = & az account get-access-token `
        --tenant $TenantId `
        --resource-type ms-graph `
        --query accessToken `
        --output tsv 2>&1
    if ($LASTEXITCODE -ne 0 -or [string]::IsNullOrWhiteSpace([string]$graphToken)) {
        throw "Unable to acquire a Microsoft Graph token: $($graphToken -join [Environment]::NewLine)"
    }
    $graphHeaders = @{
        Authorization = "Bearer $([string]$graphToken)"
        Accept = 'application/json'
    }

    # Graph API roles (AppRoleId -> Role Name)
    $graphRoleIds = @{
        'df021288-bdef-4463-88db-98f22de89214' = 'User.Read.All'
        '498476ce-e0fe-48b0-b801-37ba7e2685c6' = 'Organization.Read.All'
        '98830695-27a2-44f7-8c18-0c3ebc9698f6' = 'GroupMember.Read.All'
        '9a5d68dd-52b0-4cc2-bd40-abcf44ac3a30' = 'Application.Read.All'
        '81b4724a-58aa-41c1-8a55-84ef97466587' = 'DelegatedPermissionGrant.Read.All'
        '246dd0d5-5bd0-4def-940b-0421030a5b68' = 'Policy.Read.All'
        '483bed4a-2ad3-4361-a73b-c83ccdbdc53c' = 'RoleManagement.Read.Directory'
        'b0afded3-3588-46d8-8b3d-9842eff778da' = 'AuditLog.Read.All'
    }

    $graphServicePrincipal = Invoke-AzJson -Arguments @(
        'ad', 'sp', 'show',
        '--id', '00000003-0000-0000-c000-000000000000',
        '--output', 'json'
    )
    $GraphObjectId = [string]$graphServicePrincipal.id
    if ([string]::IsNullOrWhiteSpace($GraphObjectId)) {
        throw "Microsoft Graph service principal could not be resolved in tenant $TenantId."
    }

    $existingAssignmentsResponse = Invoke-AzJson -Arguments @(
        'rest', '--method', 'GET',
        '--url', "https://graph.microsoft.com/v1.0/servicePrincipals/$AgentId/appRoleAssignments",
        '--output', 'json'
    )
    $existingAssignments = @($existingAssignmentsResponse.value)

    foreach ($rid in $graphRoleIds.Keys) {
        $roleName = $graphRoleIds[$rid]
        $existingAssignment = $existingAssignments |
            Where-Object {
                [string]$_.resourceId -eq $GraphObjectId -and
                [string]$_.appRoleId -eq $rid
            } |
            Select-Object -First 1

        if ($existingAssignment) {
            $results += [pscustomobject]@{
                PermissionSet = 'Graph'
                Role = $roleName
                Status = 'Already assigned'
                Details = ''
            }
            continue
        }

        $body = @{
            principalId = $AgentId
            resourceId = $GraphObjectId
            appRoleId = $rid
        } | ConvertTo-Json -Compress

        try {
            Invoke-RestMethod `
                -Method Post `
                -Uri "https://graph.microsoft.com/v1.0/servicePrincipals/$AgentId/appRoleAssignments" `
                -Headers $graphHeaders `
                -ContentType 'application/json' `
                -Body $body | Out-Null
            $results += [pscustomobject]@{
                PermissionSet = 'Graph'
                Role = $roleName
                Status = 'Assigned'
                Details = ''
            }
        }
        catch {
            $details = if ($_.ErrorDetails.Message) {
                $_.ErrorDetails.Message
            }
            else {
                $_.Exception.Message
            }
            $results += [pscustomobject]@{
                PermissionSet = 'Graph'
                Role = $roleName
                Status = 'Failed'
                Details = $details
            }
        }
    }
}

if ($Permissions -in @('All', 'Azure')) {
    $azureRoles = @(
        'Reader'
        'Key Vault Reader'
        'Log Analytics Reader'
        'Security Reader'
    )

    foreach ($currentSubscriptionId in $subscriptionIds) {
        $subscription = Invoke-AzJson -Arguments @(
            'account', 'show',
            '--subscription', $currentSubscriptionId,
            '--output', 'json'
        )
        if ([string]$subscription.tenantId -ne $TenantId) {
            throw "Subscription $currentSubscriptionId belongs to tenant $($subscription.tenantId), not requested tenant $TenantId."
        }

        & az account set --subscription $currentSubscriptionId
        if ($LASTEXITCODE -ne 0) {
            throw "Unable to select Azure subscription $currentSubscriptionId."
        }

        $scope = "/subscriptions/$currentSubscriptionId"
        try {
            $canWriteRoleAssignments = Test-AzureActionAllowed `
                -Scope $scope `
                -Action 'Microsoft.Authorization/roleAssignments/write'
            if (-not $canWriteRoleAssignments) {
                throw "The signed-in account does not have Microsoft.Authorization/roleAssignments/write at $scope. Assign Owner, User Access Administrator, or Role Based Access Control Administrator at this scope or a parent scope."
            }
        }
        catch {
            $results += [pscustomobject]@{
                PermissionSet = 'Azure'
                SubscriptionId = $currentSubscriptionId
                Scope = $scope
                Role = 'Role assignment preflight'
                Status = 'Failed'
                Details = $_.Exception.Message
            }
            continue
        }

        foreach ($roleName in $azureRoles) {
            try {
                $existingRoleAssignments = @(Invoke-AzJson -Arguments @(
                    'role', 'assignment', 'list',
                    '--assignee-object-id', $AgentId,
                    '--role', $roleName,
                    '--scope', $scope,
                    '--output', 'json'
                ))

                if ($existingRoleAssignments.Count -gt 0) {
                    $results += [pscustomobject]@{
                        PermissionSet = 'Azure'
                        SubscriptionId = $currentSubscriptionId
                        Scope = $scope
                        Role = $roleName
                        Status = 'Already assigned'
                        Details = ''
                    }
                    continue
                }

                Invoke-AzJson -Arguments @(
                    'role', 'assignment', 'create',
                    '--assignee-object-id', $AgentId,
                    '--assignee-principal-type', 'ServicePrincipal',
                    '--role', $roleName,
                    '--scope', $scope,
                    '--output', 'json'
                ) | Out-Null

                $results += [pscustomobject]@{
                    PermissionSet = 'Azure'
                    SubscriptionId = $currentSubscriptionId
                    Scope = $scope
                    Role = $roleName
                    Status = 'Assigned'
                    Details = ''
                }
            }
            catch {
                $results += [pscustomobject]@{
                    PermissionSet = 'Azure'
                    SubscriptionId = $currentSubscriptionId
                    Scope = $scope
                    Role = $roleName
                    Status = 'Failed'
                    Details = $_.Exception.Message
                }
            }
        }
    }
}

Write-ConsoleResults -Results $results
Write-Host

if ($results.Status -contains 'Failed') {
    exit 1
}

exit 0

Zulassen des Zugriffs anderer Benutzer

Der Zugriff auf Agents wird durch vorhandene Sicherheitsrollen in Microsoft Defender gesteuert. Benutzer mit der Rolle "Sicherheitsleseberechtigter " oder "Sicherheitsadministrator " können Agentsitzungen anzeigen und mit ihnen interagieren, sobald der Agent eingerichtet ist.

Starten einer Recon-Agent-Sitzung

Informationen zu den verfügbaren Einstiegspunkten für Sitzungen finden Sie unter "Starten einer neuen Sitzung".

Der Recon Agent nimmt an den folgenden Ablaufplänen teil:

Führen Sie die folgenden Schritte aus, um eine Sitzung "Identitätsrisiken bewerten " zu starten:

1. Wählen Sie im Navigationsbereich Perception> aus.

2. Wählen Sie "Neue Sitzung" aus.

3. Wählen Sie das Playbook "Identitätsrisiken bewerten " aus.

   

   Der Bereich „Zusätzliche Eingaben erforderlich“ wird geöffnet. Es sind zwei Eingaben erforderlich:

   Feld	Description
   Azure-Abonnement	Die Azure-Abonnement-ID oder der Name, auf die bzw. den die Sitzung beschränkt werden soll. Jede Sitzung ist auf ein Abonnement beschränkt. Der Administrator konfiguriert diese Liste während der Konfiguration des Recon Agent vor, und Sie können nur vorkonfigurierte Abonnements verwenden.
   Verwaltete Identität	Auswählen der verwalteten Identität .

   

   Anmerkung

   Wenn Sie das Playbook zum Identifizieren von Angriffspfaden einrichten, wird ein Auswahlfeld für Abonnements angezeigt, mit dem der Sitzungsbereich festgelegt wird. Das Auswahlfeld zeigt Abonnements an, die für den angemeldeten Benutzer verfügbar sind, nicht für die Recon Agent-Anwendung. Um das Playbook zu starten, benötigt der angemeldete Benutzer Lesezugriff auf das gesamte Abonnement. Diese Einschränkung gilt nur, wenn die Sitzung gestartet wird. Nachdem die Sitzung gestartet wurde, verwendet der Recon Agent seine eigene Identität für die Aufklärung.

4. Füllen Sie beide Felder aus, und wählen Sie " Startsitzung" aus.

Die Sitzung wird mit dem Status "Läuft" geöffnet. Der Agent zeigt den Fortschritt an, während er eine Aufgabenliste erstellt und seine Arbeit startet.

Überwachen des Sitzungsfortschritts

Während die Sitzung läuft, zeigt das rechte Bedienfeld Folgendes an:

• Übersicht: Zeigt die Sitzungszusammenfassung und den aktuellen Status an.
• Fortschritt: Zeigt abgeschlossene Schritte an. Beispielsweise ändert sich der Wert von 0/1 auf 1/1 , wenn die Aufgabe abgeschlossen ist.
• Recon Agent: Identifiziert den aktiven Agent für die Sitzung.
• Eingaben: Zeigt die Zielumgebung und den von Ihnen bereitgestellten Anwendungsfall an.
• Ergebnisse: Listet die bisher generierten Dateien auf und wird im Verlauf der Sitzung aktualisiert.

Verstehen Sie den Bericht

Der Bericht enthält die folgenden Abschnitte:

• Wichtige Ergebnisse: Fasst die wichtigsten Risiken und Indikatoren mit unterstützenden Nachweisen zusammen, z. B. IP-Adressen, die schädliche Inhalte hosten, und deren DNS-Auflösungsverlauf. Jede Feststellung wird als bestätigt, wahrscheinlich oder abgeleitet bezeichnet, um die Stärke des Nachweises anzugeben.
• Ressourceninventartabelle: Listet ermittelte Ressourcen mit den Spalten Indikator, Typ, Bedrohungsbewertung, Konfidenz und First Seen auf.
• Angriffspfaddiagramm: Zeigt realistische Pfade an, die ein Angreifer verwenden kann, sowie die Beziehungen zwischen Objekten, Identitäten und Zugriff. Beispielsweise kann ein Pfad eine Verbindung zwischen einer Organisation, dem Token eines privilegierten Benutzers und einer Produktionsressource herstellen. Falls zutreffend, identifiziert das Diagramm die schnellsten, stehlensten und breitesten Routen.
• MITRE-ATT&CK-Zuordnung: Ordnet jede relevante Erkenntnis den entsprechenden MITRE-ATT&CK-Techniken zu. Der Bericht klassifiziert Techniken nach anwendbaren, nicht zutreffenden oder unzureichenden Daten , sodass Sie beurteilen können, wie viel der Angriffsfläche Ihre aktuellen Erkennungen abdecken.
• Erkennungslücken: Identifiziert Angriffspfade, die vorhandene Defender Erkennungen nicht abdecken. Sofern eine entsprechende Abdeckung besteht, enthält der Bericht relevante Defender-Warnungen und Hunting-Abfragen in Kusto Query Language (KQL).

Recon-Agent-Ausgabe anzeigen

Die Sitzung zeigt die Ausgabe des Recon-Agents als Markdown-Dateien an.

Verwandte Inhalte

• Was ist Project Perception?
• Wichtige Konzepte in Project Perception verstehen
• Arbeiten mit Agents
• Agentensitzungen überwachen und verwalten
• Angriffsuntersuchungs-Agent
• Triage Agent