# CruxHub

CruxHub is a working implementation of the Structure and Assessment layers [deployed at fenc.es](https://fenc.es), with agentic workflows on top and specs to expand into the ingestion layer on the roadmap[^1]. 

## Try it yourself
If you want to go meta, [here's me evaluating if this project should win](https://fenc.es/Flo/epistack-win-50k) this contest. You could either [complete this survey](https://fenc.es/Flo/epistack-win-50k/wdyt?i=dB) to see on which of my supporting points we have the biggest disagreement, or [create an account](https://fenc.es/users/register?code=FLF-epistack) and fork it (click copy to edit) to explain your evaluation.

## Goals
CruxHub wants to help people not waste time on dead-end arguments. Either by a) guiding people towards cruxy points in preparation for a discussion, highlighting which supporting/attacking arguments actually stand a chance of changing someone's stance on the main point. Or by b) helping people structure their own reasoning around a topic by augmenting the process with agent skills that leverage the argument graph.

The theory of change for CruxHub hinges on the fact that forming beliefs and making sense of the world is a fundamentally social endeavour, so we need tools that support the social aspects of this process.

### Features that are targeted at a):
- share your argument graph as a survey with someone, they rate the statements, the app tells them which points you should talk about.
- multi-user compare mode: your whole team collaborates on a graph and rates all the arguments (is this true?, is this important?), the app surfaces which arguments have the biggest delta in impact. (this can also be done with anonymous users in a live workshop setting, i.e. similar to slido)
- you add "sock puppet" ratings to your graph's arguments expressing "based on utterance U by author V, I estimate their confidence level as W and their importance weight towards the main point as X" these can serve both for explaining to others, here's where specifically disagree with this third party. Or you can use it in preparation for a discussion with someone, sending them the graph with their "sock puppet" saying: "Here's how I think you think about this topic, have I gotten your position right?"
- a group decision making mode built on mediation research, that uses the argument graphs as building blocks for an AI guided process helping a group to first agree on criteria and then to create proposals which are judged against those criteria, finally resulting in an approved proposal. [spec here](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/docs/specs/2026-06-10-group-decisions-design.md?ref_type=heads)

### Features that are targeted at b)
- every possible action on CruxHub is also exposed via MCP
- a set of agent skills helps with:
  - decomposing a text into an argument graph
  - argument graph guided deep research, mapping out the different hypotheses with their associated evidence throughout the research process, updating and changing the statements, connections and sock puppet ratings as subagents progress.
  - adversarial graph review: identifying weaknesses like correlated evidence in a graph's reasoning through iterated review with adversarial subagents using hallucination based halting.
  - theory of change builder, guiding the user towards a well structured theory of change graph for their project

In general goal for a) is make humans better equipped to have productive discussions by correctly understanding other's positions. While also gently moving people towards putting numbers on beliefs and structuring the supporting arguments instead of just randomly listing all the arguments they can come up with as soldiers for "their side".

The goal for b) is more paedagogical, giving people a process to follow to improve their own reasoning, which slowly introduces bayesian concepts, leading up to likelihood ratios (and in the future [Bayesian Networks with Conditional Probability Tables](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/docs/specs/2026-04-29-bayesian-lens-design.md?ref_type=heads)), with AI agents criticizing inconsistencies and/or correlated evidence in their graphs.

### Forks
A core feature that's still in development that supports both a) and b)'s goals are recommendations surfaced from forks. 

The app intentionally doesn't allow people to suggest changes or additions to other's graphs directly. The idea is that you create your own duplicate (fork) of their graph, make your modifications, and then the app surfaces optional changes to the original creator: "Others have included this argument on this topic, do you want to add it", "Here are possible alternative wordings for this point." This allows indirect collaboration that is less confrontational and avoids people getting into a defensive mindset.

