I traditionell programvaruutveckling tillhandahåller livscykeln för programvaruutveckling (SDLC) ett strukturerat, fasat tillvägagångssätt för att bygga program. Det etablerar kvalitet, minskar risken och ger en tydlig vägkarta från idé till release. Agentutvecklingslivscykeln (ADLC) är en liknande metod som är speciellt utformad för att hantera de unika komplexiteterna i att bygga autonoma agenter.

Agenter är inte passiva program, de är system som resonerar, agerar och lär sig inom dynamiska körningsmiljöer. Deras icke-deterministiska beteende gör traditionell kvalitetsbedömning otillräcklig. Agentutvecklingslivscykeln (ADLC), som stöds av plattformar som Agentforce, hanterar detta i fem faser: Idéer och design, utveckling (den ”inre loopen”), test och validering, distribuering och kontinuerlig övervakning och justering (den ”yttre loopen”).

Detta dokument fungerar som en omfattande guide för utvecklare och företagsarkitekter som redan är bekanta med komplexiteten i SDLC (Software Development Lifecycle) och vill utöka sin expertis till agentbaserade system. Vårt primära mål är att underlätta en snabb förståelse av Agentutvecklingslivscykeln (ADLC) genom att lyfta fram dess viktigaste skillnader från traditionella SDLC-metoder och tillhandahålla ett strukturerat ramverk för att konceptualisera hela processen att bygga, distribuera och hantera intelligenta agenter.

Dokumentet är organiserat i tre olika kapitel, vart och ett utformat för att gradvis bygga upp din Knowledge och praktiska färdigheter:

• Kapitel 1: ADLC Framework. Detta kapitel introducerar Agentutvecklingslivscykeln (ADLC), som beskriver dess skillnad från SDLC på grund av de unika utmaningarna med att utveckla autonoma agenter. Det skapar ett ramverk för att utforma, utveckla, testa och distribuera agenter.
• Kapitel 2: Agentforce Platform. Detta kapitel utforskar Agentforce, en enhetlig plattform som effektiviserar och snabbar på hela livscykeln för agentutveckling. Agentforce erbjuder verktyg för agentdesign, databearbetning, modellutbildning, distribution och kontinuerlig övervakning, vilket förenklar komplexa uppgifter och förbättrar effektiviteten.
• Kapitel 3: Implementering av pro-kod. Denna guide använder Agentforces prokodverktyg för att ge praktiska, steg-för-steg-instruktioner och verkliga exempel för agentutveckling. Den täcker hela livscykeln för agentutveckling, från prototyp- och funktionsteknik till modelldistribuering, prestandajustering och underhåll, och utrustar utvecklare med kompetensen att bygga produktionsklara agenter.

Detta dokument syftar till att ge dig teoretisk och praktisk Knowledge i Agentforces prokodverktyg. Du kommer att lära dig bygga, distribuera och övervaka agenter effektivt, säkert och pålitligt, få en omfattande förståelse av ADLC och maximera Agentforces potential i intelligent agentutveckling.

Den icke-deterministiska karaktären hos AI-agenter kräver ett specialiserat utvecklingsramverk. Detta kapitel sammanfattar detta ramverk genom att introducera Agentutvecklingslivscykeln (ADLC). Detta kapitel ger en omfattande översikt av de fem kärnfaserna i ADLC, från inledande idéer och design till kontinuerlig övervakning och justering. Detta kapitel etablerar den grundläggande Knowledge som behövs för att bygga robusta och pålitliga agenter.

Denna sektion mappar SDLC-koncept till de fem faserna i ADLC.

Detta är den grundläggande fasen där en agents strategiska syfte och operativa gränser definieras. En välstrukturerad designfas är det mest kritiska steget för framgång, eftersom den översätter ett verksamhetsbehov till en teknisk plan. Designprocessen säkerställer att agenten inte bara är funktionell utan också ansvarsfull och i linje med användarens förväntningar. Det är där "vad" och "varför" etableras innan någon kod skrivs.

1. Definiera agentmål och kapacitet: Först måste du tydligt artikulera agentens primära mål och de specifika, mätbara uppgifter den kommer att utföra. Detta innefattar att definiera dess roll (t.ex. "kundtjänstassistent"), dess kärnfunktioner (t.ex. "boka bokningar", "svara på produktfrågor") och framgångsmått för var och en.
2. Upprätta persona och etiska skyddsräcken: Detta steg innefattar att utforma agentens personlighet och definiera dess etiska gränser för att säkerställa att den är pålitlig och säker. Det etablerar agentens ton (t.ex. "formell", "vänlig") och implementerar strikta regler för att förhindra skadliga, partiska eller olämpliga svar.
3. Karta sammanhang och förståelse: Du måste avgöra vilken information agenten behöver förstå och komma ihåg för att vara effektiv. Detta inkluderar att definiera omfattningen av dess Knowledge bas och dess konversationsminne, vilket gör att den kan ha sammanhängande konversationer med flera vändningar.
4. Identifiera verktyg och systemintegreringar: Detta innefattar att inventera de externa system, API:n och datakällor agenten måste ansluta till för att utföra uppgifter. Varje verktyg (t.ex. en boknings-API, en kunddatabas) identifieras och dess funktion mappas till en specifik agentkapacitet.
5. Planera mänsklig omflyttning: Det är viktigt att definiera de villkor under vilka en agent flyttas om till en människa. Detta innefattar att granska potentiella felpunkter och konversations-"återvändsgränder" för att avgöra när en agent ska flyttas om till en mänsklig operator. Designen ska beskriva hur denna överlämning kommer att utföras för att säkerställa att tillräckligt sammanhang överförs, så att den snabbt kan konsumeras för att säkerställa en sömlös kundupplevelse.

Detta är den praktiska konstruktionsfasen där designritningen omvandlas till en funktionell agent. Utvecklare bygger agenten, ansluter den till dess verktyg och ger den de data den behöver för att utföra sina uppgifter. Denna iterativa "inre loop" av att bygga och förfina är där agenten verkligen kommer till liv.

