Your Personal Computer Now Has a State

The unfinished project of personal computing, reopened by AI

Over the last year, I have been working with several AI agents on the same computer. They do not experience the same computer. A coding agent sees one repository and its own session. Another sees a browser, a collection of documents, or whatever I happened to upload. A third may remember conversations from an account, but not what changed on disk after those conversations ended. Each has a reasonable partial view. I remain the process that joins those views together.

This becomes obvious whenever I open a new session and ask an agent to continue some work. It may find the repository. It may search old conversations. It may even recover a document that explains the project. But continuing correctly can depend on a more complicated combination: which branch is live, which draft is current, which argument I rejected, what a test revealed after the last conversation, whether an old decision was reversed, which source is authoritative, and what I am actually trying to do today.

All of that information exists somewhere. Finding it is not the whole problem.

An old plan and a new plan may be equally searchable. A persuasive document may have been superseded by an unpolished note written three days later. A chat message may claim that some code was implemented, while the repository shows that it never was. A preference stated six months ago may still be true, or it may describe a habit I am actively trying to change. Search can return the evidence. It does not automatically tell the next machine what the evidence currently permits it to believe or do.

I first treated this as a memory problem. That led to the usual set of ideas: longer context windows, embeddings, summaries, graphs, Markdown files, retrieval policies, and agents that periodically consolidate what happened. All of these can help. But the memory framing kept pushing me toward the archive: how do we store more, and how do we retrieve the relevant parts later?

The practical question was different. What state is this work in now?

That is what I mean by the title. Computers have always had state. Operating systems have process state; applications have state; filesystems have state; distributed systems spend a remarkable amount of engineering effort deciding which state is current. I am using the word at another level: the evolving state of the human-computer system.

This includes the projects, commitments, artifacts, decisions, permissions, uncertainties and open questions that determine what should happen next. It includes what has become stale, what remains disputed, and what should not be inferred at all. It is not the complete history of the person, and it is certainly not the person. It is a maintained, limited account of the world that a machine must enter if it is going to help without making the user reconstruct that world again.

Parts of this state already exist in every application and service we use. The calendar has one part. Git has another. Email, browser history, cloud documents, social networks and AI assistants each maintain their own version. Platforms also maintain private user models built from our activity. What is missing is not state in the general sense. What is missing is a coherent, inspectable and user-governed state that can outlive any one application or model.

Personal computing was a larger idea

Once I started looking at the problem this way, the older writing on personal computing became much more interesting.

Vannevar Bush's memex is often reduced to a prediction of hyperlinks. The more important part of As We May Think was the idea that a person could develop a continuing relationship with a body of knowledge: building trails, returning to them, extending them, and passing them to others. The machine was not only a library. It preserved something about the path a person had taken through the library. (UCI Bren School of ICS)

J. C. R. Licklider was interested in an even closer relationship. In Man-Computer Symbiosis, the computer was supposed to help with "formulative thinking": deciding what the problem was, exploring it interactively, and preparing the ground for human judgment. Licklider had tried recording how he spent his own technical working time and estimated that about 85 percent of it went into getting into a position to think—finding information, transforming it, comparing incompatible representations and preparing material for a decision. His complaint feels unusually current. Much of my time with agents is still spent getting the machine into a position where it can help. (MIT CSAIL)

Douglas Engelbart enlarged the object further. His augmentation system was not just a clever interface. It included the person, language, artifacts, methods and learned practices through which work was carried out. A change to a tool could change the available processes; those processes could then change the language and organization of the work. The relevant capability belonged to the combined system rather than to the machine in isolation. (Doug Engelbart Institute)

Alan Kay and Adele Goldberg described the personal computer as a dynamic medium. Mark Weiser later imagined computation distributed through the environment, moving between the center and periphery of attention rather than remaining inside one conspicuous desktop machine. Licklider and Robert Taylor also saw the networked computer as a communication medium in which people could work through shared, malleable representations. These projects were not one uniform movement, and they did not agree on every social or technical question. But they treated computing as a relationship that could change how people thought, communicated and organized activity—not merely as the delivery of finished applications. (DBLP)

