Skip to navigation
ConfigurerenAgentgedragProcedures

Gestructureerde procedures

Een vaste reeks getypeerde stappen die je agent telkens op dezelfde manier uitvoert

Overzicht

Een gestructureerde procedure is een procedure die een vaste reeks stappen uitvoert. Een free-form procedure biedt richtlijnen in natuurlijke taal die de agent interpreteert en aanpast aan de situatie. Een gestructureerde procedure is een geordende lijst met getypeerde stappen die de agent telkens in volgorde uitvoert wanneer de procedure van toepassing is.

Gebruik een gestructureerde procedure wanneer specifieke stappen bij elk gesprek op dezelfde manier moeten plaatsvinden: de identiteit van een beller verifiëren, een ticket escaleren of een betaling uitvoeren. Je schrijft deze als een korte lijst met stappen in gewone taal.

Zoals elke procedure heeft een gestructureerde procedure een trigger die beschrijft wanneer deze van toepassing is. Wanneer een gesprek overeenkomt met de trigger, voert de agent de stappen van de procedure in volgorde uit en keert daarna terug naar de rest van het gesprek.

Editor voor gestructureerde procedures

Wanneer gebruik je een gestructureerde procedure?

Gebruik een gestructureerde procedure wanneer specifieke stappen telkens op dezelfde manier moeten worden uitgevoerd, maar je toch snel in gewone stappen wilt schrijven. Gestructureerde procedures zijn eenvoudiger te schrijven dan een workflow, maar minder expressief. Zie Wanneer gebruik je procedures? voor een vergelijking met free-form procedures, workflows en de systeemprompt.

Opbouw van een gestructureerde procedure

Een gestructureerde procedure bestaat uit drie delen: een naam, een trigger en een geordende lijst met stappen.

Naam

Een kort label dat de procedure in het dashboard identificeert. De naam wordt nooit naar het LLM gestuurd en heeft dus geen invloed op het gedrag van de agent.

Trigger

Een beschrijving in gewone taal van wanneer de agent deze procedure moet uitvoeren, bijvoorbeeld Wanneer de gebruiker vraagt om een bestelling terug te betalen. De agent vergelijkt de intentie van de gebruiker met de trigger van elke procedure en voert de overeenkomende procedure uit. Triggers moeten daarom concreet en duidelijk van elkaar verschillen. De agent ziet alleen de triggertekst, nooit de naam of ID van de procedure. Een trigger werkt hetzelfde als bij elke procedure; zie Triggers schrijven.

Laat de trigger leeg om van de procedure een subprocedure te maken die alleen wordt uitgevoerd wanneer een andere procedure deze aanroept.

Stappen

De hoofdtekst van de procedure is een geordende lijst met getypeerde stappen. Er zijn meerdere staptypen, die je combineert om de taak te beschrijven.

StapWat deze doet
VragenVraagt de gebruiker om informatie en wacht. Blijft vragen totdat de gebruiker antwoordt. Dit is de enige stap die op de gebruiker pauzeert.
VertellenLaat de agent iets in eigen woorden overbrengen en gaat daarna verder met de volgende stap.
ZeggenLaat de agent een exact bericht woord voor woord uitspreken en gaat daarna verder met de volgende stap. Een Say-stap kan een afzonderlijk geconfigureerde vertaling bevatten voor elke taal die de agent ondersteunt.
ToolRoept een specifieke tool aan. Je kunt het LLM in gewone taal instrueren hoe de tool moet worden aangeroepen, of parameterwaarden expliciet vastzetten wanneer maximale determinisme vereist is. Je kunt ook stappen definiëren die worden uitgevoerd als de toolaanroep mislukt.
AlsEvalueert een of meer voorwaarden in volgorde en voert de stappen van de eerste overeenkomst uit. Een optionele Else wordt uitgevoerd wanneer niets overeenkomt.
SubprocedureVoert een andere gestructureerde procedure uit. Zodra de stappen zijn voltooid, keert de besturing terug naar de volgende stap in deze (aanroepende) procedure.
SysteemtoolVoert een ingebouwde systeemactie uit. Momenteel wordt alleen het beëindigen van het gesprek ondersteund.
Opnieuw proberenVoert de foutafhandeling van een Tool-stap, inclusief de toolaanroep, maximaal drie keer opnieuw uit. Alleen beschikbaar binnen de foutafhandeling van een Tool-stap.

Menu met staptypen voor een gestructureerde procedure

