Bij traditionele softwareontwikkeling biedt de Software Development Lifecycle (SDLC) een gestructureerde, gefaseerde benadering voor het samenstellen van toepassingen. Het vestigt de kwaliteit, vermindert risico's en biedt een duidelijke roadmap van idee tot release. De levenscyclus van agentontwikkeling (ADLC) is een soortgelijke methodologie die specifiek is afgestemd op de unieke complexiteit van het samenstellen van autonome agenten.

Agenten zijn geen passieve toepassingen; het zijn systemen die redeneren, handelen en leren binnen dynamische uitvoeringsomgevingen. Hun niet-deterministische gedrag maakt traditionele QA ontoereikend. De Agent Development Lifecycle (ADLC), die wordt ondersteund door platforms zoals Agentforce, pakt dit aan in vijf fasen: Idee en ontwerp, Ontwikkeling (de “binnenste lus”), Testen en valideren, Implementatie en continue Monitoring en Tuning (de “buitenste lus”).

Dit document dient als een uitgebreide handleiding voor ontwikkelaars en Enterprise Architects die al vertrouwd zijn met de fijne kneepjes van de Software Development Lifecycle (SDLC) en hun expertise willen uitbreiden naar op agenten gebaseerde systemen. Ons primaire doel is om een snel inzicht in de levenscyclus van agentontwikkeling (ADLC) te vergemakkelijken door de belangrijkste verschillen met traditionele SDLC-methoden te benadrukken en een gestructureerd raamwerk te bieden voor het conceptualiseren van het gehele proces van het samenstellen, implementeren en beheren van intelligente agenten.

Het document is ingedeeld in drie afzonderlijke hoofdstukken, elk ontworpen om uw Knowledge en praktische vaardigheden geleidelijk op te bouwen:

• Hoofdstuk 1: Het ADLC Framework. In dit hoofdstuk wordt de levenscyclus van agentontwikkeling (ADLC) geïntroduceerd en wordt ingegaan op de afwijking ervan ten opzichte van de SDLC vanwege de unieke uitdagingen van het ontwikkelen van autonome agenten. Het stelt een raamwerk vast voor het ontwerpen, ontwikkelen, testen en implementeren van agenten.
• Hoofdstuk 2: Het Agentforce Platform. Dit hoofdstuk verkent Agentforce, een gecombineerd platform dat de gehele levenscyclus van Agentontwikkeling stroomlijnt en versnelt. Agentforce biedt tools voor agentontwerp, gegevensverwerking, modeltraining, implementatie en continue bewaking, die complexe taken vereenvoudigen en de efficiëntie verbeteren.
• Hoofdstuk 3: Pro-code-implementatie. Deze handleiding gebruikt de pro-codetools van Agentforce om praktische, stapsgewijze instructies en praktijkvoorbeelden voor agentontwikkeling te bieden. Het bestrijkt de gehele levenscyclus van agentontwikkeling, van prototype- en functie-engineering tot modelimplementatie, prestatietuning en onderhoud, en biedt ontwikkelaars de vaardigheden om productieklare agenten samen te stellen.

Dit document is bedoeld om u te voorzien van de theoretische en praktische Knowledge van de pro-code tools van Agentforce. U leert agenten efficiënt, veilig en betrouwbaar te bouwen, implementeren en bewaken, waarbij u een uitgebreid inzicht krijgt in de ADLC en het potentieel van Agentforce in intelligente agentontwikkeling maximaliseert.

Het niet-deterministische karakter van AI-agenten vereist een gespecialiseerd ontwikkelingsframework. Dit hoofdstuk geeft een overzicht van dat raamwerk door de introductie van de Agent Development Lifecycle (ADLC). Dit hoofdstuk biedt een uitgebreid overzicht van de vijf kernfasen van de ADLC, van initiële Idee en Ontwerp tot continue Monitoring en Tuning. Dit hoofdstuk bevat de fundamentele Knowledge die nodig is voor het samenstellen van robuuste en betrouwbare agenten.

Deze sectie wijst SDLC-concepten toe aan de vijf fasen van de ADLC.

Dit is de basisfase waarin het strategische doel en de operationele grenzen van een agent worden gedefinieerd. Een goed gestructureerde ontwerpfase is de meest kritieke stap voor succes, omdat deze een bedrijfsbehoefte vertaalt in een technische blauwdruk. Het ontwerpproces zorgt ervoor dat de agent niet alleen functioneel is, maar ook verantwoordelijk en afgestemd op de verwachtingen van de gebruiker. Het is waar de "wat" en "waarom" worden vastgesteld voordat er code wordt geschreven.

1. Agentische doelen en mogelijkheden definiëren: Eerst moet u duidelijk maken wat de primaire doelstelling van de agent is en welke specifieke, meetbare taken de agent gaat uitvoeren. Dit omvat het definiëren van de rol ervan (bijv. "klantenserviceassistent"), de kernfuncties ervan (bijv. "afspraken boeken", "productvragen beantwoorden") en de succesmeetgegevens voor elke functie.
2. Persona- en ethische vangrails vaststellen: Deze stap omvat het ontwerpen van de persoonlijkheid van de agent en het definiëren van de ethische grenzen ervan om ervoor te zorgen dat deze betrouwbaar en veilig is. Het bepaalt de toon van de agent (bijvoorbeeld "formeel", "vriendelijk") en implementeert strikte regels om schadelijke, vertekende of ongepaste reacties te voorkomen.
3. Kaartcontext en inzicht: U moet bepalen welke informatie de agent moet begrijpen en onthouden om effectief te zijn. Dit omvat het definiëren van het bereik van de Knowledge base en het gespreksgeheugen, waardoor het consistente gesprekken met meerdere beurten kan voeren.
4. Hulpmiddelen en systeemintegraties identificeren: Dit omvat het inventariseren van de externe systemen, API's en gegevensbronnen waarmee de agent moet verbinden om taken uit te voeren. Elke tool (bijvoorbeeld een boekings-API, een klantendatabase) wordt geïdentificeerd en de functie ervan wordt toegewezen aan een specifieke agentcapaciteit.
5. Plan voor Human-in-the-Loop-escalatie: Het is essentieel om de omstandigheden te definiëren waaronder een agent escaleert naar een mens. Dit omvat het beoordelen van potentiële mislukkingspunten en doodlopende gesprekken om te bepalen wanneer een agent moet escaleren naar een menselijke operator. Het ontwerp moet beschrijven hoe deze overdracht zal worden uitgevoerd om ervoor te zorgen dat voldoende context wordt overgedragen, zodat deze snel kan worden verbruikt om een naadloze klantervaring te garanderen.

Dit is de hands-on bouwfase waarin de ontwerpblauwdruk wordt omgezet in een functionele agent. Ontwikkelaars stellen de agent samen, verbinden deze met de bijbehorende tools en geven deze de gegevens die nodig zijn voor het uitvoeren van zijn taken. Deze herhalende "innerlijke lus" van bouwen en verfijnen is waar de agent echt tot leven komt.