## Agentic use
Initially I added a direct LLM integration to allow users to paste any text which was then decomposed by Gemini models into [ArgDown](https://argdown.org/) to import as argument graph. But I quickly realized that it is way more useful to expose all actions as MCP tools, so that everyone can use their preferred model, agent harness and general context to construct and modify graphs.

CruxHub also comes with a library of skills to enable specific use cases:
- [mapping-arguments](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/priv/skills/skills/mapping-arguments/SKILL.md?ref_type=heads) — extract argumentative structure from prose (essays, articles, debates, papers) as an ArgDown map for importing.
- [toc-builder](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/priv/skills/skills/toc-builder/SKILL.md?ref_type=heads) — walk through a 7-phase Theory of Change construction, with the result built as a Bayesian support-DAG.
- [crux-research](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/priv/skills/skills/crux-research/SKILL.md?ref_type=heads) — generate prompts for deep-research models that produce a written report alongside a DAG of beliefs and arguments.
- [adversarial-graph-review](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/priv/skills/skills/adversarial-graph-review/SKILL.md?ref_type=heads) — run an adversarial review loop that hardens an existing argument graph round by round: a fresh red-team agent critiques the graph, a builder agent adjudicates and applies the justified changes, until no valid criticism remains (hallucination based termination).

## General Design Approaches
All interactions are transmitted in real time to anyone viewing any page that displays any part of the same data. This is to facilitate use in workshop scenarios, during meetings, presentations, or just general real time group collaboration.

The app aims not to presuppose any knowledge of Bayesian decision making or probability theory, and to have a soft learning curve exposing people gradually to the more complex aspects. A typical scenario for first contact with the platform would be receiving a survey link, which is just a series of likert-like questions (agree/disagree) with a second slider indicating relevant/irrelevant, this hopefully results in a useful recommendation on which point to discuss. Later when the user wants to create their own survey, they can gradually discover the other modes and features.

All confidence level and importance weight data is tracked over time. This unlocks future features like visualizations for users on where their beliefs shifted over time (CruxHub Wrapped) but more importantly, as usage grows, these data give valuable insights into when the recommendations of the app, or the addition of specific arguments have actually consistently shifted peoples beliefs on specific sub-points.

To facilitate export and import the app uses the [ArgDown](https://argdown.org/) format, which is easily digestible to LLMs and was extended with metadata not present in the standard like confidence levels, importance weights and sock puppet perspectives. In general I want to be as open as possible to allow easy interchange with other tools that live in or adjacent to the argument mapping space. Kialo import/export is already implemented, and an integration with YouCongress to import quotes as grounding for statements and sock puppets is planned as well.

## Philosophy/Vision of the project

My original inspiration for this were in-person double-crux/productive disagreement workshops which I found very effective. I wanted to find a way to be able to use these techniques with anyone without prior instruction and at scale.

In the early phases of coming up with the idea for this project ~2019 doing the initial research I discovered a range of failed projects in the argument mapping space, still I (obviously) don't agree with the position that argument mapping is doomed to fail, I've expanded on this [here](https://cruxhub.org/3mklpzgsr6c22).

My current theory of change / how CruxHub could have impact is [here](https://fenc.es/Flo/cruxhub-full-time-realizes-substantial-impact) including my reasons not to focus on it full time. (mainly that I expect my current work doing cybersecurity consulting for AI safety orgs to be more impactful).

One way this could also be impactful is as visibility tooling for a Bengio-style 'Scientist AI' system, or more general for long-running agents that use belief graphs as a more structured form of memory made inspectable to the human operator through the CruxHub UI.

## Feature to Epistemic Stack Mapping
Here's how the existing and planned features map onto the contest's categories:

### Ingestion
Shipped: ArgDown import, MCP tools, the mapping-arguments skill, Kialo import. On the roadmap, and the most direct hit on this layer's "extract claims with provenance / capture metadata tags" brief, is the sources/utterances work [^1]: typed source links, citation spans with verbatim quote snapshots, immutable provenance, per-rater source reliabilities, and a dedicated `:model_output` source type for grounding claims that came from an AI's own introspection. Planned YouCongress quote-grounding imports third-party utterances as evidence for statements and sock puppets. The [Agent Belief Coherence spec](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/docs/specs/2026-05-10-agent-belief-coherence.md?ref_type=heads) adds embeddings-based semantic discovery so that an agent ingesting evidence over many sessions can detect the same claim reworded into two unconnected nodes.

### Structure
The graph itself, forks, likelihood ratios, tracked-over-time ratings ("track evolution over time" is a named bullet in their brief).

### Assessment
**Correlated-evidence detection:** 
The adversarial-graph-review skill's loop is aimed at finding evidence treated as independent that isn't, the crux-research protocol also forces intermediate nodes for shared-cause evidence. The [Agent Belief Coherence spec](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/docs/specs/2026-05-10-agent-belief-coherence.md?ref_type=heads) makes this automatic: soft-cycle detection flags the case where a piece of evidence is really the parent claim restated in different words (or semantically entails it).

**Crux surfacing:** 
- Compare mode ranks nodes by impact-delta across perspectives. In a 10-person meeting, identifying the actual crux might take 45 minutes of back-and-forth. With the right tooling, this could take 5 minutes.
- Survey mode is basically the Calendly of identifying cruxes for 1on1s: I do the upfront work of mapping my reasoning, you just click through a quick survey and the app gives you the likely highest value points for us to talk about. If do this once, it saves me time looking for cruxes with all future meeting partners with whom I discuss the topic.
- The same coherence spec adds a `list_belief_divergences` diagnostic that surfaces "hidden divergence" — a node rated 70% whose children's math implies 95% — so an inconsistency the rater would otherwise never notice becomes visible.

**Out-of-model error & calibration:**
Currently the independence assumption is a big limitation, and so is out-of-model error since the app is using what is basically naive Bayes, and this might trap up users. It's easy for them to feel like they have mapped everything. My rudimentary mitigations there have so far been limiting confidence to 1-99% instead of 0-100% to discourage absolute certainty ratings and instructions in the skills to look for correlated evidence. I'm planning to build more features to surface these problems on graphs in the future, but it hasn't been my focus so far since I was encouraging users to treat their graphs more as rough sketches with just enough information to help others tell you where they think you're wrong, than actual full models of a particular topic. With the addition of mcp and skills this has shifted somewhat and I haven't yet had time to build out features that directly address independance and out-of-model risk. Currently I'm leaning towards first building the full Bayesian Network mode with [CPTs](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/docs/specs/2026-05-10-conditional-probability-tables.md?ref_type=heads) with a UX that gradually lead people who've started out with rough 5 node sketch graphs all the way up to these. Then I can likely use those advanced features selectively to help people correctly mitigate correlated evidence and out-of-model risk. The [drafted spec](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/docs/specs/2026-04-29-bayesian-lens-design.md?ref_type=heads) for this does full Bayesian-network inference via variable elimination across the support DAG, explicitly handling correlated children through shared ancestry — which is the principled version of what the adversarial loop currently approximates by hand-inserting intermediate nodes. 
The LHC worked example (below) collided with exactly the limitation the spec addresses — additive dB supports can't pull a node below the 50% prior, so a [genuine conjunctive/gating relation can't be expressed](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/docs/issues/39-conjunctive-aggregation.md?ref_type=heads). 

### Would this actually help someone reason better about this case? Does it generalize? 
Personally I'd say yes, I have found it useful to map out my arguments to improve my reasoning. But this is of course anecdotal and I have not tested this against for example a control of just writing down my thoughts while discussing with Claude. I've quite a lot of uncertainty here. Because of this i've recently expanded the closed beta to more people to find out if it actually helps people reason better, but have not had time to really promote this and do actual user testing, much less a more rigorous experiment. If I had funding this would be the main thing I would like to hire someone to do: Set up actual experiments that would systematically falsify CruxHub's claimed paths to impact.

### Does it compound, with multiple people or teams building on each others’ work?
Collaboration is a core focus of the app, features like real time editing, direct collaboration with shared access on graphs and documents, forks as indirect collaboration, surveys and anonymous ratings (stored in the browser's local storage), and extended ArgDown as an interchange format are designed to scale with more users and teams.
My vision here would be: Teams at orgs like FLF use it to build their theory of change for a specific project collaboratively within the team using the shared access features and rate all the factors that go into it with confidence and importance. On specific decisions they might use the [future guided group decision feature](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/docs/specs/2026-06-10-group-decisions-design.md?ref_type=heads). Then they share that graph artefact with other teams to quickly surface cruxes, iterating on the graph using forks and surveys. The final version is then made public so that anyone can quickly see the critical nodes in the theory of change and can use survey mode to see where they disagree with FLF's assessment, or use it as structured input to their agent.

### Does it scale with improvements to AI or more compute?
Sock-puppet estimation and adversarial review are likely to improve as models improve. If I had the time and compute I'm also quite confident that a custom eval that judges the fidelity of the roundtrips text -> graph -> text and graph -> text -> graph using the included skill files could help improve those skill files to yield better results. In general I have done very little optimization, I assume even just giving Fable some example session transcripts of agents using these skills might surface ways to improve them.
While I currently lean on people using their own agents with mcp, more compute would also allow to provide a lot of this in app for users without them having to do any mcp setup, skill installation or back and forth with their agents. After all we're part of a bubble that knows how to do that, often forgetting that the majority of people are using the free version of ChatGPT. 

## Worked Examples

Here are my full claude code session transcripts with successive application of the crux-research and adversarial-graph-review skills. Due to time constraints I only ran each example once, and with minimal extra prompting. Normal usage would obviously entail multiple rounds of back and forth with the agent, rating statements yourself, then looking for cruxes with specific (agent-estimated) sock puppets, and then maybe doing additional more in-depth research rounds on those cruxes.

I recommend with a [logged in account](https://fenc.es/users/register?code=FLF-epistack) to also try making copies of the resulting graphs in write mode, and clicking around the arguments and adding your own ratings to get a feel for how a user actually can interact with these outputs. 

### COVID
The run reconstructed the early-2024 Rootclaim debate (Wilf vs. Miller, judged for zoonosis) as a single shared 47-node evidence tree rated by eight perspectives — the six analysts Scott Alexander compares (Rootclaim, Miller, both debate judges, Scott, Daniel Filan) plus Michael Weissman and the model's own puppet. The headline test was whether the debate's famous ~23-orders-of-magnitude spread would emerge as a *propagated* output rather than an asserted one — and it did: from Miller at P(lab) ≈ 10⁻²⁰ to Rootclaim at ≈ 0.999, each perspective within ~1 OOM of its published number. The map then makes legible something prose summaries don't: essentially the *entire* spread is manufactured at one node — everyone agrees the Huanan-market clustering exists, they disagree by ~44 dB (−50 dB for Miller, −6 dB for Rootclaim) on what it's worth. The adversarial review caught four real defects (a sign/text contradiction that had both lab-side analysts propagating too hot, a duplicated datum, incoherent null weights, a correlated-timing over-count) plus a shared-source correlation between the market and two-introduction clusters; removing the correlated over-counts honestly shrank the reported spread from ~23 to ~21 OOM and moved Rootclaim to +27 dB (554:1), almost exactly its in-debate 533:1 figure — the correction visibly working.

[fenc.es graph](https://fenc.es/Flo/h2-lab-manipulation-origin-import-eebb227357cb-5154?mode=compare&s=sigma&sp=019f7a85-d00a-7feb-bbb9-7ebfe19a9086%2C019f7a7e-5bfd-7fcb-a0c0-d15b23a02ab2%2C019f7a7e-3525-78d6-9a14-1bfe3209da38%2C019f7a7e-288f-7339-8de3-5224b630e73e%2C019f7a7e-169e-76cf-93bc-3a358d431b6c%2C019f7a78-534c-7012-a049-e9158b0af15c%2C019f7a7e-005c-73e7-9471-b9182de544af%2C019dd5d1-a14b-796f-9551-eae349632dd7)

[Claude Code session transcript (abridged)](transcript-covid-origins.md)

[Claude Code session transcript (full)](transcript-covid-origins-full.md)

### LHC black holes
The prompt deliberately split the question into two hypotheses: the physics claim that micro black holes posed no meaningful risk, and the epistemic claim that declaring the case "closed" was justified *at the certainty expressed*. A 105-agent deep-research workflow (every finding adversarially verified against primary sources) grounded a 34-node graph rated by five perspectives (the model, LSAG/CERN 2008, the Rössler/Wagner litigants, the x-risk epistemologists, and a historical-precedent lens). The map makes the real shape of the disagreement legible: every perspective that engages the evidence converges *above 0.90* on the physics, yet they diverge by up to 0.80 on whether the institutional certainty was warranted — the disagreement was never about black holes, it was about how much confidence an institution may claim in its own unprecedented experiment. This is also the most instructive adversarial run of the three, precisely because it did **not** cleanly converge and reports that honestly: severity fell monotonically over five rounds but no round returned zero valid findings, so by the skill's own definition it's a cap-out, not a clean bill of health. The model's propagated root fell 0.98 → 0.94 → 0.89 as correlated evidence was un-stacked (the round-1 referee's verdict: the original 0.98 was "the sound of correlated evidence being summed as if independent"), two adversary findings were correctly *rejected as confabulation* after the builder re-read the cited edges, and the run collided with a genuine engine limitation — positively-weighted supports can't pull a node below the 50% prior — which it filed as issue #39, an example of the workflow compounding into product improvements.

[fenc.es graph](https://fenc.es/Flo/was-the-pre-lhc-black-hole-catastrophe-risk-credibly-ruled-out?mode=compare&sp=019f7a78-914d-7d77-825b-b20c1ac71f52%2C019f7a78-80f3-7740-b2e1-5e78c200c7ef%2C019f7a78-5eba-76d1-b620-7534ed6a12fb%2C019f7a78-6c7a-784a-9f8a-e3f795d1c285%2C019f7a78-534c-7012-a049-e9158b0af15c&v=axis)

[Claude Code session transcript (abridged)](transcript-lhc-black-holes.md)

[Claude Code session transcript (full)](transcript-lhc-black-holes-full.md)

### Eggs
This is the one run that *converged* — in round 5 of a 5-round cap: the root sits at a stated 0.85, conservatively *below* the 0.881 it propagates to, and the round-5 adversary reproduced the propagation arithmetic by hand before accepting. Every finding across rounds 1–4 was valid (the rejection ledger stayed empty until the final round), and most were correlated-evidence catches: two studies were double-counted along two paths each, and three overlapping CVD meta-analyses that share underlying cohorts (Frontiers / Godos / Zhao) were down-weighted and cross-annotated with shared-source undercuts. The run also shows disciplined restraint: one round-5 recommendation was deliberately *not* applied because its literal remedy would have made a discount stop propagating and re-inflated a node the loop had just fixed — the builder refusing a plausible-but-wrong suggestion, and documenting why.

[fenc.es graph](https://fenc.es/Flo/for-the-general-adult-population-are-eggs-net-good-net-bad-or-fine-in-moderation-to-eat?mode=compare&sp=019f7a78-534c-7012-a049-e9158b0af15c)

[Claude Code session transcript (abridged)](transcript-eggs.md)

[Claude Code session transcript (full)](transcript-eggs-full.md)

### Infrasound
An additional example that I built during and following a series of discourse rounds on Bluesky and blogposts is [Do Data-Centers cause harm through Infrasound](https://fenc.es/Flo/infrasound-harms-at-dc-levels?mode=compare&sp=019dea64-d425-7694-ba95-968b99aad554%2C019dc183-578c-78ae-98e7-aaee4e17bede%2C019dc149-3bb2-7f54-bbdc-335ee4ffb146%2C019dc149-057f-7f15-baa0-1c49b40bdc5e) which includes a range of academic papers and uses confidence level to show subjective quality of a paper's methodology and importance weight as how relevant to the main point one considers its conclusions.

---

[^1]: [Sources/Utterances Spec](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/docs/specs/archive/09-sources.md?ref_type=heads)
[Importers for Utterances](https://gitlab.com/cruxlabs/cruxhub/-/blob/dev/docs/specs/archive/2026-07-04-utterance-importers.md?ref_type=heads)