Agents en arrière-plan

Les agents en arrière-plan permettent à un agent parent de déléguer des tâches indépendantes aux agents enfants nommés. Chaque tâche s’exécute simultanément dans sa propre session d’agent enfant, tandis que le parent conserve un ID de tâche qu’il peut utiliser pour attendre, récupérer les résultats, continuer le travail ou libérer la tâche.

Important

Les agents d’arrière-plan sont expérimentaux.

Les agents en arrière-plan sont différents des réponses en arrière-plan. Une réponse en arrière-plan représente une demande de fournisseur que l’application interroge ou reprend. Une tâche d’agent en arrière-plan appelle un autre agent Agent Framework et les flux ultérieurs du résultat de texte de l’agent vers le parent.

Configurer manuellement des agents en arrière-plan

Chaque agent enfant doit avoir un nom unique sans respect de la casse. Donnez des instructions ciblées sur les agents enfants et uniquement les outils nécessaires pour leur rôle délégué.

Importez BackgroundAgentsProvider et ajoutez-le à un agent standard via ChatClientAgentOptions.AIContextProviders:

using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

var backgroundProvider = new BackgroundAgentsProvider(
    [webSearchAgent, codeAnalysisAgent]);

AIAgent parentAgent = chatClient.AsAIAgent(new ChatClientAgentOptions
{
    Name = "research-coordinator",
    AIContextProviders = [backgroundProvider],
});

AgentSession session = await parentAgent.CreateSessionAsync();

BackgroundAgentsProviderOptions personnalise les instructions du fournisseur et la mise en forme de liste d’agents.

from agent_framework import Agent, BackgroundAgentsProvider

background_provider = BackgroundAgentsProvider(
    [web_search_agent, code_analysis_agent]
)

parent_agent = Agent(
    client=client,
    name="research-coordinator",
    context_providers=[background_provider],
)
session = parent_agent.create_session()

instructions= Passez à remplacer BackgroundAgentsProvider ses instructions. Incluez {background_agents} l’emplacement où la liste d’agents enfants mis en forme doit apparaître.

Note

Le fournisseur d’agent en arrière-plan empaqueté décrit dans cette page n’est actuellement pas disponible dans Go.

Cycle de vie des tâches

Le fournisseur ajoute les mêmes outils orientés modèle dans .NET et Python :

Tool Action de cycle de vie
background_agents_start_task Démarrez une tâche non bloquante sur un agent nommé et retournez son ID de tâche entier.
background_agents_wait_for_first_completion Attendez que la première tâche d’un jeu fourni atteigne un état terminal.
background_agents_get_task_results Retournez le texte terminé, un message d’échec ou l’état actuel.
background_agents_get_all_tasks Répertorier les ID, les états, les noms de l’agent et les descriptions.
background_agents_continue_task Exécutez une entrée de suivi dans la session enfant existante une fois qu’une tâche s’est terminée ou échoue.
background_agents_clear_completed_task Supprimez une tâche de terminal et relâchez sa session enfant.

Une séquence parent-agent classique est la suivante :

  1. Démarrez chaque tâche indépendante avant d’attendre, de sorte que les tâches s’exécutent simultanément.
  2. Attendez la première saisie semi-automatique, récupérez ce résultat et répétez jusqu’à ce qu’aucune tâche ne s’exécute.
  3. Poursuivez une tâche terminée ou ayant échoué lorsque le travail de suivi a besoin de son contexte de conversation existant.
  4. Effacez les tâches terminales après avoir récupéré leurs résultats, sauf si elles seront poursuivies.

L’état de la tâche est running, completedou failedlost. Une tâche devient perdue lorsque son handle de tâche in-process ou sa session enfant n’est pas disponible, par exemple après un redémarrage ou une restauration de session. Les métadonnées de tâche sérialisables peuvent rester dans la session parente, mais les handles de travail en cours et de session enfant ne survivent pas à cette limite.

Il n’existe aucun outil d’annulation dans le fournisseur. Laissez les tâches en cours d’exécution atteindre un état terminal avant de les effacer.

Réutilisez la même session parente à plusieurs tours. Chaque tâche reçoit une session enfant dédiée. La poursuite d’une tâche de terminal réutilise cette session enfant ; L’effacement supprime les métadonnées de la tâche et libère le handle de session enfant.

