Bakgrundsagenter

Bakgrundsagenter låter en huvudagent delegera oberoende uppgifter till namngivna underagenter. Varje aktivitet körs samtidigt i sin egen underordnade agentsession, medan den överordnade har ett aktivitets-ID som den kan använda för att vänta, hämta resultat, fortsätta arbetet eller släppa uppgiften.

Important

Bakgrundsagenter är experimentella.

Bakgrundsagenter skiljer sig från bakgrundssvar. Ett bakgrundssvar representerar en providerbegäran som programmet avsöker eller återupptar. En aktivitet i en bakgrundsagent anropar en annan agent i Agent Framework och skickar senare tillbaka agentens textresultat till den överordnade.

Konfigurera bakgrundsagenter manuellt

Varje underordnad agent måste ha ett okänt, skiftlägesokänsligt unikt namn. Ge underagenter tydliga och fokuserade instruktioner och endast de verktyg som behövs för deras tilldelade roll.

Importera BackgroundAgentsProvider och lägg till den i en vanlig agent 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 anpassar providerinstruktionerna och agentlistans formatering.

from agent_framework import Agent, BackgroundAgentsProvider

background_provider = BackgroundAgentsProvider(
    [web_search_agent, code_analysis_agent],
    wait_timeout_seconds=30,
)

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

Skicka instructions= till BackgroundAgentsProvider för att ersätta dess instruktioner. Infoga {background_agents} där den formaterade listan över underordnade agenter ska visas.

wait_timeout_seconds anger hur länge varje anrop ska background_agents_wait_for_first_completion vänta. Det måste vara ett positivt heltal och är som standard 300 sekunder. Om tidsgränsen upphör att gälla returnerar verktyget normalt och lämnar aktiviteterna igång, så att den överordnade kan anropa den igen.

Anmärkning

Den paketerade bakgrundsagentprovidern som beskrivs på den här sidan är för närvarande inte tillgänglig i Go.

Aktivitetslivscykel

Providern lägger till samma modellinriktade verktyg i .NET och Python:

Tool Livscykelåtgärd
background_agents_start_task Starta en icke-blockerande aktivitet på en namngiven agent och returnera dess heltalsaktivitets-ID.
background_agents_wait_for_first_completion Vänta tills den första aktiviteten i en angiven uppsättning når ett terminaltillstånd.
background_agents_get_task_results Returnera slutförd text, ett felmeddelande eller aktuell status.
background_agents_get_all_tasks Lista ID:er, statusar, agentnamn och beskrivningar.
background_agents_continue_task Kör efterföljande indata i den befintliga undersessionen efter att en uppgift har slutförts eller misslyckats.
background_agents_clear_completed_task Ta bort en terminalaktivitet och frigör dess underordnade session.

En typisk sekvens med överordnad agent är:

  1. Starta varje oberoende aktivitet innan du väntar, så att aktiviteterna körs samtidigt.
  2. Vänta tills det första slutförts, hämta resultatet och upprepa tills inga aktiviteter körs.
  3. Fortsätt med en slutförd eller misslyckad uppgift när uppföljningsarbetet behöver sin befintliga konversationskontext.
  4. Rensa terminaluppgifter när deras resultat har hämtats, om de inte ska fortsätta.

Uppgiftsstatus är running, completed, failed eller lost. En uppgift går förlorad när dess pågående uppgiftshandtag eller underordnade session inte är tillgänglig, till exempel efter en processomstart eller sessionsåterställning. Serialiserbara uppgiftsmetadata kan finnas kvar i den överordnade sessionen, men handtagen för arbete under flygning och underordnad session överlever inte den gränsen.

Det finns inget avbokningsverktyg i providern. Låt pågående uppgifter nå en slutstatus innan du rensar dem.

Återanvänd samma överordnade session mellan svängar. Varje uppgift får en dedikerad undersession. Att fortsätta en terminaluppgift återanvänder den underordnade sessionen; att rensa den tar bort uppgiftsmetadata och frigör handtaget till den underordnade sessionen.