We inherited a surprising amount from that period: graphical interfaces, interactive documents, networked communication, personal devices and software that ordinary people can operate. But the dominant application model narrowed the ambition. Most software arrives as a finished service with a predefined data model and a small set of sanctioned operations. The user supplies information to the application and learns its workflow. Meaningful changes to the tool remain the responsibility of the company that produced it.

The internet then made the computer much larger than the device. My practical personal computer now includes a laptop, a phone, browsers, accounts, remote servers, search engines, messages, calendars, files, feeds, models and other people's machines. Some parts are local, many are not. It is an environment assembled around one person, but controlled by many institutions.

This is why I do not think personal computing can now be recovered by making a more private laptop or a better desktop operating system. Local ownership matters, but the object is distributed. The question is how a person maintains agency and continuity while moving through a networked field of machines that observe, predict and increasingly act.

The internet became part of the cognitive system

I sometimes call the internet an exocortex, but the term can hide as much as it reveals. It suggests one coherent extension attached to one mind. The actual internet is a contested information environment made from public resources, private services, communities, protocols, commercial objectives and the activity of billions of other people.

Still, something cognitively important happened when information became reliably available through the network. In experiments published in 2011, Betsy Sparrow, Jenny Liu and Daniel Wegner found that people expecting future access to information were less likely to remember the information itself and more likely to remember where it could be found. The study did not show that the internet simply makes memory worse. It showed that people reorganize memory around the external resources they expect to remain available. (PubMed)

The broader cognitive-offloading literature studies this as a general human strategy. People use reminders, physical arrangements, written marks, devices and environmental structure to reduce the internal demands of a task. Whether or not one accepts the stronger philosophical claim that these resources become literal parts of the mind, they clearly become parts of the working cognitive system. Remove the calendar, search engine, notebook or navigation system and the person must reorganize how the task is performed. (UCL Discovery)

This relationship is not one-way. We shape the information environment, and the information environment changes the problems we encounter and the actions available to us. Search changes what we bother to memorize. Maps change how we navigate. Writing tools change how we compose. Feeds change which events, arguments and people become salient. None of this requires a theory in which users are helpless and algorithms are omnipotent. A small change in what is easy to find or easy to express can be consequential when it recurs every day.

Recommendation systems make the feedback structure easier to see. A system observes behaviour, builds a model, selects what the person sees, and then treats the resulting behaviour as new evidence about the person. The researchers behind How Algorithmic Confounding in Recommendation Systems Increases Homogeneity and Decreases Utility demonstrated in simulation that training on behaviour already shaped by recommendations can homogenize subsequent behaviour without producing a corresponding increase in utility. The theory of performative prediction describes the more general case: a prediction can affect the outcome it is intended to predict, thereby changing the future data distribution. (Brandon M. Stewart)

This does not mean adaptive systems are inherently manipulative. A useful tutor, search engine or assistant must learn from what happens. The issue is that the objective of the system participates in the loop. An engagement objective produces one information environment. A learning objective produces another. A model optimized for conversion may interpret behaviour differently from a model trying to protect a budget or help someone finish a research project.

There is also a basic ambiguity in behavioural data. What I clicked is evidence that I clicked. It may be weaker evidence that I liked what I saw, and weaker still that I want more of it. Repeated behaviour may reveal a stable preference, an external constraint, a temporary obsession, an experiment, or a habit I would prefer to stop. A model that treats all observed regularity as identity will eventually make the past more difficult to leave.

The older internet already had this problem, but AI makes it harder to ignore.

When the model can act

A recommender mainly changes the information presented to a person. A generative system can also participate in what the person sends back into the world.

This begins with small interventions. A study of predictive text found that positively or negatively skewed writing suggestions changed the sentiment of the restaurant reviews people produced. In a later experiment involving 1,506 participants, an opinionated language-model writing assistant changed the views expressed in participants' writing and also shifted their answers on a subsequent attitude survey. These are bounded studies in particular settings, not evidence that an AI writing tool permanently determines a person's beliefs. They do establish that generated language can enter the feedback loop between thought, expression and later self-report. (Harvard SEAS)