1. De logica en besluitvorming van de agent configureren: Deze stap omvat het vormgeven van de redenering van de agent door het besluitvormingsframework te verbinden met context, tools en gegevensbronnen. De rol van de ontwikkelaar is om het gedrag van de agent te definiëren door API's te maken of bestaande API's te hergebruiken, operationele vangrails in te stellen en op te geven hoe de agent beschikbare tools selecteert en gebruikt voor het voltooien van complexe taken met meerdere stappen.
2. Aanwijzingen van engineer en fijnafstemmingsmodellen: De identiteit, instructies en beperkingen van de agent worden vastgelegd via zorgvuldige prompt engineering. Dit proces omvat het samenstellen van de hoofdaanwijzing die het Large Language Model (LLM) stuurt en, voor meer geavanceerde gebruikscases, het verfijnen van het model op domeinspecifieke gegevens om de prestaties ervan te verbeteren.
3. AI-tools integreren en beveiligen: De functies en API's die tijdens de ontwerpfase zijn geïdentificeerd, zijn verbonden met de agent. Met behulp van een SDK verpakken ontwikkelaars bestaande functies of maken ze nieuwe, waardoor ze veilig kunnen worden aangeroepen door de agent en ervoor kunnen zorgen dat ze de juiste authenticatie en foutafhandeling hebben.
4. Gegevens en RAG-pijplijnen samenstellen: Om de agent externe Knowledge te geven, stellen ontwikkelaars de gegevenspijplijnen samen voor Retrieval-Augmented Generation (RAG). Dit omvat het verbinden met en indexeren van gegevens uit bronnen zoals vectorstores, relationele databases, grafiekdatabases of interne documenten, waardoor die informatie toegankelijk wordt voor de agent voor het bieden van nauwkeurige, contextbewuste reacties.

Het testen van AI-agenten introduceert een paradigmaverschuiving van de deterministische validatie van traditionele software. Hoewel een conventionele toepassing wordt getest op correctheid (een specifieke invoer moet één verwachte uitvoer produceren), vereist het niet-deterministische karakter van een agent een meer geavanceerde benadering. Het doel is niet om één juist antwoord te valideren, maar om ervoor te zorgen dat het gedrag van de agent is afgestemd op het beoogde doel, robuust is tegen onverwachte invoer en betrouwbaar blijft in een spectrum van acceptabele uitkomsten.

1. Eenheid testen: Deze laag richt zich op de deterministische, niet-AI-componenten van de agent. Het omvat traditionele eenheidstests om te valideren dat elke afzonderlijke tool en functie correct op zichzelf werkt, wat een betrouwbare basis garandeert voordat de complexe redenering van de agent wordt toegepast.
2. End-to-End (E2E) testen: Deze fase evalueert het vermogen van de agent om doelen te bereiken in realistische scenario's, wat cruciaal is gezien het niet-deterministische karakter ervan. In plaats van te controleren op een exacte uitvoer, controleren deze end-to-end tests of de agent taken met succes voltooit en of de prestaties niet verslechteren wanneer er wijzigingen worden aangebracht.
3. Testen op tegenspoed en robuustheid: Dit is de praktijk van het opzettelijk proberen om de agent te breken om proactief de zwakke punten ervan te ontdekken. Testers gebruiken ambigue verzoeken, kwaadwillende aanwijzingen en andere randcases om kwetsbaarheden bloot te leggen en ervoor te zorgen dat de agent veerkrachtig en veilig blijft onder druk.
4. Evaluatie van Human-in-the-Loop (HITL): Aangezien geautomatiseerde tests geen genuanceerde kwaliteiten kunnen meten, zoals toon of gespreksstroom, vertrouwt deze fase op menselijke feedback. Testers hebben interacties met de agent om de responsen ervan te beoordelen op behulpzaamheid en algehele gebruikerservaring, waarbij essentiële gegevens worden verschaft voor het afstemmen van de werking ervan.
5. Prestatie- en schaaltests: Dit is een kritieke stap om bottlenecks in prestaties te voorkomen voordat ze gevolgen hebben voor gebruikers. Dit proces simuleert realistische scenario's voor piekgebruik om ervoor te zorgen dat agenten en toepassingen grote volumes soepel en voorspelbaar kunnen afhandelen. Het valideert dat de oplossing niet alleen correct, maar ook schaalbaar is.

Het implementeren van een AI-agent is een beheerd proces dat erop gericht is ervoor te zorgen dat gebruikers op een betrouwbare en herhaalbare manier interactie hebben met de gevalideerde agent. Dit vereist een gestructureerde aanpak die de agent verplaatst van een versiebeheerd activum naar een live, bewaakte service.

1. Verpakking en versiebeheer: De gehele definitie van de agent, inclusief de aanwijzingen en tools, wordt vastgelegd als metagegevens in een bestand en opgeslagen in een bronregelingssysteem zoals Git. Hierdoor ontstaat één bron van waarheid en een controleerbare historie van alle wijzigingen.
2. CI/CD Pijplijnen: Het traject naar productie wordt geautomatiseerd om menselijke fouten te elimineren en consistentie te waarborgen. Deze pijplijnen promoveren de agent automatisch door ontwikkel-, test- en productieomgevingen, waarbij end-to-end tests in elke fase worden uitgevoerd om als kwaliteitspoort te fungeren.
3. Gefaseerde implementatiestrategieën: Om risico's te minimaliseren worden nieuwe agentversies eerst vrijgegeven aan een kleine subset van gebruikers met behulp van strategieën zoals Canary Releases. Hierdoor kunnen prestaties in de praktijk worden bewaakt vóór een volledige implementatie, met de mogelijkheid om snel te herstellen als er problemen worden gevonden.
4. Activering en governance: De kritieke stap bij het implementeren van een agent is het veilig activeren van de agent met de juiste machtigingen en ervoor zorgen dat deze is verbonden met bewakingstools. Dit biedt onmiddellijk zicht op de gezondheid en prestaties van de nieuw geïmplementeerde agent vanaf het moment dat deze live gaat.

Implementatie is niet het einde van de levenscyclus van Agentontwikkeling; het is het begin van de continue "buitenste lus". Agenten zijn dynamische systemen die werken in onvoorspelbare, echte omgevingen. Deze fase is gewijd aan het observeren van de live prestaties van de agent, het verzamelen van insights uit de interacties ervan en het gebruik van die gegevens om de effectiviteit, veiligheid en efficiëntie ervan systematisch te verfijnen en te verbeteren in de loop van de tijd.

1. Realtime prestatiebewaking: Dit is de praktijk van het bijhouden van de belangrijkste operationele meetgegevens van de agent tijdens de interactie met gebruikers. Dashboards worden gebruikt voor het bewaken van latentie, tokenverbruik (kosten) en API-foutpercentages, wat een onmiddellijk, hoog niveau van de gezondheid en efficiëntie van de agent biedt.
2. Gedrags- en succesanalyse: Dit omvat het analyseren van gesprekslogboeken om te begrijpen hoe de agent zijn taken feitelijk uitvoert. Het richt zich op het bijhouden van percentages voltooide taken, het identificeren van veelvoorkomende foutpunten of doodlopende wegen voor gesprekken, en het meten van gebruikerstevredenheid om te bepalen of de agent zijn doelen bereikt. Als voorbeeld voor serviceagenten kan het meetgegevens bieden over hoe vaak en waarom een agent escaleert naar een mens.
3. Intelligent afstemmen en verfijnen: Dit is het actieve proces waarbij insights uit monitoring worden gebruikt om de agent te verbeteren. Dit kan variëren van prompt engineering tot tooloptimalisatie.
4. Gegevensgestuurde RAG-verbetering: De kwaliteit van de Knowledge base van de agent wordt continu verbeterd op basis van query's uit de praktijk. Bewaking kan aan het licht brengen dat de agent worstelt met bepaalde onderwerpen, wat kan leiden tot een verfijning van de gegevensbronnen of het ophaalproces (RAG-verfijning) om de nauwkeurigheid van de responsen te verbeteren.
5. Continu leren en aanpassing: Dit omvat het maken van een feedbacklus waarbij productiegegevens worden gebruikt om de agent slimmer te maken. Door interactielogboeken te labelen—met menselijk toezicht of op LLM gebaseerde labeling—wordt een beheerde gegevensset samengesteld, die kan worden gebruikt om het onderliggende model te verfijnen en verdere verbeteringen aan te bevelen