Les résultats de la tâche sont renvoyés au parent sous forme de texte. Le fournisseur ne proxy pas la demande d’approbation d’outil structurée d’un enfant par le biais du parent. Configurez donc les agents enfants pour terminer le travail délégué sans approbation interactive ni gérer leurs approbations à l’intérieur de l’hôte de l’agent enfant.

Ajouter l’attente automatique manuellement

Encapsulez le parent composé manuellement avec LoopAgent. BackgroundTaskCompletionLoopEvaluator continue uniquement pendant qu’une tâche reste dans l’état Running :

AIAgent loopingParent = new LoopAgent(
    parentAgent,
    new BackgroundTaskCompletionLoopEvaluator(),
    new LoopAgentOptions { MaxIterations = 10 });

L’évaluateur s’arrête pour les tâches terminées, ayant échoué et perdues.

Ajoutez au parent standard et associez AgentLoopMiddleware le prédicat de tâche en arrière-plan à son assistance de message suivant :

from agent_framework import (
    Agent,
    AgentLoopMiddleware,
    background_tasks_running,
    background_tasks_running_message,
)

parent_agent = Agent(
    client=client,
    context_providers=[background_provider],
    middleware=[
        AgentLoopMiddleware(
            background_tasks_running(),
            next_message=background_tasks_running_message,
            max_iterations=10,
        )
    ],
)

Le prédicat continue uniquement pendant que l’état de tâche persistant signale toujours une tâche en cours d’exécution.

L’intégration automatique de boucles de tâche en arrière-plan n’est actuellement pas disponible dans Go.

Utiliser des agents en arrière-plan avec l’agent Harness

Utilisez cette configuration lorsque vous souhaitez également que le pipeline de planification, d’approbation et d’observabilité par défaut de l’agent Harness Agent.

Définissez HarnessAgentOptions.BackgroundAgents. Ajoutez l’évaluateur d’achèvement lorsque le parent doit continuer à s’exécuter tant que le travail délégué n’est plus en cours d’exécution :

using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

var options = new HarnessAgentOptions
{
    Name = "research-coordinator",
    BackgroundAgents = [webSearchAgent, codeAnalysisAgent],
    LoopEvaluators = [new BackgroundTaskCompletionLoopEvaluator()],
    LoopAgentOptions = new LoopAgentOptions { MaxIterations = 10 },
};

HarnessAgent parentAgent = chatClient.AsHarnessAgent(options);
// Equivalent construction: new HarnessAgent(chatClient, options)
AgentSession session = await parentAgent.CreateSessionAsync();

Permet HarnessAgentOptions.BackgroundAgentsProviderOptions de personnaliser les instructions du fournisseur et la mise en forme de liste d’agents. LoopEvaluators L’omission conserve la délégation en arrière-plan disponible sans réinvocation automatique.

Fournir background_agents à create_harness_agent. Associez-la à une boucle délimitée lorsque le parent doit attendre automatiquement :

from agent_framework import (
    background_tasks_running,
    background_tasks_running_message,
    create_harness_agent,
)

parent_agent = create_harness_agent(
    client=client,
    name="research-coordinator",
    background_agents=[web_search_agent, code_analysis_agent],
    loop_should_continue=background_tasks_running(),
    loop_next_message=background_tasks_running_message,
    loop_max_iterations=10,
)
session = parent_agent.create_session()

Permet background_agents_instructions de remplacer les instructions du fournisseur. Le Python harnais permet par défaut l’intergiciel d’approbation automatique des outils. Transmettez donc toutes les exécutionssession.

Note

La délégation en arrière-plan de l’agent Harness n’est pas disponible dans Go.

Considérations relatives à la sécurité

Inscrivez uniquement les agents enfants que vous approuvez. Le parent peut leur envoyer du texte dérivé d’un contexte privé ou non approuvé, et leurs résultats sont ajoutés au contexte du parent. Un enfant compromis peut exfiltrer une entrée déléguée ou retourner du contenu d’injection d’invite indirecte.

Étapes suivantes

Planifier le travail et suivre les todos

Approfondir la question

  • Last updated on