ChatGPT’s Computer History tracks your clicks and keystrokes

OpenAI shipped a keylogger and called it a feature. Computer History arrives in the ChatGPT macOS app as an opt-in toggle that records every click, every keystroke, every application switch, and spins them into a timeline the model can query. The company frames it as productivity: ask ChatGPT what document you edited last, whether you shared it on Slack, how you spent your morning. The demo video shows Dominik Kundel getting a clean recap of his workflow. What the video doesn't show is the architecture required to make that recap possible.

The system ingests "events." Not screenshots, not audio, not video — OpenAI stresses this distinction repeatedly, as though the absence of pixels makes the ingestion benign. But an event stream that captures every window focus, every text selection, every command invoked is a higher-fidelity behavioral fingerprint than a screenshot taken every five seconds. Screenshots are noisy. Event streams are structured. They parse. They index. They train.

Microsoft's Recall captured screenshots and the backlash was immediate. OpenAI watched that debacle and built something quieter. No images. No video. Just a structured log of human-computer interaction that feeds directly into the model context window. The opt-in default is better than Microsoft's opt-out disaster. The per-app exclusion list is better than nothing. The automatic incognito blind spot is a concession to norms. But the underlying proposition is identical: your local activity is too valuable to leave on device.

Ari Weinstein's X post emphasizes control. Delete entries. Exclude apps. The product team knows the privacy playbook. They also know that defaults win. Most users will toggle it on once, forget it exists, and generate months of training signal before they think to audit the log. The half-finished task recovery — "picking up tasks you left half done" — is the hook. The dataset is the asset.

Codex integration makes the calculus explicit. Computer History isn't just a ChatGPT memory feature. It's a shared substrate for any agent that needs to know how you work. The timeline becomes a legible API for your habits. That legibility is what makes it valuable to OpenAI. A model that knows your editor, your terminal aliases, your Slack channels, your browser tab patterns doesn't need to guess context. It has context. Context is the scarcest resource in agent workflows.

The privacy policy language will say the data stays local unless you share it. The technical reality is that the feature's utility depends on sending context to the model. You cannot ask ChatGPT to summarize your morning without the timeline leaving your machine. The moment you invoke the assistant, the log becomes prompt. Prompt becomes training signal. The loop closes.

Apple's sandbox makes this possible. macOS accessibility APIs — the same ones that power screen readers and automation tools — expose the event stream OpenAI harvests. Apple permits this because the APIs are legitimate. OpenAI uses them because they're there. The user sits between two platforms that both benefit from deeper instrumentation. Neither has incentive to restrict the flow.

Windows Recall failed because it looked like surveillance. Computer History succeeds because it looks like search. The interface is a chat box. The mental model is conversation. The user asks, the assistant answers. The fact that the answer required a persistent structured log of every input event fades into implementation detail. That is the design achievement. The surveillance wears a conversational UI.

Organizations will adopt this faster than individuals. Engineering managers already instrument CI pipelines, ticket transitions, deploy frequencies. Computer History extends that visibility to the developer's local loop — editor, terminal, browser, review tool. The manager who can query "how did the team spend Tuesday" gets a new lever. The developer who opts in gets autocomplete that knows their muscle memory. The trade looks rational on both sides. The aggregate effect is a workspace where uninstrumented time becomes suspicious.

OpenAI's competitors cannot easily replicate this. Google has the OS but not the desktop agent. Microsoft has the OS but burned trust on Recall. Anthropic has the model but no distribution on macOS. OpenAI sits at the intersection of a popular desktop app, a flagship model, and a coding agent that benefits from local context. The moat is distribution, not technology.

The feature will expand. Window titles become document references. File paths become repository context. Terminal commands become skill embeddings. The event schema will grow richer because richer events make better agents. Each expansion shifts the opt-in calculus: the feature becomes more useful, the log becomes more comprehensive, the exit becomes more costly. The ratchet turns one click at a time.

Users who value local-only computing have a narrowing window. The macOS app works fine with Computer History off. Today. The roadmap implies the best capabilities will require it on. The industry pattern is clear: optional telemetry becomes mandatory utility becomes platform default. OpenAI will follow the pattern because the incentives are structural, not malicious.

The honest framing would be: we built a structured keylogger that feeds your behavior to our models so they can simulate your workflow. The marketing framing is: rediscover your work, pick up where you left off, automate the boring parts. Both are true. The second sells. The first explains why the product exists.

If you enableIf you enable Computer History, you are not just turning on a search feature. You are authorizing a persistent behavioral feed that makes your local workflow legible to a model trained on everyone else's workflows. The exchange is asymmetric: you get convenience, OpenAI gets structured signal about how developers actually work — not how they answer surveys, not how they behave in curated benchmarks, but the raw, messy, tool-switching, tab-hoarding, half-typed reality of daily engineering.

That signal compounds across the user base. A model that has seen ten thousand developers navigate the same legacy codebase, the same flaky test suite, the same deployment checklist develops a prior that no amount of public GitHub data provides. Public repos show intent. Event streams show friction. Friction is where products improve and where models learn to anticipate.

The incognito exemption reveals the threat model. OpenAI knows private tabs contain credentials, medical searches, financial data, the entire taxonomy of human shame. They built a carve-out because they had to. But the carve-out proves the rule: everything else is fair game. Your Jira tickets. Your Notion pages. Your local README edits. Your terminal history that accidentally captured an API key. The event stream does not distinguish sensitive from routine. It distinguishes excluded from included.

Deletion is retrospective. You can scrub the log after the fact, but the context window that already consumed last Tuesday's session cannot be un-consumed. The model's response to your prompt today was conditioned on the timeline you might delete tomorrow. The causal arrow points one direction.

This is not a critique of malice. It is a description of incentives. OpenAI builds the best agent it can. The best agent needs the richest context. The richest context is your complete local history. The product team will keep smoothing the on-ramp — better defaults, clearer toggles, friendlier language — because friction reduces adoption and reduced adoption reduces signal. The logic is inexorable.

The only stable equilibrium is user-side tooling that intercepts the event stream before it leaves the machine. Local-first agents that answer "what did I do this morning" without uploading the log. Apple could ship this in Shortcuts. The open-source community could build it on the same accessibility APIs. But the convenience of the integrated path is a gravity well. Most will not escape it.

Computer History is a well-executed feature that solves a real problem by constructing a surveillance substrate that the company cannot afford to discard. The opt-in is genuine. The controls are real. The trajectory is fixed. Enable it with eyes open, or keep it off and accept a dumber assistant. There is no third option that preserves both the convenience and the boundary. The industry has not built it yet.