Perplexity がエージェントの作業文脈グラフを構築し夜間に学習する自己改善型メモリシステム「Brain」を発表

Most AI memory remembers the user. It stores your preferences, your tastes, and your role. Perplexity is taking a different path. Today, Perplexity launched Brain, a self-improving memory system for its agent product, Computer. Brain does not focus on remembering you. It remembers what the agent did. That reframes what memory in AI is for.

What is Perplexity‘s Brain

Brain is a self-improving memory system. It builds a context graph of the work Computer performs. At set intervals, such as overnight, Brain reviews that graph. It then teaches itself how to do the work better. The idea is straightforward. The more work you do, the more efficient Brain makes your Computer. Brain is rolling out today to Perplexity Max and Enterprise Max subscribers in Research Preview.

Two Axes of AI Memory

Perplexity frames memory along two axes. The first is what the memory is about. The second is what the memory is for.

Traditionally, AI memory has been about the user. It stores preferences, tastes, working styles, contacts, and role. Its purpose is engagement. It helps you feel more engaged with the agent. Brain takes the other path. Its memory is about the agent’s work. It remembers what worked, what failed, and what corrections got made. Its purpose is performance. Perplexity calls helping the agent get better the most important purpose of memory.

DimensionTraditional user memoryBrain (work memory)

What it is aboutThe userThe agent’s work

What it remembersPreferences, tastes, working styles, contacts, roleWhat the agent did, what worked, what failed, corrections

What it is forFeeling more engaged with the agentHelping the agent get better at the job

What it producesA profile of the userA traceable context graph of the work

How the Context Graph Works

Brain forms a living context graph for Computer. The graph is traceable. It helps Computer understand the user’s world and learn from their work. The context layer takes the form of an LLM wiki. That wiki is automatically loaded onto the agent sandbox. Its pages reflect the ideas, people, projects, and other elements in a user’s world. Computer can traverse this web of personal information.

The Brain system updates the wiki incrementally overnight. It synthesizes the user’s sessions, connector results, changes in source documents, and corrections made. That refreshing context gives Computer a stronger signal on what to do and where to look.

Brain also shows its work. Every memory entry links back to the session, file, or source it came from. That traceability matters for debugging and trust.

Recursive Self-Improvement

Brain gets better as you use Computer. Agents learn the projects, connectors, artifacts, and other sources that lead to the best outputs. They also learn from their mistakes. They remember when a user has made a correction. They remember when a source was a dead end. That results in fewer turns, fewer model calls, and better outputs. This feedback loop is what makes Brain continuously self-improving. Perplexity team frames current token usage as an investment in more efficient token usage later.

The Performance Numbers

Perplexity shared early measurement results from its own testing.

MetricReported changeCondition

Answer correctness+25%On tasks Computer has seen before

Recall+16%Same early results

Cost−13%On tasks that require historical context

Perplexity also states results improve the longer someone uses Brain. The agents learn the user’s world over time. These are early, first-party numbers.

Use Cases With Examples

Where does work memory help? Consider three concrete cases.

A data scientist runs a weekly pipeline audit. Brain remembers the reliable sources and the past corrections. The next audit starts from a better map. Fewer dead ends follow.

A support team triages tickets through connectors. Brain learns which sources resolved past tickets. It routes future tickets faster.

A developer debugs across repositories. Brain remembers which files mattered last time. Computer reaches the root cause with fewer model calls.

In each case, the saving comes from history. The agent does not relearn the same context twice.

A Conceptual Implementation

Perplexity has not published a Brain API. The pattern, however, is easy to model. The self-contained Python below is illustrative, not Perplexity’s code. It runs on its own and prints day 1: needs review then day 2: correct.

Copy CodeCopiedUse a different Browser

Illustrative, self-contained model of Brain's loop — NOT Perplexity's API.

class ContextGraph:

def __init__(self):

self.entries = [] # every logged item keeps a source link

self.lessons = {} # task -> reusable lesson learned overnight

self.pending = [] # corrections waiting for the next sync

def retrieve(self, task):

return self.lessons.get(task) # load relevant memory

def log(self, task, result, source):

self.entries.append((task, result, source))

def log_correction(self, task, fix, source):

self.entries.append((task, "correction", source))

self.pending.append((task, fix)) # learn from a dead end

def synthesize(self): # the overnight step

for task, fix in self.pending:

self.lessons[task] = fix # teach itself to improve

self.pending = []

def agent_execute(task, lesson):

# with a learned lesson, the agent avoids the known dead end

return "correct" if lesson else "needs review"

brain = ContextGraph()

Day 1: no memory yet, so the task needs review

lesson = brain.retrieve("debug repo")

print("day 1:", agent_execute("debug repo", lesson))

brain.log_correction("debug repo", "ignore cached build", source="file:notes.md")

brain.synthesize() # overnight Brain sync

Day 2: same task, now informed by memory

lesson = brain.retrieve("debug repo")

print("day 2:", agent_execute("debug repo", lesson))

The key step is synthesize. That is where the overnight self-improvement happens.

Try It: Interactive Demo

The embeddable demo below simulates the loop. Run tasks to grow the context graph. Log a correction to mark a dead end. Then trigger an overnight Brain sync. Correctness and recall climb, and cost falls, toward Perplexity’s reported figures. It illustrates the concept and is not the product.

(function(){

window.addEventListener('message', function(e){

if(e && e.data && e.data.brainDemoHeight){

var f = document.getElementById('brain-demo-frame');

if(f){ f.style.height = e.data.brainDemoHeight + 'px'; }

}

});

})();

Strengths and Open Questions

Strengths

Memory about work, not just the user, targets agent performance directly.

The context graph is traceable, so every entry links to its source.

Overnight synthesis turns past sessions into a better starting point.

Reported changes in correctness, recall, and cost are concrete.

Open questions

The numbers are first-party and early; no independent benchmark exists yet.

Brain is limited to Max and Enterprise Max in Research Preview.

Overnight updates mean improvements arrive on a schedule, not instantly.

Persisting work history in a context graph raises data governance questions.

Check out the Project page and Technical details. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.

Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us

The post Perplexity Launches Brain, a Self-Improving Memory System That Builds a Context Graph of an Agent’s Work and Learns Overnight appeared first on MarkTechPost.