Agentforce ondersteunt elke ADLC-fase met geïntegreerde tooling voor ontwerp, ontwikkeling, testen, implementatie, bewaking en analyses—alles binnen één gecombineerd platform voor het snel samenstellen en testen van robuuste agenten.

Agentforce ADLC is gebaseerd op de volgende leidende principes:

• Gemaakt voor zowel low-code als pro-code: Ondersteuning voor op configuratie gebaseerde implementatie (low-code) en programmatische uitbreidbaarheid (pro-code).
• Doorlopende AI-gestuurde assistentie- en feedbacklussen: Legt gespreksgegevens vast en analyseert deze om agenttuning te ondersteunen voor continue AI-gestuurde verbetering.
• Testgestuurde ontwikkeling op alle niveaus: Rigoureus testen in alle fasen, valideren van deterministische componenten door middel van traditionele eenheidstests en bieden van nieuwe benaderingen voor het testen van redenering van agenten en niet-deterministisch gedrag.
• Uitvoerend en LOB-waarneembaarheid: Het leveren van meetgegevens over kosten, gebruik en prestaties voor operationele en uitvoerende belanghebbenden.

Dit hoofdstuk toont hoe Agentforce elke fase van de ADLC ondersteunt binnen één gecombineerd platform.

Idee

De ideeënfase is de basisfase van de ADLC, waarin de initiële visie en vereisten voor agenten worden geformuleerd. Het omvat een diepgaande duik in het begrijpen van het probleem, het identificeren van potentiële oplossingen en het schetsen van de kernfunctionaliteiten van de agent.

Start het ideeënproces van uw agent door de belangrijkste kenmerken ervan te definiëren:

1. Doel/doel: Definieer duidelijk de primaire doelstelling van de agent. Welk specifiek probleem moet het oplossen of welke taak moet het uitvoeren? Wie moet de agent bedienen? Dit moet een beknopte en meetbare verklaring zijn die het gehele ontwikkelingsproces stuurt.
2. Persona: Ontwikkel een gedetailleerde identiteit voor de agent. Dit omvat het definiëren van de identiteit, de communicatiestijl en de rol die het zal spelen in de interactie met gebruikers of andere systemen. Denk aan de toon, het niveau van formaliteit en eventuele specifieke kenmerken die het effectief maken in de beoogde context.
3. Patroon: Identificeer en koppel naar relevante agentische patronen en implementatiestrategieën. Dit omvat architectonische ontwerpen of best practices die de structuur en het gedrag van de agent kunnen bepalen. "Agentische patronen en implementatie voor Salesforce Agentforce: Een technische whitepaper," dient als een waardevolle resource voor deze stap en biedt insights in effectief agentontwerp op het Salesforce Platform en Agentforce.

Ontwerp

De ontwerpfase vertaalt de concepten van ideatie naar een gedetailleerde blauwdruk voor de constructie van de agent. Dit omvat het definiëren van de architectuur, gebruikersstromen, interactiemodellen en technische specificaties van de agent, zoals onderwerpen, tools en vangrails.

Tijdens de ontwerpfase maakt u een gedetailleerde blauwdruk voor de constructie van uw agent, die het volgende omvat:

• Agentontwerp: Geef een overzicht van de interne structuur van de agent, inclusief de componenten, modules en de manier waarop ze samenwerken. Dit kan inhouden dat u de Knowledge base, configuratie en logica definieert om het gedrag van agenten te controleren, componenten van natuurlijke taalverwerking (NLP) en integratiepunten met andere systemen.
• Gebruikersstromen/Interactieontwerp: Wijs de volledige gebruikersjourney en de interacties van de agent toe. Definieer gespreksstromen, beslissingsstructuren, foutafhandeling en feedbackmechanismen om intuïtieve, effectieve ervaringen te creëren.
• Technische specificaties: Documenteer de technische niet-functionele vereisten voor de agent, zoals prestatiemeetgegevens, overwegingen bij schaalbaarheid, beveiligingsprotocollen en integratiespecificaties.
• Prototyping en mockups: Maak visuele voorstellingen of interactieve prototypen van de interface en interacties van de agent. Dit maakt vroegtijdig testen en feedback mogelijk, waardoor het ontwerp kan worden verfijnd voordat de volledige ontwikkeling begint.
• Data: Bij het bepalen van het type en de bronnen van gegevens die een agent nodig heeft, identificeert u gegevenssets, API's, databases en opslagplaatsen waartoe de agent toegang moet hebben. Richt u voor Agentforce op welke gegevens als context worden aangeleverd, of deze gestructureerd of niet-gestructureerd zijn, en of het realtime of batchgewijs is. Het Agentforce platform is gebouwd met diepe integratie met Data 360, waardoor u zowel gestructureerde als ongestructureerde gegevens uit Salesforce CRM en andere bronnen kunt gebruiken. Niet-gestructureerde inhoud kan in blokken worden verdeeld en geïndexeerd voor RAG. Met MuleSoft kunt u verbinding maken met externe systemen.
• Tools: Bepaal welke acties de agent moet uitvoeren. Gebruik Agentforce Actions om tools zichtbaar te maken waarmee bedrijfsdoelen worden bereikt. Deze acties maken gebruik van bestaande Salesforce-activa zoals Aanwijzingen via Aanwijzingensamensteller, MuleSoft, Apex, Stromen en API's met OpenAPI-specificaties. Elke aanroepbare actie kan worden geïntegreerd in Agentforce en door de agent worden gebruikt, waardoor alle bekende Salesforce-ontwikkeltools direct beschikbaar zijn als Agentforce Acties.
• Invoergegevens voor agenten: In traditionele SDLC worden ingangen nauwkeurig opgegeven. In de ADLC zijn invoer vaak natuurlijke, niet-deterministische, vrije-vormuitingen. Verzamel een representatief corpus van uitingen waarvan wordt verwacht dat ze de juiste reacties opleveren.

De ontwikkelingsfase richt zich op het vertalen van het doel, de mogelijkheden en het operationele bereik van de gedefinieerde agent, zoals bepaald in de fase Idee en ontwerp, naar een nieuwe Agentforce Agent.

Om ontwikkelaars te helpen agenten te maken, biedt Agentforce zowel de Agent Builder als Agentforce Developer Experience (AFDX). Deze basistools fungeren als de primaire omgevingen voor het samenstellen en configureren van de agent.

• Agent Builder biedt een UI-ervaring voor het definiëren van de kernfunctionaliteit van de agent.
• AFDX biedt een programmatische interface voor aanpassing en integratie met andere systemen.

Het ontwikkelen en samenstellen van een agent omvat deze stappen die kunnen worden uitgevoerd met behulp van de Agentsamensteller of AFDX:

1. De identiteit definiëren: Een cruciaal aspect van agentontwerp is het vaststellen van een eigen identiteit. Dit omvat het configureren van:
   • Beschrijving agent: Een gedetailleerde beschrijving van de rol, doelstellingen en de specifieke klantenservicetaken van de agent.
   • Toon: De communicatiestijl van de agent, het niveau van empathie en eventuele specifieke merkrichtlijnen waaraan de agent zich moet houden.
