# Graph Desk

> Paste an edge list for any network - an org chart, a software dependency graph, a supply chain, a
> citation network, a social graph - and get its exact structure computed free in the browser: degree,
> connected components, cut-vertices and bridges, cycles, clustering coefficient, closeness and
> betweenness centrality, diameter. An AI pass, held to those exact numbers, explains what the structure
> means and can turn it into a decision brief for a stated purpose.

- URL: https://graph-desk.skillsafe.ai/
- API docs: https://graph-desk.skillsafe.ai/api.html
- Token panel: https://graph-desk.skillsafe.ai/tokens.html
- Platform: SkillSafe (https://skillsafe.ai/)
- Model: `gpt-terra` (the balanced OpenAI tier alias)
- Price: the app itself is free; each run costs the signed-in user credits for the model call

## What it is for

One user, in one sitting, holding one pasted network they want understood: which nodes matter and why,
what is fragile, whether the paste itself looks right, and - if they want it - a short decision brief
tailored to what the network actually is. Graph Desk is not a graph drawing tool, a database, or a
recommendation to act against a specific person; it describes structure.

## The one work object

An **edge list**: one relationship per line. Recognised separators: arrows (`->`, `<-`, `<->`, always
directed regardless of a toggle), commas, tabs, semicolons, pipes, or a spaced dash (`A - B`). An
optional trailing weight (`A -> B : 3.5`). A bare line with a single name declares an isolated node. A
toggle governs how the ambiguous separators (comma/tab/semicolon/pipe/dash) are read when no arrow is
present - undirected by default, or forced directed. A `purpose` field (org chart, dependency graph,
supply chain, social network, citation network, or other) steers only the `brief` lane's language.

## The two lanes

Both read the same graph and return the same envelope; only the `body` differs.

1. **`structure`** — which nodes are hubs, cut-vertices, bridge endpoints, sources or sinks, and why;
   an overview of the graph's overall shape; a note on its connected components. This is the
   inspect-and-decide stage, and it is the one that usually hands off to `brief`.
2. **`brief`** — the same graph turned into a short, decision-oriented brief for a stated purpose:
   ranked priority actions, per-node recommendations, and longer-term structural suggestions. Reads
   `prior_structure` (the `structure` lane's own prior output on the same graph) as established context
   when the user follows the handoff button, rather than recomputing everything from scratch.

## What runs free, in the browser, with no account

- **Parsing** every recognised separator and weight syntax, with isolated-node declarations.
- **Degree distribution** — min/max/mean/median, top-10 by degree, and in/out-degree when the graph has
  directed edges.
- **Connected components** (the undirected projection) — count, sizes, and the largest component's share
  of the graph.
- **Strongly connected components and DAG detection** for directed graphs (Kosaraju's algorithm),
  including the source and sink node lists.
- **A cyclomatic (independent-cycle) count**, computed exactly from edges, nodes and components.
- **Cut-vertices and bridges** (Tarjan's algorithm) — the nodes and edges whose removal fragments the
  graph, computed iteratively so a large paste cannot overflow the call stack.
- **Global and per-node clustering coefficient** (triangle density around each node).
- **Closeness and betweenness centrality** (Brandes' algorithm for betweenness), each with a size guard
  so an unusually large paste degrades to a stated "skipped" note rather than hanging the tab.
- **Diameter and average shortest-path length** on the largest component.
- **Flags**: self-loops, duplicate edges collapsed, isolated nodes, a disconnected graph, one dominant
  node, two node names that differ only by case or whitespace, truncated input, and metrics skipped for
  size.
- **Exports**: nodes and edges as CSV, and the read-out as Markdown - all with no run and no charge.

## How the model is held accountable

The engine's facts go **into** the run input as `prescan`, and the model's answer is checked back
**against** them:

- Every flag the browser raised must come back in `reconciliation`, one entry per flag, marked
  `confirmed`, `noted`, `set-aside` or `superseded`. A flag the model ignored is displayed as ignored.
- Every node name the model cites anywhere in its reply - in a finding, a key node, a priority action,
  or a recommendation - is checked back against the actual parsed graph. A name that does not appear in
  it is still rendered, but marked `ungrounded` rather than trusted silently.
- Every numeric metric value the model cites is expected to match what `prescan` already computed;
  the house rules in the system prompt forbid inventing or altering it.

## Deliberate limits

- **Directed edges govern cycle and DAG detection; almost everything else (components, cut-vertices,
  bridges, clustering, centrality, diameter) is computed on the undirected projection.** This is a
  structural-fragility choice, stated in the read-out, not an oversight.
- **O(n²) metrics (closeness, betweenness, diameter) are skipped above a node-count cap** rather than
  hanging the browser tab; the skip is named, not silent.
- **A paste longer than one run can carry is cut on whole-line boundaries**, with the number of lines
  profiled locally versus sent stated to both the user and the model.
- **This is not organizational, legal, security, or engineering advice.** Every finding is a prompt to
  verify with the people who actually run the system, never a decision already made, and the prompt
  explicitly forbids framing any action as firing or restructuring a person.

## Persistence

Runs are saved to the signed-in user's SkillSafe account in a declared `graphruns` collection, mirrored
in `localStorage` for instant paint and offline fallback. The mirror is scoped per subject, so two
people sharing a browser never see each other's graphs, and signing out purges this device's copy.

## Sources

Graph Desk is an independent derived work built on the published agent skill `@k-dense-ai/networkx`
(`k-dense-ai/scientific-agent-skills`, MIT licence). Credit for the graph-theoretic vocabulary
(centrality, cut-vertices, bridges, clustering) implemented here belongs to the NetworkX project and its
documentation, which the skill draws on. Graph Desk is not affiliated with, endorsed by, or maintained by
k-dense-ai or the NetworkX authors.