1. Konfigurera agentens logik och beslutsfattande: Detta steg innefattar att forma agentens resonemang genom att ansluta dess beslutsram till sammanhang, verktyg och datakällor. Utvecklarens roll är att definiera agentens beteende genom att skapa API:n eller återanvända befintliga API:n, ange operativa skyddsräcken och specificera hur agenten väljer och använder tillgängliga verktyg för att utföra komplexa uppgifter i flera steg.
2. Ingenjörsuppmaningar och finjusterade modeller: Agentens persona, instruktioner och begränsningar kodifieras genom noggrann uppmaningsteknik. Denna process innefattar att skapa huvuduppmaningen som guidar Large Language Model (LLM) och, för mer avancerade användningsfall, finjustera modellen på domänspecifika data för att förbättra dess prestanda.
3. Integrera och säkra AI-verktyg: De funktioner och API som identifierats under designfasen är anslutna till agenten. Med hjälp av en SDK omger utvecklare befintliga funktioner eller skapar nya, vilket gör att de säkert kan anropas av agenten och säkerställer att de har rätt autentisering och felhantering.
4. Bygg data- och RAG-pipelines: För att ge agenten extern Knowledge bygger utvecklare datapipeline för hämtningsutökat skapande (RAG). Detta innefattar att ansluta till och indexera data från källor som vektorlager, relationsdatabaser, grafdatabaser eller interna dokument, vilket gör att denna information är tillgänglig för agenten för att ge korrekta, sammanhangsbaserade svar.

Att testa AI-agenter introducerar ett paradigmskifte från deterministisk validering av traditionell programvara. Medan ett konventionellt program testas för korrekthet — en specifik indata måste producera en enskild, förväntad utdata — kräver en agents icke-deterministiska natur ett mer sofistikerat tillvägagångssätt. Målet är inte att validera ett enskilt rätt svar utan att säkerställa att agentens beteende är i linje med dess avsedda syfte, är robust mot oväntade inmatningar och förblir pålitligt över ett spektrum av acceptabla resultat.

1. Enhetstest: Detta lager fokuserar på agentens deterministiska, icke-AI-komponenter. Det innefattar traditionella enhetstester för att validera att varje enskilt verktyg och funktion fungerar korrekt isolerat, vilket säkerställer en pålitlig grund innan agentens komplexa resonemang tillämpas.
2. End-to-End-test (E2E): Denna fas utvärderar agentens förmåga att uppnå mål i realistiska scenarion, vilket är kritiskt med tanke på dess icke-deterministiska karaktär. Istället för att kontrollera om det finns en exakt utdata verifierar dessa end-to-end-test att agenten utför uppgifter och att dess prestanda inte försämras när ändringar görs.
3. Kontradiktorisk testning och robusthetstestning: Detta är metoden att avsiktligt försöka bryta ner agenten för att proaktivt upptäcka dess svagheter. Testare använder tvetydiga begäranden, skadliga uppmaningar och andra kundcase för att avslöja sårbarheter och säkerställa att agenten förblir motståndskraftig och säker under press.
4. Utvärdering av HITL (Human-in-the-Loop): Eftersom automatiserade tester inte kan mäta nyanserade egenskaper som ton eller konversationsflöde förlitar sig denna fas på mänsklig feedback. Testare interagerar med agenten för att betygsätta dess svar för hjälpsamhet och övergripande användarupplevelse, vilket ger viktiga data för att finjustera dess beteende.
5. Test av prestanda och skala: Detta är ett viktigt steg för att förhindra flaskhalsar i prestanda innan de påverkar användare. Denna process simulerar realistiska scenarion med maximal användning för att säkerställa att agenter och program kan hantera stora volymer smidigt och förutsägbart. Det validerar att lösningen inte bara är korrekt, utan även skalbar.

Att distribuera en AI-agent är en hanterad process som fokuserar på att säkerställa att den validerade agenten är vad användare interagerar med på ett pålitligt och repeterbart sätt. Detta kräver ett strukturerat tillvägagångssätt som flyttar agenten från en versionsstyrd tillgång till en live, bevakad tjänst.

1. Paketering och versionshantering: Agentens hela definition, inklusive dess uppmaningar och verktyg, samlas in som metadata i en fil och lagras i ett källkontrollsystem som Git. Detta skapar en enda källa till sanning och en granskningsbar historik över alla ändringar.
2. CI/CD-pipelines: Vägen till produktion automatiseras för att eliminera mänskliga fel och säkerställa enhetlighet. Dessa pipelines främjar automatiskt agenten genom utvecklings-, test- och produktionsmiljöer och kör slut till slut-test i varje steg för att fungera som en kvalitetsgrind.
3. Strategier för fasad lansering: För att minimera risken släpps nya agentversioner till en liten undergrupp användare först med strategier som Canary Releases. Detta möjliggör övervakning av verkliga prestanda innan en fullständig lansering, med möjligheten att snabbt återgå om några problem hittas.
4. Aktivering och styrning: Det viktiga steget i att lansera en agent innefattar att säkert aktivera agenten med rätt behörigheter och säkerställa att den är ansluten till övervakningsverktyg. Detta ger omedelbar insyn i den nyligen distribuerade agentens hälsa och prestanda från det ögonblick den går live.

Distribuering är inte slutet på Agentutvecklingslivscykeln; det är början på dess kontinuerliga "yttre loop". Agenter är dynamiska system som fungerar i oförutsägbara, verkliga miljöer. Denna fas är dedikerad till att observera agentens liveresultat, samla insikter från dess interaktioner och använda dessa data för att systematiskt förfina och förbättra dess effektivitet, säkerhet och effektivitet över tid.

1. Resultatövervakning i realtid: Detta är metoden för att följa agentens viktigaste operativa mått när den interagerar med användare. Instrumentpaneler används för att övervaka latens, tokenkonsumtion (kostnad) och API-felfrekvenser, vilket ger en omedelbar överblick av agentens hälsa och effektivitet.
2. Beteende- och Success Analytics: Detta innefattar att analysera konversationsloggar för att förstå hur agenten faktiskt utför sina uppgifter. Den fokuserar på att följa slutförande av uppgifter, identifiera vanliga felpunkter eller konversations-"återvändsgränder" och mäta användarnöjdhet för att avgöra om agenten uppnår sina mål. Som ett exempel för serviceagenter kan det ge mått på hur ofta och varför en agent flyttas om till en människa.
3. Intelligent justering och förfining: Detta är den aktiva processen att använda insikter från övervakning för att förbättra agenten. Detta kan vara allt från snabb teknik till verktygsoptimering.
4. Datadriven RAG-utökning: Kvaliteten på agentens Knowledge Base förbättras kontinuerligt baserat på verkliga sökfrågor. Övervakning kan avslöja att agenten kämpar med vissa ämnen, vilket leder till en förfining av datakällorna eller hämtningsprocessen (RAG-förfining) för att förbättra precisionen i dess svar.
5. Kontinuerligt lärande och anpassning: Detta innefattar att skapa en feedbackloop där produktionsdata används för att göra agenten smartare. Genom att märka interaktionsloggar—antingen med mänsklig tillsyn eller LLM-baserad märkning—byggs en utvald datauppsättning, som kan användas för att finjustera den underliggande modellen och rekommendera ytterligare förbättringar