Personalization adds another dimension. Across four studies containing seven sub-studies and 1,788 participants, researchers found that messages generated to match psychological characteristics were more influential than non-personalized messages across several tested domains. Again, the responsible conclusion is not that any sufficiently personalized model can control anyone. It is that producing individually adapted persuasive language has become cheap enough to be a normal system capability rather than a specialized campaign operation. (Nature)

Agents go further because their output need not stop at language. They can search, edit files, write code, call APIs, spend money, schedule events and send messages. A model of the user can therefore affect both what the user sees and what happens on the user's behalf.

The major platform companies are now describing this direction openly. Apple's June 2026 announcement, for example, presents Siri as using personal context, system indexes and application tools to answer questions and perform actions across devices. That is a vendor description of a product rollout, not independent proof that the system works as promised. What matters here is the product category: personal context is being joined to cross-application action. (Apple)

At that point, the quality and governance of state become operational concerns. A stale restaurant preference causes an irritating recommendation. A stale medical constraint, travel document, project decision or financial assumption can cause an incorrect action. A model that confuses observed behaviour with an endorsed goal may begin to optimize the wrong future very efficiently.

The natural response is to ask for a model that is better aligned with the person. That is directionally right, but "the person" is not the only legitimate actor in the environment.

Personal agents and platform agents

Suppose I ask an agent to book a flight. My side of the transaction may include my budget, passport validity, schedule, dislike of red-eye flights, willingness to accept a layover and the importance of arriving rested. The airline has another state: actual inventory, prices, operating constraints, refund rules and legal obligations. A payment provider has its own risk and authorization requirements.

None of these parties should have to surrender its entire state to the others. My agent can disclose the constraints required to request an offer. The airline's agent can return available itineraries and conditions. I can authorize a particular transaction, and the resulting receipt can become new evidence in my personal state.

This is different from imagining one universally aligned assistant with privileged access to every system. A company agent can legitimately represent the company. A bank agent should enforce the bank's security requirements. An employer may operate agents that serve the organization within clearly stated employment boundaries. The problem arises when a service agent is presented as a neutral personal assistant while its data, objectives and permitted actions remain controlled by the platform.

Internet architecture already contains a useful concept for this. The browser has long been called a user agent: software that mediates between a person and remote services. RFC 8890, published by the Internet Architecture Board in 2020, argues that when the interests of internet end users conflict with those of other parties, protocol decisions should favour end users. It also notes that a person may be represented indirectly by software and treats decentralized control and edge-user empowerment as architectural choices rather than automatic consequences of technology. (RFC Editor)

A W3C Group Note Draft published on July 24, 2026 extends this language beyond browsers. It describes user agents as software that retrieves, presents and acts on web content for a person, and proposes duties of protection, honesty and loyalty. It explicitly says that a user agent should communicate automated actions and their consequences, minimize unnecessary disclosure, and serve the user's interests over those of its implementer. This document is a work in progress and is not an endorsed W3C standard, but it is a useful sign that browser-era ideas about representation are being reconsidered for acting software. (W3C)

The Agent Advocates position paper makes a related institutional argument. Its authors distinguish user-controlled agents from platform agents and argue that useful agent advocacy will require access to capable models, interoperability and rules that prevent dominant platforms from foreclosing alternatives. The important part is not that every agent must be local or open source. It is that the role of the agent and the identity of its principal should be legible. (Proceedings of Machine Learning Research)

A user-controlled agent cannot simply obey every instruction either. People have obligations to other people, and current desires can conflict with earlier commitments, safety constraints and law. An agent that conceals consequences, fabricates external facts or encourages every impulse is not meaningfully serving its user. User governance has to include correction, refusal, explanation and the ability to make commitments that remain binding later.

