Your notes, your mail and messaging, your task queue, and durable AI agents, one system, in a place you control. Nothing slips through the cracks, and your assistant actually remembers you.
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.
Every line 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. Fold it to collapse a subtree, zoom in to make it the whole view, or open it as a pane.
Subspace is not an AI layer bolted onto a note-taker. Take the agents away and what remains is a complete personal knowledge base, so arriving from Roam, Logseq, Obsidian, or Notion costs you none of the primitives you actually use.
Mail and IM are pages in the graph that render as complete apps: a thread files itself against the CRM, an agent drafts replies grounded in your own notes, and every send passes the same gates.
Describe the tool you wish existed and an agent builds it — but it lands as a page in the system you already live in, not a repo with its own deploy and login. Hyperpersonal doesn't have to mean fifteen half-finished apps.
Mail rules are plain-language prompts. A rule can label, skip the inbox, trigger an agent, and set the severity for whatever it matches, so a message from a supervisor is always important while newsletters stay silent.
Notifications are engineered to be addictive, and the interruption itself does the damage: merely receiving one measurably fragments attention and degrades performance on a demanding task, even when you never touch the device (Stothart et al., 2015).
So decide once what is genuinely urgent, and let nothing else through. Every event, mail, message, agent result, or reminder flows through triage you configure: what interrupts, what queues, what files silently. Only the level you mark critical pierces focus mode.
Mail, calendar invites, reminders, a nudge your assistant drafted, a Slack ping, a call you just finished — they all land in one inbox as small live cards, not a wall of subject lines. Reply, RSVP, sort, or mark it done right there in the card.
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.
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.
Insight happens between two things held in mind at once, and nothing you have to search for is ever in the room at the moment it would matter. Spaced review keeps the things you think with in your head — facts, but also the business idea you sketched and the approach you shelved.
A native desktop app with tabs, split panes, and a global capture hotkey. A phone app with offline capture, voice notes, meeting recording that captures you and the room on separate channels and transcribes onto a page, and full read access on the go: ask your graph through an agent and browse any page. A browser extension that saves any article or a deep research report from Claude/GPT as clean text.
Open any page as a standalone desktop app with its own window and dock icon: a dedicated Mail app, an app for one project. Every app is a window on the same graph, so links resolve between windows, they share one notification queue, and each app is its own access boundary.
Connect Google Calendar and your week mirrors in continuously, every attendee resolved to their person page. An agent can add an event on your behalf, waiting for your approval before it writes to your real calendar.
Send an e-mail with an ask and a waiting-for item opens; the reply closes it; a daily sweep nudges whatever has gone quiet. A clarify agent sorts every capture — trash, reference, someday, delegate, defer, or do — and when the next action is a reply, drafts it for your approval. A weekly review keeps the lists honest.
When a meeting ends, a feedback agent critiques the call against a playbook you curate and comes back with specific quotes from the transcript. Point the same agent at a hiring page for interviews or a support page for tickets.
Configure ingestion for the sources you follow: scrape specific sites, pull the newsletters you subscribe to, watch a handful of social accounts. Scheduled agents capture each new item, compile it into an interlinked wiki, and route it to the project pages that opted in, so what you read becomes knowledge you can search instead of a browser tab you lose.
Subspace runs on Node and tsx, React on the front end, an embedded Postgres, durable workflows compiled by the Workflow Dev Kit (WDK), and the Vercel AI SDK on the model seam — with AI SDK Harnesses slotting whole coding runtimes, Claude Code and Codex, into those same durable workflows as sandboxed background agents. The privileged core stays small — the graph, the command pipeline, the agent engine, gates and audit — and features like CRM, meetings, spaced repetition, outreach, GTD, and the ML research loop ship as plugins on the same contracts you can build on. Every definition, from a page type to an agent, is either a live page you edit or a file you deploy from git. Plugin authoring › · SDKs › · Architecture ›
Write a TypeScript function on a page and call it from any bullet. Page types, durable workflows, agents, skills, and tools are pages too, so the whole system is reshapeable without forking anything. A workflow is an ordinary async function whose steps are durable: it can wait days for an approval or a reply and resume exactly where it paused, on the same WDK engine the built-in agents run on. Functions › · Workflows ›
typescript, python) put the whole surface behind one scoped token, from a code cell, a cron job, or CI. A subspace-mcp server exposes the same methods to any MCP client. SDK docs ›'use workflow' // durable: suspends for days at zero compute, then resumes right here export async function followUpNudge(input) { const sent = await runTool(input.runId, { name: 'mail.send', // gated: waits for your approval args: { to: input.to, subject: input.subject, body: input.body }, }) if (sent.output === 'denied') return finishRun(input.runId) await sleepFor(input.delay ?? '3 days') // no process running if (!(await hasReply(input.runId, input.threadId))) { await runTool(input.runId, { name: 'mail.send', args: { subject: `Re: ${input.subject}`, body: 'Just following up.' }, }) } return finishRun(input.runId) }
Agent definitions, page types, mail rules, schedules, skills, and connectors are all pages, and any of them can be owned by a git repo. Subspace pulls the repo and reconciles it into the graph; the managed pages go read-only in the app, so the repo stays the single source of truth. Your automation is code: reviewed in a pull request, versioned, reproducible on a fresh install from the repo alone.
Subspace continuously mirrors every page to Markdown on disk in the Open Knowledge Format (OKF sync). Point Claude Code, a script, or a teammate's editor at the folder and let it work: Subspace pulls the edits back into your graph automatically, merged three-way per bullet, even while you edit the same page in the app.
Open a terminal as a tab or split it beside any page, rooted at the repo that page is about. It is a real PTY: your shell, your tools, ssh, a coding agent. The session is hosted by the app, so it survives reloads and a second window can attach to it. The place you think and the place you run commands are the same window. Docs ›
AI SDK Harnesses wrap a whole coding runtime — Claude Code, Codex — behind the Vercel AI SDK Subspace already speaks; Subspace runs it sandboxed, as a durable WDK workflow. Link a page to a repo, its beads (bd) issues mirror as checkbox bullets both ways, and a harness run picks one off the backlog — no terminal to babysit — streaming typed progress into the run tree and landing a pull request, a code/ page, or a gated plugin install, each filed as a card. Docs ›
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. Sharing & ACLs docs ›
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 stays on the page. 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.
Any directory page and the task queue render as a board: lanes come from a status field on the child pages, cards are the pages themselves. List and board are two views of one directory, so dragging a card is a real command on the ordinary audited write path — versioned, synced, and visible to agents like any other edit.
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.
A multi-channel outreach workflow runs a sequence for each prospect: an intro e-mail, a LinkedIn connection and note, a nudge if it goes quiet. It waits durably between touches and stops the moment they reply on any channel. Every touch is logged to the account page, which becomes the single record of who was contacted, where, and what came back.
Ask how your team answers these today:
These are memory, attention, and orchestration problems, not modeling problems. Everything on the Teams tab applies. The model-agnostic research graph installs on its own; an optional MLOps adapter adds run reading and launch scheduling. Because both are plugins, these loops are yours to configure, not a fixed product you have to accept. Autoresearch docs ›
Goals, hypotheses, observations, concepts, and pending proposals form the core graph. Add the MLOps adapter for runs, ordered backlogs, and 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 and every source or run that produced evidence. That graph is institutional memory.
| 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 |
Route the sources you already capture — papers, newsletters, web pages, and notes — through a research goal's specialized triage. Each item is injection-screened, distilled to an auditable concept when relevant, and linked to the hypotheses it bears on. Use ordinary triggers with the ingestion connectors you have installed when you want that capture to run on a cadence.
With the MLOps adapter enabled, a terminal run is read against your open hypotheses and drafts observations. Then, deliberately, the AI's reading stays hidden until you commit your own. The merged interpretation enters the record only after the review gate.
You can see the metrics above. Write what you think this run shows for H-07, then reveal and merge the analyst's draft.
A bounded heartbeat gathers one goal's current evidence and drafts pending hypotheses or status changes; it never approves or executes them. An optional Elo sweep compares a bounded set pairwise under a pinned judge rubric and writes advisory ratings. The broader multi-agent architecture is informed by Accelerating scientific discovery with Co-Scientist, but the shipped 1.0 loop remains explicit and human-confirmed.
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. Docs ›
Write what you want on a bullet and run the default agent on it with ⌘↵. It reads your graph, writes a Python code cell right under the line, and runs it in a kernel that already knows who you are. The analysis lands on the page it answers, next to the runs and hypotheses it came from: re-run it, edit it, or link its figure into a report.
import subspace; sb = subspace.Subspace() just works and the blast radius is only the scopes you granted. The same SDK drives cron jobs and CI from outside the app (see the Developers tab). Docs ›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.