Självförbättrande skills

Så lär sig Perplexity Brain återkommande procedurer av erfarenhet och håller dem uppdaterade.

FörfattarePerplexity Engineering

Introduktion

Användare har arbetsflödesspecifika preferenser och krav som en allmän modell inte kan känna till i förväg. En agent behöver lära sig dessa detaljer för att anpassa sitt arbete efter användaren, i stället för att användaren ska behöva förklara samma procedur eller göra samma korrigeringar i varje session. Kontinuerligt lärande gör detta möjligt: erfarenheter från slutförda uppgifter bör påverka hur agenten tar sig an framtida arbete.

Brain, Computers personanpassade system för självförbättring, möjliggör lärande genom erfarenhet. Det underhåller redan en strukturerad kunskapswiki som kopplar samman information om användaren och användarens arbete med underlaget som stöder den. Bakgrundsagenter uppdaterar wikin i takt med att ny information samlas in, så att minnessystemet förbättras över tid.

Agent Skills är ytterligare ett sätt att styra agenters beteende utan att ändra den underliggande modellen. Skills är återanvändbara instruktioner som vägleder en agent genom specifika uppgifter. De fångar krav och stödresurser för återkommande arbetsflöden som agenten annars skulle behöva härleda från minnet eller få från användaren varje gång, vilket förbättrar prestandan i uppgifter utanför träningsfördelningen. De kan också innehålla skript för repetitiva procedurer eller bearbetning som tillförlitligt kan uttryckas i kod, så att agenten helt enkelt kan köra skripten när de är tillämpliga. Tillgängliga Skills görs upptäckbara av harnessen, som laddar deras instruktioner till kontexten när agenten begär dem. Användare kan också direkt ange vilka Skills som ska användas i prompten.

Vi utökar Brain så att det automatiskt kan skapa och uppdatera Agent Skills. Brain bygger vidare på en användares minne och sessionshistorik för att skriva och förfina personliga Skills som fångar procedurer för användarens arbetsflöden. Vi tillämpar ett liknande tillvägagångssätt för att uppdatera inbyggda Skills, som är tillgängliga för alla Perplexity-användare, baserat på aggregerade mönster i alla sessioner.

En agent kombinerar allmän förmåga med utvald uppgiftskontext och personlig erfarenhet. Den underliggande modellen använder arbetskontexten för att välja vad som ska ske härnäst, och kontexten förändras allteftersom uppgiften fortskrider. Brain tillhandahåller minne och personliga skills och använder sedan utvalt sessionsunderlag för senare uppdateringar, med förbehåll för kontroller och auktorisering. Personaliseringen ändrar kontext och instruktioner, inte modellvikter. Källor väljs ut efter behov och laddas inte alla på en gång; den här konceptuella vyn förenklar uppdateringsmekanismerna.

Vi beskriver först vår självförbättringsmotor som delas av alla typer av Skills och förklarar hur den fungerar för personliga och inbyggda Skills.

Delad motor för självförbättring

En användbar Skill behöver fortfarande förändras när nya preferenser uppstår eller när erfarenheten avslöjar luckor i dess instruktioner. Brain ansvarar för att upptäcka hur agentens beteende bör förändras nästa gång Computer stöter på en liknande uppgift och för att avgöra hur Skillen bör ändras för att bättre uppnå det önskade resultatet.

Den här förbättringsprocessen bildar en loop med fyra steg:

  1. Underlag. Brain hittar tidigare sessioner där Skillen användes, särskilt sådana där den inte räckte till.
  2. Reflektion. En förbättringsagent studerar underlaget och föreslår uppdateringar av Skillen.
  3. Verifiering. Kontroller bekräftar att förslaget är korrekt utformat och sannolikt kommer att förbättra resultaten.
  4. Aktivering. Den verifierade ändringen tillämpas. Framtida sessioner använder den nya versionen och ger underlag för nästa omgång.