The healthy shape is therefore plural. Personal agents, company agents, public institutions and community systems will carry different state and different responsibilities. They need protocols for selective disclosure, delegation, offers, authorization, provenance, receipts, revocation and dispute. The goal is not to align every machine to one private worldview. It is to give the person an actual representative inside a network of other representatives.

What I mean by state

I have found it useful to separate four objects that are often called memory.

Data is the underlying evidence: messages, files, commits, receipts, calendar entries, browser events, tool results and observations from external systems.

Memory is the machinery that preserves, compresses, indexes, relates and reconstructs that evidence over time.

Context is the bounded material presented to one model or agent for one task.

State is the maintained interpretation of what the available evidence currently supports: what is active, what changed, what remains unresolved, which source has authority, where uncertainty remains, and what actions are permitted.

This separation matters because copying all available data into a large context window does not produce state. Nor does summarizing it once. State must be revised as the world changes, and those revisions can themselves be wrong.

Imagine that three records concern the same trip. A note says I intend to book a flight. A receipt says the flight was purchased. A later airline message says it was cancelled. The current state is not the most semantically similar record and not necessarily the most recent sentence in a global timeline. It is the result of understanding the kind of claim each source can establish and how the events relate.

Authority therefore needs to be typed. I am usually authoritative about my present intention: "I am no longer willing to take the red-eye." A repository is more authoritative than my recollection about whether a commit exists. A bank ledger is evidence about whether a payment cleared. An agent's inference that I am generally risk-averse is a hypothesis, not a fact of the same kind. It should carry evidence, scope and uncertainty, and it should be easy to reject.

A useful state system should preserve supersession without erasing history. It should know that an approach was rejected while retaining why it was considered. It should distinguish "false" from "unknown," and "no longer current" from "never happened." It should allow a claim to expire, become conditional, or remain contested. It should also be able to forget or quarantine information when continued use is no longer justified.

This does not require normalizing the whole machine into one grand database. In many cases, the native source should remain authoritative. Git can remain Git. The calendar can remain the calendar. The filesystem, email service and external APIs can retain their own structures. The personal state layer can maintain enough orientation, provenance and routing information to return to those sources when deeper evidence is needed.

The resulting object should be sparse. The aim is not to model everything about a person. A personal computer does not need a total psychological replica in order to help continue a release, organize a trip, or notice that two commitments conflict. It needs enough grounded state for the relevant future work, at an acceptable cost in attention, computation, privacy and risk.

Several recent papers are moving from retrieval toward versions of this problem. Is Agent Memory a Database? argues that correctness belongs to the evolving state trajectory and proposes ingestion, revision, forgetting and retrieval as state-level operations. User as Code explores typed, executable user state rather than a retrieved bag of textual facts. Beyond Similarity treats memory admission as a trust boundary because a relevant memory can still be inappropriate for the present domain or action. These are recent preprints rather than settled foundations, and each chooses a particular architecture, but their shared direction is important: long-term memory is becoming a problem of governed mutation and consequential use. (arXiv)

Work on latent-state sufficiency makes another useful correction. More retained information is not automatically a better state. A state representation is useful because it preserves what is needed for prediction, planning, grounding or control while discarding irrelevant detail. Under partial observability, it may also need to preserve competing hypotheses rather than collapse uncertainty into one convenient summary. (arXiv)

For personal computing, I would add one more requirement: the state should survive the model. A person should be able to change the model, agent harness or interface without losing the accumulated account of their work. Otherwise the "memory" is another form of platform lock-in, held inside the private internal state of whichever assistant happens to be running.

Personal computing after AI

There is already a contemporary body of work trying to recover different parts of the personal-computing project.

Andy Matuschak and Michael Nielsen have treated tools for thought as an experimental field rather than a productivity-app genre. Their work asks how interfaces and representations might produce qualitatively different forms of thought and learning, and why those possibilities require long periods of careful design rather than feature accumulation. (Numinous Productions)

Dynamicland explores computation as a communal, physical medium whose users can inspect and change the systems around them. Its account of agency includes the ability and confidence to view, modify, extend and remake the structures one depends on. That is a stronger standard than an interface being easy to use. (Dynamicland)