Niet elke stap kan overal voorkomen. Binnen een If-tak kun je elke stap gebruiken behalve nog een If of een Retry. Binnen de foutafhandeling van een Tool-stap kun je elke stap gebruiken behalve een If of nog een Tool.

API-referentie voor stappen

De content van een gestructureerde procedure is een JSON-gecodeerd document met een steps-array. Elke stap is een object dat wordt geïdentificeerd door zijn type. De trigger is een afzonderlijk veld op het hoogste niveau van de procedure en geen onderdeel van content. API- en SDK-payloads gebruiken type: "deterministic" voor de procedure zelf.

Vragen

Een Ask-stap instrueert de agent om informatie op te vragen en te wachten totdat de gebruiker een passend antwoord geeft.

  • API-type: ask
  • instruction: Vereiste, niet-lege string.
{
  "type": "ask",
  "instruction": "Ask the user for their order ID."
}

Vertellen

Een Tell-stap instrueert de agent om één bericht in eigen woorden te genereren. De stap wacht niet op een antwoord van de gebruiker voordat deze doorgaat.

  • API-type: tell
  • instruction: Vereiste, niet-lege string.
{
  "type": "tell",
  "instruction": "Explain that the refund normally takes five to ten business days."
}

Zeggen

Een Say-stap spreekt de opgegeven tekst exact uit zoals deze is geschreven en gaat daarna verder. Geef message_translations op om de agent een exact bericht te geven voor elke extra taal die deze ondersteunt, ingedeeld op taalcode.

  • API-type: say
  • message: Vereiste, niet-lege string.
  • message_translations: Optioneel object dat een taalcode koppelt aan { "value": "..." }.
{
  "type": "say",
  "message": "Your refund has been submitted.",
  "message_translations": {
    "es": { "value": "Su reembolso ha sido enviado." }
  }
}

If, else if en else

Een If-stap bevat een of meer geordende voorwaardelijke takken. De eerste overeenkomende tak wordt uitgevoerd. De optionele fallback-array is de Else-tak.

  • API-type: branch
  • branches: Vereiste, niet-lege lijst met voorwaardelijke takken.
  • fallback: Optionele lijst met Else-stappen.
  • Elke tak vereist een condition en een niet-lege steps-lijst.
{
  "type": "branch",
  "branches": [
    {
      "condition": {
        "type": "llm",
        "condition": "The user is on an annual plan."
      },
      "steps": [
        {
          "type": "say",
          "message": "Your annual plan is eligible for a prorated refund."
        }
      ]
    }
  ],
  "fallback": [
    {
      "type": "tell",
      "instruction": "Explain that the account's plan could not be determined."
    }
  ]
}

Dit werkt als if/else-if/else:

  1. Voorwaarden worden in volgorde geëvalueerd.
  2. De eerste overeenkomende tak wordt uitgevoerd.
  3. Als geen voorwaarde overeenkomt, wordt fallback uitgevoerd.
  4. Nadat een tak is voltooid, sluit de procedure weer aan op de hoofdreeks.

Het bovenstaande voorbeeld gebruikt een tekstvoorwaarde, die het model in natuurlijke taal evalueert. Voorwaarden kunnen ook expressies over dynamische variabelen zijn:

{
  "type": "expression",
  "expression": {
    "type": "eq_operator",
    "left": {
      "type": "dynamic_variable",
      "name": "plan_tier"
    },
    "right": {
      "type": "string_literal",
      "value": "annual"
    }
  }
}

Een expressievoorwaarde test dynamische variabelen, die worden ingevuld door toolresultaten of ingesteld wanneer het gesprek begint. Deze kan het meest recente antwoord van de gebruiker niet lezen. Gebruik een tekstvoorwaarde om te vertakken op basis van wat de gebruiker zei.

Alle takken in één If-stap moeten hetzelfde voorwaardetype gebruiken: llm of expression.

Tool

Een Tool-stap roept een specifieke tool aan.

  • API-type: tool_call
  • tool_id: Vereiste, niet-lege tool-ID. De tool moet aan de agent zijn gekoppeld.
  • tool_name: Vereiste toolnaam die overeenkomt met de tool.
  • instruction: Optionele instructie die beschrijft hoe je de tool aanroept.
  • schema_overrides: Optionele vaste waarden voor de parameters van de tool.
  • on_failure: Optionele foutafhandeling.
{
  "type": "tool_call",
  "tool_id": "tool_abc123",
  "tool_name": "lookup_order",
  "instruction": "Look up the order using the order ID provided by the user."
}

Vaste parameterwaarden

