Perplexity Launches Brain, a Self-Improving Memory System That Builds a Context Graph of an Agent’s Work and Learns Overnight

Most of the AI’s memory remembers the user. It stores your preferences, tastes and role. Confusion takes a different path. Today, the confusion has been unleashed brain,a self-improving memory system for its agent product, Computer. The brain is not focused on remembering you. He remembers what the agent did. This reframes the purpose of memory in artificial intelligence.

What is it Confusionbrain

The brain is a self-improving memory system. It builds a contextual graph of the work performed by the computer. At specific time intervals, such as at night, Brain reviews this chart. Then he teaches himself how to do the work better. The idea is clear and straightforward. The more work you do, the more efficient your brain becomes at making your computer. Brain is rolling out today to Perplexity Max and Enterprise Max subscribers in Research Preview.

Two axes of artificial intelligence memory

Confusion frames memory throughout Two axes. the Firstly It is what memory is about. the second It is what memory is for.

Traditionally, AI memory has been about the user. It stores preferences, tastes, work styles, contacts and role. Its purpose is to share. It helps you feel more engaged with the agent. The brain takes the other path. Her memory revolves around the agent’s work. It remembers what worked, what failed, and what corrections were made. Its purpose is performance. Confusion calls for helping the agent optimize the most important object in memory.

How does a context graph work?

The brain forms a live context graph for the computer. The chart can be traced. It helps the computer understand the user’s world and learn from their work. The context layer takes the form of an LLM wiki. This wiki is automatically loaded into proxy sandbox. Its pages reflect ideas, people, projects, and other elements in the user’s world. The computer can traverse this personal information network.

The Brain system updates the wiki incrementally overnight. It collects user sessions, connector results, changes to source documents, and corrections made. This refreshed context gives the computer a stronger signal about what to do and where to look.

The brain also shows its work. Each entry in memory is associated with the session, file, or source from which it came. Traceability is important for error correction and trust.

Recursive self-improvement

The brain improves as you use the computer. Agents learn which projects, connectors, elements, and other sources lead to the best results. They also learn from their mistakes. They remember when the user makes a correction. They remember when the source was a dead end. This results in fewer cycles, fewer model calls, and better output. This feedback loop is what makes the brain continually improve itself. The Perplexity team frames current token use as an investment in more efficient token use later.

Performance numbers

Perplexity shared early measurement results from its own tests.

Perplexity also suggests that results improve the more a person uses their brain. Agents learn the user’s world over time. These are early first-party numbers.

Use cases with examples

Where does working memory help? Consider three concrete cases.

• The data scientist performs a weekly pipeline audit. The brain remembers reliable sources and past corrections. The next audit starts from a better map. Fewer dead ends follow.
• The support team sorts tickets through conductors. Brain learns which sources have solved previous tickets. It routes future tickets faster.
• The developer debugs via repositories. The brain remembers which files were important last time. The computer gets to the root cause through fewer form calls.

In each case, the rescue comes from history. An agent never learns the same context twice.

Conceptual implementation

Perplexity has not published the Brain API. However, the model is easy to design. The stand-alone Python below is illustrative and not Perplexity code. It runs on its own and prints day 1: needs review then day 2: correct.

# 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 basic step is synthesize. This is where overnight self-improvement happens.

Try it: Interactive demo

The embeddable demo below simulates the loop. Run tasks to grow the context graph. Register a correction to mark a dead end. Then turn on Brain Sync overnight. The correction rate and recall are higher, and the cost is lower, compared to the numbers reported by Perplexity. It shows the concept, not the product.