Agentlooping

Agentloopning anropar en agent tills ett slutförandevillkor är uppfyllt. Använd den för iterativ förfining, slutförande, väntar på bakgrundsaktiviteter eller utvärderar om ett svar uppfyller explicita kriterier.

Alltid bundna autonoma loopar. Ett slutförandevillkor kan misslyckas, en modell kan stanna upp och en utvärderare kan vara probabilistisk.

Important

Agentloopning är experimentell.

Konfigurera loopning manuellt

Använd API:et för direkt sammansättning när du vill loopa utan de andra standardvärdena för Harness Agent.

Importera looptyperna och radbryt alla AIAgent med LoopAgent. Standardvärdet är 10 agentanrop:

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

AIAgent baseAgent = chatClient.AsAIAgent();
AIAgent agent = new LoopAgent(
    baseAgent,
    new CompletionMarkerLoopEvaluator("DONE"),
    new LoopAgentOptions { MaxIterations = 5 });

Importera AgentLoopMiddleware och lägg till den i en vanlig Agent. Standardvärdet är 10 agentkörningar:

from agent_framework import Agent, AgentLoopMiddleware


def needs_more_work(*, last_result, **kwargs):
    return "DONE" not in last_result.text


agent = Agent(
    client=client,
    middleware=[
        AgentLoopMiddleware(
            needs_more_work,
            max_iterations=5,
        )
    ],
)

Predikatet kan vara synkront eller asynkront. Gå tillbaka True för att fortsätta, False stoppa eller (continue, feedback) skicka feedback till nästa iteration.

Anmärkning

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

Välj ett slutförandevillkor

LoopAgent accepterar en utvärderare eller en ordnad samling:

Utvärderare	Fortsätter medan
CompletionMarkerLoopEvaluator	Det senaste svaret innehåller inte den konfigurerade markören.
TodoCompletionLoopEvaluator	En löst TodoProvider har fortfarande ofullständiga objekt, eventuellt i valda agentlägen.
BackgroundTaskCompletionLoopEvaluator	En löst BackgroundAgentsProvider har fortfarande aktiviteter som körs.
AIJudgeLoopEvaluator	En separat domarklient säger att den ursprungliga begäran inte besvaras fullt ut.
DelegateLoopEvaluator	Återanropet returnerar LoopEvaluation.Continue(...).

När flera utvärderare har konfigurerats körs de i ordning. Den första utvärderaren som begär en annan iteration ger sin feedback. -loopen stoppas endast när alla utvärderare avböjer att fortsätta.

Använda en AI-domare

Domaren får den ursprungliga begäran och det senaste agentsvaret. Om den hittar en lucka blir analysen feedback för nästa iteration:

var evaluator = new AIJudgeLoopEvaluator(
    judgeClient,
    new AIJudgeLoopEvaluatorOptions
    {
        Criteria =
        [
            "Answer every part of the request.",
            "Support conclusions with evidence.",
        ],
    });

AIAgent loopAgent = new LoopAgent(
    agent,
    evaluator,
    new LoopAgentOptions { MaxIterations = 4 });

Använd endast en domarslutpunkt som du litar på med den ursprungliga begäran och det genererade svaret.

Kontrollera kontext och utdata

Som standard LoopAgent återanvänder en session och skickar den vinnande utvärderarens senaste feedback som nästa indata. FreshContextPerIteration = true återskapar i stället varje pass från den ursprungliga begäran plus en aggregerad feedbacklogg och återställer eller återställer sessionen.

Icke-direktuppspelningskörningar returnerar en aggregerad avskrift som standard. Ange NonStreamingReturnsLastResponseOnly = true att endast returnera det slutliga svaret. Direktuppspelning genererar alltid varje iteration och alla synliga feedbackmeddelanden som visas på uppdrag av feedbackmeddelanden.

Predikatet tar emot nyckelordsargument som iteration, last_result, messages, original_messages, session, , agent, progressoch feedback. Hjälparna todos_remaining() och background_tasks_running() tillhandahåller inbyggda villkor för att göra och bakgrundsaktiviteter. Koppla ihop dem med todos_remaining_message eller background_tasks_running_message för att generera en riktad nästa indata.

Använda en AI-domare

AgentLoopMiddleware.with_judge bygger en domardriven loop. Domarslingor är som standard fem iterationer:

from agent_framework import Agent, AgentLoopMiddleware

loop = AgentLoopMiddleware.with_judge(
    judge_client,
    criteria=[
        "Answer every part of the request.",
        "Support conclusions with evidence.",
    ],
    max_iterations=4,
)

agent = Agent(
    client=client,
    middleware=[loop],
)