2. Agentonderwerpen en -acties definiëren: Als u een agent geavanceerd wilt maken en in staat wilt maken om een breed scala aan taken af te handelen, is het essentieel om de mogelijkheden ervan op te splitsen in afzonderlijke onderwerpen met bijbehorende acties.
   • Onderwerpen: Elk onderwerp kan worden opgevat als een eigen gespecialiseerde agent met een unieke set instructies en tools.
     • Modulaire architectuur. De modulaire benadering van onderwerpen zorgt voor meer organisatie en schaalbaarheid. Door meerdere onderwerpen te definiëren, kan de agent een breder scala aan complexe scenario's afhandelen. Een agent kan bijvoorbeeld afzonderlijke onderwerpen hebben voor "Orderbeheer", "Veelgestelde vragen (FAQ), "Technische ondersteuning" en "Factureringsvragen".
   • Onderwerpinstructies (vangrails): Elk onderwerp bevat specifieke instructies die als vangrails fungeren en het bereik definiëren van wat de agent binnen dat onderwerp kan bespreken of doen. Deze instructies voorkomen dat de agent afwijkt van het onderwerp of irrelevante informatie verstrekt. Ze helpen ook consistentie en nauwkeurigheid in responsen te behouden.
   • Acties: Onderwerpen zijn ook uitgerust met "tools", die de acties vertegenwoordigen die de agent kan ondernemen. Deze tools kunnen zijn:
     • Informatieve acties: Gegevens ophalen uit een Knowledge base of een extern systeem om een query te beantwoorden.
     • Transactionele acties: Het uitvoeren van acties namens de gebruiker, zoals het plaatsen van een order, het bijwerken van een klantenrecord of het initiëren van een restitutieproces. Deze acties zijn vaak geïntegreerd met andere systemen (bijv. CRM, ERP).

Bij het evalueren van de prestaties en betrouwbaarheid van AI-agenten stuiten testers vaak op een reeks uitdagingen die de gebruikerservaring kunnen verslechteren. Deze problemen variëren van het verkeerd interpreteren van de intentie van de gebruiker tot het niet correct uitvoeren van taken.

Veel voorkomende scenario's voor agentfouten

Het bouwen van een robuuste agent vereist inzicht in hoe en waar deze kan mislukken. De volgende tabel categoriseert veelvoorkomende problemen tijdens de levenscyclus van agenten, van gebrekkig redeneren tot slecht ophalen van Knowledge. Gebruik dit als een strategische leidraad tijdens de ontwikkeling en een controlelijst tijdens het testen om ervoor te zorgen dat uw agent niet alleen functioneel is, maar ook betrouwbaar en intuïtief voor de eindgebruiker. Deze mislukkingsscenario's moeten u helpen testcases te definiëren.

Best practices voor het testen van AI-agenten

Het volgende schetst best practices om in gedachten te houden bij het testen van agenten op Agentforce.

1. Testgegevens verbeteren
   De basis van effectief testen is uitgebreide en realistische testgegevens. Volg deze principes om ervoor te zorgen dat u effectieve testgegevens hebt voor het testen van uw agenten:

   • Voldoende dekking: Probeer voldoende testgegevens te hebben voor alle kritieke onderwerpen en gebruikersidentiteiten.
   • Realistische scenario's: Zorg ervoor dat uw testgegevens de interacties van gebruikers in de praktijk nauwkeurig weergeven.
   • Negatieve en Edge-cases: Neem negatieve testcases (wat de agent niet moet doen) en randscenario's op om de grenzen van de agent uit te dagen.
   • Testen van vangrails: Voeg specifieke testcases toe om te controleren of de vangrails van de agent correct functioneren.

2. Testuitvoeringen optimaliseren
   Als u uw testresources optimaal wilt benutten, optimaliseert u de manier waarop u uw tests uitvoert. Hier zijn overwegingen bij het testen van Agentforce agenten:

   • Volume testcase: U kunt maximaal 1000 testcases gebruiken.
   • Gelijktijdige tests uitvoeren: Het is mogelijk om maximaal 10 testcases tegelijk uit te voeren binnen een tijdsbestek van 10 uur.
   • Resources beheren: Houd er rekening mee dat het uitvoeren van tests credits verbruikt. Zorg ervoor dat u tevreden bent met uw testgegevens voordat u een uitvoering start om onnodige kosten te voorkomen.

3. Resultaten beoordelen
   Analyseer testuitkomsten zorgvuldig om verbeterpunten te identificeren:

   • Mislukte analyseren: Inspecteer elke mislukte testcase afzonderlijk. Lees en begrijp zorgvuldig het verschil tussen de verwachte en de feitelijke resultaten om het probleem op te sporen.
   • Een sandboxomgeving gebruiken: Testagenten kunnen CRM-gegevens wijzigen. Voer ter voorkoming van onbedoelde wijzigingen aan uw live gegevens altijd testen uit in een niet-productieomgeving, zoals een sandbox of een scratch-organisatie.

4. Afstemmen en opnieuw testen
   Testen is een herhalend proces dat wordt voortgezet naarmate de agent zich ontwikkelt:

   • Continu testen: Voer testen uit na elke wijziging aan de onderwerpen of acties van de agent. Dit valideert de wijzigingen en zorgt ervoor dat de kwaliteit behouden blijft.
   • Testdekking uitbreiden: Beheer en breid uw gegevensset continu uit met nieuwe testcases om de algehele dekking en robuustheid van de agent te verbeteren.

Benaderingen testen

Gezien de complexiteit van de agent is geen enkele testmethode voldoende. Een uitgebreide validatiestrategie moet worden gelaagd, waarbij verschillende benaderingen worden gecombineerd om alles te bestrijken, van voorspelbare, deterministische acties tot de nuances van het niet-deterministische, conversationele gedrag ervan. Deze benaderingen bieden een raamwerk voor het systematisch evalueren van elke component van de agent om ervoor te zorgen dat deze robuust, betrouwbaar en veilig is.

1. Handmatig testen met Agentsimulator en Plantracering

   • Doel: Dit is de eerste en vaak eenvoudigste manier om een agent te testen. Het is ideaal voor een kleine set voorbeeldgebruikscases en voor het verkrijgen van een fundamenteel inzicht in het gedrag van de agent.
   • Mechanisme: Een agentsimulator biedt een gecontroleerde omgeving waarin ontwikkelaars en beheerders rechtstreeks met de agent kunnen werken. Deze simulator maakt gedetailleerde tracering mogelijk van de informatie die wordt aangeleverd door de beheerder/ontwikkelaar, en biedt insights in de manier waarop de agent invoer verwerkt en uitvoer genereert.
   • Voordelen:
     • Snelle feedback
     • Gemakkelijk om directe problemen te identificeren
     • Helpt bij het begrijpen van de logicastroom van de agent

2. Geautomatiseerd testen met Testcentrum of AFDX Test Suite

   • Doel: Zodra handmatig testen een baseline van functionaliteit heeft vastgesteld, wordt geautomatiseerd testen cruciaal voor schaalbaarheid, grondigheid en regressietests.
   • Mechanisme: Met tools zoals het Testcentrum of de AFDX-testreeks kunnen geautomatiseerde tests worden gegenereerd op basis van vooraf gedefinieerde voorbeeldgebruikscases. Deze tests zijn ontworpen om te valideren of de instructies en subagentclassificaties van de agent correct werken voor een breder scala aan scenario's.
   • Voordelen:
     • Zorgt voor consistente prestaties
     • Identificeert subtiele bugs
     • Ondersteunt continue integratie/continue implementatie (CI/CD)-pijplijnen
     • Biedt uitgebreide dekking

