GoalT
A multi-parent, value-propagating goal tree for Claude Code. Turn a project into a map of why everything in it exists, see which goal actually pulls the most weight right now, and watch a live dashboard light up as Claude works on it.
No cost, no account, no lock-in. _
Not every goal deserves equal attention.
It's a tree of purposes, not a list of tasks. Every goal answers one question: what is this actually for? GoalT models that as a value-propagating graph. The root goal starts with a value of 1.0, and that value flows downward through every dependency, so the sub-goal with the most real pull on the outcome is always the one that rises to the top.
As a project grows, it gets harder for any one person to hold the whole reason for it in their head. GoalT keeps that reason visible as the graph grows, instead of letting it live in one person's memory.
It's a DAG, not a tree
A goal can have more than one parent. Cycles are rejected explicitly: the graph can't loop forever.
Value flows from one root
The root always holds 1.0. Every sub-goal's weight is computed from how real dependencies actually connect to it, not from where it sits on a list.
Math by default, LLM optional
A deterministic equal-split fallback always converges with zero API calls. An LLM can be plugged in to weigh edges, but its output is always validated and re-normalized: it never sets values directly.
Updates are incremental
Adding one goal only recomputes the sub-graph it affects, not the whole tree.
Watch it happen, live.
A single local dashboard, no build step. Every tool call pulses the header. Editing a file linked to a goal lights that node up green. Uncommitted work stays marked amber until it's committed.
Rework the payment flow to support saved cards.
Built to be actually used, not just looked at.
Live activity pulse
Every tool call pulses the dashboard header, guaranteed: wired through a Claude Code hook, not a tool Claude has to remember to call.
File-edit auto-highlight
Link a goal to its files once. Every edit to those files lights the goal up automatically: deterministic path matching, zero cooperation required.
Uncommitted-work tracking
A background thread polls git status and marks goals amber the moment their files diverge from HEAD, independent of what's being edited right now.
One click into VS Code
Every related or changed file is a vscode:// link. Files with uncommitted changes get a real side-by-side diff button, no setup required.
Two-command install
Add the marketplace, install the plugin. bootstrap.sh finds Python and installs dependencies itself: no manual clone, no manual pip install.
Deterministic, LLM optional
The default equal-weight propagation always converges with zero API calls. Plug in an LLM for smarter weighting only if you want it.
Press start.
Two commands inside a Claude Code session. No separate clone, no manual pip install: bootstrap.sh finds Python and installs everything itself the first time it runs.
$ /plugin marketplace add GOAL-T/goaltree$ /plugin install goalt@goalt-marketplace
Wires up the MCP tools and the live "Claude is currently..." activity hook automatically.
$ git clone https://github.com/GOAL-T/goaltree.git$ cd goaltree$ claude mcp add --transport stdio goalt -- bash "$(pwd)/bootstrap.sh"
Still gets you every tool, just not the automatic pulse. That part relies on the plugin's hook registration.
Then, in a Claude Code session: "run /goalt:start" to onboard an existing codebase, or just describe your goals and Claude will call create_tree, add_goal, and open_dashboard for you.
GoalT ships as a Claude Code plugin first: MCP tools, a PreToolUse hook, and a /goalt:start command that onboards an existing codebase for you. It exists so people already using Claude Code get a live, visual answer to why the project is shaped the way it is, and which goal actually matters right now.
Made independently, not by Anthropic. Free and open source under Apache 2.0.
Concept-stage, and said out loud.
GoalT is a reference implementation of an evolving idea, not a finished product with something to oversell. The README keeps a running list of what's unproven. Here's a sample:
Convergence with LLM-driven weights isn't proven at scale: only observed on small graphs.
Global value isn't conserved across the whole graph, only locally per parent: intentional, but easy to misread.
No benchmark yet against classical prioritization methods (AHP, weighted scoring, OKR cascading).
Cycle detection is a defensive backstop today, not yet load-bearing: it matters once goal-linking ships.
Breaking it is as useful as extending it: if you build a graph that produces something wrong or unstable, that's exactly the feedback this needs right now.