Agentforce har stöd för varje ADLC-fas med integrerade verktyg för design, utveckling, test, distribuering, övervakning och analys – allt inom en enda enhetlig plattform för att snabbt bygga och testa robusta agenter.

Agentforce ADLC baseras på följande vägledande principer:

• Byggd för både lågkod och prokod: Stöd för konfigurationsbaserad distribuering (lågkod) och programmatisk utökning (prokod).
• Kontinuerliga AI-drivna hjälp- och feedbackloopar: Samlar in och analyserar konversationsdata för att informera agenter om justering för kontinuerlig AI-driven förbättring.
• Testdriven utveckling på alla nivåer: Rigorösa tester över alla faser, validering av deterministiska komponenter genom traditionella enhetstester och nya metoder för att testa agentresonemang och icke-deterministiskt beteende.
• Verkställande och LOB-observerbarhet: Tillhandahåller mått för kostnad, användning och prestanda för operativa och överordnade intressenter.

Detta kapitel visar hur Agentforce stöder varje fas i ADLC inom en enda enhetlig plattform.

Idéer

Idéfasen är den grundläggande fasen i ADLC, där inledande vision och krav på agenter formuleras. Det innefattar en djupdykning i att förstå problemet, identifiera potentiella lösningar och beskriva agentens kärnfunktioner.

Starta din agents idéprocess genom att definiera dess nyckelattribut:

1. Syfte/Mål: Definiera tydligt agentens primära mål. Vilket specifikt problem är det avsett att lösa, eller vilken uppgift är det avsett att utföra? Vem ska agenten tjäna? Detta bör vara ett koncist och mätbart uttalande som guidar hela utvecklingsprocessen.
2. Persona: Utveckla en detaljerad persona för agenten. Detta inkluderar att definiera dess identitet, kommunikationsstil och den roll den kommer att spela i interaktionen med användare eller andra system. Tänk på dess ton, nivå av formalitet och eventuella specifika egenskaper som gör den effektiv i sitt avsedda sammanhang.
3. Mönster: Identifiera och länka till relevanta agentmönster och implementeringsstrategier. Detta involverar arkitektonisk design eller rekommenderade metoder som kan informera agentens struktur och beteende. "Agentiska mönster och implementering i Salesforce Agentforce: Ett tekniskt whitepaper," fungerar som en värdefull resurs för detta steg och erbjuder insikter i effektiv agentdesign på Salesforce Platform och Agentforce.

Design

Designfasen översätter koncepten från idé till en detaljerad ritning för agentens konstruktion. Detta innefattar att definiera agentens arkitektur, användarflöden, interaktionsmodeller och tekniska specifikationer som ämnen, verktyg och skyddsräcken.

Under designfasen skapar du en detaljerad ritning för din agents konstruktion som inkluderar:

• Agentdesign: Ange agentens interna struktur, inklusive dess komponenter, moduler och hur de interagerar. Detta kan innefatta att definiera Knowledge base, konfiguration och logik för att styra agentbeteende, komponenter för naturlig språkbehandling (NLP) och integreringspunkter med andra system.
• Användarflöden/Interaktionsdesign: Mappa hela användarresan och agentens interaktioner. Definiera konversationsflöden, beslutsträd, felhantering och feedbackmekanismer för att skapa intuitiva, effektiva upplevelser.
• Tekniska specifikationer: Dokumentera de tekniska icke-funktionella kraven för agenten, som prestandamått, överväganden om skalbarhet, säkerhetsprotokoll och integreringsspecifikationer.
• Prototypning och modeller: Skapa visuella representationer eller interaktiva prototyper av agentens gränssnitt och interaktioner. Detta möjliggör tidiga tester och feedback, vilket hjälper till att förfina designen innan fullskalig utveckling börjar.
• Data: När du avgör vilken typ av data och vilka datakällor en agent behöver, identifiera datauppsättningar, API:n, databaser och databaser som agenten måste komma åt. För Agentforce, fokusera på vilka data som tillhandahålls som sammanhang, om de är strukturerade eller ostrukturerade, och om de är i realtid eller batch. Agentforce Platform är byggd med djup integrering med Data 360, vilket låter dig använda både strukturerade och ostrukturerade data från Salesforce CRM och andra källor. Ostrukturerat innehåll kan delas upp och indexeras för RAG. MuleSoft låter dig ansluta till externa system.
• Verktyg: Identifiera de åtgärder agenten måste utföra. Använd Agentforce Actions för att visa verktyg som uppnår verksamhetsmål. Dessa åtgärder använder befintliga Salesforce-tillgångar som till exempel Uppmaningar via Promptbyggaren, MuleSoft, Apex, flöden och API:n med OpenAPI-specifikationer. Alla åberopbara åtgärder kan integreras i Agentforce och användas av agenten, vilket gör alla bekanta Salesforce-utvecklingsverktyg lättillgängliga som Agentforce.
• Indata för agenter: I traditionell SDLC specificeras indata exakt. I ADLC är indata ofta naturliga, icke-deterministiska yttranden med fri form. Samla in en representativ uppsättning yttranden som förväntas ge lämpliga svar.

Utvecklingsfasen fokuserar på att översätta den definierade agentens syfte, kapacitet och operativa omfattning som avgörs i fasen Idéer och design till en ny Agentforce Agent.

För att hjälpa utvecklare skapa agenter tillhandahåller Agentforce både Agentbyggaren och Agentforce Developer Experience (AFDX). Dessa grundläggande verktyg fungerar som de primära miljöerna för att konstruera och konfigurera agenten.

• Agentbyggaren har ett användargränssnitt för att definiera agentens kärnfunktionalitet.
• AFDX har ett programmatiskt gränssnitt för anpassning och integrering med andra system.

Att utveckla och bygga en agent innefattar dessa steg som kan utföras med antingen Agentbyggaren eller AFDX:

1. Definiera personan: En viktig aspekt av agentdesign är att etablera en distinkt persona. Detta innefattar att konfigurera:
   • Agentbeskrivning: En detaljerad beskrivning av agentens roll, mål och de specifika kundserviceuppgifter den är utformad för att hantera.
   • Ton: Agentens kommunikationsstil, nivå av empati och eventuella specifika varumärkesriktlinjer som den behöver följa.