3. Actiespecifieke eenheid testen met behulp van Apex en stromen

   • Doel: Om de deterministische bedrijfslogica te valideren die is ingekapseld in agentacties. Hoewel het algemene gedrag van de agent niet-deterministisch is, worden agentacties vaak aangestuurd door technologieën zoals stromen en Apex, waarop standaard ontwikkelpraktijken van toepassing zijn.
   • Mechanisme: Ontwikkelaars schrijven eenheidstests voor de specifieke stromen of Apex klassen die een agentactie aanroept. Deze tests verifiëren de afzonderlijke componenten van de logica van de agent en zorgen ervoor dat ze de verwachte uitvoer voor een bepaalde set invoer produceren.
   • Voordelen:
     • Het integreren van deze eenheidstests in een DevOps-pijplijn biedt een geautomatiseerd vangnet
     • Valideert dat wijzigingen of verbeteringen in de logica van een actie geen regressies veroorzaken
     • Garandeert de betrouwbaarheid van de mogelijkheden van de agent voordat deze in productie worden geïmplementeerd

4. Tegenstrijdig testen - beveiliging en vangrailafdwinging:

   • Doel: Het samenstellen van verschillende soorten agenten vereist een sterke nadruk op beveiliging en ervoor zorgen dat ze werken binnen gedefinieerde parameters en vangrails. Dit is essentieel om onbedoelde acties, gegevensinbreuken of misbruik te voorkomen. Daarom is het doel van tegengestelde tests om deze potentiële kwetsbaarheden proactief te identificeren en te verhelpen door de agent bewust uit te dagen met invoer die is ontworpen om zijn veiligheidsmechanismen te omzeilen, waardoor de robuustheid en weerstand tegen manipulatie worden getest.
   • Mechanisme: Tegenstrijdig testen wordt geïmplementeerd door uitdagende, ambigue of kwaadwillige invoer te maken die de grenzen verlegt van het beoogde gedrag van de agent. Platformtools zoals de voorziening "Vangrails" in Agentsamensteller bieden insights in het naleven van instructies, maar ontwikkelaars moeten ook aangepaste testcases maken die actief proberen om de agent te laten mislukken in een gecontroleerde omgeving.
   • Voordelen: Deze benadering beperkt systematisch beveiligings- en nalevingsrisico's vóór implementatie. Door potentiële foutpunten te identificeren, verbetert vijandig testen de betrouwbaarheid van agenten en zorgt het ervoor dat deze veilig en zoals bedoeld werken bij interactie met gebruikers.

Herhalend testen in scratch-organisaties en sandboxen

De "inner loop" is de kritieke, herhalende cyclus waarbij een agent van concept naar een gevalideerde component gaat, klaar voor implementatie. Dit proces van continue verfijning vereist omgevingen voor zowel ontwikkeling als testen. Agentforce biedt dit framework via scratch-organisaties, die geïsoleerde, tijdelijke omgevingen bieden voor snelle prototypes die geen invloed hebben op gedeelde omgevingen, en sandboxen, die grondige tests met realistische gegevens mogelijk maken om het traject naar productie te versnellen.

1. Ontwikkeling in scratch-organisaties: Initiële ontwikkeling moet plaatsvinden in een scratch-organisatie. De tools die binnen de ontwikkelomgeving worden geleverd, zoals Agent Builder en AFDX, worden hier volledig benut. Scratch-organisaties zijn sterke kandidaten voor CI/CD-pijplijnen voor het uitvoeren van eenheidstests, het uitvoeren van codeanalyses en het doorzetten van wijzigingen naar hogere omgevingen.
2. Implementatie naar sandbox voor testen van echte gegevens: Zodra de kernfunctionaliteiten van de agent zijn ontwikkeld in een scratch-organisatie, implementeert u deze naar een sandbox. Sandboxen zijn kopieën van een productieomgeving en bieden een realistischer proeftuin.
   • Real Data vs. Nepgegevens: Hoewel sommige ontwikkelaars gegevens in scratch-organisaties kunnen namaken voor initiële tests, maakt implementatie naar een sandbox het mogelijk om te testen met "echte gegevens". Dit is van cruciaal belang voor het evalueren van de prestaties van de agent in scenario's die de feitelijke interacties met klanten goed weerspiegelen. Het gebruik van representatievere gegevens in een sandbox versnelt het ontwikkeling- en verfijningsproces aanzienlijk.
   • Volledige of gedeeltelijke sandbox voor kern-CRM-gegevens: Afhankelijk van het gegevensvolume en specifieke testvereisten kan een volledige of gedeeltelijke sandbox worden gebruikt.
     • Full sandbox: Biedt een volledige replica van de productieomgeving, inclusief alle metagegevens en gegevens. Ideaal voor uitgebreide testen en prestatietuning met grote gegevenssets.
     • Gedeeltelijke sandbox: Bevat een subset van de productiegegevens, vaak voldoende voor het testen van specifieke voorzieningen of functionaliteiten waarbij een volledige gegevensset niet strikt noodzakelijk is.
   • Knowledge en RAG Management: Als de agent vertrouwt op een Knowledge Base- of Retrieval-Augmented Generation-model (RAG-model), neemt u alle relevante inhoud op in de sandbox en indexeert u deze opnieuw. Dit zorgt ervoor dat de agent actuele informatie gebruikt tijdens het testen en inhoud nauwkeurig kan ophalen en synthetiseren.

Agentforce definieert agenten door middel van metagegevens, zodat ze kunnen worden geïmplementeerd met behulp van standaard Salesforce-procedures zoals wijzigingssets of AFDX. Deze fase benadrukt een veilige en gecontroleerde implementatie door middel van kritieke voorzieningen zoals versiebeheer voor agenten en een afzonderlijke activeringsstap, die systeemstabiliteit garandeert en snel herstel van problemen mogelijk maakt.

Volg deze stappen om uw nieuwe agent te implementeren en vrij te geven.

1. Implementeren via wijzigingsset/metagegevens-API of AFDX: Het implementatieproces voor agenten maakt gebruik van standaard Salesforce-procedures en behandelt agenten als metagegevens. Dit zou een vertrouwd proces moeten zijn voor iedereen die gewend is aan de ontwikkeling en implementatie van Salesforce. Het gebruik van wijzigingssets of AFDX zorgt voor een gestructureerde en consistente benadering van het migreren van agentconfiguraties tussen omgevingen, zoals van sandbox naar productie. Deze methode vergemakkelijkt versiebeheer en goed wijzigingsbeheer, die cruciaal zijn voor het behoud van systeemstabiliteit en betrouwbaarheid.
2. Agenten activeren na implementatie: Na een succesvolle implementatie is het noodzakelijk dat een systeembeheerder de agent actief "activeert". Implementatie plaatst gewoon de code en metagegevens van de agent in de doelomgeving; activering is de stap die de agent operationeel en beschikbaar voor gebruik maakt. Deze scheiding maakt gecontroleerde implementatie en testen mogelijk voordat een agent live gaat en een interactie heeft met eindgebruikers of andere systeemcomponenten.
3. Versiebeheer gebruiken voor veilig agentbeheer: Agentversiebeheer is een kritieke voorziening die de veiligheid en flexibiliteit van de ontwikkeling en het onderhoud van agenten aanzienlijk verbetert.
   1. Nieuwe versies maken, testen en publiceren: De aanbevolen werkwijze bestaat uit het maken van een nieuwe versie van een agent telkens wanneer er wijzigingen of uitbreidingen nodig zijn. Deze nieuwe versie kan vervolgens grondig worden getest in een sandboxomgeving zonder gevolgen voor de live, geactiveerde agent. Zodra de nieuwe versie is gevalideerd en gereed wordt geacht, kan deze worden gepubliceerd en vervolgens worden geactiveerd, waarbij de vorige operationele versie wordt vervangen. Dit herhalende proces maakt continue verbetering en innovatie mogelijk en minimaliseert onderbrekingen.
   2. Terugdraaien naar vorige versies: Een belangrijk voordeel van versiebeheer is de mogelijkheid om snel en gemakkelijk terug te keren naar een vorige, stabiele versie als er een probleem optreedt met een nieuw geïmplementeerde of geactiveerde agent. Als er iets misgaat, bijvoorbeeld als een agent zich misdraagt of een onvoorziene fout introduceert, kunnen beheerders gewoon teruggaan naar de laatst bekende goede versie en deze activeren. Deze mogelijkheid biedt een kritiek veiligheidsnet, waardoor snel herstel mogelijk is en downtime wordt geminimaliseerd, waardoor bedrijfscontinuïteit en gebruikerstevredenheid worden gegarandeerd.