Aktivitetsresultat returneras till den överordnade som text. Providern proxyar inte ett underordnat barns begäran om strukturerat verktygsgodkännande tillbaka via den överordnade, så konfigurera underordnade agenter för att slutföra delegerat arbete utan interaktivt godkännande eller hantera deras godkännanden inuti den underordnade agentvärden.

Släppa en överordnad session från värden

Anmärkning

Sessionsversionen av bakgrundsagenten på värdsidan är för närvarande inte tillgänglig i .NET.

När värden avvisar eller kasserar en parentsession frigör du providerns handtag för pågående aktiviteter och barnsessioner i ett finally-block:

session = parent_agent.create_session()
try:
    await parent_agent.run("Coordinate the research.", session=session)
finally:
    await background_provider.release_session(session)

release_session(session, *, cancel_running=True, timeout=30.0) är ett livscykel-API på värdsidan, inte ett modellbaserat verktyg. Som standard avbryts underordnade uppgifter som körs, och systemet väntar upp till 30 sekunder på att de ska avbrytas innan allt körtidstillstånd för den överordnade sessionen frigörs. Ställ in cancel_running=False på att avvisa lanseringen medan uppgifter körs, eller ställ in timeout=None på att vänta på obestämd tid.

Däremot låter background_agents_clear_completed_task modellen ta bort en terminaluppgift och dess underordnade session under en konversation. Den avvisar pågående uppgifter och ersätter inte nedmontering av den överordnade sessionen på värdsidan.

Anmärkning

Sessionsversionen av bakgrundsagenten på värdsidan är för närvarande inte tillgänglig i Go.

Lägg till automatisk väntan manuellt

Omslut det manuellt sammansatta överordnade elementet med LoopAgent. BackgroundTaskCompletionLoopEvaluator fortsätter bara medan en uppgift förblir i tillståndet Running :

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

Utvärderaren stannar vid slutförda, misslyckade och förlorade uppgifter.

Lägg till AgentLoopMiddleware i den vanliga överordnade noden och para ihop predikatet för bakgrundsuppgiften med dess hjälpfunktion för nästa meddelande:

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,
        )
    ],
)

Predikatet fortsätter endast så länge det sparade aktivitetstillståndet fortfarande anger att aktiviteten körs.

Automatisk integrering av loopar för bakgrundsaktiviteter är för närvarande inte tillgänglig i Go.

Använda bakgrundsagenter med Harness Agent

Använd den här konfigurationen när du också vill ha Harness-agentens standardpipeline för planering, minne, godkännande och observerbarhet.

Ange HarnessAgentOptions.BackgroundAgents. Lägg till utvärderaren för slutförande när den överordnade processen ska fortsätta köra tills det delegerade arbetet inte längre körs:

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();

Använd HarnessAgentOptions.BackgroundAgentsProviderOptions för att anpassa providerinstruktioner och agentlistformatering. Om LoopEvaluators utelämnas är delegering i bakgrunden fortfarande tillgänglig utan att den anropas automatiskt igen.

Ange background_agents till create_harness_agent. Koppla ihop den med en begränsad loop när den överordnade ska vänta automatiskt:

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],
    background_agents_wait_timeout_seconds=30,
    loop_should_continue=background_tasks_running(),
    loop_next_message=background_tasks_running_message,
    loop_max_iterations=10,
)
session = parent_agent.create_session()

Använd background_agents_instructions för att ersätta providerinstruktionerna. background_agents_wait_timeout_seconds konfigurerar samma avgränsade väntetid som wait_timeout_seconds på BackgroundAgentsProvider. Python-ramverket aktiverar mellanprogramvara för automatisk verktygsgodkänning som standard, så skicka med session vid varje körning.

Anmärkning

Delegering i bakgrunden för Harness Agent är för närvarande inte tillgängligt i Go.

Säkerhetsfrågor

Registrera endast underordnade agenter som du litar på. Föräldern kan skicka dem text som kommer från privat eller icke betrodd kontext, och resultaten läggs tillbaka i förälderns kontext. En komprometterad underordnad komponent kan exfiltrera delegerad indata eller returnera innehåll från indirekt promptinjektion.

Nästa steg

Planera arbete och spåra todos

Gå djupare

  • Last updated on