Tangential
Tangential

Keyboard-first · Multimodal · Local-only

AI chat that grows like a mind,
not a scroll.

Tangential turns every conversation into a branching knowledge map on an infinite canvas. Chase many lines of thought at once, wire nodes together for context, and read any branch back as a familiar linear chat.

Open the canvas See how it works

No sign-up, no backend — start free with your own API key.

A Tangential knowledge map about bioluminescence: a root node branches into four questions, each with its own answer, laid out on a dark canvas.
Free to start · no credit card

Bring your own key — and go with OpenRouter's free models

Paste an OpenRouter key and you're generating in seconds. Its catalogue includes plenty of models that cost nothing, so you can build your first knowledge map without spending a cent — then swap in a premium model whenever you want more power. Straico works too, and the app always talks to your provider directly, never marking up a token.

Start free
OpenRouter free models Straico

The idea

Linear chat forgets.
A map remembers.

A normal AI chat is one long scroll — every tangent buries the last, and branching means starting over. Tangential makes each prompt-and-answer a node you can branch, wire, and revisit, so your thinking becomes a space you can actually navigate.

The old way

One endless scroll

  • Tangents push good ideas out of view
  • Exploring an alternative means a whole new chat
  • Context is whatever happened to come before
Tangential

A living knowledge map

  • Every branch is its own line of thought, side by side
  • Fork any node to explore without losing your place
  • You wire exactly what context each node can see

What you can do

Built for branching thought

Branch any thought

Spin as many children off a node as you like. Each branch is an independent line of reasoning you can compare at a glance.

AI suggests what to ask next

Clickable next-prompt ideas drawn from a node's ancestors — nudge them exploratory, deeper, tangential, or critical.

Wires are context

Draw a wire and a node inherits its parents' history. Cut it and that context is gone. You decide precisely what the model sees.

Text, image, video & audio

Every node can be multimodal. Generated media lives inline on the canvas, and images flow into the nodes that build on them.

Never trust a stale answer

When a parent changes, descendants built on the old context are flagged amber — so you rerun only what actually needs it.

Read any branch as a chat

Open a ChatGPT-style pane beside the map. Reply to continue a branch, fork any message into a new one, and switch between branches like tabs.

Skim it as an outline

The thread pane turns your whole map into a collapsible index — every node a row, every answer previewed — so you can jump straight to any point.

Keyboard-first

Create, branch, navigate, generate, and auto-lay-out your whole map without ever reaching for the mouse.

Close-up of three nodes: a prompt in monospace above its rendered answer, a warm note, and green branch-off suggestion chips.

Anatomy of a node

Prompt, answer, and everywhere it could go next

Each node pairs a prompt with its answer, rendered in Markdown. Add a title and free-form notes that never reach the AI, then follow the green branch-off suggestions to spin up the next question.

The map on the left and a linear chat pane on the right, showing the selected node's thread as user and AI messages with a branch switcher.

Prefer to just chat?

Any branch, as a familiar linear conversation

Open the chat pane beside the map and read a whole branch top to bottom. Every reply becomes a new node, ⑂ fork a message to try a different tack, and use the ‹ › switchers to flip between branches — the map stays perfectly in sync.

The thread pane as a collapsible outline: each node is a row with its answer previewed and reply counts, nested under its parent.

See the whole shape

Or skim the map as an outline

The thread pane folds your entire map into a linear index — every node a row, every answer previewed, nested under its parent. Collapse the noise, find the thread you want, and jump straight to that node.

Split view: the branching canvas on the left and the outline index on the right.

Best of both

Canvas and outline, side by side

Keep the big picture and the detail in view at once. Work spatially on the left, read the index on the right — they stay perfectly in sync.

How it works

From a blank canvas to a map in three steps

  1. 1

    Bring your own key

    Add an OpenRouter or Straico key in Settings — OpenRouter's free models let you start at no cost. It's encrypted at rest and never leaves this browser.

  2. 2

    Branch your questions

    Start a node, press Tab to branch a child, and let the AI suggest where to go next — or type your own prompt.

  3. 3

    See the shape of an idea

    Wire nodes for context, tidy the whole map with a, and switch between map and thread whenever you like.

Yours, and only yours

Completely local. No backend, ever.

There's no server to sign up for and nothing to trust with your data. Projects live in your browser's IndexedDB, settings in localStorage, and API keys are encrypted at rest with WebCrypto. The only libraries — a Markdown parser and sanitizer — are vendored in, with no build step; generating answers is the one thing that reaches out, calling the AI provider you choose directly.

  • Encrypted keysAES-GCM, non-extractable — never in exports or snapshots
  • Direct to providerRequests go from your browser straight to OpenRouter or Straico
  • No build stepA plain static app — open it, or self-host in seconds

Fast by design

Your hands never leave the keyboard

Tab new branch n new sibling Enter edit Ctrl+Enter generate [ ] context depth , . versions a auto-layout c chat pane w switch view ? all shortcuts

Start mapping your next idea.

Open a blank canvas and press Tab. That's the whole tutorial.

Open the canvas

Runs entirely in your browser.