Agentbewaking

Agentforce Sessietracering is een open, uitbreidbaar model dat is gebaseerd op Data 360 en dat end-to-end agentinteracties vastlegt. Agentforce neemt gegevens op uit verschillende bronnen (te beginnen met logboeken van de redeneringsengine) en combineert alles onder een sessie-ID.

Het gegevensmodel Sessietracering (STDM) biedt gedetailleerde informatie over wat er is gebeurd tijdens agentsessies, waaronder:

• Stapsgewijze interacties
• Redeneren van engine-uitvoeringen
• Acties, prompt- en gateway-invoer/-uitvoer
• Foutberichten
• Definitieve antwoorden

De STDM is een essentiële tool om ontwikkelaars te helpen:

• Set-up- en configuratieproblemen van foutopsporingsagenten tijdens het samenstellen.
• Leer waarom bepaalde testcases zijn mislukt tijdens batchtests.
• Ga na waarom een agent een set gebruikersvragen niet kan afhandelen of off-topic gaat.

Ontwikkelaars moeten deze sessietraceringsgegevens gebruiken voor het observeren, bewaken, onderzoeken en oplossen van problemen met agentevents, -incidenten en -gedragspatronen.

De STDM bestaat uit gegevens-lakeobjecten (Data Lake Objects, DLO's) en gegevensmodelobjecten (Data Model Objects, DMO's) waarin gedetailleerde logboeken van het gedrag van agenten worden opgeslagen. Metagegevens over elke LLM-aanroep die door de redeneringsengine wordt gedaan, kunnen worden samengevoegd met feedback of vangrailsmeetgegevens. Gegevensstromen naar DLO's in Data 360 en toewijzingen naar van toepassing zijnde DMO's.

Ontwikkelaars hebben toegang tot deze gegevens en krijgen insights door query's en rapporten uit te voeren op de STDM. De componenten van een STDM worden hieronder beschreven.

Gegevensmodel-ERD van Agentforce Session Tracing

Agentforce optimalisering

Agentforce Optimalisering is een krachtige voorziening die is ontworpen om de prestaties van AI-agenten te verbeteren door diepgaande insights in gebruikersinteracties te bieden. Het is gebaseerd op de analysemogelijkheden van het Session Tracing Data Model (STDM). Hierdoor krijgen beheerders en ontwikkelaars inzicht in gebruikersonderwerpen, betrokkenheidspatronen en de effectiviteit van oplossingen van agenten.

Belangrijke aspecten van Agentforce optimalisering zijn:

• Momentspecifieke gegevens: Agentforce Optimalisering breidt STDM uit door "Momenten" te introduceren, die interacties vertegenwoordigen die zijn gericht op een specifieke gebruikersintent of een specifiek verzoek tijdens een sessie. Deze gedetailleerde gegevens maken gedetailleerde inspectie van elk aspect van een interactie mogelijk, van het eerste gebruikersverzoek tot de oplossing van de agent.
• Automatische momentverwerking: Momenten worden dagelijks gegenereerd en vervolgens wekelijks geclusterd en getagd voor alle actieve agenten met behulp van een geavanceerd Large Language Model (LLM). Deze segmentering vereenvoudigt het uitvoeren van query's en biedt insights in verschillende facetten van agentsessies.
• Query's uitvoeren en analyseren: Gebruikers kunnen een query uitvoeren op Momenten op basis van tags, kwaliteitsscores en andere criteria. Dit maakt het mogelijk om gebruikersbetrokkenheid te beoordelen aan de hand van meetgegevens zoals Momentduur en kwaliteitsscores voor relevantie, waardoor gebieden voor verbetering kunnen worden bepaald.
• Gecombineerd gegevensmodel: Agentforce optimalisering maakt gebruik van het gecombineerde Session Tracing Data Model (STDM), dat elke vastgelegde event binnen een sessie vastlegt, inclusief afzonderlijke gespreksbeurten. Alle relevante entiteiten worden geleverd wanneer STDM wordt ingeschakeld in de set-up.

Door de interacties van AI-agenten te analyseren, stelt Agentforce optimalisering gebruikers in staat om gebieden voor verbetering te identificeren en configuraties te verfijnen om beter te voldoen aan de behoeften van gebruikers.

Zie Gegevensmodel voor Agentforce Optimalisering voor meer informatie.

Dit hoofdstuk is een praktische handleiding voor ontwikkelaars van pro-code. Het laat zien hoe u snel en veilig agenten samenstelt, test en implementeert met Agentforce DX (AFDX) en onze Python SDK. We doorlopen de volledige levenscyclus, van het eerste ontwerp tot een versiebeheerde agent, met behulp van de krachtige combinatie van AFDX en onze Python SDK.

De volgende voorbeelden maken gebruik van twee belangrijke toolsets die zijn ontworpen voor het samenstellen en beheren van agenten op het Agentforce platform. Een goed begrip van deze tools wordt aanbevolen om het maximale uit deze handleiding te halen.

1. Agentforce DX (AFDX): Voor het beheren van de levenscyclus

Agentforce DX breidt de vertrouwde Salesforce Developer Experience-toolset (SFDX) uit—inclusief de Salesforce CLI en VS Code-extensies—ter ondersteuning van de gehele levenscyclus van Agent Development. Het wordt gebruikt om een agent te beheren als versiebeheerde metagegevens, testen te automatiseren vanaf de opdrachtregel en implementaties te organiseren tussen uw ontwikkelsandboxen en productie.

Zie voor meer informatie: Aan de slag met Agentforce DX Development.

2. Agentforce Python SDK: Voor het samenstellen van de agent

De Python SDK biedt de programmatische interface voor de "inner loop" van ontwikkeling. Hiermee kunt u de redeneringslogica van een agent definiëren, de tools ervan verbinden en aanwijzingssjablonen rechtstreeks binnen een vertrouwde Python-omgeving beheren, waardoor de kernfase van de ADLC wordt gestroomlijnd.

De SDK is beschikbaar op PyPI: https://pypi.org/project/agentforce-sdk/.

Het volledige project is hier beschikbaar:
https://github.com/akshatasawant9699/ADLC_Whitepaper.

Deze basisfase definieert het doel, de identiteit en de kernmogelijkheden van een agent. Het omvat het beantwoorden van kritieke vragen aan de architect van het "brein" van de agent voordat er code wordt geschreven. In dit voorbeeld ontwerpen we een agent voor Coral Cloud Resorts.