2. Definiera agentämnen och åtgärder: För att göra en agent sofistikerad och kapabel att hantera en mängd olika uppgifter är det viktigt att dela upp dess kapacitet i distinkta ämnen med motsvarande åtgärder.
   • Ämnen: Varje ämne kan konceptualiseras som sin egen specialiserade agent med en unik uppsättning instruktioner och verktyg.
     • Modulär arkitektur. Det modulära tillvägagångssättet för ämnen ger större organisation och skalbarhet. Genom att definiera flera ämnen kan agenten hantera en bredare uppsättning komplexa scenarion. Till exempel kan en agent ha separata ämnen för "Orderhantering", "Vanliga frågor", "Teknisk support" och "Faktureringsfrågor".
   • Ämnesinstruktioner (skyddsräcken): Varje ämne levereras med specifika instruktioner som fungerar som skyddsräcken och definierar omfattningen av vad agenten kan diskutera eller göra inom ämnet. Dessa instruktioner förhindrar agenten från att avvika från ämnet eller ge irrelevant information. De hjälper även till att upprätthålla enhetlighet och precision i svaren.
   • Åtgärder: Ämnen är även utrustade med "verktyg" som representerar de åtgärder agenten kan utföra. Dessa verktyg kan vara:
     • Informationsåtgärder: Hämta data från en Knowledge bas eller ett externt system för att besvara en sökfråga.
     • Transaktionella åtgärder: Utföra åtgärder åt användaren, som att placera en order, uppdatera en kundpost eller inleda en återbetalningsprocess. Dessa åtgärder integreras ofta med andra system (t.ex. CRM, ERP).

Vid utvärdering av AI-agenters prestanda och pålitlighet stöter testare ofta på en rad utmaningar som kan försämra användarupplevelsen. Dessa problem sträcker sig från att misstolka användares syfte till att inte utföra uppgifter korrekt.

Vanliga agentfelscenarier

Att bygga en robust agent kräver att man förstår hur och var det kan misslyckas. Följande tabell kategoriserar vanliga problem som uppstår under agentens livscykel, från felaktiga resonemang till dålig Knowledge hämtning. Använd detta som en strategisk guide under utveckling och en checklista under tester för att säkerställa att din agent inte bara är funktionell utan också pålitlig och intuitiv för slutanvändaren. Dessa felscenarion bör hjälpa dig definiera testfall.

Rekommenderade metoder för att testa AI-agenter

Följande sammanfattar rekommenderade metoder att tänka på när du testar Agenter i Agentforce.

1. Förbättra testdata
   Grunden för effektiva tester är omfattande och realistiska testdata. Följ dessa principer för att säkerställa att du har effektiva testdata för att testa dina agenter:

   • Tillräcklig täckning: Sikta på att ha tillräckligt med testdata för att täcka alla viktiga ämnen och användarpersonas.
   • Realistiska scenarion: Se till att dina testdata representerar verkliga användarinteraktioner korrekt.
   • Negativa kundcase och Edge-kundcase: Inkludera negativa testfall (vad agenten inte ska göra) och edge-scenarion för att utmana agentens gränser.
   • Test av skyddsräcken: Lägg till specifika testfall utformade för att verifiera att agentens skyddsräcken fungerar korrekt.

2. Optimera testkörningar
   För att få ut det mesta av dina testresurser, optimera hur du kör dina tester. Följande är saker att tänka på vid test av Agentforce agenter:

   • Testkundcasevolym: Du kan använda upp till 1 000 testfall.
   • Kör samtidiga tester: Det går att köra upp till 10 testfall samtidigt inom en 10-timmarsperiod.
   • Hantera resurser: Var medveten om att tester konsumerar krediter. Se till att du är nöjd med dina testdata innan du inleder en körning för att undvika onödiga kostnader.

3. Granska resultat
   Analysera noggrant testresultaten för att identifiera förbättringsområden:

   • Analysera fel: Inspektera varje misslyckat testfall individuellt. Läs noggrant igenom och förstå skillnaden mellan de förväntade och faktiska resultaten för att identifiera problemet.
   • Använda en sandboxmiljö: Testagenter kan ändra CRM-data. För att förhindra oavsiktliga ändringar av dina livedata, utför alltid tester i en icke-produktionsmiljö, som en sandbox eller en skissorganisation.

4. Stäm och testa igen
   Tester är en iterativ process som fortsätter medan agenten utvecklas:

   • Testa kontinuerligt: Utför tester efter varje ändring av agentens ämnen eller åtgärder. Detta validerar ändringarna och säkerställer att kvaliteten upprätthålls.
   • Utöka testtäckning: Utse och utöka kontinuerligt din datauppsättning med nya testfall för att förbättra agentens övergripande täckning och robusthet.

Testa tillvägagångssätt

Med tanke på agentens komplexitet är ingen enskild testmetod tillräcklig. En omfattande valideringsstrategi måste byggas på flera lager och kombinera olika metoder för att täcka allt från förutsägbara, deterministiska åtgärder till nyanserna i dess icke-deterministiska, konversationsbeteende. Dessa metoder ger ett ramverk för att systematiskt utvärdera varje komponent i agenten för att säkerställa att den är robust, pålitlig och säker.

1. Manuella tester med Agentsimulator och Planspårare

   • Syfte: Detta är det inledande och ofta enklaste sättet att testa en agent. Det är idealiskt för en liten uppsättning exempel på användningsfall och för att få en grundläggande förståelse av agentens beteende.
   • Mekanism: En agentsimulator tillhandahåller en kontrollerad miljö där utvecklare och administratörer kan interagera direkt med agenten. Denna simulator tillåter detaljerad spårning av informationen som tillhandahålls av administratören/utvecklaren, vilket ger insikter i hur agenten bearbetar inmatningar och skapar utdata.
   • Fördelar:
     • Snabbfeedback
     • Enkelt att identifiera omedelbara problem
     • Hjälper till att förstå agentens logikflöde

2. Automatiserade tester med Testcenter eller AFDX-testsvit

   • Syfte: När manuella tester har etablerat en baslinje för funktionalitet blir automatiserade tester avgörande för skalbarhet, grundlighet och regressionstest.
   • Mekanism: Verktyg som Testcenter eller AFDX-testsviten möjliggör skapandet av automatiserade tester baserat på fördefinierade exempel på användningsfall. Dessa tester är utformade för att validera om agentens instruktioner och underagentklassificeringar fungerar korrekt i ett bredare spektrum av scenarion.
   • Fördelar:
     • Säkerställer enhetlig prestanda
     • Identifierar små buggar
     • Stöder pipelines för kontinuerlig integrering/kontinuerlig distribution (CI/CD)
     • Ger omfattande täckning

