For years we have used artificial intelligence assistants with a fairly uncomfortable limitation: every conversation starts almost from scratch.

The model may be excellent at reasoning, programming, or writing, but if an hour ago you were debugging an application, reading documentation, and switching between several tools, you normally have to reconstruct all of that context manually.

With Computer History, OpenAI is beginning to attack exactly that problem.

The feature, announced for the ChatGPT app on macOS, allows ChatGPT and Codex to use context from applications and websites selected by the user. OpenAI describes it as a way to continue work without having to explain every detail again.

That may sound like a memory improvement. In reality, it points to something much larger: turning operating-system activity into usable context for an agent.

Computer History turns selected desktop activity into context for ChatGPT and Codex.

What exactly is Computer History?

Computer History is an optional feature in the ChatGPT app for macOS.

According to OpenAI’s official notes published on August 13, 2026, it can record interaction events from applications and websites the user chooses to include. ChatGPT and Codex can later query that history to better understand what the person was doing and resume a task with less explanation.

The idea can be summarized like this:

activity on the Mac
        ↓
Computer History
        ↓
retrievable context
        ↓
ChatGPT / Codex
        ↓
continue work

The difference from a conventional history is important.

It is not only about remembering which conversations you had inside ChatGPT. The system begins to have context about activity performed outside the chat.

From a user-experience perspective, that opens the door to questions such as:

  • “What was I doing before I left?”
  • “Which document was I reviewing this morning?”
  • “Continue from where I left this task.”
  • “Summarize what I worked on during the last hour.”

That kind of interaction changes the relationship between user and assistant. The human stops being solely responsible for reconstructing session state.

The important part: it does not work like Windows Recall

One of the first inevitable questions is what information it actually captures.

OpenAI specifies that Computer History records interaction events, but not screenshots, screen recordings, microphone input, or system audio. Private browsing is not included either.

The feature is also disabled by default. The user can:

  • opt in;
  • select which applications and sites participate;
  • pause it;
  • inspect items in the timeline;
  • delete stored items.

On Business and Enterprise plans, the administrator must allow the feature before each member can enable it.

Computer History records selected events, but OpenAI says it does not store screenshots or audio.

This distinction matters because persistent context can be extremely useful, but also extremely sensitive.

The better an assistant remembers our activity, the more important it becomes to have clear controls over what enters that memory, how long it remains, and who can use it.

The real novelty: the desktop becomes context

Until now, the dominant mental model was simple:

user
  ↓
prompt
  ↓
model
  ↓
response

Computer History adds another layer:

previous activity
      ↓
contextual memory
      ↓
current prompt
      ↓
model
      ↓
response or action

The difference looks small on paper, but it is enormous for agents.

A useful agent should not require the user to constantly redescribe the world in which they are working. It needs a representation of the current state and recent state.

In software development we see this all the time. To continue a task, knowing the broad objective is not enough. It also matters:

  • which repository was open;
  • which file was modified;
  • what error appeared;
  • what documentation was consulted;
  • what decision was made ten minutes ago;
  • which steps have already been executed.

Computer History begins to provide a continuity layer between those interactions.

From memory to resident agent

Memory by itself does not turn ChatGPT into a resident operating-system agent.

But combined with other capabilities, a fairly clear architecture begins to emerge.

We can divide it into four layers:

  1. Memory: Computer History preserves context from selected activity.
  2. Reasoning: ChatGPT and Codex interpret that context and decide what to do.
  3. Action: computer-use capabilities allow interaction with interfaces and tools.
  4. Integrations: files, plugins, browser, and external services expand what the agent can execute.

A conceptual resident-agent architecture: memory, reasoning, action, and tools.

Conceptually:

Computer History
      ↓
   memory
      +
ChatGPT / Codex
      ↓
 reasoning
      +
Computer Use
      ↓
    action
      +
plugins / Work / files / browser
      ↓
 tools

That combination gets much closer to the idea of a persistent personal agent than to a traditional chatbot.

The important leap is not “remembering,” but “continuing”

The word history can make Computer History sound like a passive feature.

But the real value appears when that memory feeds a later action.

Imagine a work session:

09:00  you open a repository
09:15  you read an issue
09:30  you review documentation
10:00  you modify a function
10:20  an error appears
10:30  you leave the desk

Hours later you return and say:

“Continue with the problem I was solving.”

A traditional chatbot needs a lengthy explanation.

An agent with historical context could retrieve enough signals to reconstruct part of the situation and dramatically reduce re-entry cost.

That has especially strong implications for long tasks: programming, research, financial analysis, documentation, technical support, or any work spanning several applications.

The evolution of Codex fits this direction perfectly

Codex is already evolving from the “generate this code snippet” paradigm toward longer delegated tasks.

In that kind of workflow, model quality remains important, but it stops being the only bottleneck.

You also need:

  • state memory;
  • tools;
  • action capabilities;
  • resume mechanisms;
  • environment observation;
  • well-defined permissions.

That is why Computer History is interesting even if it does not generate a single line of code.

It is contextual infrastructure.

And contextual infrastructure is exactly what an agent needs to work for longer without continually asking the user to retell the story.

From “AI assistant” to “AI operating layer”

Here a more ambitious possibility appears.

Traditional operating systems organize processes, files, windows, devices, and permissions. An AI layer sitting above the system can begin to organize something different: human intentions, tasks, and context.

Instead of thinking only in terms of independent applications:

editor
browser
terminal
email
messaging

we can imagine a layer that understands a cross-application task:

"publish this version"
        ↓
read the issue
        ↓
review the code
        ↓
run tests
        ↓
open the PR
        ↓
check CI
        ↓
notify the team

The task is one thing even though it crosses six applications.

That is one of the fundamental changes promised by agents: the unit of work stops being the application and starts being the goal.

Computer History helps preserve the thread connecting those applications.

The hard problem will be control

The more continuity an agent has, the more useful it can become.

But the importance of control also increases.

A truly persistent system will need clear answers to questions such as:

What does it remember?
What can it see?
What can it execute?
What requires approval?
What can it do automatically?
What information must it forget?

In that sense, making Computer History opt-in and allowing users to choose sources is an important design decision.

The race for agents will not only be a competition for autonomy. It will also be a competition to build governable autonomy.

The most capable agent will not necessarily be the one that can do the most without asking. It may end up being the one that best understands when to act, when to ask permission, and what context it should not retain.

So why does this feature matter so much?

Because it addresses one of the historical weaknesses of AI assistants: discontinuity.

A model can have a million tokens of context and still be clumsy if the user has to manually provide the right information every time.

Computer History moves part of that work into the system itself.

The evolution could look like this:

Chatbot
  ↓
Assistant with memory
  ↓
Assistant with tools
  ↓
Agent with desktop context
  ↓
Persistent goal-oriented agent

We are not yet on the last step.

But the direction is difficult to ignore.

The underlying idea

During the first stage of generative AI, we asked:

“What can this model answer?”

Then we moved to:

“What tools can it use?”

The next question seems to be:

“How much does it understand about what I am doing without me having to explain it again?”

Computer History is a small piece of that transition, but it touches a fundamental layer: continuity between the human, the model, and the work environment.

If that trend continues, ChatGPT will stop feeling like an application we visit to ask questions and will increasingly resemble an intelligent layer that accompanies work across the operating system.

And that is where the idea of an AI-native desktop stops sounding like a futuristic interface and starts looking like a concrete architecture.

Sources