Gebruik schema_overrides wanneer een parameter altijd een specifieke waarde moet hebben. Het model ziet of kiest geen overschreven parameter. Sleutels zijn parameterpaden in het schema van de tool; elke waarde benoemt een bron:

sourceVeldenGedrag
constantconstant_valueVerstuurt altijd de opgegeven waarde.
dynamic_variabledynamic_variableVerstuurt de huidige waarde van de benoemde dynamische variabele.
llmprompt (optioneel)Laat het model de waarde kiezen, met een optionele promptoverride.
omitLaat de parameter weg uit de aanroep.
{
  "type": "tool_call",
  "tool_id": "tool_abc123",
  "tool_name": "update_ticket",
  "schema_overrides": {
    "request_body.status": { "source": "constant", "constant_value": "pending" },
    "request_body.ticket_id": { "source": "dynamic_variable", "dynamic_variable": "ticket_id" }
  }
}

Foutafhandeling

Zonder on_failure beëindigt een mislukte toolaanroep het gesprek. Voeg on_failure toe om in plaats daarvan herstelstappen uit te voeren.

  • fallback: Vereiste, niet-lege lijst met stappen die worden uitgevoerd wanneer de tool mislukt.
  • branches: Gereserveerd voor voorwaardelijke foutafhandeling. Laat dit leeg.
{
  "type": "tool_call",
  "tool_id": "tool_abc123",
  "tool_name": "lookup_order",
  "on_failure": {
    "branches": [],
    "fallback": [
      {
        "type": "tell",
        "instruction": "Explain that the order could not be retrieved and offer to connect the user with support."
      }
    ]
  }
}

Een foutafhandeling kan stappen van het type Ask, Tell, Say, Sub-procedure, System tool en Retry bevatten. Deze kan geen Tool- of If-stappen bevatten. Nadat de afhandeling is uitgevoerd, gaat de procedure verder met de stap na de Tool-stap.

Opnieuw proberen

Een Retry-stap voert de foutafhandeling waarin deze staat opnieuw uit, inclusief de toolaanroep. Elke poging roept de tool opnieuw aan en voert, als die opnieuw mislukt, elke stap in de afhandeling opnieuw uit. Wanneer de pogingen op zijn, eindigt het gesprek.

  • API-type: retry
  • max_retries: Optioneel geheel getal van 1 tot en met 3. Standaard is dit 1.
  • De waarde telt pogingen na de oorspronkelijke toolaanroep.
  • Retry is alleen geldig binnen on_failure.
  • Retry moet de laatste stap in de foutafhandeling zijn, omdat latere stappen anders onbereikbaar zijn.
{
  "type": "retry",
  "max_retries": 2
}

Subprocedure

Een Sub-procedure-stap voert een andere gestructureerde procedure uit. Wanneer de stappen van die procedure zijn voltooid, keert de uitvoering terug naar de stap na de Sub-procedure-stap.

  • API-type: sub_procedure
  • procedure_id: Vereiste, niet-lege procedure-ID.
  • Het doel moet op dezelfde agent bestaan.
  • Het doel moet een gestructureerde procedure zijn.
  • Een procedure kan zichzelf niet aanroepen.
{
  "type": "sub_procedure",
  "procedure_id": "agtprc_6qbpwdq8n01bxhk44bgjy6f10ck3"
}

Systeemtool

Een System tool-stap voert een ingebouwde systeemactie uit.

  • API-type: system_tool
  • system_tool_name: Vereiste systeemtoolnaam.
  • Momenteel wordt alleen end_call ondersteund. Later kunnen meer systeemtools worden toegevoegd.
  • Omdat end_call terminaal is, moet dit de laatste stap zijn in de reeks, tak of foutafhandeling waarin het staat.
{
  "type": "system_tool",
  "system_tool_name": "end_call"
}

Validatieregels

Bij het publiceren van de agent of opslaan van het agentconcept wordt een gestructureerde procedure afgewezen die een van deze regels schendt. De fout benoemt de betreffende stap aan de hand van het pad.

  • Twee If-stappen kunnen niet direct na elkaar worden geplaatst.
  • If-stappen kunnen niet worden genest.
  • Een If-stap met expressievoorwaarden kan niet direct na een Ask-stap staan.
  • Alle voorwaarden in één If-stap moeten hetzelfde type hebben: llm of expression.
  • Retry mag alleen binnen on_failure voorkomen en moet daar de laatste stap zijn.
  • end_call moet de laatste stap zijn in elke lijst waarin deze voorkomt.
  • De fallback van een foutafhandeling moet minstens één stap bevatten.
  • Een Sub-procedure moet verwijzen naar een bestaande gestructureerde procedure op dezelfde agent, en niet naar zichzelf.
  • tool_id moet een tool op de agent zijn, tool_name moet overeenkomen en schema_overrides moet overeenkomen met het schema van de tool.
  • De steps-lijst, elke instruction en elke message mogen niet leeg zijn.