3. Åtgärdsspecifika enhetstester med Apex och flöden

   • Syfte: För att validera den deterministiska verksamhetslogiken inkapslad i agentåtgärder. Agentens övergripande beteende är icke-deterministiskt, men agentåtgärder drivs ofta av tekniker som Flöden och Apex, som standardutvecklingsmetoder gäller för.
   • Mekanism: Utvecklare skriver enhetstester för de specifika flöden eller Apex klasser som en agentåtgärd åberopar. Dessa tester verifierar de individuella komponenterna i agentens logik och säkerställer att de producerar de förväntade utdata för en given uppsättning indata.
   • Fördelar:
     • Att integrera dessa enhetstester i en DevOps-pipeline ger ett automatiserat skyddsnät
     • Kontrollerar att ändringar eller förbättringar av en åtgärds logik inte medför regressioner
     • Säkerställer pålitligheten hos agentens kapacitet innan de distribueras till produktion

4. Kontradiktorisk testning – Säkerhet och skyddsräcke:

   • Syfte: Att bygga olika typer av agenter kräver en stark betoning på säkerhet och att säkerställa att de arbetar inom definierade parametrar och skyddsräcken. Detta är av största vikt för att förhindra oavsiktliga åtgärder, dataintrång eller missbruk. Syftet med kontradiktoriska tester är därför att proaktivt identifiera och åtgärda dessa potentiella sårbarheter genom att medvetet utmana agenten med indata utformade för att kringgå dess säkerhetsmekanismer och därigenom testa dess robusthet och motståndskraft mot manipulation.
   • Mekanism: Kontradiktoriska tester implementeras genom att skapa utmanande, tvetydiga eller skadliga inmatningar som flyttar gränserna för agentens avsedda beteende. Plattformsverktyg som "Guardrails"-funktionen i Agentbyggaren ger insikter i efterlevnad av instruktioner, men utvecklare bör även skapa egna kontradiktoriska testfall som aktivt försöker få agenten att misslyckas i en kontrollerad miljö.
   • Fördelar: Detta tillvägagångssätt minskar systematiskt säkerhets- och efterlevnadsrisker innan distribuering. Genom att identifiera potentiella felpunkter förbättrar kontradiktoriska tester agenters förtroende och säkerställer att de fungerar säkert och som de ska när de interagerar med användare.

Iterativa tester i skissorganisationer och sandboxar

Den "inre loopen" är den kritiska, iterativa cykel där en agent går från koncept till en validerad komponent, redo för distribuering. Denna process av kontinuerlig förfining kräver miljöer för både utveckling och test. Agentforce tillhandahåller detta ramverk genom skissorganisationer, som är isolerade, tillfälliga miljöer för snabb prototypframställning som inte påverkar delade miljöer, och sandboxar, som möjliggör grundliga tester med realistiska data för att snabba på vägen till produktion.

1. Utveckling i skissorganisationer: Inledande utveckling ska ske i en skissorganisation. Verktygen som tillhandahålls i utvecklingsmiljön, som Agentbyggaren och AFDX, används fullt ut här. Skissorganisationer är starka kandidater för CI/CD-pipelines för att köra enhetstester, utföra kodanalyser och främja ändringar till högre miljöer.
2. Distribuering till sandbox för verkliga datatest: När agentens kärnfunktioner har utvecklats i en skissorganisation, distribuera till en sandbox. Sandboxar är kopior av en produktionsmiljö och erbjuder en mer realistisk testmiljö.
   • Realdata vs. Låtsasdata: Vissa utvecklare kanske hånar data i skissorganisationer för inledande tester, men att distribuera till en sandbox tillåter tester med "riktiga data". Detta är viktigt för att utvärdera agentens resultat i scenarion som nära återspeglar faktiska kundinteraktioner. Att använda mer representativa data i en sandbox snabbar på utveckling och förfining betydligt.
   • Fullständig eller delvis sandbox för grundläggande CRM-data: Beroende på datavolymen och specifika testkrav kan antingen en fullständig eller delvis sandbox användas.
     • Full Sandbox: Ger en fullständig kopia av produktionsmiljön, inklusive alla metadata och data. Idealisk för omfattande tester och prestandajusteringar med stora datauppsättningar.
     • Delvis sandbox: Innehåller en underuppsättning av produktionsdata, ofta tillräcklig för att testa specifika funktioner eller funktioner där en fullständig datauppsättning inte är absolut nödvändig.
   • Kunskaps- och RAG-hantering: Om agenten förlitar sig på en Knowledge eller RAG-modell (Retrieval-Augmented Generation), ta in allt relevant innehåll i sandboxen och indexera igen. Detta säkerställer att agenten använder aktuell information under tester och kan korrekt hämta och syntetisera innehåll.

Agentforce definierar agenter genom metadata, så att de kan distribueras med Salesforces standardförfaranden som ändringsanvisningar eller AFDX. Denna fas betonar en säker och kontrollerad lansering genom viktiga funktioner som agentversioner och ett separat aktiveringssteg, vilket säkerställer systemstabilitet och möjliggör snabb återställning från problem.

Följ dessa steg för att distribuera och släppa din nya agent.

1. Distribuera via Change Set/Metadata API eller AFDX: Distributionsprocessen för agenter använder Salesforces standardförfaranden och behandlar agenter som metadata. Detta bör vara en bekant process för alla som är vana vid Salesforces utveckling och distribuering. Att använda ändringsanvisningar eller AFDX säkerställer ett strukturerat och enhetligt tillvägagångssätt för att migrera agentkonfigurationer mellan miljöer, som från sandbox till produktion. Denna metod underlättar versionshantering och korrekt ändringshantering, vilket är avgörande för att upprätthålla systemets stabilitet och pålitlighet.
2. Aktivera agenter efter distribuering: Efter en framgångsrik distribuering är det viktigt för en systemadministratör att aktivt "aktivera" agenten. Distribution placerar bara agentens kod och metadata i målmiljön. Aktivering är det steg som gör agenten operativ och tillgänglig för användning. Denna separation möjliggör kontrollerad lansering och testning innan en agent blir live och interagerar med slutanvändare eller andra systemkomponenter.
3. Använd versionshantering för säker agenthantering: Agentversioner är en viktig funktion som avsevärt förbättrar säkerheten och flexibiliteten för agentutveckling och underhåll.
   1. Skapa, testa och publicera nya versioner: Den rekommenderade metoden innefattar att skapa en ny version av en agent om ändringar eller förbättringar behövs. Denna nya version kan sedan testas noggrant i en sandboxmiljö utan att påverka den aktiva agenten. När den nya versionen har validerats och anses vara färdig kan den publiceras och aktiveras och ersätta den tidigare operativa versionen. Denna iterativa process möjliggör kontinuerlig förbättring och innovation samtidigt som störningar minimeras.
   2. Tillbaka till tidigare versioner: En viktig fördel med versionshantering är möjligheten att snabbt och enkelt gå tillbaka till en tidigare, stabil version om ett problem uppstår med en nyligen distribuerad eller aktiverad agent. Om något går fel—till exempel om en agent missköter sig eller introducerar ett oförutsett fel—kan administratörer helt enkelt gå tillbaka till den senast kända bra versionen och aktivera den. Denna kapacitet ger ett viktigt skyddsnät som möjliggör snabb återställning och minimerar nedtid, vilket säkerställer verksamhetskontinuitet och nöjda användare.

