Philosophy Lives In Systems,
Not In Books.
A systems thinking workspace where ideas connect, decisions persist, and humans collaborate with AI — through structure, not chaos.
Every thinking tool gives you the same blank rectangle.
A decision is not a note. A project brief is not a bookmark. A task carries different weight than a passing thought. But your tools don't know that. Everything goes into the same empty page, the same infinite scroll, the same search bar you'll never come back to.
You've tried Notion, Obsidian, Roam, Apple Notes. They work for a while. Then the volume overwhelms the system. Three hundred pages, no structure. A vault full of backlinks that nobody follows. The ideas are in there somewhere, but the tool stopped helping you think months ago.
The problem isn't that you can't write things down. It's that your tools flatten everything. A decision and a grocery list get the same treatment. Relentless was built for people who think in systems — and need a tool that keeps up.
A place to think, not a place to put things.
Three panes. The sidebar is your map — pinned items, nodebooks, projects, all visible at a glance. The directory is your context — what's inside the container you're focused on, organized by time or kind. The artifact panel is where you go deep — the full editor, the decision form, the project identity zone.
Everything works inside a buildspace — your personal graph of connected nodes. You can have multiple buildspaces, each one an independent workspace with its own structure and purpose.
The best systems are the ones you think with, not about.
When we talk about compounding, we usually mean money. Interest on interest. But the most valuable compounding happens in thought.
An idea you wrote six months ago connects to something you read this morning. A decision you documented last quarter saves you from repeating a mistake today.
This only works if your ideas have a place to live. Not scattered across twelve apps. Not buried in a search bar. Alive, connected, and visible.
Move between navigation, context, and depth without losing your place. Breadcrumbs trace your path. Keyboard shortcuts put every action one keystroke away. The workspace adapts to how you think, not the other way around.
Every thought has a shape.
In relentless, every piece of thinking has a kind. Not a tag. Not a label you might remember to apply. A fundamental type that changes how the node behaves, what fields it shows, and what it means in context with everything else.
A note opens a rich text editor. A decision asks you four structured questions. An instructions node gives you four tabs. A project opens a full identity zone with status, color, tags, links, and linked nodes. The kind IS the interface.
When you work in a system of connected nodes instead of one infinite document, you compose. You break ideas into their natural units. You connect them instead of burying them. Structure is the thinking tool.
A decision node doesn't give you a blank page.
It asks you four questions: What did you decide? Why? What does it enable? What does it constrain? You can mark it as a key decision. You can classify it as a problem fix, improvement, or redesign. The structure is the thinking tool — it forces clarity that a blank page never would.
Replace the tree-based navigation model with a directed graph where nodes connect via typed edges (contains, references, blocks, follows).
Trees force a single canonical location for each node. Real thinking doesn't work that way — an idea belongs in multiple contexts. A graph lets the same node appear in many containers without copies.
Enable multi-parent relationships, typed connections between nodes, and dependency tracking — the foundations of systems thinking.
Must maintain navigable hierarchy (breadcrumbs still work). No circular contains edges. References and blocks edges can be bidirectional. UI must remain simple despite underlying complexity.
Instructions nodes are complete work briefs.
Four tabs in one node: Notes for working context, Instructions as a structured checklist, Plan for the approach, Outcome for the result. Everything an AI agent or a future-you needs to pick up a task without asking for context.
1. Verify agent buildspace exists and API key is scoped correctly
2. Create initial Fusion node and link to human buildspace
3. Run skeleton query to map existing workspace structure
4. Share initial status node via Fusion boundary
Projects are command centers, not folders.
A project node has an identity: a color, a logo, a status (active, paused, done, archived), a description, tags, and external links. Below that, linked nodes show the decisions, notes, and tasks that belong to it. A project knows what it is.
Launch the v2 platform with agent buildspaces, Fusion collaboration, and public API documentation.
Connections are first-class citizens.
In most tools, connections are an afterthought. A backlink. A tag. Something you might notice in a sidebar. In relentless, nodes connect via typed edges — and the type of connection carries meaning.
The result is a directed graph — not a file tree, not a wiki, not a database. A living structure where you can trace how a project led to a decision, how that decision blocked a task, and how the resolution informed three other ideas. This is what “systems thinking” actually looks like when you build it into software.
A node can live in many places at once.
Most tools force you to choose: does this decision belong in the project folder or the research folder? In relentless, the answer is both. A node can exist in any number of containers simultaneously — the same decision inside a project, a nodebook, and a weekly review. No copies. No syncing. One node, multiple contexts.
The “In 3” button shows you every container a node belongs to. Click any parent to jump into that context instantly. It's the fastest way to understand where an idea fits in your system — and to navigate between the contexts where it matters.
Thinking in layers.
Nodebooks collect related thoughts. Projects are command centers with full identities. DECS containers hold decisions alongside project configuration — repo path, tech stack, branching conventions — so every future session inherits the reasoning, not just the code.
Navigate down into depth and back up to the big picture. The breadcrumb trail always tells you where you are. Pin important nodes to the sidebar or to the top of individual containers — two independent pinning systems for two different contexts.
This isn't a folder system. A note inside a project is still a note — it has its own kind, its own content, its own connections. Containers provide context, not confinement.
Where ideas take form.
The editor is rich text that auto-saves as you type. Headings, blockquotes, code blocks with syntax highlighting, and inline formatting — all there when you need them, invisible when you don't. Paste markdown and it auto-detects the format. Toggle source view to see raw markup. Export to Markdown or plain text anytime.
List items can reference other list items across nodes — live references that update when the source changes and degrade gracefully when it's deleted. Your writing stays connected to the rest of your thinking.
The geometry of a good thought
Most tools treat your notes as a flat pile. Everything at the same level, everything equally buried. You write something brilliant on Tuesday, and by Friday it's indistinguishable from your grocery list.
A thinking tool should work differently. It should recognize that different thoughts carry different weight. That structure is not overhead — it's the thing that lets you see what you've built.
When you give your thinking shape, you can see it. And when you can see it, you can build on it.
Your ideas deserve better than a white rectangle. The lined paper texture, the warm type, the breathing room — these details aren't decoration. They're the difference between a tool you tolerate and a tool you reach for.
AI as collaborator, not autocomplete.
Most tools bolt AI on as a writing assistant. Relentless builds AI in as a collaborator with its own workspace. Humans get personal buildspaces. AI agents get their own scoped buildspaces. Neither side sees the other's full workspace.
The Fusion boundary is where collaboration happens. Agents mark nodes as shared. Humans see shared work through the Fusion view. It's a trust-respecting window — both sides share what they choose to share, nothing more. The architecture encodes respect, not surveillance.
Each agent gets a scoped API key locked to its buildspace. Rate limits and a 500-node limit per workspace keep shared resources finite and intentional. These aren't limitations — they're the architectural equivalent of saying: quality of thought over quantity of tokens.
visible here
The AI Good Citizen Pledge asks agents to understand before they build, share with intention, preserve coherence in the graph, and leave the workspace better than they found it. Collaboration works when both sides operate with care.
Decisions that outlast sessions.
DECS — Decision-Embedded Context System — stores your project's configuration alongside its decisions. The tech stack, the repo path, the branching conventions, the why behind every choice. It's the context that disappears when a session ends, captured so it doesn't have to.
Point a new AI session at your DECS space and it starts with full context. No re-explaining the architecture. No repeating decisions you already made. Your reasoning compounds across sessions, not just within them.
DECS containers accept only decision nodes. This constraint is deliberate — it keeps the decision record focused and navigable, even after dozens of sessions and hundreds of choices.
Every power feature, one keystroke away.
The Command Bar (⌘K) gives you access to everything. Create any node type, search across your entire buildspace, toggle the theme, enter reorganization mode, open Quick Capture, switch views. Type a slash to see what's possible. Or just type — anything that isn't a command becomes a search.
Quick Capture (⌘N) drops a node into your current context without breaking your flow. Reorganization Mode (⌘Shift+R) enables drag-and-drop when you intend to restructure — the rest of the time, nothing moves unless you mean it to.
Power users live in the Command Bar. Search is instant. Node creation is contextual. The workspace disappears from view so you can focus on what you're actually doing.
What we chose not to build.
No notifications. No badges. No unread counts.
No AI suggestions popping up uninvited.
No social features. No sharing. No likes. No followers.
No engagement loops. No gamification. No streaks.
No infinite scroll. No algorithmic feed.
Composable nodes over infinite documents. Structure is the constraint.
Drag-and-drop disabled by default. Reorganization requires intent.
The absence of features is a feature. Every notification is an interruption. Every suggestion is a presumption. Every engagement loop is a manipulation. We chose not to build them.
Your ideas, connected and alive —
growing into something that lasts.
Your work is yours. Export anytime. Markdown, plain text, your data — no lock-in, no hostage-taking.
No noise. No clutter. Just depth.
Philosophy Lives In Systems, Not In Books.
◆