Brain väljer ut tidigare sessioner där skillen användes, särskilt de där den inte räckte till. En förbättringsagent föreslår en uppdatering, och kontroller bedömer om den är korrekt utformad och sannolikt förbättrar resultaten. När den nya versionen har tillämpats används den i framtida sessioner och ger underlag för nästa omgång.

Den här loopen bygger på många befintliga funktioner som har byggts för Computer och Brain. Här beskriver vi den delade mekanik som möjliggör underlag och reflektion. Procedurerna för verifiering och aktivering beror på om en ändring når en enda användare eller alla Perplexity-användare, så vi går igenom dem i de följande avsnitten om förbättringslooparna för personliga och inbyggda Skills.

Underlag från tidigare sessioner

Reflektion kräver att man hittar sessioner där en Skill användes, särskilt sådana där det finns utrymme för förbättring. I Computer registrerar harnessen signaler som gör detta möjligt. När agenten laddar en Skill registrerar harnessen en Skill-laddningshändelse som kopplar Skillen till sessionen. När agenten märker frustration hos användaren, trasigt beteende eller tydlig ineffektivitet lämnar agenten en kort, strukturerad diagnostik, och harnessen bifogar de Skills som används. Dessa är särskilt användbara för inbyggda Skills, där vilken session som helst potentiellt kan vara relevant, så systemet behöver ett sätt att snabbt avgränsa underlaget.

Agenter har nytta av att få tillgång till hela historiken i stället för att göra en bedömning utifrån resultatet eller en kort sammanfattning. Computer lagrar tidigare sessioner med leverantörsoberoende representationer av trajektorier som fångar meddelanden, verktygsanrop, resonemang och resultat. Vi har också byggt en uppsättning kommandoradsverktyg som agenter kan använda för att avkoda dessa trajektorier och rekonstruera hela sessioner. Det gör det möjligt för reflektionsagenten att granska specifika Skill-laddningar och verktygsanrop och identifiera exakt var problem uppstod eller var förbättringar kunde göras.

bash
# Decode a stored trajectory into structured messages, # including tool calls, their arguments, and their results. python3 deserialize_trajectory.py \ --convo-path session/convo.pb.lz4 \ --jsonl -o session.jsonl # Identify which skills the agent loaded and how often. python3 list_skills_used.py session.jsonl # Read one turn in detail, including its tool calls and results. python3 deserialize_trajectory.py \ --convo-path session/convo.pb.lz4 \ --turn 3 -o turn-3.md # Recover earlier steps preserved before a context compaction. python3 deserialize_trajectory.py \ --convo-path session/compactions/001/original_convo.pb.lz4 \ --jsonl -o earlier-history.jsonl

Exempel på användning av de interna verktygen i Computer för granskning av trajektorier. Sökvägar och identifierare är förenklade i illustrationssyfte; kommandonamn och argument följer implementeringen.

Reflektion med bakgrundsagenter

Brain använder ett team av bakgrundsagenter för att kontinuerligt optimera upplevelsen för varje användare. Till exempel granskar Dream-agenter samlad erfarenhet för att uppdatera kunskapswikin. På liknande sätt drivs Skill-förbättringen av förbättringsagenter som reflekterar över underlag om Skill-användning för att föreslå uppdateringar.

Varje agent arbetar i sin egen sandlåda med en frontiermodell, relevant underlag och det aktuella Skill-biblioteket, vägledd av tillägg och Skills. Den bestämmer vilka sessioner den ska läsa, drar en konkret lärdom från var och en och grupperar lärdomar som kräver samma återanvändbara beteende. Eftersom en åtgärd för ett fel kan motsäga en annan instruktion eller skapa extra arbete på annat håll läser den hela Skillen innan den föreslår en ändring, och avstår när underlaget inte stöder någon.

Förbättringsagenter körs på samma harness som Computer. Vi gjorde harnessen modulär, så att en ny agentapplikation kan återanvända dess mekanik för resonemang, verktygsanvändning och kontexthantering och samtidigt definiera sina egna instruktioner och funktioner via tillägg. En dedikerad flotta av bakgrundsarbetare gör att vi kan skala den här bearbetningen oberoende av förgrundsuppgifter.