Agentövervakning

Agentforce Sessionsspårning är en öppen, utökningsbar modell byggd på Data 360 som samlar in agentinteraktioner från början till slut. Agentforce sessionsspårning tar in data från olika källor (med början i loggar för resonerande motorer) och kombinerar allt under ett sessions-ID.

Datamodellen för sessionsspårning (STDM) ger detaljerad information om vad som hände under agentsessioner, inklusive:

• Interaktioner sväng för sväng
• Resonerande motorkörningar
• Åtgärder, uppmaningar och gatewayinmatningar/utmatningar
• Felmeddelanden
• Slutliga svar

STDM är ett viktigt verktyg för att hjälpa utvecklare:

• Felsök problem med agenters konfiguration och inställningar under byggtiden.
• Få reda på varför vissa testfall misslyckades under batchtest.
• Hantera varför en agent inte kan hantera en uppsättning användarfrågor eller går utanför ämnet.

Utvecklare bör använda denna sessions spårningsdata för att observera, övervaka, undersöka och felsöka agenthändelser, incidenter och beteendemönster.

STDM består av datasjöobjekt (DLO) och datamodellobjekt (DMO) som lagrar detaljerade loggar över agenters beteende. Metadata om varje LLM-anrop som görs av den resonerande motorn kan kopplas med feedback eller skyddsräckesmått. Data strömmar till DLO i Data 360 och mappar till tillämpliga DMO.

Utvecklare kan komma åt dessa data och få insikter genom att köra sökfrågor och rapporter mot STDM. Komponenterna i en STDM beskrivs nedan.

ERD för Agentforce sessionsspårningsdatamodell

Agentforce Optimering

Agentforce Optimering är en kraftfull funktion utformad för att förbättra prestandan för AI-agenter genom att ge djupgående insikter i användarinteraktioner. Byggd på analyskapaciteten hos STDM (Sessionsspårningsdatamodell) låter den administratörer och utvecklare förstå användarämnen, engagemangsmönster och agentlösningars effektivitet.

Viktiga aspekter av Agentforce optimering inkluderar:

• Ögonblicksspecifika data: Agentforce Optimering utökar STDM genom att introducera "Stunder", som representerar interaktioner som fokuserar på ett specifikt användarsyfte eller en specifik begäran under en session. Dessa detaljerade data möjliggör detaljerad granskning av varje aspekt av en interaktion, från den inledande användarbegäran till agentens lösning.
• Automatiserad ögonblicksbearbetning: Ögonblick skapas dagligen och klustras och taggas sedan veckovis över alla aktiva agenter med hjälp av en avancerad Large Language Model (LLM). Denna segmentering förenklar sökfrågor och ger insikter i olika aspekter av agentsessioner.
• Förfrågan och analys: Användare kan fråga Ögonblick baserat på taggar, kvalitetsbetyg och andra kriterier. Detta möjliggör bedömningen av användarengagemang genom mått som ögonblicksvaraktighet och relevanskvalitetsbetyg, vilket hjälper till att hitta områden som kan förbättras.
• Samlad datamodell: Agentforce använder den sammanslagna datamodellen för sessionsspårning (STDM), som samlar in varje loggad händelse inom en session, inklusive individuella konversationsomgångar. Alla relevanta enheter provisioneras när STDM aktiveras i konfigurationen.

Genom att analysera AI-agentinteraktioner låter Agentforce användare identifiera områden som kan förbättras och förfina konfigurationer för att bättre uppfylla användarbehov.

Mer information finns i Datamodell för Agentforce Optimering.

Detta kapitel är en praktisk guide för prokodutvecklare. Den visar hur du bygger, testar och distribuerar agenter med Agentforce DX (AFDX) och vår Python SDK med snabbhet och säkerhet. Vi kommer att gå igenom hela livscykeln, från inledande design till en versionsstyrd agent, med den kraftfulla kombinationen av AFDX och vår Python SDK.

Följande exempel kommer att använda två viktiga verktygsuppsättningar utformade för att bygga och hantera agenter på Agentforce Platform. En grundläggande förståelse av dessa verktyg rekommenderas för att få ut det mesta av denna guide.

1. Agentforce DX (AFDX): För att hantera livscykeln

Agentforce DX utökar den bekanta Salesforce Developer Experience-verktygsuppsättningen (SFDX)—inklusive Salesforce CLI och VS Code-tilläggen—för att stödja hela Agentutvecklingslivscykeln. Den används för att hantera en agent som versionsstyrda metadata, automatisera tester från kommandoraden och orkestrera distribueringar mellan dina utvecklingssandboxar och produktion.

Mer information finns i: Komma igång med Agentforce DX-utveckling.

2. Agentforce Python SDK: För att bygga agenten

Python SDK tillhandahåller det programmatiska gränssnittet för den "inre loopen" av utveckling. Det låter dig definiera en agents resonemangslogik, ansluta dess verktyg och hantera uppmaningsmallar direkt i en bekant Python-miljö, vilket effektiviserar kärnkonstruktionsfasen i ADLC.

SDK finns på PyPI: https://pypi.org/project/Agentforce-sdk/.

Det fullständiga projektet finns här:
https://github.com/akshatasawant9699/ADLC_Whitepaper.

Denna grundläggande fas definierar en agents syfte, persona och kärnkapacitet. Det innefattar att svara på kritiska frågor för att arkitekta agentens "hjärna" innan någon kod skrivs. I detta exempel utformar vi en agent för Coral Cloud Resorts.

