---
title: "New Primitives"
code: "RP-0054"
language: "en"
canonical: "https://regentspark.ai/RP-0054/"
html: "https://regentspark.ai/RP-0054/"
markdown: "https://regentspark.ai/RP-0054.md"
updated: "27 April 2026"
---
# The Four Primitives of Computing
**Research 005 — Synthesis v2**
**Regent's Park · March 2026**
> **Summary:** Modern computing still lacks a shared foundation for identity, place, durable objects, and context. Apps try to supply these missing pieces inside their own walls, which makes each tool larger while leaving people, work, and memory fragmented across incompatible systems. The deeper problem is not that we need a better all-in-one app; it is that computing is missing primitives beneath apps. Regent's Park currently names four of them — People, Spaces, Objects, and Memory — and argues that they should become universal infrastructure, more like TCP/IP or HTTP than another product feature.
> **Alt text:** Three-panel illustration comparing disconnected app silos, larger super-apps with still-needed commuting, and a shared park-like system of the primitives People, Spaces, Objects, and Memory.
> **Visible text:** App silos; Super-app commuting; New primitives; Place + Legibility; People; Spaces; Objects; Memory
> **Description:** The image is divided into three main columns across the top, with a wide infrastructure diagram running along the bottom. On the left, under the heading “App silos,” several separate island-like app containers float in water, each with its own small app icon and no shared structure, while a lone person walks a dotted path between them to suggest disconnected usage. In the center, under “Super-app commuting,” the islands are replaced by a few much larger enclosed app compounds with many internal app tiles, but the same person still walks between them on a dotted route, showing that consolidation has not removed the need to move between systems. On the right, under “New primitives,” a large park scene with paths, benches, trees, water, and people illustrates a shared public space; above it the label “Place + Legibility” sits over icons for people, an object, and a clock, linking the park metaphor to identity, things, and time/memory. The bottom panel presents four connected blocks labeled “People,” “Spaces,” “Objects,” and “Memory,” each topped with a corresponding symbol, and all joined by colored pipes that run through and between them to communicate these as foundational layers beneath apps.
> **Image source:** content/RP-0054/illustrations/005-article-map.png
---
## Houston, we have a problem
> **Summary:** Forty-seven apps, none of them connected. Your notes trapped in one place, your designs in another. These feel like separate frustrations, but they're all the same problem: computing is missing foundational pieces that were never built.
You use forty-seven apps. That number is not rhetorical — someone probably counted yours and it's worse. You have a note-taking app, a calendar app, a messaging app (three, actually), a document app, a spreadsheet app, a design tool, a project management tool, an email client, a cloud storage service (two of those), a password manager to keep track of the logins for all the others, and a growing constellation of AI assistants that each know a different sliver of your life.
Each one is a little kingdom. Your notes are inside Apple Notes. Your designs are inside Figma. Your conversations are inside Slack. Your itinerary is inside Google Docs. You can't pick up a note and put it next to a design. You can't invite a colleague into your working context the way you'd wave them into your office. You can't leave a project on Friday and return on Monday to find everything the way you left it — the windows rearranged themselves, the tabs lost their state, the chat scrolled past the conversation that mattered. And your AI assistant? It forgot everything you talked about yesterday.
These feel like separate frustrations. A little annoyance here, a workaround there. But they're not separate. They are the same problem, wearing different costumes.
The problem is that computing is missing foundational pieces. Not features — foundations. The layer beneath apps, beneath interfaces, beneath the entire edifice of modern software. Pieces so basic, so elemental, that their absence is hard to see precisely because everything has been built on top of the gap.
We think there are at least four. We call them **People**, **Spaces**, **Objects**, and **Memory** — though the list may grow as we learn more.
And here's the part nobody talks about: the reason you don't have them isn't that nobody's tried. Everyone's tried. They keep building them inside apps.
---
## The world you already know
> **Summary:** You already understand all four missing pieces — you've understood them since before you could read. People, rooms, things, and memory are the invisible architecture of physical life. Computers have none of them.
Here's the strange part: you already understand all four. You've understood them since before you could read. You just don't notice them, because they're the invisible architecture of physical life.
There are **people**. You are one. You know other people. Each relationship has a different shape — your mother knows your childhood; your bank knows your account number; your colleague knows your project deadlines. You are one person with many relationships, and those relationships define what you can do in the world.
There are **rooms**. Your kitchen, your office, a meeting room, a café. Each room has a purpose, contains certain things, and admits certain people. When you leave a room and come back, your stuff is where you left it. When you invite someone into your office, they see what you see.
There are **things**. A book, a notebook, a photograph, a coffee mug. You pick them up, put them down, hand them to someone, arrange them on a table. A book works on any shelf. A photograph works in any room. Things don't care which room they're in or who's holding them.
And there is **memory**. Not the things themselves — the story of the things. The whiteboard still has last week's brainstorm. The coffee cup on the desk reminds you that you were mid-thought when you left. Your colleague walks in and says "so, about what we discussed Thursday" and you both know exactly what that means, because you share the memory of the room.
People. Rooms. Things. Memory. So fundamental that naming them feels almost silly — like pointing out that the world has gravity. Of course it does. You don't notice gravity until it's gone.
Computers have none of them.
This framing — grounding abstract computing concepts in physical-world intuition — is central to our research methodology. We start with what people already understand, then show where computing breaks that understanding. See How We Work.
> **Alt text:** Split illustration showing a collaborative office scene on the left and a lonely user surrounded by disconnected app windows on the right.
> **Description:** The illustration is a horizontal split scene with a warm, physical collaboration space on the left and a dark, digital fragmentation space on the right. On the left, three people stand around a large wall-mounted whiteboard in a tidy office: one person gestures toward the board while another holds papers or a notebook, and a third faces them as if in discussion; the foreground includes a desk piled with documents, a lamp, and scattered office items, reinforcing a shared room with persistent objects. On the right, a lone seated person looks down at a phone or small device beneath many floating, disconnected application windows and cards, some showing generic document blocks, charts, image placeholders, and UI panels, suggesting many separate digital contexts with no shared room or memory. The composition contrasts a single coherent workspace on the left with a dispersed cloud of app surfaces on the right, implying that physical offices naturally provide people, spaces, objects, and memory, while software fragments them across isolated tools. The image communicates the argument that computing should have foundational primitives beneath apps rather than forcing collaboration and context to live inside separate applications.
> **Image source:** content/RP-0054/illustrations/005-split-physical-digital.png
---
## Why your computer isn't a room
> **Summary:** An office building has one identity, persistent rooms, moveable things, and accumulated memory. Your computer has two hundred accounts, no rooms, trapped data, and amnesia. Every frustration maps to one of these four gaps.
Picture an office building. You badge in at the front desk — not with forty-seven different ID cards, one per room, but with one identity that everyone in the building recognizes. You walk to your office. The door is open. Inside: your desk, your whiteboard with Tuesday's diagrams still on it, a stack of papers you were reviewing, a borrowed book from the library downstairs. You sit down and pick up exactly where you left off. A colleague knocks — you wave them in. They see your whiteboard, your papers. You talk. You rearrange things on the desk together. When you both leave for lunch, the room holds everything until you come back.
Now picture your computer.
You don't badge in — you log in. Forty-seven times, to forty-seven different systems, each of which has no idea you just authenticated with the one next door. You are not one person to your computer. You are two hundred accounts in a password manager.
You don't walk into a room — you open an app. Then another app. Then a browser with six tabs. Then you try to remember which folder the file was in, and which messaging thread had the relevant conversation. There is no room. There is no "here." There is only everything, all at once, and your ability to filter.
The things in your office don't care which shelf they're on. But a note in Apple Notes can't leave Apple Notes. A design in Figma can't leave Figma. They're not things you own — they're features of applications you're permitted to use. Try picking up a note and putting it next to a design and a map pin and a flight confirmation, the way you'd spread papers on a kitchen table. You can't.
And the whiteboard? It gets wiped every night. Your computer preserves every byte of data you've ever created and retains zero context about what any of it means. It can tell you a file was modified at 3:47 PM on Tuesday. It cannot tell you that at 3:47 PM on Tuesday, you and Sarah realized the original approach wouldn't scale and pivoted to something simpler.
We explore the "closed-door axiom" — the idea that a Space hides the outside rather than filtering it — in much more detail in Spaces as Namespaces, which traces this property through 30 years of operating system design.
The office works because it has people who carry their identity through every doorway, rooms that scope and persist, things that can be moved and combined freely, and memory that accumulates in the fabric of the space itself. Your computer has accounts instead of people, desktops instead of rooms, data trapped in apps instead of things, and amnesia instead of memory.
Every frustration you have with software — the fragmentation, the context-switching, the rebuilding, the forgetting — maps to one of these four missing pieces.
---
## Everyone is trying to fix this
> **Summary:** Every major app has noticed the missing pieces and tried to build them. But they keep building them inside their own walls — creating super apps that are just fancier fragmentation. The question is where in the stack these pieces should actually live.
Now here's where it gets interesting. Because you're reading this and thinking: "Yeah, obviously. But people are working on it." And you're right. Everyone's working on it. Figma added real-time collaboration. Slack added canvases and persistent context. Notion added AI, wikis, projects, databases. Apple added shared photo libraries and collaborative playlists. Every major app looked at the missing primitives and said: "We'll build that."
And every single one of them built it inside their own walls.
### The Super App Trap
Watch what happens when apps absorb the missing primitives. Figma adds collaboration — great. Now your design collaboration happens inside Figma. But what about the people on your team who don't use Figma? They're cut out. The collaboration isn't yours — it's Figma's. Slack adds canvases and knowledge bases — great. Now your team documents live inside Slack. But what about the teams who use Teams, or Discord, or nothing? The documents aren't yours — they're Slack's. Notion adds spaces, databases, AI — great. Now Notion is your everything-app. Until you need to collaborate with someone who uses a different everything-app.
Each app absorbs more primitives. Each app gets more complex. Each app becomes a little country with its own citizens, its own currency, its own borders. And you — you now commute between super apps instead of commuting between simple apps. The fragmentation didn't disappear. It shifted up a level.
Jim Barksdale famously said there are only two ways to make money in business: bundling and unbundling. Computing history oscillates between the two — mainframes → PCs → web → super apps → agents. We think the missing primitives are the layer underneath this cycle. See Bundling and Unbundling.
```mermaid
flowchart LR
subgraph small["1. Small apps"]
direction TB
N["📝 Notes"]
C["💬 Chat"]
D["🎨 Design"]
Doc["📄 Docs"]
P["📋 Projects"]
N ~~~ C
N ~~~ D
C ~~~ Doc
D ~~~ Doc
D ~~~ P
Doc ~~~ P
end
subgraph superapps["2. Super apps"]
direction TB
A["🏢 Super app A
notes · docs · projects · AI"]
B["🏙️ Super app B
chat · workflows · AI"]
S["🏛️ Super app C
design · collab · dev mode"]
A ~~~ B ~~~ S
end
subgraph commute["3. Still commuting"]
direction TB
Y(("👤
You"))
A2["🏢 App A
locally useful
not portable"]
B2["🏙️ App B
locally useful
not portable"]
C2["🏛️ App C
locally useful
not portable"]
Y -. re-auth .-> A2
Y -. copy state .-> B2
Y -. rebuild context .-> C2
end
small -->|absorbs
primitives| superapps
superapps -->|larger
borders| commute
```
> **Alt text:** Diagram showing isolated app functions on the left, larger merged super-app enclosures in the center, and a person commuting between app spaces on the right.
> **Description:** The illustration is organized as a left-to-right argument about software fragmentation and consolidation. On the far left, a vertical stack of simple app-like tiles shows isolated functions—note/document, chat bubbles, a design tile, a file page, and a checklist/person tile—each sending an arrow into a separate small circular “app” enclosure, implying each function lives in its own silo. In the middle, three much larger circular enclosures represent broader combined systems: the top one contains a grid of mixed content panels and a central classical building, the middle one mixes chat, workflow, and checklist-like panels, and the bottom one combines design/code/people-style panels with a larger office-like building; these are linked by large arrows showing escalation into super-apps. On the right, a walking person carrying a briefcase is shown between two similar large enclosures, with a dotted path looping between them to suggest commuting between apps rather than being inside a shared room. The top and bottom right enclosures mirror the central combined systems but remain separate, reinforcing that even integrated apps still create boundaries instead of a universal shared layer. Overall, the image communicates that modern tools absorb more functions, but the user still moves between isolated systems instead of having portable people, spaces, objects, and memory beneath the apps.
> **Image source:** content/RP-0054/illustrations/005-superapp-trap.png
This is the super app trap: the missing primitives are so essential that every app tries to become all of them, and the result is a dozen would-be operating systems, each covering 60% of what you need, each incompatible with the others. You don't have less fragmentation. You have fancier fragmentation.
### Where should these live?
So if apps can't solve it, where in the stack *should* these primitives live?
**App level** — we just covered this. Every app absorbs the primitives for its own users, creating walled-off versions of identity, collaboration, and persistence. Your Figma identity doesn't know your Slack identity. Your Notion spaces can't hold Figma objects. It's countries, not infrastructure.
**OS level** — better. macOS has an identity (your Apple ID). It has a file system. It has some cross-app features. But you don't use one operating system anymore. You use your phone, your laptop, your work computer, maybe a tablet. You use a browser that's practically its own OS. The operating system isn't low enough — it stops at the edge of one device.
**Platform level** — Apple, Google, Microsoft. They each build their own version of everything: identity (Apple ID, Google Account), storage (iCloud, Google Drive), collaboration (SharePlay, Google Workspace). And they each work beautifully — within their own walls. But your life doesn't fit inside one company's walls. Your work laptop runs Windows. Your phone is an iPhone. Your partner uses Android. Your team's project lives on Google Docs. Our lives are more complex than any one platform.
**Protocol level** — this is where it works. A protocol doesn't care about your device, your operating system, or your platform. TCP/IP doesn't care if you're on a Mac or a phone or a refrigerator — it just moves data. HTTP doesn't care who you are or what browser you're using — it just serves pages. Email doesn't care if you use Gmail or Outlook — it just delivers messages (mostly). Protocols are universal, composable, and no one company controls them.
The protocol-level argument has precedent. Nostr provides a simple, open identity model (keypairs + relays) that works across any client. The AT Protocol (Bluesky) takes a different approach with portable accounts and algorithmic choice. Neither has the full stack we describe, but both demonstrate that protocol-level identity is viable. See Identity Landscape for a full survey.
```mermaid
block-beta
columns 1
AP["4 · 📱 App level
Notion · Figma · Slack
creates super apps and lock-in
too high"]
OS["3 · 💻 OS level
macOS · Windows · iOS · Android
stops at one device boundary
device-bound"]
PL["2 · 🏢 Platform level
Apple · Google · Microsoft
works inside one ecosystem only
walled garden"]
PR["1 · 🌐 Protocol level
TCP/IP · HTTP · SMTP · Bitcoin
universal · device-agnostic · composable
where primitives work"]
```
Portability increases as the primitives move below company and device boundaries.
> **Alt text:** A four-level stacked diagram showing protocol, platform, OS, and app layers, with callouts explaining that apps turn missing primitives into silos while lower layers are more universal.
> **Visible text:** App Level; Apps absorb the primitives into separate silos.; OS Level; Identity and files improve, but stop at one device.; Platform Level; Everything works inside one company’s walls.; Protocol Level; Universal, composable, device-agnostic infrastructure.
> **Description:** The image is a stacked, layered architecture diagram centered on four horizontal levels that read from bottom to top: “Protocol Level,” “Platform Level,” “OS Level,” and “App Level.” At the bottom, the “Protocol Level” is a green block with a network of connected devices, cables, and nodes around it, and a callout states “Universal, composable, device-agnostic infrastructure.” Above it sits the “Platform Level,” shown as a walled compound with buildings, trees, a gate, and a courtyard, paired with the note “Everything works inside one company’s walls.” The next layer, “OS Level,” is a gold block containing a laptop, phone, tablet, and desktop laid out like separate device slots, with a caption saying “Identity and files improve, but stop at one device.” At the top, the “App Level” is a pink block supporting three silo-like app towers with tiny room interiors, and a callout reads “Apps absorb the primitives into separate silos.” The overall composition communicates that universal infrastructure should sit below apps, because higher layers recreate fragmentation instead of solving it.
> **Image source:** content/RP-0054/illustrations/005-stack-levels.png
The web already proved this once. Before HTTP, information was locked inside proprietary systems — CompuServe, AOL, Prodigy. Each one was a walled garden with its own content, its own identity, its own interface. Then the web came along: a *protocol* for information. Suddenly any content was accessible from any device through any browser. The gardens didn't disappear overnight, but the protocol won because universality always beats lock-in, given enough time.
But here's the thing the web got right and the thing it never finished: **the web gave us a universal protocol for information. It gave us nothing else.** No universal identity. No universal storage. No universal presence. No universal spaces. The web is a library — magnificent, open, boundless — and that's *all* it is. You can look at anything, but you can't *be* anywhere. You can't bring your identity across websites without logging in to each one separately. You can't carry your things from one place to another. The web has no rooms, no memory, no sense of "here."
The four missing primitives need to be protocols. Not features of Notion. Not capabilities of macOS. Not services from Google. Protocols — the way TCP/IP is a protocol, the way HTTP is a protocol, the way Bitcoin is a protocol for exchanging value without caring what device you're on or what country you're in.
---
## Gas, electricity, storage
> **Summary:** Every app subscription bundles the same things: identity, storage, compute, collaboration, AI. You pay for each of them fifty times. What if computing had utilities — universal services you paid for once, like electricity — and apps just plugged in? AI is already showing us this model.
There's an economic way to see this that makes it even clearer.
Think about your house. You have utilities: electricity, gas, water, internet, mobile service. You pay for each once. Then every appliance you own — your fridge, your lamp, your TV — uses those utilities without bundling them. Your refrigerator doesn't come with its own electricity subscription. Your TV doesn't charge you for its own internet connection. The utilities are universal infrastructure. Appliances plug into them.
Now think about your apps. Every subscription you pay for bundles the same things over and over: an identity (your account), storage (your data), compute (the app running), collaboration (sharing with others), and increasingly, AI. You pay for identity fifty times. You pay for storage fifty times. Why does Notion charge for storage? Because there's no universal storage to plug into. Why does every app make you create an account? Because there's no universal identity to recognize. Why does every app build its own AI assistant? Because — well, actually, that one is starting to change.
This unbundling pattern is already visible in business computing. Amazon S3 is universal storage — for businesses. Hugging Face is universal AI compute — for developers. The pattern exists; it just hasn't crossed into personal computing. We're investigating what makes that crossing happen.
```mermaid
flowchart LR
subgraph today["Today: every app bundles utilities"]
direction TB
N["🧱 Notion bundle
identity · storage · compute · collab · AI"]
F["🎨 Figma bundle
identity · storage · compute · collab · AI"]
S["💬 Slack bundle
identity · storage · compute · collab · AI"]
G["📮 Gmail bundle
identity · storage · compute · collab · AI"]
end
subgraph future["Unbundled: apps plug into shared services"]
direction TB
ID["🔑 Identity
one portable relationship graph"]
ST["💾 Storage
one place for durable objects"]
PR["👥 Presence
one way to be here together"]
AI2["🧠 Intelligence
one utility across tools"]
end
today -->|unbundle the primitives| future
N -.-> ID
F -.-> ST
S -.-> PR
G -.-> AI2
```
> **Alt text:** Two-column diagram comparing tangled app-specific infrastructure on the left with shared universal services plugged into a single outlet on the right.
> **Visible text:** Redundant Infrastructure Bundling; IDENTITY; STORAGE; AI; Compounding Monthly Costs; The “Power Plant” Approach; PRIVATE POWER PLANT; Universal Service Subscriptions; UNIVERSAL SERVICES (Identity, Storage, AI); Lightweight, Cheap Applications; Electricity for Computing
> **Description:** The image is a two-column conceptual comparison split by a vertical line down the center. On the left, under the heading “Redundant Infrastructure Bundling,” a cluster of app-like machines is tangled together with many cables, each carrying its own labeled services such as “IDENTITY,” “STORAGE,” and “AI,” suggesting that every application duplicates the same core infrastructure; below it, the text “Compounding Monthly Costs” and “The ‘Power Plant’ Approach” are paired with a refrigerator-like machine labeled “PRIVATE POWER PLANT.” On the right, under “Universal Service Subscriptions,” several separate devices plug via clean cables into a single wall outlet labeled “UNIVERSAL SERVICES (Identity, Storage, AI),” showing shared infrastructure instead of per-app duplication. Beneath that, “Lightweight, Cheap Applications” and “Electricity for Computing” are illustrated with a simple refrigerator plugged into a shared power source, reinforcing the analogy that apps should consume universal services like appliances draw from the grid. The overall layout communicates the shift from redundant, app-specific bundling to a shared utility model for core computing primitives. The image’s structure is organized as a before/after argument: left side complexity and duplication, right side simplicity and shared foundations.
> **Image source:** content/RP-0054/illustrations/005-unbundling.png
Look at what's already happening with AI. Two years ago, every app was building its own AI from scratch. Now? You pay for one AI subscription — Claude, GPT, Gemini — and you connect it to dozens of tools. AI is becoming a *utility*. You pay for intelligence once and plug it in everywhere.
This is the future for all four primitives. What if you paid for storage once — the way you pay for electricity once — and every app you used just *accessed* it? Your fifty subscriptions would get cheaper, because they'd stop bundling storage you're already paying for. What if you had one identity, and every service recognized it? No more account creation, no more password management, no more "sign in with Google" compromises that hand your identity to a corporation. What if presence — the ability to see who's around, to share a context, to collaborate in real time — was a service you subscribed to once, not a feature each app reinvents?
These are the utilities of computing. The basic services that should exist beneath all software, the way electricity exists beneath all appliances.
| Utility | Physical World | Computing Today | What It Should Be |
|---------|---------------|-----------------|-------------------|
| **Identity** | You are one person. Everyone recognizes you. | 200 accounts in a password manager | One portable identity, many relationships |
| **Storage** | You own your stuff. Put it on any shelf. | Pay for storage 50x across 50 apps | Universal storage, like electricity |
| **Presence** | You're in a room. Others can see you. | Each app reinvents "sharing" | Universal presence protocol |
| **Intelligence** | You can think and reason. | *Already unbundling* (Claude/GPT + tools) | Commodity service, plugged in everywhere |
AI showed us the model. The rest should follow.
> **Alt text:** Two cutaway houses compare a normal home on the left with a software-like house on the right, where rooms are powered by labeled underground primitives: identity, storage, presence, and intelligence.
> **Visible text:** identity; storage; presence; intelligence
> **Description:** The illustration is split into two side-by-side house cross-sections, with the left half showing a warm, ordinary home and the right half showing a more technological house. On the left, the upper floor contains a bedroom with a bed and small nightstand, while the lower floor is divided into a living room with a chair and bookcase and a kitchen/dining area with a table, cabinets, sink, stove, and hanging lamp, suggesting a coherent shared space. On the right, the house is similarly cut open into rooms, but the rooms are populated by app-like screens and service icons: a chat bubble in the lower left room, a shopping cart in the lower middle room, a video player in the lower right room, and two small interface panels in the upper floor. Beneath the houses, exposed pipes and cables run through the ground, visually implying the hidden infrastructure that supports the rooms above; under the right house, the pipes are explicitly labeled in sequence as identity, storage, presence, and intelligence. The composition communicates a contrast between physical places with persistent, integrated life on the left and software services assembled from underlying primitives on the right, reinforcing the article’s argument that computing needs foundational layers below apps.
> **Image source:** content/RP-0054/illustrations/005-digital-utilities.png
---
## The missing pieces
> **Summary:** Four areas where computing has no foundation: People (identity as a relationship graph), Spaces (persistent scoped containers), Objects (things that exist independently of apps), and Memory (contextual awareness of what happened). Each maps to something humans already understand from physical life.
We've been studying each of these independently. What follows is not a summary of what we found — it's what emerged when we put them together.
### People
**A person is a portable identity that carries its relationships.**
Not a username. Not a profile. Not a cryptographic key (though keys are useful machinery). A person is the node at the center of a graph of relationships, each with its own shape — its own permissions, its own memory, its own capabilities.
Your identity is not the data stored about you. It is the living web of connections between you and every person, service, and agent in your life. Your mother, your bank, your barista, your AI assistant — each relationship reveals a different facet of who you are and grants a different set of capabilities. The barista can make you a coffee. The bank can move your money. Your mother can call at 2am without being blocked. These are relationships, not entries in a database.
We explore identity as a relationship graph — and the distinction between identity, reputation, and disclosure — in People. The question of whether AI agents can be "People" in this sense is open. See also Identity Landscape for a survey of existing approaches.
The People primitive means your relationships survive regardless of which software you're using. You bring yourself — your connections, your reputation, your history — into a new context the way you walk into a room. You're still you. The room can see that.
### Spaces
**A Space is a persistent, shareable, scoped container for work and life.**
Not a window arrangement. Not a folder. Not a project management tool. A room. You create it, you furnish it, you invite people in. It persists when you leave. It's alive when you enter. It holds only what you put there — not everything you've ever done, but the specific collection of things and people relevant to the purpose at hand.
The critical property of Spaces is *scoping*. Your computer today is one giant room containing everything. A Space is the opposite: it holds a project, a trip, a collaboration, a domain of your life. You enter it and you're *in it* — surrounded by only what matters. You leave and it doesn't follow you. You come back and it hasn't reset. If you rent a new office, it's an empty room and you choose what to bring. It's not like the office has everything you've ever done in your whole life and you need to filter and invoke.
The "closed-door axiom" — the idea that a Space makes the outside nonexistent, not merely hidden — turns out to have been implemented in operating systems since Plan 9 in 1992. Security containers, namespaces, and sandboxes all create Spaces in this sense. See Spaces as Namespaces for the full history.
A Space is cross-application — it can hold a note from one app, a design from another, a running process from a third. The Space is the environment. The apps are tools you bring into it.
### Objects
**An Object is a thing that exists independently of any application.**
Not a file (too low-level), not a database entry (too captive), not a cloud blob (too dependent). A thing. Like a book, a photograph, a hammer. It has its own identity. It can be moved, combined, shared. It works on any shelf.
Modern software has collapsed three distinct things into one opaque bundle: the *domain* (who provides and manages the data), the *objects* (the actual things — your notes, your designs), and the *interface* (how you see and edit them). These three are welded shut. You can't separate your notes from Apple Notes. You can't view your designs through a different tool than the one that made them. The Object primitive is the act of unbundling: let domains be domains, let interfaces be interfaces, and let objects be objects — free to move between them.
The question of how objects connect to each other — and what the connection knows — is one of our most active research areas. A relationship between two objects may actually be two separate half-links, each owned by one side. See Relationship Primitives.
### Memory
**Memory is persistent, contextual awareness of what happened.**
Not version history. Not undo. Not chat logs. Not "recently used files." Memory is the connective tissue of experience: *what happened here, who was here, what was decided, what was tried, what was abandoned, and why.*
Memory is what distinguishes a home from a hotel room. A home is saturated with context — you know where things are because you *remember* putting them there. A hotel room is functional and clean and utterly devoid of story. Today, every project you open on a computer feels like a hotel room. The files are there. The context is gone.
Digital memory spans a vast spectrum — from sub-second undo stacks to permanent blockchain anchors — but every layer was built independently with no connection to the others. The missing piece may be a shared vocabulary for memory intent, not a unified system. See State & Memory.
Memory is not a log of everything that ever happened — that would be noise. It's curated, contextual, and associative — the way human memory works. It surfaces when it's relevant. It fades when it's not. It answers the question "what happened here?" the way a colleague would: with a story, not a spreadsheet.
---
## What happens at the intersections
> **Summary:** The four primitives are a system, not a list. Each pair produces something new: People + Spaces = Presence. Spaces + Memory = Place. All four together create legibility — environments that explain themselves.
These four primitives are not a list. They're a system. Each one is incomplete without the others — and something new appears when they combine.
**People + Spaces = Presence.** A Space with no one in it is just empty architecture. People bring Spaces to life — they enter, they collaborate, they leave traces. And a person without Spaces has nowhere to *be*. Presence isn't a feature you bolt on — it's what naturally emerges when People can inhabit Spaces. You're not "online" in some abstract sense. You're *here*, in this room, working on this project. Others can see you. You can see them.
**People + Objects = Ownership.** An Object without a person is unclaimed property. A person without Objects is a ghost — identity with nothing to show for it. When People and Objects combine, you get real ownership: this is *my* note, *my* design, and I can carry it anywhere. Not "my data in Notion's database." My thing, in my hand, on my shelf.
**Spaces + Objects = Arrangement.** A Space without Objects is an empty room. Objects without a Space are scattered across your entire digital life, findable only through search. Together they create arrangement — the ability to put *these specific things* in *this specific place* for *this specific purpose*. The way you'd spread papers on a table, pin things to a wall, arrange a workspace for the task at hand.
**People + Memory = Relationship.** Not just that you know someone, but the accumulated history of knowing them. What you've discussed, decided, built together. Memory is what turns a contact list into relationships. It's why "so, about what we discussed Thursday" works with your colleague and not with a stranger.
**Spaces + Memory = Place.** This is the big one. A Space that remembers is fundamentally different from a Space that resets. It becomes a *place* — somewhere things have happened and continue to happen. Your office isn't special because of its physical dimensions. It's special because of everything that's happened in it. Computing has had locations (URLs, file paths) and tools (apps), but never *place*: the experience of being somewhere specific, with a history, that persists.
**Objects + Memory = Provenance.** An Object with memory knows its own story — who created it, why it changed, what conversation shaped it. A note that remembers it started as a brainstorm in a meeting with Sarah, was refined over three weeks, and became the core of a project proposal. Not metadata. Narrative.
```mermaid
flowchart LR
PS["👤 + 📍
Presence
being here, together"]
PO["👤 + 📦
Ownership
my things, my hands"]
PM["👤 + 🧠
Relationship
shared history"]
SO["📍 + 📦
Arrangement
things in their place"]
SM["📍 + 🧠
Place
somewhere that remembers"]
OM["📦 + 🧠
Provenance
the story of things"]
PS --- PO --- PM
SO --- SM --- OM
PS -.- SO
PO -.- SM
PM -.- OM
```
> **Alt text:** Concept map titled “The Geometry of Meaning” showing People, Spaces, Objects, and Memory connected through related sub-concepts around a central town scene.
> **Visible text:** The Geometry of Meaning:; How Primitives Compose Our World; People; The human element; the observers and participants within a system.; Presence; The state of existing within a specific volume; the immediate human experience of a physical area.; Arrangement; The intentional organization and layout of items within a defined area.; Spaces; The physical or digital volumes and areas where activity occurs.; Ownership; The social and legal bond between a person and an item.; Objects; The discrete items, tools, or artifacts contained within a space.; Relationship; The history and shared experiences that connect individuals over time.; Legibility; The property that emerges when all four primitives (People, Spaces, Objects, and Memory) combine, making an environment intuitively self-explaining to its inhabitants.; Place; Described as “the big one,” this is where a generic space gains meaning and history through memory.; Memory; The record of past events, history, and personal or collective associations.; Provenance; The history of an item; knowing where an object came from and who it belonged to.
> **Description:** The image is a conceptual map titled “The Geometry of Meaning: How Primitives Compose Our World,” with a central illustrated town square in the middle acting as the hub. Thick branching connectors radiate outward to labeled clusters around the page, each cluster showing a small scene or object group that represents one primitive or related concept. On the left, “People” shows a group of human figures, with “Presence” nearby as a doorway/arch scene, while lower left “Ownership” shows hands exchanging an item and “Objects” shows discrete items like a clock, book, pen, cup, and phone. Along the bottom, “Relationship” depicts two people with thought bubbles and connected groups, and “Provenance” shows a vessel, while the lower right “Memory” is represented by a tied notebook and key and the caption about “the record of past events.” On the right side, “Spaces” shows buildings and rooms, and “Place” shows a populated historic street scene with the idea of a generic space gaining meaning through memory; near the center-right, “Arrangement” depicts a furnished room and “Legibility” sits below the central hub as the emergent property when People, Spaces, Objects, and Memory combine. The overall composition communicates that these primitives are distinct but interdependent layers, with the central town and the connecting paths illustrating how they compose a meaningful environment.
> **Image source:** content/RP-0054/illustrations/005-composition-notebooklm.png
And here's what emerges when all four combine: **legibility**. A newcomer can walk into a Space and *understand* it — not because someone wrote perfect documentation, but because the space itself carries its history, the objects carry their provenance, and the people in it carry their relationships. The environment is self-explaining. This is what makes physical offices readable — the whiteboard, the arrangement of desks, the stack of papers tells you what's happening here. Computing today is opaque. Four primitives, working together, make it legible.
Place. Legibility. Presence. Ownership. These aren't features on a roadmap. They're what naturally emerges when the foundations exist. You don't have to build "presence" — you get it for free when People can inhabit Spaces. You don't have to build "provenance" — you get it for free when Objects carry Memory. The primitives compose, and the things we've been building as features simply *appear*.
---
## None of this is new
> **Summary:** Engelbart demoed shared documents and real-time collaboration in 1968. Kay designed object-oriented environments for people in the 1970s. These ideas are older than the web. We got distracted by personal computers, then the internet, then apps, then the cloud — each solving real problems while deepening the structural absence.
None of this is new. That's the uncomfortable part.
In 1968, Douglas Engelbart gave what became known as "The Mother of All Demos." He showed a computer system with shared documents, real-time collaboration, hypertext linking, and video conferencing. People in the room could work on the same document at the same time. Objects moved between contexts. The system had memory of what happened. That was fifty-seven years ago.
Engelbart's NLS system demonstrated collaborative editing, shared screens, hypertext, and video conferencing — in 1968. Most of these capabilities weren't widely available in consumer software until the 2010s.
In the 1970s, Alan Kay and the team at Xerox PARC built the Alto — a computer where everything was an object, where objects could be composed, where the environment was designed around human mental models rather than machine constraints. Kay's vision of the Dynabook was explicitly about *people* working with *things* in *contexts* — persistent, portable, alive.
Kay's 1972 Dynabook paper describes a portable computer for children that anticipates tablets, object-oriented interfaces, and persistent personal environments. The hardware arrived decades later; the software vision is still largely unrealized.
These ideas are older than the web. Older than the iPhone. Older than most of the people reading this. And yet here we are, in 2026, and your computer still can't do what Engelbart demoed in 1968: let two people work in the same persistent context with shared objects and cumulative memory.
We didn't forget these ideas. We got distracted. The personal computer revolution optimized for one person at one desk. The internet optimized for connecting documents, not people. The mobile revolution optimized for apps — self-contained little worlds that each reinvented everything from scratch. And the cloud revolution optimized for putting those same apps on someone else's computer.
Each revolution solved real problems. Each one also deepened the structural absence. The primitives that Engelbart and Kay intuited — people, environments, objects, memory — kept getting deferred. There was always something more urgent to build. And so, fifty years later, we have unimaginable computing power running software that can't remember what you were doing yesterday.
The four primitives aren't a new idea. They're an old idea whose time may have finally come — because AI, open protocols, and the sheer exhaustion of the super-app era are creating the conditions to actually build them.
> **Alt text:** Three-panel illustration showing a group presentation, then a shared old computer, then a lone person working at a desk with multiple devices.
> **Description:** The image is a three-panel sequence arranged left to right with arrows between panels, showing the evolution from physical collaboration to mediated software use. In the left panel, a presenter stands beside a large whiteboard or display in front of an audience of seated people, implying a shared room with everyone looking at the same object; a small plant sits near the front. The middle panel shifts to a crowded desk scene around a bulky old computer, with several people standing and leaning in while one person sits and uses the machine, again with a small plant nearby, suggesting collaborative work centered on a shared device. The right panel shows a single person working alone at a desk in a bright office-like space, using a laptop with a tablet and phone nearby and a potted plant at the far right, emphasizing isolated individual computing. The sequence communicates a historical and conceptual transition from shared physical contexts to fragmented personal app/device contexts, matching the article’s argument about missing computing primitives beneath apps.
> **Image source:** content/RP-0054/illustrations/005-timeline-engelbart.png
---
## What it would feel like
> **Summary:** A concrete scenario: planning a trip with a friend using Spaces, Objects, People, and Memory working together. You don't "use apps" — you inhabit spaces. The apps are tools you bring into a room, not rooms you enter one at a time.
Enough abstraction. What would it actually feel like to use a computer that had these four primitives?
You're planning a trip to Japan with your friend Sarah.
You create a Space. You call it "Japan Trip." It's empty — an empty room, waiting to be furnished. You drag in a note with restaurant recommendations. A shared document for the itinerary. A map with pins for the places you want to visit. A folder of inspiration photos. You invite Sarah. She accepts — she can see the room, everything you've laid out.
You close your laptop and go to bed.
The next morning, you open the Space. Everything is exactly where you left it. But something's changed — Sarah was here overnight. She added a spreadsheet comparing flight prices. She left a note on the map: "This neighborhood has the best ramen." The Space remembers you were last looking at the restaurant list, so it opens there. You can see what Sarah did while you were away — not as a list of file modifications, but as a story: "Sarah added flight comparisons and annotated the map with restaurant neighborhoods."
A week later, you're deciding between two neighborhoods to book a hotel. You vaguely remember a conversation about this. You ask the Space: "What did Sarah and I discuss about where to stay?" And it answers — not by searching chat logs across three messaging apps, but because the Space was *there* for the conversation. It remembers. "Last Tuesday, Sarah suggested Shimokitazawa because it's central and has good food. You were leaning toward Shibuya for convenience. No decision was made."
Your AI assistant is in the Space too. It has the same context Sarah has — the documents, the map, the budget. When you ask it to find restaurant reviews, it already knows the trip. It doesn't ask what you're planning or who Sarah is. It's been in the room the whole time.
Now scale this up. A Space for each project at work. A Space for your family's shared life. A Space for that open-source project you contribute to on weekends. Each one scoped, each one persistent, each one shared with exactly the right people, each one accumulating memory over time.
You don't "use apps." You *inhabit spaces*. The apps still exist — but they're tools you bring into a room, not rooms you have to enter one at a time.
---
## What's hard
> **Summary:** Building this is genuinely difficult. The bootstrap problem, the economics of app unbundling, the judgment required for memory curation, the UX of decentralized identity, and the patience required for protocol adoption. We name these honestly.
If this all sounds obvious — good. The framing should feel inevitable. But building it is genuinely hard, and it's worth naming the hardest problems honestly.
**The bootstrap problem is the deepest.** A People primitive that nobody uses is useless. A Space with no content is an empty room. Memory needs time to accumulate. Each primitive is most useful in a world where the other three already exist. You start small — a handful of people who use all four in a tightly integrated prototype, and grow from there. It needs to be useful with five people before it works for five million.
**Apps don't want to be unbundled.** The current model — domain + objects + interface welded together — is not an accident. It's how companies make money. Figma is a bundle because Figma wants you using Figma. Unbundling Objects from their apps requires either a forcing function (AI agents reaching into apps through protocols like MCP, which is already happening) or apps gradually opening up as the competitive landscape shifts. This will be messy. But the economic pressure is real: once universal storage and identity exist, apps that bundle them will look like refrigerators with their own power plants — absurd and expensive.
Anthropic's Model Context Protocol (MCP) is an early example of the forcing function: AI agents can already reach into apps and extract objects, whether the app was designed for it or not. This is unbundling happening from the outside in.
**Memory requires judgment.** Recording everything is easy. Remembering the right things is hard. A computing memory that captures every keystroke would be noise; one that captures nothing is what we already have. The hard part is curation — knowing that "we decided to drop the free tier" is worth remembering and "I scrolled past a tweet" is not. AI is well-positioned to help here, but it introduces its own questions: whose judgment? What biases? What gets lost?
**Identity without centralization is a UX problem.** Cryptographic keys can represent People beautifully. The math works. But real humans lose phones, forget passwords, and get locked out. Recovery mechanisms that don't hand custody to a corporation — social recovery, multi-device redundancy — are possible but not yet seamless. This is a design problem, not a cryptography problem.
**Protocol adoption takes time and taste.** The right approach is probably what the web did: make it work for a small community, make it obviously better, and let adoption spread. Not a standards committee. Not a spec that tries to cover everything. A working thing that solves a real problem for real people, and then grows. The first website didn't need to explain what "the web" would become. It just needed to be useful.
A first prototype probably combines experience and engineering: one Space, two People, a few Objects, basic Memory — working end-to-end, even if fragile. Something you can show to a person and have them say: "Oh. *That's* what you mean."
---
## Where this leads
> **Summary:** Computing was designed for one person at one desk. The fix isn't another app — it's universal protocols providing the basic services of computing. This essay is a first attempt at seeing the whole picture. The thinking continues to evolve.
We set out to answer a simple question: why does computing feel so broken despite being so powerful?
The answer is that computing was designed for a single person at a single desk doing a single thing. That assumption is baked into everything — operating systems, applications, protocols, the entire stack. Collaboration is bolted on. Context is an afterthought. Identity is fragmented by design. And now we're trying to graft AI, multiplayer, and persistent context onto foundations that reject all three.
The fix is not another app. It is not a better super app that absorbs even more primitives into an even larger walled garden. It is not a platform feature that works only within Apple's or Google's ecosystem. The fix is universal protocols — the way TCP/IP is universal, the way HTTP is universal, the way Bitcoin is universal. Protocols that provide the basic services of computing the way electricity and water provide the basic services of a home.
**People:** you are one person, and your relationships carry across every digital context.
**Spaces:** you can create a room, bring things and people into it, and return to find everything as you left it.
**Objects:** your things are yours — holdable, moveable, combinable — regardless of which app made them.
**Memory:** your computing environment remembers what happened, the way a lived-in room remembers who was there.
These four, taken together, create something computing has never had: *place*. The experience of being somewhere specific, with your people, your things, and your shared history. Not browsing. Not switching between apps. *Being somewhere.*
Engelbart saw this in 1968. Kay designed for it in the 1970s. The super-app era is proving, by exhaustion, that building it at the wrong level doesn't work. The unbundling of AI into a universal service is showing us the economic model. The pieces are finally here.
This essay is an introduction — a first attempt at seeing the whole picture. The details are in the individual research briefs, and the thinking continues to evolve.
The individual research briefs go deeper into each area: People, Spaces, Objects, Memory. For the full list of research, see Writing.
---
> **Alt text:** Wide infographic showing app silos on the left, four core computing primitives in the center, and a utility-style comparison table on the right.
> **Visible text:** THE PROBLEM: THE SUPER APP TRAP; ACCOUNTS; The #7-App Paradox; IDENTITY: ONE PERSON; 200 ACCOUNTS IN A PASSWORD MANAGER; THE FOUR PRIMITIVES: PHYSICAL vs. DIGITAL; PEOPLE; SPACES; OBJECTS; MEMORY; COMPOSITION: WHAT HAPPENS WHEN PRIMITIVES COMBINE; PEOPLE + SPACES = PRESENCE; PEOPLE + OBJECTS = OWNERSHIP; SPACES + MEMORY = PLACE; SPACES + OBJECTS = ARRANGEMENT; THE RESULT = LEGIBILITY; THE IMPLEMENTATION: COMPUTING AS A UTILITY; PHYSICAL WORLD; COMPUTING TODAY; WHAT IT SHOULD BE; STORAGE; PRESENCE; INTELLIGENCE; You are one person.; 200 accounts/passwords; One portable identity; You own your stuff.; Pay for storage 30x; Universal storage utility; You’re in a room.; Apps reinvent “sharing”; Universal presence protocol; You can reason.; Fragmented app features.; Commodity service/API; EXAMPLE: AI as the First Utility
> **Description:** The illustration is a wide infographic with a large central title, "The Architecture of Digital Life," and a subtitle about why computing is broken and how the four primitives fix it. On the left, under "THE PROBLEM: THE SUPER APP TRAP," a person carrying keys walks toward a cluster of castle-like app fortresses; a nearby "ACCOUNTS" label and notes about the app paradox and password-manager overload frame apps as separate walled kingdoms. In the middle, under "THE FOUR PRIMITIVES: PHYSICAL vs. DIGITAL," four column-like icons label the primitives as "PEOPLE," "SPACES," "OBJECTS," and "MEMORY," each paired with a short explanatory paragraph. Beneath them, a Venn-diagram-style section titled "COMPOSITION: WHAT HAPPENS WHEN PRIMITIVES COMBINE" shows combinations like "PEOPLE + SPACES = PRESENCE," "PEOPLE + OBJECTS = OWNERSHIP," "SPACES + MEMORY = PLACE," and "SPACES + OBJECTS = ARRANGEMENT," converging on a central scene of a room and the result "LEGIBILITY." On the right, a building panel titled "THE IMPLEMENTATION: COMPUTING AS A UTILITY" compares "PHYSICAL WORLD" to "COMPUTING TODAY" and "WHAT IT SHOULD BE" across rows for identity, storage, presence, and intelligence, using phrases like "You are one person," "200 accounts/passwords," "Universal storage utility," and "Commodity service/API." The overall composition communicates that modern software fragments basic human concepts into app-specific silos, and that the proposed fix is to move identity, space, objects, and memory into shared infrastructure beneath apps.
> **Image source:** content/RP-0054/illustrations/005-notebooklm-infographic.png