• Missie: De agent treedt op als resortmanager, behandelt klachten van klanten, beheert personeelsplanningen en zorgt voor een soepele resortwerking.
• Persona: De agent heeft een behulpzame, professionele en gespreksgerichte toon.
• Tools en mogelijkheden: De agent heeft toegang nodig tot reserveringssystemen, planningssoftware voor medewerkers en resortbeleid.
• Beslissingslogica: De agent gebruikt door AI gegenereerde onderwerpen om de intent van de gebruiker te bepalen en de juiste acties te genereren.

Met Agentforce DX vertaalt de ontwerpfase zich in een tastbaar specificatiebestand: Agentforce DX: Een agentspecificatie genereren. De eerste stap in de pro-code journey is het genereren van een bestand agentSpec.yaml. Het YAML-bestand legt het kernontwerp van de agent vast, inclusief diens rol, relevante bedrijfsdetails en een door AI gegenereerde lijst van onderwerpen die de taken definiëren die de agent kan afhandelen.

Gebruik de Salesforce CLI om deze specificatie te genereren via interactieve aanwijzingen. Voer voor het maken van uw agent met Agentforce DX het volgende uit:

U moet specifieke details opgeven die zijn gedefinieerd tijdens de fase van het ideeënproces:

• Type agent: Klant
• Bedrijfsnaam: Coral Cloud-resorts
• Bedrijfsbeschrijving: Coral Cloud Resorts biedt klanten uitzonderlijke bestemmingsactiviteiten, onvergetelijke ervaringen en reserveringsservices, allemaal ondersteund door een belofte om eersteklas klantenservice te bieden.
• Agentrol: De resortmanager legt klachten van klanten vast, beheert personeelsplanningen en zorgt ervoor dat alle processen soepel verlopen.

Het uitvoeren van deze opdracht maakt een bestand agentSpec.yaml in de directory met specificaties van het DX-project. Het bestand bevat de informatie die is verstrekt, samen met een lijst van door AI gegenereerde onderwerpen die de naam en beschrijving van elk onderwerp bevatten. Controleer en bewerk het bestand indien nodig om de mogelijkheden van de agent te verfijnen.

Op soortgelijke wijze gebruikt de Python SDK-implementatie interactieve specificatieverzameling om automatisch agentonderwerpen te genereren met de juiste bereikvelden die vereist zijn voor SDK-compatibiliteit.
Verder wordt er een volledig JSON-bestand met agentspecificaties gemaakt, dat wordt gebruikt om een agent te maken in fase 2.

De ontwikkelingsfase richt zich op het samenstellen van de kerncomponenten van de agent: de redeneerengine, tools die deze kan gebruiken en de Knowledge base. Agentforce abstraheert veel van de complexiteit, waardoor ontwikkelaars zich kunnen richten op bedrijfslogica.

Deze sectie deelt twee pro-code benaderingen voor de Agentforce ontwikkelingsfase. Ten eerste het gebruik van Agentforce DX en ten tweede het gebruik van Python.

Agentforce DX: Een agent maken op basis van een specificatie

Zodra het bestand agentSpec.yaml gereed is, maakt u de agent in uw Salesforce-organisatie. Voer deze opdracht uit om de agent te maken en de bijbehorende metagegevens terug te synchroniseren naar uw lokale DX-project:

Accepteer de standaard API-naam, Resort_Manager, wanneer u daarom wordt gevraagd. De opdracht parseert de specificatie, maakt de agent en haalt de metagegevens op. De metagegevens omvatten een Bot, BotVersion en een GenAiPlannerBundle, die AI-intelligence en verwijzingen naar de onderwerpen en acties van de agent toevoegen.

Bekijk een voorbeeld van de structuur van de agent voordat u deze maakt, door de vlag --voorbeeld toe te voegen om een lokaal JSON-bestand te genereren met details over het type agent dat de LLM gaat maken, inclusief voorgestelde acties. Bijvoorbeeld:

Raadpleeg voor meer informatie Een agent maken vanuit uw DX-project vanuit Trailhead.

Agentforce Python SDK: Specifieke tools definiëren

De Agent SDK vergemakkelijkt het testen van agenten door nepacties te maken. Deze nepacties moeten uiteindelijk worden vervangen door echte acties binnen Salesforce. Salesforce biedt een reeks platformvoorzieningen, waaronder stromen, Apex, aanwijzingssjablonen en API's, die allemaal kunnen worden ingekapseld als Agentforce acties.

Hier is een nep-actiecodesnippet om te illustreren hoe een Agentforce actie eruit zou kunnen zien.

De implementatie brengt de verbinding met Salesforce tot stand, maakt het agentexemplaar en definieert aangepaste tools en acties die de agent kan gebruiken voor interactie met externe systemen en het uitvoeren van specifieke bedrijfsfuncties.

Zoals we hierboven hebben besproken, is het testen van een agent complexer dan traditionele softwaretests. Het vereist het valideren van gedrag, redenering en robuustheid voor verschillende scenario's. Dit omvat eenheidstests voor afzonderlijke tools, end-to-end testen voor gesprekken en vijandig testen om kwetsbaarheden te vinden.

Agentforce DX biedt een werkstroom op hoog niveau voor het maken, implementeren en uitvoeren van tests naast het Testing Center en de directe Testing API. Deze sectie demonstreert het uitvoeren van tests met Agentforce DX.

Agentforce DX: Een agenttest uitvoeren

Gebruik Agentforce DX om vooraf gedefinieerde agenttests rechtstreeks vanaf de opdrachtregel uit te voeren. Dit is ideaal voor het integreren van agenttests in moderne DevOps-processen.

Agentforce Python SDK: E2E- en tegenstanderstests simuleren

Conceptueel maakt Python SDK het mogelijk om gesprekken in scripts te simuleren om end-to-end (E2E) tests te simuleren en redeneringen van agenten te valideren.

Agentforce Python SDK met Salesforce Testing API

De Python SDK-implementatie gebruikt uitgebreide tests met de Salesforce Testing API en AiEvaluationDefinition-metagegevens, waardoor gestructureerde testcases worden gemaakt met verwachtingen voor onderwerpreeksen, actiereeksen, tekenreeksovereenkomsten en kwaliteitsmeetgegevens. Het systeem genereert XML-metagegevensdefinities die kunnen worden geïmplementeerd naar Salesforce voor het testen en valideren van geautomatiseerde agenten.

Eenmaal gevalideerd, wordt de agent geïmplementeerd in een productieomgeving. Tijdens deze fase is Agentforce DX cruciaal bij het helpen beheren en verplaatsen van metagegevens van agenten tussen verschillende organisaties (bijvoorbeeld sandboxen en productie). Agentimplementaties maken een nieuwe versie van de Agent en de Agent gaat pas live nadat u deze expliciet hebt geactiveerd. Dit geeft u volledige controle over wanneer de nieuwe versie van de agent moet worden vrijgegeven.

Agentforce DX: Agentmetagegevens implementeren

De standaard Salesforce DX projectstructuur organiseert metagegevens van agenten onder de directory force-app. Gebruik standaardopdrachten voor sf-projectimplementatie om een agent en de bijbehorende tests te implementeren naar een doelorganisatie.

Nadat een agent is gemaakt of geïmplementeerd, kunt u deze rechtstreeks in de Agentforce Builder UI openen om de configuratie ervan te verifiëren door het uitvoeren van:

Nadat u hebt gevalideerd dat de agent is geïmplementeerd, kunt u deze activeren. Als u onverwachte problemen ondervindt, gaat u terug naar de vorige werkversie van de agent.

Agentforce Python SDK: Agent implementeren

De implementatie neemt de gevalideerde agentspecificatie en implementeert deze naar de Salesforce-organisatie, waardoor de agent beschikbaar wordt voor gebruik. Het implementatieproces omvat het maken van agenten, het synchroniseren van metagegevens en het verifiëren van een geslaagde implementatie.