• Mission: Agenten fungerar som resortchef och hanterar kundklagomål, hanterar anställdas scheman och säkerställer smidig resortdrift.
• Persona: Agenten har en hjälpsam, professionell och konversationsinriktad ton.
• Verktyg och kapacitet: Agenten behöver åtkomst till bokningssystem, programvara för schemaläggning av anställda och resortpolicyer.
• Beslutslogik: Agenten använder AI-skapade ämnen för att avgöra användarens syfte och skapa lämpliga åtgärder.

Med Agentforce DX översätts designfasen till en konkret specifikationsfil: Agentforce DX: Skapa en agentspecifikation. Det första steget i prokodresan är att skapa en agentSpec.yaml-fil. YAML-filen samlar in agentens kärndesign, inklusive dess roll, relevanta företagsdetaljer och en AI-genererad lista över ämnen som definierar de jobb den kan hantera.

Använd Salesforce CLI för att skapa denna specifikation via interaktiva uppmaningar. För att börja skapa din agent med Agentforce DX, kör:

Du måste ange specifika detaljer som definierades under idéfasen:

• Typ av agent: Kund
• Företagsnamn: Coral Cloud miljöhotell
• Företagsbeskrivning: Coral Cloud Resorts erbjuder kunder exceptionella destinationsaktiviteter, oförglömliga upplevelser och bokningstjänster, allt uppbackat av ett åtagande att tillhandahålla kundservice i toppklass.
• Agentroll: Resortchefen fältar kundklagomål, hanterar anställdas scheman och säkerställer att alla processer löper smidigt.

Att köra detta kommando skapar en agentSpec.yaml-fil i DX-projektets specifikationskatalog. Filen innehåller den information som tillhandahålls tillsammans med en lista över AI-skapade ämnen som innehåller namn och beskrivning för varje ämne. Granska och redigera filen efter behov för att förfina agentens kapacitet.

På samma sätt använder Python SDK-implementeringen interaktiv specifikationssamling för att automatiskt skapa agentämnen med rätt omfattningsfält som krävs för SDK-kompatibilitet.
Dessutom kommer det att skapa en fullständig JSON-fil för agentspecifikationen som kommer att användas för att skapa en agent i Fas 2.

Utvecklingsfasen fokuserar på att konstruera agentens kärnkomponenter: resonemangsmotorn, verktygen den kan använda och dess Knowledge base. Agentforce abstraherar mycket av komplexiteten, vilket låter utvecklare fokusera på affärslogik.

Denna sektion delar två prokodmetoder för Agentforces utvecklingsfas. För det första att använda Agentforce DX och för det andra att använda Python.

Agentforce DX: Skapa en agent från en specifikation

När filen agentSpec.yaml är färdig, skapa agenten i din Salesforce-organisation. Kör detta kommando för att skapa agenten och synkronisera dess associerade metadata tillbaka till ditt lokala DX-projekt:

Acceptera standard-API-namnet Resort_Manager när du ombes. Kommandot tolkar specifikationen, skapar agenten och hämtar metadata. Metadata innehåller en Bot, BotVersion och ett GenAiPlannerBundle, som lägger till AI-intelligens och referenser till agentens ämnen och åtgärder.

Förhandsgranska agentens struktur innan du skapar den genom att lägga till flaggan --preview för att skapa en lokal JSON-fil som beskriver vilken typ av agent LLM kommer att skapa, inklusive föreslagna åtgärder. Exempel:

Mer information finns i Skapa en agent från ditt DX-projekt från Trailhead.

Agentforce Python SDK: Definiera specifika verktyg

Agent SDK underlättar agenttester genom att skapa låtsasåtgärder. Dessa låtsasåtgärder måste så småningom ersättas med riktiga åtgärder inom Salesforce. Salesforce erbjuder en rad olika plattformsfunktioner, inklusive flöden, Apex, uppmaningsmallar och API:n, som alla kan kapslas in som Agentforce.

Här är ett falskt åtgärdskodstycke för att illustrera hur en Agentforce kan se ut.

Genomförandet etablerar anslutningen till Salesforce, skapar agentinstansen och definierar egna verktyg och åtgärder som agenten kan använda för att interagera med externa system och utföra specifika verksamhetsfunktioner.

Som vi har diskuterat ovan är det mer komplicerat att testa en agent än traditionella programvarutester. Det kräver validering av beteende, resonemang och robusthet över olika scenarion. Detta inkluderar enhetstester för individuella verktyg, end-to-end-tester för konversationer och kontradiktoriska tester för att hitta sårbarheter.

Agentforce DX tillhandahåller ett arbetsflöde på hög nivå för att skapa, distribuera och köra tester utöver Testing Center och Direct Testing API. Denna sektion visar hur du utför tester med Agentforce DX.

Agentforce DX: Kör ett agenttest

Använd Agentforce DX för att köra fördefinierade agenttester direkt från kommandoraden. Detta är idealiskt för att integrera agenttester i moderna DevOps-processer.

Agentforce Python SDK: Simulera E2E och kontradiktoriska tester

Python SDK tillåter skriptade konversationer för att simulera end-to-end-test (E2E) och validera agentresonemang.

Agentforce Python SDK med Salesforce Testing API

Python SDK-implementeringen använder omfattande tester med Salesforce Testing API och AiEvaluationDefinition-metadata, vilket skapar strukturerade testfall med förväntningar på ämnessekvenser, åtgärdssekvenser, strängmatchning och kvalitetsmått. Systemet skapar XML-metadatadefinitioner som kan distribueras till Salesforce för automatiserade agenttester och valideringar.

När agenten har validerats distribueras den till en produktionsmiljö. Under denna fas är Agentforce DX avgörande för att hjälpa till att hantera och flytta agenters metadata mellan olika organisationer (till exempel sandboxar och produktion). Agentdistribueringar skapar en ny version av agenten och agenten går inte live förrän du uttryckligen aktiverar den. Detta ger dig full kontroll över när du ska släppa den nya versionen av agenten.

Agentforce DX: Distribuera agentmetadata

Projektstrukturen för Salesforce DX organiserar agentmetadata under tvångsappkatalogen. Använd standardkommandon för sf-projektdistribuering för att distribuera en agent och dess associerade tester till en målorganisation.

När en agent har skapats eller distribuerats kan du öppna den direkt i Agentforce Builders användargränssnitt för att bekräfta dess konfiguration genom att köra:

När du har validerat att agenten är distribuerad kan du aktivera den. Om du stöter på några oväntade problem, gå tillbaka till den tidigare arbetsversionen av agenten.

Agentforce Python SDK: Distribuera agentdistribuering

Implementeringen tar den validerade agentspecifikationen och distribuerar den till Salesforce-organisationen, vilket gör agenten tillgänglig för användning. Distributionsprocessen inkluderar agentskapande, metadatasynkronisering och verifiering av framgångsrik distribution.