Ink & Switch has pursued malleable software and local-first systems: software that users can adapt, and collaborative data that remains available and meaningfully owned despite the use of networks and cloud services. Solid approaches the same ownership problem through user-controlled data pods and explicit permissions for people, applications and agents. Robin Sloan's "home-cooked software" makes a smaller cultural argument: software made for a handful of known people can be complete and successful without becoming a universal product. (Ink & Switch)

Language models create new opportunities for this work because they can translate vague intent into executable structure. Geoffrey Litt has argued that LLMs may loosen the programming bottleneck that kept most users dependent on prefabricated applications. At the same time, he points out why chat alone is insufficient. A good computational medium still needs visible structures, direct manipulation, fast feedback and objects the user can inspect and edit. The model can help reshape the tool; it should not make the tool disappear into a conversation. (Geoffrey Litt)

A maintained personal state could connect these ideas.

It would allow models to become replaceable. A new research or coding agent could enter an existing project without inheriting the opaque internal memory of its predecessor. It would receive a task-appropriate projection of the current state and follow provenance back to native evidence when needed.

It could support genuinely malleable software. Instead of generating another isolated application, an agent could construct a temporary interface around the current state of a task: a comparison table for a purchase, a map of claims and unresolved evidence for an article, or a control surface for one release. Because the underlying state remains explicit, the interface can disappear without taking the work with it.

It could also support better cognitive filtering. Today, the dominant filtering question is usually some variation of "what is this person likely to engage with?" A personal filter could consider the projects the person has chosen, which sources they trust, what is urgent, what can wait, how much interruption they can tolerate, and where the system's evidence is weak. This would still be a model with an objective and therefore still require inspection. The difference is that its objective and update process would be open to the person it affects.

Most importantly, a good personal model could preserve change rather than resist it. It could distinguish what I have done from what I endorse, what I endorse from what I am testing, and my present behaviour from the direction in which I am trying to move. It could remember a boundary without turning every old preference into a permanent identity.

None of this requires the personal computer to withdraw from the rest of the world. Personal state will contain shared commitments, external facts and the consequences of actions taken with others. User governance does not mean private control over reality. It means that evidence, inference, access and authority remain distinguishable, and that another party cannot silently turn its model of the person into the person's operative world.

Syke and Replay Lab

Syke is my current attempt to build the first narrow part of this.

The public system runs locally alongside several AI-agent harnesses. It observes their local activity, maintains a timeline and exposes a current MEMEX projection that other agents can use for orientation. It also separates the source activity from the learned, mutable memory that Syke writes about that activity.

This distinction has become more important to me than the choice between a graph, a vector database or a Markdown tree. Evidence is not the same thing as inference. The original session, repository or file should remain available. The maintained state can say what it currently believes happened, why that matters and where to look more closely. The MEMEX is therefore a map and routing surface rather than an attempt to contain the whole machine.

I do not think the current system proves the larger thesis. A memory agent can produce a very convincing account of a project while silently preserving the wrong branch, losing an important uncertainty, or spending more computation on maintenance than it saves in human effort. The interesting question is not whether its memory looks intelligent. It is whether a later agent continues the work better because that memory existed.

That is the reason for Replay Lab. The method I am developing begins with a time-bounded history of real work rather than a set of questions generated in advance. Different systems move through the same admissible sequence while maintaining their own private state. At historical checkpoints, they are asked to reconstruct or continue what was actually happening using only what was knowable then.

This makes it possible to study failures that ordinary memory questions miss. Did the system revive a rejected plan? Did it use evidence that had not yet occurred? Did it find the relevant file but misunderstand which version governed? How many turns did the user spend repairing the reconstruction? Could the agent produce the right continuation rather than merely a plausible description of the past?

A July 2026 position paper on evaluating personal agents under temporal interventions independently arrives near one part of this problem. It argues that personal-agent evaluation should preserve persistent user-conditioned state, apply explicit interventions through time, and observe how effects propagate across memory, skills, tools and policy. The authors are careful to describe it as a bounded gap analysis and proposed protocol, which is also the right level of confidence for this emerging field. (arXiv)

