Tana Outliner and the new Tana can finally talk to each other. In this systems lab, Mark walks through the release of Tana Outliner Remote MCP: what it is, how to connect it, and the workflows it opens up between the two tools. Remote MCP is the hosted version of the Outliner MCP server, so a client can reach your graph over the internet with the desktop app closed.
What Remote MCP is [0:45]
MCP lets an AI tool read and act on the software you use. Tana Outliner has had a local MCP since the start of the year: the desktop app and your AI client both run on the same machine and talk over localhost. Remote MCP moves that connection to the cloud, so your client reaches Outliner over the internet with the app closed, and the new Tana can finally query your Outliner graph.
Set it up in the new Tana [5:00]
Setup is far simpler than the local server: no tokens, no localhost, nothing to keep running. In the new Tana, open Settings, go to Custom MCP servers, and click Add server. Paste the hosted URL, give it a name like "Outliner MCP", and add it. Tana Outliner asks you to allow the connection; click Allow and you are connected within moments.
Which plan you need [6:45]
Remote MCP requires a paid Tana Outliner plan. The local MCP server stays free for everyone. A paid plan also includes access to the new Tana, so it can stand in as a Claude Code or Codex alternative when you would rather not run a client locally.
Query your Outliner from a chat [9:00]
Start a chat in the new Tana, type slash to pick the Outliner MCP, and ask about your graph. Ask what tools are available and it lists what it can do: list workspaces, search nodes with the same query structure you use in Outliner, read nodes and walk their children and parents, and read or edit supertags. Natural language sometimes needs a nudge, say "nodes tagged with OKR" rather than "OKR instances", which is exactly what a skill file is for later.
Turn Outliner context into documents [15:00]
Ask the AI to pull context around something in your graph and write it up as new documents in the new Tana. It follows references beyond the direct path, so it can gather surrounding context, a related meeting transcript, or notes on cost and profitability, and synthesize a useful brief rather than dropping a raw link. Handy for prepping a meeting from a backlog that lived only in Outliner.
Query Outliner live in a meeting [23:35]
The new Tana is built around meetings. Start one and it records a transcript you can pause at any time. In the meeting's private chat you can ask it to read the transcript and pin the relevant Outliner documents to the meeting, so material you prepared earlier is one request away mid call.
Keep your Outliner node IDs [30:00]
When you bring content across, ask the AI to include the Outliner node IDs. With a node ID you can always jump back to the source: use an @ mention or Command S in the new Tana and paste the ID to resolve the exact node. It keeps the structured references from your Outliner graph intact instead of flattening them into plain text. Worth saving as a habit in a skill.
Send content back to Outliner [32:50]
The connection runs both ways. Ask the new Tana to summarize documents into a mermaid diagram and send it back into a specific node in Outliner, and it creates the content there. You can create documents, canvases, and tasks in Outliner from a Tana chat the same way.
Save it as a reusable skill [39:00]
Once a workflow works, tell Tana to turn it into a skill. It reads what you just did and writes a repeatable version, often preserving good practices like carrying node IDs across on its own. Run the skill by name from the slash menu. You can hook up other tools the same way, from GitHub and Jira to Linear or another note app's MCP.
Run agents without your machine on [45:15]
Because the server is hosted, a cloud agent can reach your Outliner around the clock with nothing running on your desktop. A small virtual server running Claude Code or Codex, reachable from Telegram, WhatsApp, or a voice call, can query your graph while you are away. It also points toward building your own lightweight mobile front end for a graph that has always been heavy to load on a phone.