ADLC är en kontinuerlig cykel; distribuering är inte slutet. Agenter är levande system som kräver ständig övervakning för att följa mått som latens, kostnader och framgångsresultat. Insikterna från övervakning används för att finjustera och förbättra agenters prestanda genom snabb teknik, verktygsoptimering och förfina Knowledge.

Agentforces plattform tillhandahåller omfattande instrumentpaneler och analyser för att stödja denna avgörande fas, vilket säkerställer att agenter fortsätter att utvecklas och förbättras över tid.

Agentforce Analytics

Agentforce Analytics finns i mappen Agentforce (standard) och använder Data 360 för att ge insikter i agenters prestanda. Den anpassningsbara instrumentpanelen och rapporterna erbjuder data om användning, feedback och användning, vilket hjälper dig förfina ämnen och åtgärder för att förbättra användarnöjdheten. Du kan fördjupa dig i resultaten genom att klicka på diagram eller länkade rapporter. För att anpassa, klona befintliga rapporter och ändra klonerna för att undvika att störa analysprocesser.

Yttrandeanalys

Yttrandeanalys visar hur Agentforce (standard) använder agenter, vad de begär och om agenten kunde hantera dessa begäranden. Dessa anpassningsbara rapporter kan hjälpa dig förfina dina ämnen och åtgärder så att dina agenter svarar mer effektivt och korrekt.

Agentforce Python SDK: Övervaka med Data 360-integreringar

Agent SDK-implementeringen använder avancerad övervakning och analys med Data 360 Python-anslutare, etablerar anslutning till Salesforce Data 360, frågar agenters prestandamått och skapar omfattande övervakningsinstrumentpaneler.
Systemet följer svarstider, framgångsresultat, användarnöjdhet och kostnadsmått för att ge användbara insikter för agentoptimering.

Agentforce DX: Agentövervakning

Implementeringen använder standardkommandon för AFDX med CLI-baserad agenthantering, vilket håller agenten uppdaterad med plattformsändringar och införlivar användarfeedback för kontinuerlig förbättring.

Hänvisa GitHub-arkivet här för ADLC-implementering med Agent SDK och AFDX.

Att bemästra agentutvecklingslivscykeln kräver att följa en uppsättning kärnprinciper som säkerställer effektivitet, pålitlighet och strategisk anpassning. Följande riktlinjer sammanfattar de viktigaste lärdomarna från varje fas i ADLC till ett strategiskt ramverk för arkitekter och utvecklare.

1. Planera och idéer

Denna inledande fas fokuserar på att anpassa agentens syfte till verksamhetsmålen och säkerställa att det vilar på en solid grund.

• Prioritera för verksamhetspåverkan: Börja med att mappa potentiella användningsfall direkt till strategiska verksamhetsmål. Använd en prioriteringsmatris för att betygsätta deras potentiella påverkan och börja med ett enskilt, fokuserat användningsfall med tydliga nyckeltal.
• Involvera intressenter tidigt: Samla insikter om smärtpunkter och säkerställ anpassning.
• Utnyttja datainsikter: En agent är bara så bra som dess data. Använd Data 360 för att utforska tillgängliga strukturerade och ostrukturerade data för att informera agentens sammanhang och kapacitet. Granska befintliga rapporter och instrumentpaneler för att identifiera aktuella trender som kan ligga till grund för ditt val av användningsfall.
• Använd ramverk för idéer: Tillämpa strukturerade idémetoder för att brainstorma och förfina potentiella tillämpningar, som designtänkande eller SWOT-analys.

2. Byggagenter

Denna fas täcker de rekommenderade metoderna för att konstruera en högpresterande och effektiv agent.

• Undvik för många ämnen: Begränsa antalet ämnen för att minska risken för att skapa liknande eller överlappande ämnen som kan förvirra agenten.
• Håll instruktioner och uppmaningar koncisa: Använd direkt, enkelt språk och ge exempel på yttranden för att guida agenten effektivt.
• Leveragevariabler och deterministiska åtgärder: Använd dessa verktyg för att guida agentens beteende och optimera dess prestanda för mer förutsägbara resultat.
• Håll åtgärdsresultaten små och koncisa: Se till att agentens svar är korta och rakt på sak. Längre utdata använder mer sammanhang och är långsammare att skapa.
• Optimera åtgärder för hastighet: Utforma flöden och Apex klasser för att returnera minimalt med data som behövs. Sikta på att ha färre åtgärder som behövs för att skapa ett svar genom förbearbetning där så är möjligt.
• Definiera ett tydligt omfång: Skriv korrekta beskrivningar, instruktioner och omfattning för åtgärder för att förhindra agenten från att anropa RAG (hämtningsutökat skapande) för frågor utanför omfattningen.
• Använd hybridsökning sparsamt: Använd endast hybridsökning om det är absolut nödvändigt, eftersom det kan påverka latensen negativt.

3. Testa, övervaka och finjustera

Denna iterativa fas är avgörande för att förfina agentens precision och prestanda.

• Upprätta ett testflöde: Följ en konsekvent testcykel:
  1. Kör batchtest: Utför en omfattande uppsättning tester.
  2. Visa betyg/fel: Analysera prestandamåtten och identifiera fel.
  3. Inspektionsfel: Undersök varje felrad för att förstå avvikelsen.
  4. Uppdatera agent: Gör nödvändiga justeringar av agenten eller dess utvärderingsdata.
• Granska information om sessionsspårning: Använd datamodellen för sessionsspårning och Agentforce Interaction Explorer för att utföra analys av grundorsaken när problem eller oväntade beteenden identifieras. Finjustera din agent baserat på informationen och fortsätt upprepa din agent.

Agentutvecklingslivscykeln representerar en viktig utveckling av traditionella principer för programvaruutveckling, utformade för en tid med intelligenta, autonoma system.

• Utveckling, inte ersättning: Agentutvecklingslivscykel utökar och förbättrar traditionell hantering av programlivscykel utan att ersätta den.
• Data som en förstklassig medborgare: Data spelar en mycket mer dynamisk och central roll i agentutveckling.
• Specialiserade verktyg och färdigheter: Kräver nya verktyg och en bredare uppsättning specialiserade kompetenser inom datavetenskap, ML-teknik och agentutveckling.
• Kontinuerligt lärande: Agentutveckling lägger till kontinuerlig inlärning och anpassning av själva systemet.
• Framtida påverkan: Agentisk AI lovar att ytterligare automatisera och optimera komplexa IT-operationer och programutvecklingsflöden.