HN Debrief

Show HN: ThoughtDAG – An editable context graph for LLM conversations

  • AI
  • Developer Tools
  • Open Source
  • Security
  • UX

ThoughtDAG is a desktop tool for running LLM conversations on a canvas instead of a linear chat. Each question and answer becomes a node, and the links are not just visual. They decide which upstream material is included in the next prompt. The pitch is explicit, human-controlled context management for long-running work like research, learning, and coding. You can branch, prune, weave, condense, attach PDF snippets with provenance, and keep old explorations visible without letting them keep polluting future answers.

If you build AI tooling, treat editable context selection as a real product primitive rather than assuming bigger windows or retrieval solve the problem. The opportunity looks strongest as a plugin or API that existing tools can read from and write to, with UX that explains context in plain lists before exposing graph surgery.

Discussion mood

Positive on the core idea and its fit for context drift, but skeptical of the standalone app and current UX. People saw real value in explicit context control, then immediately asked for editor and agent integrations, simpler explanations of what is in context, and more polish. The confirmed security bug was a sharp negative note, softened by the fast fix.

Key insights

  1. 01

    The product wants to be infrastructure

    The enthusiasm kept collapsing into the same request: stop making this another place to chat and make it a context service other tools can use. Comments named Claude Code, Codex, Replit, editors, and planning tools because the pain is not missing chat surfaces. It is missing a shared way to inspect, branch, and prune what agents carry forward. That shifts ThoughtDAG from “alternative client” to “memory and context boundary” for an existing workflow.

    If you are building in this space, design an API and plugin boundary early. A read-only selected-context feed is probably the minimum useful integration, but write-back support is where this becomes a workflow substrate instead of a demo.

      Attribution:
    • embedding-shape #1
    • chatchan #1 #2 #3
    • esperent #1
  2. 02

    Graph power needs a plain-language layer

    The graph is doing real work, but it is not self-explanatory to mainstream users. Comments singled out weave and condense as friendlier than deleting edges, and asked for a sidebar that answers a concrete question like what prior facts this answer can see. That framing matters because the product is about hidden prompt state. Users need a direct explanation of included context before they can trust visual wiring controls.

    Expose context as an inspectable list, not just a topology. If users cannot quickly verify what the model will actually receive, they will treat the graph as decorative and fall back to ordinary chat habits.

      Attribution:
    • mikeebener #1
    • chatchan #1
    • kody_06 #1
  3. 03

    Manual context editing competes with caching

    Editing history is useful precisely because it lets you drop a toxic early detail without restarting the session, but that can work against prefix-cache reuse. The author said ancestor-only inclusion has not shown measurable slowdown yet and that long contexts still need benchmarking. The practical point is that this interaction model is not free. It trades some prompt reuse efficiency for better control over what survives into later calls.

    Benchmark context surgery against your provider’s prefix caching behavior before promising performance. In hosted and local setups alike, the win may be quality and recoverability rather than raw latency.

      Attribution:
    • chatchan #1 #2
    • esperent #1
    • olejorgenb #1
  4. 04

    Debugging context is easier than explaining reasoning

    A useful distinction emerged between showing what the model saw and claiming to show why it answered the way it did. Comments pushed back on the idea that agents can cleanly explain their own causality, even if they can summarize traces, tool outputs, or visible prior turns. ThoughtDAG landed on the narrower and more defensible target: make incoming context legible and editable. That is a much sturdier product promise than AI introspection.

    Build observability around prompt inputs first. Treat model self-explanations as hints, not ground truth, and avoid hinging core UX on the claim that the model can faithfully report its own causes.

      Attribution:
    • Esras #1
    • r3trohack3r #1
    • panarky #1
    • chatchan #1
  5. 05

    This pattern is converging across projects

    Multiple people said they had built near-misses already, from browser branching tools to Neo4j plus Cypher control to research harnesses and other chat graph products. That is a sign the problem is real and recurring, not a quirky personal workflow. The shared target is selective carry-forward of explored branches, often for research breadth, blind-spot checking, and preserving dead ends without letting them contaminate the main line of work.

    Assume editable context graphs will become a category, not a lone experiment. Differentiate on interoperability and workflow fit, because the basic idea is already obvious to many heavy LLM users.

      Attribution:
    • floriangoebel #1
    • Xx_crazy420_xX #1
    • Zierax #1
    • smrtinsert #1
    • _boffin_ #1
    • UltraSane #1
  6. 06

    Local-first still needs serious security hygiene

    A commenter found a command injection path in PDF rendering, combined with a server binding that exposed the app on all interfaces. The author confirmed it as urgent, removed shell execution, tightened validation and origin restrictions, and forced localhost binding. The episode changed the product from harmless sketch to normal software that can hurt users if packaging and local services are sloppy.

    Audit desktop AI tools like any other networked app. Check shell calls, bind addresses, origin controls, package signing, and sandbox settings before asking users to run local binaries.

      Attribution:
    • embedding-shape #1
    • chatchan #1 #2

Against the grain

  1. 01

    Public bug reports can be the wrong venue

    The objection was not about the bug itself but about disclosing a live exploit path in a public thread. That cuts against the mostly approving response to the fast patch. It is a reminder that “early alpha” does not automatically erase responsible disclosure norms once people are downloading binaries.

    If you publish installable software, set a visible security contact and disclosure path. That gives reviewers an alternative to dropping exploit details into public launch threads.

      Attribution:
    • fractorial #1
  2. 02

    The launch page undermined the product

    A few comments were harsher than simple UX nitpicks. They argued the homepage read like generic AI landing-page sludge and even warned against using LLM-written promotional copy. That pushed on credibility, not just aesthetics. For a tool about making context explicit, vague marketing language made the product harder to trust.

    Lead with the actual interaction and cut generic AI page furniture. In this category, clear demos and precise language do more persuasion than polished landing-page tropes.

      Attribution:
    • darrmit #1
    • angoragoats #1 #2

In plain english

Claude Code ↩
Anthropic’s coding-focused command-line agent tool, used here through Emacs integrations or terminal sessions.
Codex ↩
An AI coding model name commonly used for systems that generate or edit code from prompts.
command injection ↩
A security flaw where untrusted input is treated as a system command, letting an attacker run unintended commands.
compaction ↩
A technique for shortening conversation history while trying to preserve the important facts and decisions for later turns.
Cypher ↩
The query language used to search and manipulate data in graph databases such as Neo4j.
LLM ↩
Large Language Model, a machine learning model trained to generate and analyze human-like text.
local-first ↩
A software design approach where apps work primarily with local data and sync changes later, reducing dependence on central servers.
Neo4j ↩
A graph database that stores data as nodes and relationships rather than rows and tables.
PDF ↩
Portable Document Format, a file format commonly used for documents with fixed layout.
provenance ↩
Information about where a piece of text or data came from and who or what produced it.
Replit ↩
A browser-based coding platform that includes hosted development environments and AI assistance.
retrieval ↩
A method where a system searches external documents or notes and inserts only the most relevant pieces into an LLM prompt.

Reference links

Project links and adjacent tools

Related discussions and references