The current Replay Lab work is unfinished. The public held-out evidence package, restoration tests and larger task set still need to be released. That limitation is not separate from the research program. It is the reason the measurement work exists. Claims about a personal state layer should be tested against the kinds of histories, ambiguities and costs that the system will encounter outside a demo.

Reopening the personal-computing question

The first personal-computing movement moved interactive computation closer to individuals. The internet connected those computers to other people, institutions and an effectively unlimited information environment. AI now gives that environment enough interpretive and operational capacity to adapt itself and perform actions.

That combination reopens questions that the application era allowed us to postpone. What should a personal computer know? Which observations should become durable? Which should remain temporary? When should a machine interrupt, ask, infer, refuse, forget or act? How does a person correct the model without having to understand every implementation detail? How can one agent receive enough context to help without receiving a complete dossier? What happens when the interests of the user, the service and other affected people do not coincide?

I do not think the answer will be one perfect assistant that contains the person and mediates everything. The more plausible shape is a field of specialized agents and services around a state layer whose evidence, permissions and update rules remain under meaningful user governance. Some parts will be local. Some will be federated. Some state will be private, some shared, and some established by external institutions. Different models will come and go.

The unit I care about is not the model, or even the device. It is the evolving relationship between a person, their information environment and the machines acting within it.

That relationship already has state. At present it is fragmented, privately modelled by many services, and frequently reconstructed by the person at the moment it is needed. The work ahead is to make enough of it coherent without making it total; adaptive without making it manipulative; shared without surrendering it; and useful without quietly replacing the agency it was meant to extend.

Syke is one experiment inside that larger problem. Replay Lab is how I intend to find out where the experiment fails. The broader project is to make personal computing personal again, now that the computer is no longer waiting passively for us to operate it.

A reading trail

The older material is best read as a sequence of different research ambitions, not as a parade of people who "predicted AI." The 2026 papers below are mostly recent preprints. They are useful indicators of where the field is moving, not settled canon.

The original personal-computing project

Vannevar Bush, "As We May Think" (1945). Read it for the personal trail through knowledge, rather than only for the memex as a proto-hyperlink machine. (UCI Bren School of ICS)
J. C. R. Licklider, "Man-Computer Symbiosis" (1960). Still one of the clearest statements that the computer should participate in formulating the problem, not merely calculate an answer after the human has formalized everything. (MIT CSAIL)
Douglas Engelbart, "Augmenting Human Intellect" (1962). The essential source for treating the person, language, methods and artifacts as one improvable system. (Doug Engelbart Institute)
J. C. R. Licklider and Robert Taylor, "The Computer as a Communication Device" (1968). The personal-computing vision widened into networked collaboration and shared, dynamic representations. (Open Library)
Alan Kay and Adele Goldberg, "Personal Dynamic Media" (1977). The computer as a general medium a person could explore and reshape, rather than a terminal for consuming finished software. (DBLP)
Mark Weiser, "The Computer for the 21st Century" (1991), and Weiser with John Seely Brown on calm technology. Useful for thinking about computation distributed through the environment and competing for the center or periphery of attention. (Calm Technology)

Memory, activity and cognition outside the head

Eric Freeman and David Gelernter, the Lifestreams work. A temporal stream as an alternative to the hierarchical desktop, and an important ancestor of personal histories as computational objects. (Yale Computer Science)
Susan Dumais and colleagues, "Stuff I've Seen" (2003). Unified personal retrieval across email, documents, web pages and calendars, using contextual cues from the user's own history. (DOI.org)
Andy Clark and David Chalmers, "The Extended Mind" (1998). The philosophical case for taking the active role of external artifacts in cognition seriously. It is worth reading even if one rejects its strongest conclusion. (Web Archive Southampton)
Betsy Sparrow, Jenny Liu and Daniel Wegner, "Google Effects on Memory" (2011). A compact experimental demonstration that expected access to external information can alter what people remember. (PubMed)
Evan Risko and Sam Gilbert, "Cognitive Offloading" (2016). A useful review of how people change the environment to reduce cognitive demand and how metacognitive judgments influence that choice. (UCL Discovery)