ADLC is een continue cyclus; implementatie is niet het einde. Agenten zijn levende systemen die constante bewaking vereisen voor het bijhouden van meetgegevens zoals latentie, kosten en successcores. De inzichten die worden verkregen uit bewaking, worden gebruikt om de prestaties van agenten af te stemmen en te verbeteren door middel van prompt engineering, tooloptimalisatie en het verfijnen van Knowledge bases.

Het Agentforce platform biedt uitgebreide dashboards en analyses om deze cruciale fase te ondersteunen, zodat agenten zich in de loop van de tijd blijven ontwikkelen en verbeteren.

Agentforce Analytics

Agentforce Analytics, te vinden in de map Agentforce (standaard), gebruikt Data 360 om insights te bieden in prestaties van agenten. Het aanpasbare dashboard en de aanpasbare rapporten bieden gegevens over acceptatie, feedback en gebruik, zodat u onderwerpen en acties kunt verfijnen om de gebruikerstevredenheid te verbeteren. U kunt doorklikken naar resultaten door te klikken op diagrammen of gekoppelde rapporten. Als u bestaande rapporten wilt aanpassen, kloont u ze en wijzigt u de klonen om te voorkomen dat analyseprocessen worden verstoord.

Uitingsanalyse

Uitingsanalyse toont hoe Agentforce (Standaard) gebruikers agenten gebruiken, wat ze aanvragen en of de agent deze verzoeken heeft kunnen afhandelen. Deze aanpasbare rapporten kunnen u helpen uw onderwerpen en acties te verfijnen, zodat uw agenten effectiever en nauwkeuriger reageren.

Agentforce Python SDK: Bewaking met Data 360-integraties

De Agent SDK-implementatie gebruikt geavanceerde bewaking en analyses met de Data 360 Python-connector, brengt verbinding tot stand met Salesforce Data 360, voert query's uit op meetgegevens over agentprestaties en maakt uitgebreide bewakingsdashboards.
Het systeem houdt reactietijden, successcores, gebruikerstevredenheid en kostenmeetgegevens bij om navolgbare insights te bieden voor optimalisering van agenten.

Agentforce DX: Agentbewaking

De implementatie gebruikt standaard AFDX-opdrachten met op CLI gebaseerd agentbeheer, waardoor de agent up-to-date blijft met platformwijzigingen en feedback van gebruikers wordt verwerkt voor continue verbetering.

Raadpleeg de GitHub-repository hier voor ADLC-implementatie met behulp van Agent SDK en AFDX.

Het beheersen van de levenscyclus van agentontwikkeling vereist het naleven van een set kernprincipes die efficiëntie, betrouwbaarheid en strategische afstemming waarborgen. De volgende richtlijnen bundelen de belangrijkste lessen uit elke fase van de ADLC in een strategisch raamwerk voor architecten en ontwikkelaars.

1. Planning en Ideeën

Deze eerste fase richt zich op het afstemmen van het doel van de agent op bedrijfsdoelen en ervoor zorgen dat het is gebouwd op een solide basis.

• Prioriseren voor bedrijfsimpact: Begin door potentiële gebruikscases rechtstreeks toe te wijzen aan strategische bedrijfsdoelen. Gebruik een prioriteringsmatrix om hun potentiële impact te beoordelen en te beginnen met één gerichte gebruikscase met duidelijke KPI's.
• Betrek belanghebbenden in een vroeg stadium: Verzamel insights over pijnpunten en zorg voor uitlijning.
• Gegevensinsights benutten: Een agent is slechts zo goed als zijn gegevens. Gebruik Data 360 om beschikbare gestructureerde en ongestructureerde gegevens te verkennen om de context en mogelijkheden van de agent te bepalen. Controleer bestaande rapporten en dashboards om huidige trends te identificeren die uw selectie van gebruikscases kunnen bepalen.
• Raamwerken gebruiken voor Ideeën: Pas gestructureerde ideeënmethoden toe om te brainstormen en potentiële toepassingen te verfijnen, zoals ontwerpdenken of SWOT-analyse.

2. Bouwagenten

Deze fase omvat de best practices voor het samenstellen van een goed presterende en efficiënte agent.

• Vermijd te veel onderwerpen: Beperk het aantal onderwerpen om het risico te verkleinen dat er soortgelijke of overlappende onderwerpen ontstaan die de agent in verwarring kunnen brengen.
• Houd instructies en aanwijzingen beknopt: Gebruik directe, eenvoudige taal en geef voorbeelduitingen om de agent effectief te begeleiden.
• Hefboomvariabelen en deterministische acties: Gebruik deze tools om het gedrag van de agent te sturen en de prestaties ervan te optimaliseren voor meer voorspelbare resultaten.
• Houd actie-uitvoer klein en beknopt: Zorg ervoor dat de reacties van de agent kort en bondig zijn. Langere uitvoer gebruikt meer context en genereert langzamer.
• Acties optimaliseren voor snelheid: Ontwerp stromen en Apex klassen om minimaal vereiste gegevens te retourneren. Probeer minder acties nodig te hebben om een respons te genereren door voorverwerking waar mogelijk.
• Een duidelijk bereik definiëren: Schrijf de juiste beschrijvingen, instructies en het bereik voor acties om te voorkomen dat de agent RAG (Retrieval-Augmented Generation) belt voor vragen die buiten het bereik vallen.
• Gebruik Hybride zoekopdracht spaarzaam: Gebruik alleen hybride zoekopdrachten als dit absoluut noodzakelijk is, omdat dit een negatieve invloed kan hebben op de latentie.

3. Testen, bewaken en afstemmen

Deze herhalingsfase is cruciaal voor het verfijnen van de nauwkeurigheid en prestaties van de agent.

• Een teststroom instellen: Volg een consistente testcyclus:
  1. Batchtest uitvoeren: Voer een uitgebreide set tests uit.
  2. Scores/fouten weergeven: Analyseer de prestatiemeetgegevens en identificeer fouten.
  3. Fouten inspecteren: Onderzoek elke foutenrij om de discrepantie te begrijpen.
  4. Agent bijwerken: Breng de nodige aanpassingen aan in de agent of de evaluatiegegevens ervan.
• Informatie over sessietracering beoordelen: Gebruik het gegevensmodel Sessietracering en Agentforce Interaction Explorer om een analyse van de hoofdoorzaak uit te voeren wanneer er problemen of onverwachte werkingen worden geïdentificeerd. Stem uw agent af op basis van de informatie en blijf uw agent herhalen.

De Agent Development Lifecycle vertegenwoordigt een kritieke evolutie van traditionele principes voor softwareontwikkeling, ontworpen voor het tijdperk van intelligente, autonome systemen.

• Evolutie, niet vervanging: De levenscyclus van Agentontwikkeling breidt het traditionele levenscyclusbeheer voor toepassingen uit en verbetert het zonder het te vervangen.
• Gegevens als eersteklas burger: Gegevens spelen een veel dynamischere en centralere rol in de ontwikkeling van agenten.
• Gespecialiseerde tools en vaardigheden: Vereist nieuwe tools en een bredere set gespecialiseerde vaardigheden voor gegevenswetenschappen, ML-engineering en agentontwikkeling.
• Continu leren: Agentontwikkeling voegt continu leren en aanpassing van het systeem zelf toe.
• Toekomstige impact: Agentic AI belooft complexe IT-activiteiten en softwareontwikkelingswerkstromen verder te automatiseren en optimaliseren.