Nothing slips through the cracks, nothing leaks to a vendor, and your assistant actually remembers. A linked knowledge base, your mail and messaging, a task queue, and durable AI agents, running as one system so the joins stop living in your head.
People, meetings, agent definitions, tasks: all outline pages in one graph, all linkable, all searchable. Record something once and it is connected to everything it touches.
Mail, messages, reminders, and agent results flow through one triage engine you configure: what interrupts, what queues, what files silently. Decide once what "urgent" means.
Agents read your graph, draft replies, run analyses, and remember what they learn, but anything consequential waits for your approval, and every run is recorded and inspectable.
You have an outliner, an inbox, a calendar, a to-do app, a CRM you never update, and an AI subscription that forgets you between sessions. Subspace is what happens when those are one system. The demos are live.
Every line on every page is a bullet, and the bullet is the unit of everything: a note, a table, a code cell, a running workflow, or a whole embedded app. Give it a custom glyph. Fold it to collapse a subtree and navigate a long page by its shape. Write a custom viewer so a workflow task renders as a live status card, not a line of text.
Pages are bullet outlines with links, backlinks, and tags, plus tables whose formulas reference numbers on other pages. The analysis lives next to the reasoning it supports.
Write a TypeScript function on a page and call it from any bullet. Define your own page types and your own durable workflows. Agents, skills, and tools are all pages too, so the whole system is reshapeable without forking anything.
Mail and IM are not bolted-on integrations. They are pages in the graph that render as complete apps, so a thread files itself against the CRM, an agent can draft a reply grounded in your own notes, and everything an agent does passes through the same gates.
Mail rules are plain-language prompts, not sieve syntax, and each one shows how many messages it has caught. A rule can label, skip the inbox, and trigger an agent.
Every event, mail, message, agent result, or reminder, flows through triage you configure once: what interrupts, what queues, what files silently. Only the level you mark critical pierces focus mode.
Press one key on any bullet and an agent takes it as an instruction, answering from your whole graph. It remembers what it learns, and that memory feeds every future run.
Agent definitions are readable pages: prompt, allowed tools, approval policy, schedule. Review a change to an agent like a change to a document, with history. Every run is a step-by-step record anyone can inspect.
The failure mode you know: check "real quick", lose forty minutes. Subspace enforces the rules you set. Mail and IM open once every couple of hours; social feeds lock after a quota. Enforcement is central, so reloading the page or switching devices does not help.
Flag a page or a directory as remember this and Subspace derives flashcards and schedules them. It is not only for facts. It resurfaces the ideas you meant to come back to: a business idea, a scientific approach, a design you shelved.
A native desktop app with tabs, split panes, and a global capture hotkey. A phone app with offline capture, voice notes, and on-device meeting recording that transcribes onto a page. A browser extension that saves any article as clean text.
Subspace continuously mirrors every page to Markdown on disk (OKF sync). Point Claude Code, a script, or a teammate's editor at the folder and let it work. Edits on disk merge back into the graph three-way, per bullet, so your in-app work and an external agent's changes both survive.
A team workspace is one graph with two parts: a private part that is yours alone (your inbox, your captures, your drafts) and a shared part the team works in together. So every person gets all the For Individuals benefits, and on top of that the record becomes collective: it accretes as a side effect of the work instead of rotting in a wiki nobody updates.
Your inbox and your half-formed notes stay yours. The account pages, the decisions, the meeting record live in the shared graph, linkable from both. Nobody has to choose between a personal tool and a team tool.
People and companies build themselves from the team's mail and calendar: company, history, decisions, remembered facts. When someone leaves, the context is on the page, not in their inbox. When someone joins, "read the account pages" is the onboarding.
Both resolve to the same normalized name and the acme.test domain. Confirm merges nodes, joins aliases, and re-points backlinks in one commit. Dismiss keeps both.
The task queue and any project page render as a board: columns are status, cards are tasks or child pages. It is a view over the same graph as the outline, so moving a card is a real, audited command, not a separate tool to keep in sync.
Reviews and standups are where decisions actually get made. Recorded meetings become transcript and summary pages, linked from the calendar event and from every attendee. The decision reached out loud becomes a durable, linked note the whole team can find.
Ask how your team answers these today:
These are memory, attention, and orchestration problems, not modeling problems. Everything on the Teams tab applies; the research layer sits on top. And because it is built on the plugin system, these loops are yours to configure, not a fixed product you have to accept.
Goals, then hypotheses, then runs, then observations, then concepts, with a machine-maintained profile (the current recipe derived from your real run configs). From any goal you can walk to every hypothesis raised against it, every run that tested one, and every paper that fed it. That graph is institutional memory, and it builds itself as a side effect of working.
| Run | Hypothesis | IoU | Δ | When | Reading |
|---|---|---|---|---|---|
| segnet-2451 | H-09 boundary-loss v2 | 0.804 | +0.008 | 2h | supports |
| segnet-2449 | H-07 keep-small-crops | 0.811 | +0.015 | 6h | your read |
| segnet-2447 | H-09 boundary-loss v1 | 0.792 | −0.004 | 1d | neutral |
| segnet-2440 | H-04 mixup | 0.781 | −0.015 | 5d | refutes |
When a run finishes, an AI analyst reads it against your open hypotheses and drafts observations. Then, deliberately, the AI's reading stays hidden until you commit your own. The merged interpretation is what enters the record.
You can see the metrics above. Write what you think this run shows for H-07, then reveal and merge the analyst's draft.
On your schedule, per goal, an orchestrator reads everything new, observations, hypothesis status, ingested papers, meeting decisions, and proposes: new hypotheses, coding tasks that come back as PRs, and runs queued with their hypothesis attached.
Three runs varying class weights (2451, 2447, 2438) moved rare-class recall < 0.01 despite 3× reweighting, a ceiling more consistent with noisy labels than sampling. Enters as a draft.
segnet-2447 underperformed because edge weights were not normalized per-image; arXiv:2506.14822 §3.2 gives the correction. Dispatches a coding agent on segnet and returns a PR.
From approved PR #221. Tests H-11 against the current best (segnet-2449, 0.811). Est. 5h wall-clock.
The page types, the loops, the gates, the connectors are plugins on open contracts. Prefer a two-stage review? A different budget rule? A launcher we have not built? Reshape it, or write your own, without forking the app.
Every person and every team runs their own graph. The future is federation: mount parts of another graph you have access to, your employer's, a tool you use that hosts one, and reason across them as if they were yours. Talk to another graph's tools over MCP, and expose your own, with access controls and approvals on every boundary.
Bring parts of another graph into your view with scoped, read access. Your employer's runbooks and a tool's data sit next to your own notes, linkable and searchable, without a sync job or a second copy to drift.
Every graph can expose tools over MCP. Your agents call another graph's tools, and it calls yours, so automation spans organizations without anyone shipping a bespoke integration.
You decide what you expose, to whom, and what needs approval before it runs. The same gates that protect a single run protect a shared one: read is scoped, writes are approved, everything is logged.