Zie Best practices voor informatie over het herstructureren van een procedure die tegen een van deze regels aanloopt.

Volledig API-voorbeeld

Dit voorbeeld behandelt een annulering van een bestelling op basis van de verzendstatus. Het zet een toolparameter vast, herstelt van een mislukte toolaanroep, roept een andere gestructureerde procedure aan en beëindigt vervolgens het gesprek.

{
  "steps": [
    {
      "type": "ask",
      "instruction": "Ask the user for their order ID."
    },
    {
      "type": "branch",
      "branches": [
        {
          "condition": {
            "type": "llm",
            "condition": "The user says the order has already shipped."
          },
          "steps": [
            {
              "type": "tell",
              "instruction": "Explain that shipped orders must be returned before they can be refunded."
            }
          ]
        },
        {
          "condition": {
            "type": "llm",
            "condition": "The user says the order has not shipped."
          },
          "steps": [
            {
              "type": "tool_call",
              "tool_id": "tool_abc123",
              "tool_name": "cancel_order",
              "instruction": "Cancel the order using the order ID provided by the user.",
              "schema_overrides": {
                "request_body.notify_customer": { "source": "constant", "constant_value": true }
              },
              "on_failure": {
                "branches": [],
                "fallback": [
                  {
                    "type": "tell",
                    "instruction": "Apologize that the cancellation did not go through and say you will try once more."
                  },
                  {
                    "type": "retry",
                    "max_retries": 1
                  }
                ]
              }
            }
          ]
        }
      ],
      "fallback": [
        {
          "type": "ask",
          "instruction": "Ask whether the order has already shipped."
        }
      ]
    },
    {
      "type": "sub_procedure",
      "procedure_id": "agtprc_6qbpwdq8n01bxhk44bgjy6f10ck3"
    },
    {
      "type": "say",
      "message": "Thank you for contacting us. Goodbye.",
      "message_translations": {
        "es": { "value": "Gracias por contactarnos. Adiós." }
      }
    },
    {
      "type": "system_tool",
      "system_tool_name": "end_call"
    }
  ]
}

Hoe een gestructureerde procedure wordt uitgevoerd

Het omzetten van de stappen van een gestructureerde procedure naar de vorm die de agent uitvoert, heet compileren. Het platform compileert elke gestructureerde procedure wanneer het agentconcept wordt opgeslagen of de agent wordt gepubliceerd; auteurs hoeven zelf niets te compileren.

Wanneer het verzoek van de gebruiker overeenkomt met de trigger van een procedure, gaat het platform de procedure in en voert het de stappen in volgorde uit. Binnen de gestructureerde procedure richt de agent zich afzonderlijk op elke stap. Wanneer het einde is bereikt, geeft het platform de besturing terug aan de rest van het gesprek.

Workflowranden kunnen niet naar of vanuit een gestructureerde procedure verbinden. Gebruik een Sub-procedure-stap om gestructureerde procedures aan elkaar te koppelen. Het platform beheert de start vanuit een overeenkomende trigger en de voltooiing, inclusief het teruggeven van de besturing aan de workflownode waar de procedure begon.

De volgende regels beschrijven hoe stappen tijdens runtime werken.

Elke stap behalve Ask wordt onmiddellijk uitgevoerd en de besturing gaat binnen dezelfde beurt naar de volgende stap. Een Tell- of Say-stap brengt het bericht over en gaat verder. Er is geen stap die het gesprek pauzeert behalve Ask, en geen stap die de huidige beurt beëindigt. Gebruik een Ask-stap als je invoer van de gebruiker nodig hebt. Gebruik de end_call-systeemtool als het gesprek moet eindigen.

Wanneer de laatste stap is voltooid, eindigt de procedure en keert de agent terug naar de rest van het gesprek terwijl de beurt nog open is, zodat deze meer kan zeggen. Wanneer een subprocedure is voltooid, keert de besturing terug naar de volgende stap van de procedure die deze heeft aangeroepen.

