Shared State as Infrastructure: Why Personal AI Needs a New Systems Layer

The Fragmentation Problem in Personal Computing

Consider a seemingly simple question: "Is my heart rate too high right now?" Answering this situated query requires synthesizing data from disparate sources. Your workout intensity from the past hour, sleep quality from last night, current motion state from your phone's accelerometer, and even contextual awareness such as whether your parking meter is about to expire while you rush back to your car. The difficulty lies not in data availability, but in fragmentation. Each signal lives in a separate siloed application, locked behind incompatible interfaces and proprietary databases.

In their paper "PSI: Shared State as the Missing Layer for Coherent AI-Generated Instruments in Personal AI Agents," Wang et al. identify this fragmentation as the fundamental barrier preventing personal AI from becoming truly useful. While recent AI coding agents can generate functional software from natural language descriptions, generation alone produces yet more isolated artifacts. The authors argue that coherence across AI generated tools is not a generation problem, but a systems layer problem. Their solution, PSI (Personal Shared Instruments), introduces a shared state architecture that transforms independently generated modules into persistent, interconnected instruments capable of cross module reasoning.

The Architecture of Coherence

At the core of PSI lies the personal context bus, a shared state layer that operates as a publish subscribe system for structured personal data. This is not merely a data aggregation pipeline, but a runtime contract that defines how modules communicate. Each instrument, defined by the authors as a generated artifact that is persistent, connected, and complementary to chat, publishes its current state to this bus following a standardized schema. The bus then makes this state available to both persistent GUI surfaces and a generic chat agent named Facai.

The technical distinction between a module (the full software bundle including GUI, data provider, and services) and an instrument (the user facing artifact) is crucial. A module like "BoBo," which tracks daily timelines from phone and watch sensors, registers itself with the bus upon generation. It publishes structured state updates regarding health metrics, while simultaneously exposing write back affordances that allow the chat agent to modify its behavior. When a user asks Facai whether their heart rate is elevated, the agent queries not just the health module, but correlates data from the parking instrument (detecting the user is still walking) and the sleep logger (noting poor rest), constructing a situated response that no single application could provide.

This architecture borrows from Beaudouin Lafon’s instrumental interaction model, extending it to AI generated software. The innovation lies in the registration path: newly generated modules automatically integrate by satisfying the same contract, eliminating bespoke integration code. The authors demonstrate this through a three week autobiographical deployment in RyanHub, a self developed iOS based personal AI environment. During this deployment, later generated instruments integrated automatically through the shared bus, enabling bidirectional actions across the personal computing environment without manual API wiring.

Evidence from the Field

The autobiographical study, while necessarily limited to a single technically skilled user, provides compelling evidence for the efficacy of shared state architecture. Wang et al. evaluate PSI against two baselines: a search only approach where the chat agent retrieves but does not subscribe to live state, and a single module approach lacking cross instrument awareness. Their results demonstrate significantly stronger cross module reasoning capabilities when instruments publish to the shared bus, particularly for situated questions requiring temporal and contextual synthesis.

The technical implementation details reveal thoughtful engineering constraints. State updates are structured and typed, allowing the chat agent to reason about not just raw values but semantic relationships. Write back capabilities ensure that actions initiated through chat propagate correctly to persistent GUI instruments, maintaining synchronization across interfaces. When the user purchases parking through the chat interface, the parking instrument updates its display automatically because both read from and write to the identical shared state, not through fragile message passing between applications.

However, the study's limitations are openly acknowledged and significant. The three week deployment involved only the primary author, a scenario far removed from typical end users. The RyanHub environment represents a vertically integrated stack where schema compliance can be enforced, unlike the heterogeneous ecosystem of commercial health apps and parking services that dominate actual personal computing. Generalizing PSI to multi user scenarios, or to environments where modules are authored by different developers with competing data models, remains an open challenge.

Beyond Generation: Rethinking Personal Computing

The deeper insight of PSI extends beyond the specific implementation. The paper identifies that we have been asking the wrong question about personal AI. The research community has focused intensively on improving generation quality, crafting better coding agents, and refining natural language to code translation. Yet PSI demonstrates that the bottleneck for coherent personal computing is architectural, not algorithmic.

This observation connects PSI to broader movements in software architecture, particularly the pub sub patterns found in robotic operating systems such as ROS, or industrial IoT messaging protocols like MQTT. However, these systems typically assume professional engineering contexts with centralized control. Applying similar principles to personal computing, where end users generate instruments dynamically through natural language intent, represents a genuine shift in how we conceptualize software boundaries.

The traditional "app" metaphor, where discrete applications own distinct data silos, proves increasingly inadequate for AI mediated personal work. PSI proposes instead an environment metaphor, where instruments are temporary configurations of persistent capabilities that assemble and dissolve around user intent. The shared state layer functions as the operating system for this environment, mediating between sensing, reasoning, and acting components that may not have been designed to interact.

This raises critical questions about schema evolution and governance. In the RyanHub deployment, schema consistency was maintained because a single user generated all instruments within a bounded technical context. Scaling PSI to diverse ecosystems requires answering how schemas negotiate when independently developed modules encounter type mismatches, or how security policies enforce that sensitive health data publishes only to authorized consumers on the bus. The paper gestures toward these challenges but correctly treats them as future work rather than solved problems.

The Path Forward

PSI represents a necessary corrective to the current trajectory of personal AI development. As large language models make software generation increasingly accessible, we risk drowning in a proliferation of single purpose tools that compound rather than solve the fragmentation problem. Wang et al. demonstrate that shared mutable state, a concept familiar to distributed systems engineers but underexplored in personal informatics, provides the missing integration layer.

The most promising direction for future research lies in standardization. The authors have open sourced their artifact, including the RyanHub iOS application and representative modules, which will enable replication studies. However, the field ultimately requires consensus on personal context schemas, or at least robust translation layers between competing standards. We must also explore federated models where the personal context bus operates across devices and cloud boundaries without centralizing sensitive data.

The question of whether shared state architectures like PSI should be implemented at the operating system level, or remain as user space middleware, remains unresolved. If personal AI agents are to become genuine infrastructure rather than interesting experiments, we need systematic approaches to schema governance, conflict resolution between competing instruments, and privacy preserving shared state. PSI provides the architectural proof of concept; the next step is building the standards that make such environments accessible to users who cannot develop their own iOS applications.

For researchers and practitioners building the next generation of personal AI tools, the message is clear: stop optimizing generation in isolation, and start designing the integration layers that make generated artifacts cohere. Coherence is a systems problem, and shared state is the substrate upon which truly intelligent personal computing must be built.