Den interaktiva agenten och förbättringsagenten i bakgrunden körs på samma Computer-harness. Förbättringsagenten använder sessionsunderlag och aktuella skills för att föreslå en ändring eller avstå. Ett förslag måste klara kontroller som är specifika för skill-typen innan en ny version blir tillgänglig för framtida sessioner.

Förbättringsloopen för personliga Skills

Vi beskriver först hur den delade självförbättringsmotorn tillämpas på den personliga förbättringsloopen, som omvandlar en användares uppgiftshistorik till nya eller uppdaterade personliga Skills. Figuren nedan följer ett exempel på en Skill genom hela loopen och slutar med den reviderade versionen.

Loopen för personliga Skills går från sessionsunderlag via en förbättringsagent, kontroller av förslag och aktivering. Nuvarande Skills informerar också förbättringsagenten; aktiverade ändringar blir tillgängliga för framtida sessioner.

Under en daglig genereringskörning granskar förbättringsagenten användarens senaste sessioner för att avgöra vilka ändringar som är värda att göra. En uppsättning nyliga sessioner förladdas i sandlådan tillsammans med data om Skill-användning; resten av användarens sessionshistorik kan hämtas vid behov. Förbättringsagenten får också katalogen över befintliga Skills. Den har inte åtkomst till internet eller andra anslutningar.

Tillägg och Skills som är utformade för arbetsflödet för förbättring av personliga Skills vägleder reflektionsprocessen och utgår från våra principer för vad som kännetecknar en bra uppdatering. Agenten analyserar först hela trajektorier för att identifiera en konkret lärdom i varje session. Därefter jämför den lärdomarna med de befintliga instruktionerna och avgör om den ska uppdatera en Skill, skapa en ny eller inte göra någon ändring. För att skapa en Skill krävs två oberoende förekomster av samma återanvändbara beteende, medan en uppdatering av en befintlig Skill kan motiveras med en enda väl underbyggd förekomst.

Agenten ändrar inte Skillen direkt. I stället tar den fram ett förslag som dokumenterar de avsedda ändringarna samt resonemanget och underlaget bakom dem. Uppdateringarna är begränsade till en ändring per Skill och körning. Deterministiska kontroller verifierar att förslagen är korrekt utformade och kan tillämpas på Skillen. Separat granskar en LLM-bedömare ett urval av förslagen och kontrollerar om underlaget stöder ändringen och om den resulterande Skillen ger användbara instruktioner.

Aktivering omvandlar ett verifierat förslag till en ändring i användarens Skill-bibliotek, så att den nya versionen kan laddas och användas i framtida sessioner. Eftersom harnessen laddar ett index över alla tillgängliga Skills i början av varje session kan ett stort bibliotek av Skills belasta kontextfönstret och göra det svårare för agenten att hitta och ladda relevanta Skills. Därför behåller systemet bara de mest värdefulla Skills och fasar ut Skills som inte behövs, för att hålla biblioteket litet och kurerat. Mer specifikt tillämpar vi en gräns på 10 automatiskt skapade Skills per användare. När gränsen är nådd kan förbättringsagenten fortfarande uppdatera eller ta bort Skills, men för att lägga till en ny Skill måste den fasa ut en befintlig Skill och motivera varför den nya Skillen är mer användbar för användarens arbete.

Förbättringsloopen för inbyggda Skills

Vi utvidgar också Brains ramverk för kontinuerlig Skill-förbättring till inbyggda Skills. I stället för att använda en användares minne och sessionshistorik för att förbättra den användarens personliga Skills använder den inbyggda loopen underlag från många användare för att förbättra de Skills som är tillgängliga för alla Perplexity-användare. Eftersom inbyggda Skills kan användas av vem som helst är ribban för ändringar högt satt; uppdateringar som oavsiktligt försämrar prestandan kan påverka tusentals sessioner. Den inbyggda förbättringsagenten ändrar endast kandidatversioner av Skills. För att nå den kanoniska versionen av Skillen måste uppdateringarna passera parvis omkörning och intern mänsklig granskning. Återigen följer vi hela loopen med ett exempel på en Skill och tillhörande underlag.