Een Tool-stap kan niet vertakken op een statuscode of op de responsebody. Als de tool slaagt, gaat de procedure verder. Als deze mislukt en de stap geen foutafhandeling heeft, eindigt het gesprek. Als er wel een is, worden de stappen van de afhandeling uitgevoerd en gaat de procedure verder met de volgende stap. Een Retry binnen de afhandeling voert de tool opnieuw uit en, als deze opnieuw mislukt, elke stap in de afhandeling, totdat de tool slaagt of de pogingen op zijn. Als ze op zijn, eindigt het gesprek.

Voorwaarden worden in volgorde geëvalueerd en de eerste overeenkomst wordt uitgevoerd. De Else-tak wordt uitgevoerd wanneer niets overeenkomt. Als er geen Else is en niets overeenkomt, gaat de procedure verder met de stap na de If. Een niet-afgehandeld geval is geen fout.

Niets wat binnen een If-tak wordt besloten, wordt onthouden door latere stappen. Als iets dat in een tak is geleerd later nodig is, sla het dan expliciet op met een toolaanroep of een dynamische variabele.

Alleen Tool-stappen kunnen tools aanroepen. Je hoeft een Ask-, Tell- of Say-stap niet te vertellen geen tools aan te roepen; dat kan niet.

Een gestructureerde procedure beheren

Open je agent in het dashboard en selecteer vervolgens Procedures. Gebruik + om een gestructureerde procedure te maken. Voeg een trigger toe, selecteer voor elke stap een type en publiceer de wijzigingen aan de agent.

Het dashboard valideert gestructureerde procedures tijdens het bewerken. Als een procedure een validatieregel schendt, toont de knop Publish een foutstatus, toont het tabblad Procedures een foutbadge en kan de preview niet starten totdat de procedure is opgelost. Selecteer de foutindicator om te zien welke procedure en stap zijn getroffen.

Editor voor gestructureerde procedures met de knop Publish in foutstatus en een badge met 1 Error

Dialoogvenster met validatiedetails waarin de mislukte procedure en de stap die een bericht nodig heeft worden vermeld

Best practices

Elk type stap dwingt al zijn eigen gedrag af, dus je hoeft dit zelden expliciet te vermelden. Beschrijf de bedoeling van elke stap en laat het staptype de rest doen. De richtlijnen hieronder behandelen de gevallen die belangrijk zijn om goed aan te pakken.

Volg Een procedure itereren om een gestructureerde procedure te testen.

Staptypen kiezen

Een Ask-stap wacht op één antwoord. Als je meerdere vragen in één instructie bundelt, slaat de agent er vaak enkele over of voegt deze samen. Gebruik één Ask-stap per gegeven.

Een Tell-stap geeft zijn bericht en gaat verder zonder te wachten. Een Tell die als vraag is geformuleerd, krijgt nooit een antwoord. Als een stap een reactie van de gebruiker nodig heeft, is het een Ask-stap.

Een Ask-stap gaat verder zodra deze een passend antwoord heeft. Als uit de vraag niet duidelijk is wat als antwoord geldt, vermeld dat dan in de instructie, bijvoorbeeld _Vraag naar de order-ID; een geldig ID bestaat uit acht cijfers _.

Gebruik een Tell-stap wanneer de agent het bericht zelf moet formuleren, en een Say-stap wanneer de tekst letterlijk of vertaald moet zijn. Beide geven precies één bericht, dus je hoeft een stap niet te instrueren om één enkel bericht te sturen.

Ask-, Tell- en Say-stappen kunnen geen tools aanroepen. Roep geen tools aan erin schrijven voegt ruis toe aan de instructie zonder het gedrag te veranderen.

De procedure structureren

Twee If-stappen kunnen niet direct na elkaar worden geplaatst. Een niet-gerelateerde Tell- of Say-stap ertussen voegen om aan de regel te voldoen, zorgt ervoor dat de agent iets zegt wat deze niet zou moeten zeggen. Neem in plaats daarvan de tweede beslissing op in de eerste If-stap als extra Else if-takken, of verplaats deze naar een subprocedure.

If-stappen kunnen niet worden genest. Wanneer één beslissing van een andere afhangt, plaats je de interne beslissing in een eigen gestructureerde procedure en roep je die aan met een Sub-procedure-stap vanuit de tak die deze nodig heeft.

Een If-stap zonder Else gaat door naar de volgende stap wanneer niets overeenkomt. Als het niet-overeenkomende geval zich anders moet gedragen, voeg er dan een Else-tak voor toe.