Domarens resonemang matas tillbaka till agenten när mer arbete krävs. Använd endast en domarslutpunkt som du litar på med den ursprungliga begäran och det genererade svaret.

Kontrollera kontext, förlopp och utdata

För avancerade loopar skapar du AgentLoopMiddleware direkt:

• record_feedback skapar en koncis förloppspost efter varje arbets-iteration.
• progress exponerar ackumulerade poster för återanrop.
• inject_progress=True lägger till förlopp till nästa iterations indata.
• fresh_context=True startar om från den ursprungliga aktiviteten och förloppsloggen och återställer en ansluten session till dess ögonblicksbild före loopen.
• return_final_only=True returnerar endast det sista svaret för icke-direktuppspelningskörningar.

Godkänn max_iterations=None endast när slutförandepredikatet garanterat avslutas.

De paketerade slutförandevillkoren och domarintegrering som beskrivs på den här sidan är för närvarande inte tillgängliga i Go.

Använda loopning med Harness Agent

Använd konfigurationen av Harness Agent när du också vill ha dess förkonfigurerade pipeline för historik, planering, minne, godkännande och observerbarhet.

Ange HarnessAgentOptions.LoopEvaluators. Selen gäller LoopAgent som dess yttersta agentdekoratör:

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

var options = new HarnessAgentOptions
{
    LoopEvaluators =
    [
        new CompletionMarkerLoopEvaluator("DONE"),
    ],
    LoopAgentOptions = new LoopAgentOptions
    {
        MaxIterations = 5,
    },
};

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

En tom samling eller nullLoopEvaluators samling lämnar selen enkelbild.

Godkännande- och sessionsbeteende

LoopAgent stoppar innan dess slutförandevillkor utvärderas när en iteration returnerar en väntande begäran om godkännande av verktyg. Den returnerar begäran till anroparen i stället för att dölja den bakom en annan autonom iteration. När anroparen tillhandahåller godkännandesvaret via det normala verktygets godkännandeflöde kan agenten fortsätta.

LoopAgent lägger inte till själva godkännandehanteringen. Harness-agenten tillämpar loopen utanför ToolApprovalAgent, vilket gör att väntande godkännandebegäranden kan undkomma loopen.

Återanvänd samma AgentSession mellan anrop för att fortsätta konversationen. Loop-iterationer delar den sessionen som standard. LoopAgent Med FreshContextPerIteration = trueåterställer eller återställer sessionstillståndet som tillhandahålls av anroparen där det stöds. Tjänstägd konversationslagring kan behålla historiken när den serialiserade sessionen endast innehåller en fjärrkonversationsidentifierare.

Ange loop_should_continue till create_harness_agent, loop_max_iterations standardvärdet är 10:

from agent_framework import create_harness_agent


def needs_more_work(*, last_result, **kwargs):
    return "DONE" not in last_result.text


agent = create_harness_agent(
    client=client,
    loop_should_continue=needs_more_work,
    loop_max_iterations=5,
)
session = agent.create_session()

loop_next_message anpassar nästa indata. loop_should_continueUtan lägger fabriken inte till en loop och ignorerar de andra loopargumenten.

Godkännande- och sessionsbeteende

AgentLoopMiddleware stoppar innan dess fortsättningspredikat utvärderas när en iteration returnerar en väntande begäran om godkännande av verktyg. Den returnerar begäran till anroparen i stället för att dölja den bakom en annan autonom iteration. När anroparen tillhandahåller godkännandesvaret via det normala verktygets godkännandeflöde kan agenten fortsätta.

AgentLoopMiddleware lägger inte till ToolApprovalMiddleware sig själv. Harness-agenten placerar loopen utanför sitt godkännandemellanprogram, vilket gör att väntande godkännandebegäranden kan undkomma loopen. Skapa och skicka en AgentSession på varje Harness Agent-körning medan automatiskt godkännande av verktyget är aktiverat.

Återanvänd samma AgentSession mellan anrop för att fortsätta konversationen. Loop-iterationer delar den sessionen som standard. Med fresh_context=Trueåterställer mellanprogrammet den anslutna sessionen till dess ögonblicksbild före loopen mellan iterationer. Tjänstägd konversationslagring kan behålla historiken när den serialiserade sessionen endast innehåller en fjärrkonversationsidentifierare.

Anmärkning

Sele Agent-loopning är för närvarande inte tillgängligt i Go, så dess godkännande- och sessionsbeteende gäller inte.

Nästa steg

Delegera arbete till bakgrundsagenter

Gå djupare

• Planering och todos
• Godkännande av verktyg
• Agenthämt