Persome Wants to Build a Root, Not a Chatbot

The Hinge Moment

The AI assistant landscape is splitting into two camps: cloud concierges that know everything about everyone and nothing about you, and local runners that keep secrets but lack context. Persome arrives at the hinge of this split. It is not a chat interface, not a model runner, and not quite a framework. It is an attempt to build a persistent, structured memory of a single human—running on their own Mac, inspectable, correctable, and deletable—and to serve that memory to existing coding agents through the Model Context Protocol.

The timing is deliberate. The personal AI assistant market is expanding rapidly, with privacy-first deployment cited as a primary adoption driver [2]. Meanwhile, the infrastructure for agent memory has matured enough that practitioners now distinguish between short-term working memory and long-term persistent stores, recognizing that even frontier models with vast context windows require external memory architecture for cross-session persistence [3][9]. Persome bets that the next bottleneck is not model size but model context: the gap between what an agent can process and what it knows about the person it is supposed to assist.

A Geometry of Habits

Most retrieval systems treat memory as a flat archive. Persome treats it as a geometry. The system ingests macOS activity—keyboard focus, screen content, file changes—and distills it into a hierarchy it calls Point, Line, Face, Volume, and Root. A Point is a sourced observation. Lines connect them across time. Faces emerge as patterns backed by multiple evidence sources. Volumes map higher-order structures across projects or life domains. The Root is the current integrated model: what matters now, how you decide, where your attention drifts.

This is not merely taxonomy. The structure forces provenance. Every inference that rises from Point to Face must carry receipts; new evidence can strengthen, revise, or overturn an earlier conclusion. In a field where agent memory is often implemented as opaque vector embeddings or rolling conversation buffers, Persome’s insistence on evidence-linked claims is a methodological stance. It borrows from the formal memory literature—where episodic memory captures concrete experiences and semantic memory stores distilled facts [3][12]—but adds a layer of epistemic bookkeeping that makes the model auditable. You can open the local viewer and trace why the system thinks you are prioritizing a particular project, because the path from raw event to inferred priority is preserved.

The architecture also creates a natural compression gradient. Raw capture generates thousands of Points, but only a handful survive the ascent to Root. This addresses a known failure mode in agent memory: excessive data slows retrieval, and unpruned histories degrade relevance [3]. By collapsing low-level events into higher-order structures, Persome attempts to keep retrieval latency low without sacrificing the ability to drill down into source material when an agent needs to verify a claim. The approach echoes recent academic work formalizing memory within a Partially Observable Markov Decision Process, where memory serves as the agent’s belief state over a partially observable environment [12]. Persome’s hierarchy is essentially a hand-engineered belief state, updated through a write-manage-read loop that the system runs continuously against your local activity stream.

The Client Is Not the Model

Persome’s most strategic decision is architectural humility. It does not try to replace Codex, Claude Code, or Cursor. Instead, it registers as an MCP server, offering its model of you to any client that speaks the protocol. The pitch is simple: two people can give the same agent the same prompt and deserve different answers. The model stays the same; the person it understands changes.

This positioning distinguishes Persome from the broader open-source assistant ecosystem, which includes everything from document-chat interfaces to messaging-platform bots like OpenClaw [2][5]. Those tools aim to be the primary interface. Persome aims to be the identity layer underneath. When connected, it can identify unfinished work, rank it against inferred priorities, and separate safe local tasks from decisions that require human authority. The agent executes; the human keeps the veto.

The MCP integration is technically significant because it sidesteps a persistent problem in personal AI: lock-in. By speaking a standard protocol rather than a proprietary API, Persome allows users to swap clients without rebuilding their memory. In a landscape where one-third of enterprise software is projected to include agentic AI by 2028 [5], interoperability at the memory layer may prove more valuable than any single client feature.

Local-First, Cloud-Adjacent

For all its local-first rhetoric, Persome lives in a pragmatic middle zone. The capture runtime and storage are strictly local—SQLite, macOS-native OCR, no Full Disk Access required. But semantic modeling, the process that turns Points into Faces and Volumes, requires an LLM. Users can configure a local provider, though the documentation implies that lending an existing coding-agent subscription is the expected path for unattended processing. The system stores only the executable path, routing policy, and a daily call cap; it never holds the client’s OAuth token.

This arrangement exposes a tension running through the entire personal AI space. Fully local assistants that rely on small open-source models often suffer from poor reasoning and unacceptable latency on consumer hardware, as one developer found when testing Llama variants on phones [11]. Meanwhile, cloud-dependent systems sacrifice privacy. Persome’s compromise is to keep the raw biography local while outsourcing the synthesis. Whether this is sustainable depends on whether local models improve fast enough to handle semantic abstraction without waking the cloud. The current market suggests they are approaching conversational parity for simple tasks [5], but structured world-modeling may remain a heavy lift for edge hardware.

The Permission Problem

Persome’s weakest link is also its most distinctive: it must ask your Mac for permission to watch you work. Onboarding requires Accessibility access for the capture helpers and, optionally, Screen Recording for pixel-based OCR. The team has clearly thought hard about this—onboarding explains each request before it appears, and the system never demands Full Disk Access—but the psychological barrier remains. Users are being asked to let a relatively young open-source project observe their digital life in real time.

The Mac-only constraint further narrows the field. There is no Windows or Linux runtime, and the capture architecture is deeply tied to macOS APIs. For a project that bills itself as yours to inspect, correct, export, and delete, the inability to run on a user’s operating system of choice is a notable boundary. The small contributor team—seven people at the time of writing—suggests that cross-platform expansion is not imminent.

There are also operational rough edges visible in the documentation. The system distinguishes between a synthetic demo and real-data installation, implying that users may want to kick the tires before granting surveillance rights. WAL maintenance for SQLite requires periodic attention if write-heavy MCP clients are used. And the semantic model is explicitly described as sparse or degraded early on; Persome reports missing geometry rather than fabricating structure. This honesty is refreshing, but it also signals that the system needs hours or days of capture before it becomes useful.

Outlook

Persome is best understood as a research artifact with production ambitions. It tests a specific hypothesis: that the future of agentic AI is not better models, but better context. The investment surge in world models—over two billion dollars raised in a single month by labs pursuing spatial and personal world models [7]—suggests that the industry agrees on the destination, if not the route. Those projects aim to learn internal representations of objects, spaces, and dynamics from real-world visual data. Persome narrows the scope to a single user’s digital workspace, but the ambition is similar: a self-supervised model of an individual’s environment that improves planning and reasoning.

What remains unclear is whether individuals will tolerate the intimacy required to make a personal model work. The social-work literature on personal practice models warns that building an explicit model of a person is duplicative, time-consuming, and subjective [4]. Persome automates the data collection, but the subjectivity remains. An agent that knows your habits can just as easily enforce your blind spots. The project’s insistence on evidence links and human inspectability is a partial answer, yet the ultimate authority question—who controls the Root—has no technical fix.

For now, Persome occupies a unique coordinate in the open-source assistant landscape [2]. It is not the easiest to deploy, nor the most general. But it is one of the few projects treating personal AI as a modeling problem rather than a chat problem. In an era where every foundation model is trained on everyone, building a model of someone is a different kind of engineering altogether.