Beslissingen die binnen een If-tak worden genomen, worden daarna niet onthouden. Als een latere stap afhangt van iets dat in een tak is geleerd, leg dit dan vast met een toolaanroep of een dynamische variabele in de tak.

Expressievoorwaarden testen dynamische variabelen. Plaats een If-stap die deze gebruikt direct na de Tool- stap die deze variabelen instelt. Gebruik een tekstvoorwaarde om te vertakken op basis van wat de gebruiker zei.

Wanneer meerdere gestructureerde procedures dezelfde reeks delen, zoals escaleren naar een medewerker, plaats je die in één gestructureerde procedure met een lege trigger en roep je deze vanuit elke procedure aan. Gekopieerde reeksen gaan na verloop van tijd uiteenlopen.

Werken met tools

Een Tool-stap roept altijd de bijbehorende tool aan. Een voorwaarde die in de instructie staat, zoals _sla dit over als het ticket al een tag heeft _, kan de aanroep niet voorkomen. Als de aanroep niet altijd moet plaatsvinden, plaats de voorwaarde dan in een If-stap vóór de Tool-stap.

Wanneer een parameter altijd een specifieke waarde moet hebben, stel je die in met een constant-override in schema_overrides. Een instructie zoals stel status altijd in op pending vraagt het model om hieraan te voldoen; een override wordt afgedwongen en kan niet worden overgeslagen.

Zonder on_failure beëindigt elke toolfout het gesprek. Voeg een afhandeling toe die de gebruiker vertelt wat er is gebeurd en opnieuw probeert, escaleert of doorgaat.

Een Tool-stap voert alleen de tool uit; de agent kan daarin niet spreken of een beslissing nemen. Om met de gebruiker te praten of te vertakken op basis van wat de tool heeft teruggegeven, plaats je dat in een aparte stap vóór of na de Tool-stap.

Instructies schrijven

De procedure bepaalt wat er daarna wordt uitgevoerd, en de agent is zich tijdens het uitvoeren van de huidige stap niet bewust van latere stappen. Laat de volgorde van stappen de sequencing bepalen.

Zinnen in stapinstructies, zoals dit is het laatste bericht van deze beurt, vragen de agent om een grens af te dwingen die het platform niet ondersteunt. Gebruik een Ask-stap om op de gebruiker te wachten of de end_call-systeemtool om het gesprek te beëindigen.

Toon, opmaak, afsluitingen en weigeringsbeleid horen in de systeem- prompt. Een stapinstructie mag alleen vermelden wat specifiek is voor die stap.

Procedures samenstellen

De algemene richtlijnen voor het samenstellen van procedures gelden ook voor gestructureerde procedures; zie Procedures samenstellen op de pagina over free-form procedures.

Eén patroon is specifiek voor het combineren van typen: een free-form procedure kan verwijzen naar een gestructureerde procedure. Houd open verwerking in een free-form procedure en delegeer onderdelen die elke keer op dezelfde manier moeten worden uitgevoerd, zoals identiteitsverificatie of escalatie, aan een gestructureerde procedure.

Beperkingen

  • If-stappen kunnen niet worden genest, en twee If-stappen kunnen niet direct na elkaar worden geplaatst.
  • De enige ondersteunde systeemtool is end_call.
  • Gestructureerde procedures kunnen niet naar kennisbankdocumenten verwijzen.
  • Er is geen manier om de huidige beurt te beëindigen wanneer een procedure is voltooid; de agent houdt de beurt open en kan blijven spreken.
  • Workflowranden kunnen niet van of naar een gestructureerde procedure lopen. Gebruik een Sub-procedure-stap om gestructureerde procedures te koppelen; het platform beheert het starten en voltooien.
  • Het starten van een procedure voegt vertraging toe: de agent doet een toolaanroep om deze te openen en doorloopt vervolgens de gegenereerde workflow.

Ondersteuning door modelproviders

Gestructureerde procedures dwingen interne toolaanroepen af bij het openen van een subprocedure en het voltooien van een procedure. Grote modelfamilies van OpenAI, Anthropic, Gemini en Grok ondersteunen geforceerde toolkeuze. Andere modellen of aangepaste providers garanderen dit mogelijk niet, waardoor overgangen naar subprocedures of het voltooien van procedures minder betrouwbaar kunnen zijn. Controleer ondersteuning voor geforceerde toolkeuze wanneer je een andere modelprovider gebruikt.

Zie Procedures voor limieten die voor alle procedures gelden, waaronder de limiet voor de contentgrootte en hoe gestructureerde procedures verschillen van free-form procedures.