Misslyckade sessioner ger en grundorsak och undanhållna felscenarier. Förbättringsagenten använder grundorsaken och felfria exempel för att föreslå en revision; scenarierna visas aldrig för den. Parvis omkörning jämför nuvarande och reviderade Skills i samma tester, och lyckade kandidater går vidare till mänsklig granskning före godkännande och sammanslagning.

Den inbyggda förbättringsloopen använder sanerat underlag från sessioner som får användas för träning. Diagnostik och felsignaler används för att välja ut relevant underlag, tillsammans med kontrollsessioner där Skillen användes utan att några flaggor uppstod. En saneringspipeline tar bort inloggningsuppgifter och andra hemligheter, liksom bifogade filer och media.

En agent för scenariogenerering omvandlar sanerat underlag till konkreta felscenarier. Den behåller bara den kontext som krävs för att förstå felfallet och förbättra Skillen; resten av sessionen återskapas syntetiskt, vilket ger ett fristående test för verifieringsprocessen. Scenarierna måste kunna köras utan anslutna appar eller inloggning; om den ursprungliga uppgiften var beroende av en anslutning ersätts dessa indata med syntetiska filer i scenariot. En separat kontroll verifierar att Skillen misslyckas i det genererade scenariot.

Reflektionen sker genom ett veckovist revisionsjobb som omvandlar observerade fel till åtgärder. Jobbet letar efter Skill-fel som återkommer i flera sessioner, så att en enskild dålig session inte leder till en ändring. Varje återkommande fel får en separat körning av förbättringsagenten. Agenten får en beskrivning av grundorsaken tillsammans med sanerade data från lyckade sessioner. Den använder detta underlag för att skriva en kandidatrevision av Skillen. Den får inte de fullständiga felscenarierna, eftersom de används i utvärderingen.

Ett separat omkörningsjobb använder de genererade scenarierna för att jämföra den ursprungliga och den reviderade versionen av Skillen. En LLM-bedömare utvärderar en agents svar och trajektorier mot varje scenarios bedömningsmall. För att ett förslag ska godkännas måste varje testscenario klaras med den reviderade Skillen, och minst ett måste misslyckas med den ursprungliga. Scenarier som byggts från kontrollsessionerna körs också om för att bekräfta att ingenting har slutat fungera. För felscenarierna kontrollerar bedömaren också att just det specifika felet inträffade, i stället för att behandla en misslyckad uppgift som belägg för samma problem.

I arbetsflödet paketeras kandidatändringarna och utvärderingsresultaten i en pull request för intern mänsklig granskning. Ändringarna träder bara i kraft om en ingenjör godkänner PR:en.

Utvärderingar

Automatisk Skill-förbättring har avsevärt ökat skapandet och användningen av Skills. Brain skrev över 80 000 personliga Skills för över 20 000 användare mellan den 1 augusti och den 14 november. Dessutom tillämpades mer än 100 000 automatiska uppdateringar på över 30 000 befintliga personliga Skills mellan den 4 september och den 14 november.

Dessa Skills spänner över ett brett spektrum av områden och uppgifter, från att verifiera programvara till att stämma av löner och utforma figurer. Vi kategoriserade Skills som genererats av Brain utifrån de arbetsflöden de beskriver. Även det största området, programvaruutveckling, stod för endast 11 % av alla Skills; därefter följer forskning och genomgångar (10,1 %), försäljning och drift (9,9 %) samt finans och investeringar (9,9 %).

Bland de 64 230 personliga Skills som skapades automatiskt mellan den 1 augusti och den 4 november stod programvaruutveckling för den största andelen (11,0 %), följt av forskning och genomgångar (10,1 %). De tio områden som visas står för 80,3 % av alla Skills i urvalet.

