On November 18, Perplexity said its Brain system can create and update agent skills from Computer sessions. A skill is a reusable package of procedural instructions that changes the agent’s working context, not the model’s weights. The company says Brain looks for recurring work, studies prior successful and failed sessions, proposes a targeted revision and checks the result before activating it. The release describes two different governance paths. Personal skills are generated and updated for an individual, with automatic activation for eligible US Max subscribers. Built-in skills use aggregate evidence and require paired replay tests plus internal engineer approval before a revision is shared. Perplexity’s self-improving skills report
That separation is more than a product detail. A personal preference can be useful even if it fits only one person’s working style. A shared instruction can affect thousands of users and therefore needs stronger evidence that an improvement does not break other cases. Perplexity’s announcement is notable because it describes not just an agent writing instructions, but a system for proposing, validating and deploying those instructions at different scopes. Its own results are encouraging, but they measure adoption and selected task outcomes inside Perplexity’s product, not a universal improvement in agent capability.
A skill is procedural memory, not a new model#
Brain already maintains a structured knowledge wiki connecting information about a user and their work to supporting evidence. The new capability adds another form of memory. A skill captures how to carry out a recurring procedure, including relevant requirements and supporting resources. For example, a personal workflow may need a specific report order, a company’s approved source hierarchy or a set of fields to include in a project update. The skill can carry those instructions into a future Computer task instead of asking the user to repeat them each time. The model itself remains the same; the context it receives changes. Perplexity on Brain and personal skills
This distinction affects how to judge the claim. When a system learns from use by changing model weights, the change is difficult for an individual user to inspect or reverse. A procedural skill is a more visible artifact. It can be read, revised, enabled or removed, depending on the product’s controls. Perplexity describes personal skills as instructions in the user’s library and says the Plugins tab identifies those authored by Brain. The change is therefore closer to maintaining a reusable playbook than retraining a model after every task.
The skill is also not a transcript of everything the user has done. Brain’s improvement agents select session evidence related to a skill, look for a concrete reusable lesson and compare it with current instructions. They can abstain when the evidence does not justify a change. Perplexity says creating a new personal skill requires the same reusable behavior to appear independently twice, while one well-grounded occurrence may justify changing an existing skill. Updates are limited to one change per skill per run. These thresholds are design choices intended to avoid turning a one-off correction into a general rule. Perplexity’s account of the personal-skill pipeline
There is a practical benefit to writing down a procedure instead of relying on conversational memory. A memory might say that a user prefers short updates, while a skill can say which sources to inspect, which calculations to perform and how to verify an output. Skills can also include scripts for deterministic repetitive processing. That can make recurring work more predictable. It can also create a stale instruction if the user’s role, preference or toolset changes. The question is not simply whether a skill persists, but whether the system notices when its evidence has expired or conflicts with a newer instruction.
The improvement loop starts with session evidence#
Perplexity describes a four-stage loop. Brain finds previous sessions in which a skill was used, especially cases where it fell short. An improvement agent studies selected evidence and proposes a revision. Checks determine whether the proposal is well-formed and likely to improve results. The verified version is then activated for future sessions, whose outcomes provide new evidence. This structure makes skill writing part of a continuing procedure rather than a one-time prompt-generation step. Each stage introduces its own failure mode: missed evidence, mistaken diagnosis, a weak test or an update that performs poorly after deployment. Perplexity’s four-stage improvement process
The system records which skills were loaded in a session and can attach concise diagnoses when the agent detects user frustration, defective behavior or clear inefficiency. Improvement agents run in isolated environments with selected evidence and the current skill library. Perplexity says they can inspect trajectories, including messages, tool calls, arguments and results, rather than judging from an outcome label alone. This can make a diagnosis more specific. A task can fail because the agent used the wrong tool, because the tool returned incomplete data or because the instruction omitted a needed validation. Those failures call for different skill changes.
The system’s ability to inspect full trajectories comes with a data boundary. For personal skills, the improvement agent uses a user’s memory and session history; that is how it learns the procedures relevant to that individual. For shared built-in skills, Perplexity says it uses evidence from many sessions after sanitization. A separate channel removes credentials and other secrets, as well as attached files and media. The report says selected session data can be reconstructed synthetically for verification, and the improvement agent does not receive the full failure scenarios used in tests. These descriptions are important, but users evaluating the feature should still understand the product’s data controls and eligibility settings. Perplexity on evidence selection and sanitization
Reflection is designed to produce a proposal, not directly overwrite a skill. The proposal records the intended change, reasoning and supporting evidence. Deterministic checks confirm the change is well-formed and applicable. A separate language-model judge audits a sample of proposals for whether evidence supports the change and the revised instruction is useful. Restricting each run to one change per skill makes review and rollback more focused. It also means the system may need several rounds to correct a broad weakness, which is preferable to bundling many untested assumptions into one edit.
Evidence selection itself is a product decision. If Brain sees only the most recent sessions, it may miss an older but still important preference. If it uses too much history, irrelevant circumstances may dominate. A failure diagnostic can be mistaken, and a successful session may have succeeded by chance. Requiring two independent examples for new personal skills reduces one-off overfitting, but does not prove that the procedure transfers to a different task. For updates, one occurrence can suffice when it is well grounded, which is more responsive but places weight on how the system judges evidence quality.
Personal skills have a different approval threshold#
Personal skill improvement is available to eligible US Max subscribers and is on by default, according to Perplexity. Users can turn it off. The Plugins tab lists available skills, identifies Brain-authored ones and lets a user choose which are enabled. The report also says the system caps automatically created personal skills at ten per user. At capacity it can update or retire an existing skill, but must justify why a new skill is more valuable before replacing one. This cap responds to a practical retrieval problem: an overly large skill library can consume context and make relevant instructions harder for an agent to find. Perplexity on availability and personal-skill controls
The cap also shapes the kind of learning that can persist. A personal assistant may encounter many one-off tasks but only a few recurring workflows. A small curated library encourages it to retain procedures likely to be reused rather than every correction. Retirement, however, can remove something a user still values but has not used recently. The system’s evidence should therefore consider frequency, usefulness and user intent, not just recent activity. A visible list and a disable control give the user some agency, though the quality of the replacement and the clarity of its explanation still matter.
Perplexity says new personal skills need two independent appearances of the same reusable behavior, while an update to an existing skill can use one well-supported case. This asymmetry is reasonable: there is a higher bar for adding new context than for correcting a known procedure. But “independent” depends on how sessions are clustered. Two retries of the same task may not count as separate evidence, while two related tasks could provide better transfer evidence. The report explains the threshold, but does not describe every operational rule used to decide independence.
The feature’s default-on status matters because the product is learning from task history without a separate manual skill-authoring step. A user who does not want that behavior must use the opt-out control. The announcement says Brain uses session history and memory to derive personal procedures. It also says users can disable automatic improvement. A clear product interface should help users see which instructions were created, what evidence supported a change, when it was applied and how to reverse it. Perplexity says the Plugins tab identifies Brain-authored skills, providing one such entry point.
These procedures can affect work more directly than a preference memory. A skill might add a review step, change a report’s structure or decide which tool to call first. If it improves a repeated workflow, it can save repeated instructions. If it misreads a correction, it can repeatedly propagate a mistake. The difference depends on the skill’s scope and test coverage. A narrowly stated procedure with an explicit trigger is easier to audit than a broad instruction such as “handle this better.” The mechanism should preserve the conditions under which a lesson was learned, not promote every local fix into a global rule for that user.
Shared skills require replay and a human decision#
Built-in skills are different because one revision can affect many Perplexity users. The company says an improvement agent proposes candidate changes based on aggregate patterns, but the candidate does not immediately become canonical. Failure scenarios are created from sanitized evidence, and the improvement agent receives root-cause descriptions and clean-session records rather than the full failure cases. A separate replay job compares old and revised skills on the same scenarios. This separation is intended to reduce the chance that the improvement agent simply memorizes the evaluation examples. Perplexity on shared-skill governance
The proposed shared-skill update must pass every test scenario under the revised version, while at least one scenario must fail under the original. Control scenarios from sessions without a reported issue are replayed too, to detect regressions. A judge also checks that a failure scenario reproduces the specific failure rather than just any unsuccessful task. The change and test results are packaged as a pull request for internal human review. Perplexity says the revision goes live only after an engineer approves that PR. This is a stronger gate than the personal-skill path and reflects the wider blast radius of a built-in instruction.
Paired replay is a useful control because both versions receive the same scenario. It reduces noise from different prompts, tool outputs or task conditions and can reveal whether the change fixed the target case. The acceptance rule does not prove the skill will perform better on every untested workflow. All known failure cases passing and at least one prior failure being reproduced is evidence of targeted repair, not a universal guarantee. The control scenarios help catch regressions, but their coverage depends on how representative the sampled sessions are.
Human approval adds a further decision point. A reviewer can inspect the proposed diff, evidence and replay results before a shared procedure affects users. That process can catch cases where an automated judge rewards an awkward or overly narrow instruction. It also creates review work and may limit how quickly updates ship. Perplexity’s report says built-in changes require an engineer’s approval, whereas personal skills can activate automatically after checks. Keeping these paths distinct helps explain why “self-improving” does not mean every generated instruction immediately changes the shared product.
The evidence used for shared skills is also treated differently from personal evidence. Perplexity says shared updates use sessions eligible for training, sanitized to remove credentials, secrets, attachments and media. Failure scenarios are reduced to necessary context and may replace connector-dependent inputs with synthetic files so they can run without logged-in applications. This enables replay while reducing exposure of original session content. The report describes the process at a high level. It does not imply that every possible sensitive detail is automatically harmless; data eligibility, sanitization and reviewer access remain important parts of the system design.
The reported results are promising and product-specific#
Perplexity reports that Brain wrote more than 80,000 personal skills for over 20,000 users between August 1 and November 14. It also says more than 100,000 automatic updates were applied to over 30,000 existing personal skills from September 4 to November 14. The company’s category breakdown says software engineering accounted for 11% of skills, followed by research and briefings at 10.1%, sales and operations at 9.9%, and finance and investing at 9.9%. These are rollout and distribution figures. They show breadth of use, not whether the skills improved a task or remained correct over time. Perplexity’s usage and category figures
The company reports an eight-week randomized production experiment comparing users with personal-skill improvement enabled to a control group where automatic improvement was disabled. In the treatment group, 72.9% received at least one new personal skill, versus 6.5% of the control group manually adding one. A skill was loaded into a user-started conversation for 53% of treatment users and 13% of controls; turns in treatment loaded personal skills about 3.6 times more often. Among customers who received a Brain-authored skill, 63% reused one in a later conversation within four weeks. These figures measure adoption and reuse under the experiment’s product conditions, not task success by themselves.
Perplexity further reports that tool-call failures fell 11% across all Computer activity for users with automatic skill improvement enabled. Excluding the system’s own background runs, tool calls still failed about 7% less. User dissatisfaction, measured as threads with medium or high dissatisfaction per user, fell 7.6%. The company observed no measurable change in cost or response time. This is more directly connected to user outcomes than skill counts, but it remains a company-run experiment. The report’s summary does not provide all details needed to assess effect sizes, confidence intervals, subgroup variation or which workflows drove the gains.
Offline results are narrower. In a SkillLearnBench experiment, Computer used prior task trajectories to create a personal skill for each of nine task families. Across 16 paired evaluation instances, task success increased from 43.8% without skills to 62.5% with generated skills. This supports the idea that experience-derived instructions can help on repeated tasks. The small number of paired instances and the selected task families limit how far the result can be generalized. A gain on a repeated workflow does not by itself show that an automatically generated procedure transfers to different users, tools or task types. Perplexity’s SkillLearnBench results
For a built-in ecommerce skill, Perplexity says revisions produced a 6% quality increase at 32% lower cost, with quality scored by an automated judge. The example suggests a procedure can improve both output and efficiency. It is one case study; it should not be blended into the randomized production result or presented as an average across built-in skills. The approval pipeline for shared skills is a separate safeguard, and the public report does not provide a broad aggregate of production outcomes after engineer approval.
Independent benchmarks frame what remains unknown#
Research on procedural memory and skills provides context, not a direct test of Perplexity Brain. SkillsBench, a benchmark paper with a current inventory of 87 tasks across eight domains, reports a matched evaluation of curated skills against no-skill baselines across 18 model-harness configurations. Its average pass rate rose from 33.9% to 50.5% with curated skills, a 16.6 percentage-point gain. The paper also reports that focused bundles of at most three modules outperform larger or exhaustive bundles. This supports evaluating whether skills help, but the benchmark studies curated skills and does not validate Perplexity’s automatic generation pipeline. SkillsBench paper
The AFTER benchmark examines how procedural memory transfers across tasks, roles and model backbones. It contains 382 enterprise tasks across six roles and 22 skills. The authors report a 3.7-to-6.7-point gain after one refinement round and 73.1% cross-model test accuracy for skills evolved from diverse multi-model traces. They also find that some skills generalize while others become role-specific and lose effectiveness under transfer. This reinforces why reuse should be tested beyond the session that created a skill. The study evaluates its own framework and dataset, not Perplexity’s Brain. AFTER paper
Together, these studies suggest a useful evaluation shape: compare with and without a skill on matched tasks, hold out related tasks to test transfer, test across different models and roles, and track regressions as instructions evolve. A system that performs better on the exact interaction from which a skill was derived may have memorized a local correction. A skill that helps on held-out work is stronger evidence of reusable procedure. A skill that works only with one model or tool configuration may still be valuable, but its scope should be explicit.
Skill evolution also creates a balance between adaptation and forgetting. A new instruction can capture a preference that recurs across work, but old and new sessions may conflict. A procedure helpful for one project may be harmful in another. A skill library can become too large to retrieve from reliably, which is why Perplexity sets a cap on automatically created personal skills. The next evaluation question is whether the system can decide when to merge, specialize, retire or disable procedures without losing knowledge a user still depends on.
There is also a distinction between procedural learning and model learning. Perplexity says these changes modify the agent’s context and instructions, not underlying model weights. This makes updates more inspectable and reversible than a weight change, while keeping the base model’s general abilities intact. It also means the benefit depends on retrieval: the right skill must be selected and loaded for the task. A procedure not retrieved at the right time cannot help; an irrelevant one can consume context or steer the agent away from the user’s actual intent.
What would make skill updates trustworthy#
The first requirement is traceability. A user should be able to see which skill changed, the instruction before and after, the evidence category that motivated it and the date the new version became active. The product describes a Plugins view that identifies Brain-authored skills and lets users enable or disable them. A clear history of revisions would make troubleshooting easier when a workflow changes unexpectedly. It would also let a user distinguish a new preference from an old instruction that no longer applies.
The second is evaluation that separates development from testing. Failure cases should not be visible to the agent proposing a shared update, and the revised instruction should be tested on both the target failures and known-good controls. Personal skills can be evaluated with held-out related tasks, not just the original repeated workflow. Across both paths, the system should track whether changes reduce failures without creating new ones, and whether improvements persist after weeks of use.
The third is clear handling of data and scope. Users need to know whether their sessions can inform personal skill creation, whether any content contributes to shared instructions, and how sensitive material is removed. Shared skill updates require different protections than private procedures because they affect many accounts. Perplexity describes separate evidence pools and human review for built-in skills. Those distinctions should remain visible in the product settings and documentation rather than being collapsed into a single “learning” switch.
The fourth is a measured opt-out and recovery path. Automatic updates are on by default for eligible US Max subscribers, according to the announcement, but can be disabled. A user should be able to turn off future learning without losing access to existing skills, inspect and remove an unwanted procedure, and restore a prior version if a change causes a regression. These controls make automatic personalization compatible with work where procedures are sensitive, regulated or stable by design.
Finally, performance should be reported in units tied to useful work. Skill counts and loads measure adoption. Tool-call failures and dissatisfaction are closer to user outcomes. Task success on matched and held-out tasks measures whether a procedure generalizes. Cost and response time indicate operational trade-offs. Perplexity’s initial results cover several of these dimensions, but the experiments have different scopes and should not be pooled into a single headline score. The next evidence should show how benefits vary by task type, user cohort and skill version.
A learning loop with two levels of control#
Perplexity’s Brain update offers a concrete design for agents that turn experience into reusable procedures. For personal skills, a background system can adapt one user’s repeated workflow, with a small library, evidence thresholds and controls in the product. For built-in skills, aggregated evidence leads to a candidate change that must pass paired replay and human approval. The separation reflects a real difference in the consequences of a local instruction and a shared one.
The reported rollout shows that users generate and reuse skills, while the randomized experiment reports lower tool failure and dissatisfaction without a measurable increase in cost or response time. The task benchmark and offline skill test offer additional evidence, but neither establishes universal reliability. Independent research on procedural memory similarly finds that skills can help while transfer varies across tasks, roles and models. An automatically written skill is therefore best treated as a procedure with evidence, scope and a version, not as a permanent truth about how work should be done.
The result worth following is whether the loop continues to improve repeated workflows without making the instruction library harder to inspect or control. If future reports show held-out task gains, visible regression rates and clear user control over versions and data, they will answer more than how many skills Brain wrote. They will show whether an agent can learn procedures that remain useful after the original correction, user and task have changed.