Information systems as feedback systems

Allison Chaney, Brandon Stewart and Barbara Engelhardt, "How Algorithmic Confounding in Recommendation Systems Increases Homogeneity and Decreases Utility" (2018). A precise way to see how behaviour shaped by a recommender returns as supposedly independent evidence about the user. (Brandon M. Stewart)
Juan Perdomo and colleagues, "Performative Prediction" (2020). The general mathematical framing for predictions that alter the outcomes and data distributions they are intended to predict. (Proceedings of Machine Learning Research)
Kenneth Arnold, Krysta Chauncey and Krzysztof Gajos, "Sentiment Bias in Predictive Text Recommendations Results in Biased Writing" (2018). A small, legible example of generated suggestions changing human output. (Harvard SEAS)
Maurice Jakesch and colleagues, "Co-Writing with Opinionated Language Models Affects Users' Views" (2023). Important evidence that a generative writing interface can participate in both expression and subsequent attitudes under controlled conditions. (arXiv)
Sandra Matz and colleagues, "The Potential of Generative AI for Personalized Persuasion at Scale" (2024). Useful for understanding what changes when psychological tailoring and language generation become one automated process. (Nature)

Contemporary attempts to recover personal computing

Andy Matuschak and Michael Nielsen, "How Can We Develop Transformative Tools for Thought?" A serious account of why tools for thought require experimental practice and long-term refinement. (Numinous Productions)
Dynamicland. Read the introduction and FAQ for an unusually demanding definition of agency: people should be able to inspect, change, extend and remake the systems around them. (Dynamicland)
Ink & Switch, "Malleable Software." A modern map of systems that let users reshape software beyond the options anticipated by its original developers. (Ink & Switch)
Martin Kleppmann and colleagues, "Local-First Software." The best starting point for ownership, longevity, collaboration and control over data in a networked world. (Ink & Switch)
Geoffrey Litt, "Malleable Software in the Age of LLMs." Particularly good on why language models may open end-user programming while chat remains an inadequate universal interface. (Geoffrey Litt)
Robin Sloan, "An App Can Be a Home-Cooked Meal." A cultural counterweight to software that only counts once it serves a market at platform scale. (Robin Sloan)
Solid. A concrete attempt to separate applications from ownership of the personal data they use, with permissions that can also apply to AI agents. (Solid Project)

Agents, state and governance

RFC 8890, "The Internet Is for End Users" (2020). The architectural principle behind the user-agent argument, with useful nuance about competing users and competing interests. (RFC Editor)
Kapoor, Kolt and Lazar, "Build Agent Advocates, Not Platform Agents" (2025). A direct treatment of who controls the agent that mediates a person's online activity. (Proceedings of Machine Learning Research)
W3C, "Web User Agents" Group Note Draft (2026). A work-in-progress proposal for protection, honesty and loyalty duties as software moves from displaying the web to acting on it. (W3C)
"Is Agent Memory a Database?" (2026). A state-trajectory account of memory correctness, with revision and forgetting treated as first-class operations. (arXiv)
"User as Code" (2026). A provocative argument for executable, typed user state rather than similarity search over accumulated facts. (arXiv)
"Beyond Similarity" (2026). The most useful recent framing of personal memory retrieval as a trust boundary and durable control channel. (arXiv)
"Latent State Design for World Models under Sufficiency Constraints" (2026). Helpful for thinking about what a state representation should deliberately preserve and discard. (arXiv)
"Belief Memory: Agent Memory Under Partial Observability" (2026). A useful argument for maintaining uncertainty and competing hypotheses rather than producing one prematurely confident memory. (arXiv)
"Toward User-Conditioned Evaluation of Personal LLM Agents under Temporal Interventions" (2026). The closest recent methodological bridge to evaluating persistent personal agents as evolving systems rather than isolated memory components. (arXiv)