Vi genomförde ett åtta veckor långt randomiserat test på produktionstrafik och jämförde användare som hade automatisk förbättring av personliga Skills aktiverad med en kontrollgrupp där funktionen var inaktiverad. 72,9 % av personerna med Skill-förbättring aktiverad fick minst en ny personlig Skill, medan endast 6,5 % av personerna utan funktionen manuellt lade till en ny Skill. Mer än hälften av behandlingsgruppen (53 %) hade en personlig Skill laddad i en konversation de startade, jämfört med 13 % i kontrollgruppen; i deras samtalsturer laddades en personlig Skill ungefär 3,6 gånger så ofta. Bland kunder som fick en Skill skriven av Brain använde 63 % en sådan igen i en senare konversation inom fyra veckor.

I ett åtta veckor långt randomiserat produktionstest fick 72,9 % av användarna med automatisk skill-förbättring aktiverad minst en ny personlig skill, jämfört med 6,5 % i kontrollgruppen. En personlig skill laddades i en konversation som användaren själv startat för 53 % av den aktiverade gruppen och 13 % av kontrollgruppen.

Våra utvärderingar syftar till att fastställa hur dessa nya och uppdaterade Skills påverkar uppgiftsutförandet och den övergripande prestandan.

Resultat från samma randomiserade experiment visar en minskning av misslyckade verktygsanrop och användarmissnöje. För användare med automatisk Skill-förbättring minskade andelen misslyckade verktygsanrop med 11 % i all aktivitet i Computer. Om man exkluderar systemets egna bakgrundskörningar misslyckades verktygsanrop fortfarande omkring 7 % mer sällan, vilket tyder på att tillförlitligheten förbättrades i användarnas arbete. Användarmissnöjet, mätt som antalet trådar med medelhögt eller högt missnöje per användare, minskade med 7,6 %. Vi såg ingen mätbar förändring i kostnad eller svarstid. Dessa tidiga tester visar lovande resultat, och vi förväntar oss att förbättringarna ökar över tid i takt med att vi förfinar systemet och lanserar självförbättrande Skills för fler användare.

Offlineexperiment har också visat förbättringar i mer avgränsade miljöer. I ett experiment med SkillLearnBench använde Computer tidigare uppgiftstrajektorier för att skapa en personlig Skill för var och en av nio uppgiftsfamiljer. Över 16 parade utvärderingsinstanser ökade andelen lyckade uppgifter från 43,8 % utan Skills till 62,5 % med genererade Skills, vilket ger belägg för att Skills som härleds från tidigare erfarenhet kan förbättra prestandan i återkommande uppgifter. I en fallstudie med inbyggda Skills ledde ändringar i en Skill för e-handel till 6 % högre kvalitet till 32 % lägre kostnad, där kvaliteten mättes av en automatiserad bedömare.

Slutsats

Självförbättrande Skills ger Computer ytterligare ett sätt att lära sig av det arbete den utför. De utökar Brain så att det kan skapa och underhålla procedurminne, vilket förbättrar prestandan i komplexa arbetsflöden. Automatisk Skill-förbättring har redan ökat användningen av Skills, minskat andelen misslyckade verktygsanrop och sänkt användarmissnöjet.

Förbättring av personliga Skills är nu tillgänglig för alla Max-prenumeranter i USA. Funktionen är aktiverad som standard för berättigade användare men kan stängas av. Fliken Tillägg visar tillgängliga Skills, anger vilka som har skapats av Brain och låter användarna välja vilka Skills som ska vara aktiverade.

Härnäst utökar vi förbättringen till fler klasser av Skills, inklusive Skills som skapats av användare, Skills som delas inom projekt och organisationens Skills. Vi kommer att fortsätta förfina förbättringspipelinen och dess utvärderingar så att revisionerna leder till mer tillförlitliga procedurer och bättre resultat.

Citering

BibTeX
@online{perplexity2026SelfImprovingSkills,
  author = {{Perplexity} and Nicholas Bien and Se Won Jang and Kate Jung and Nikila Venkat and Jarrod Bryan and Claire Beamer and Jeremy Yang},
  title = {{Self-improving skills}},
  date = {2026-11-18},
  url = {https://www.perplexity.ai/hub/blog/self-improving-skills}
}