An externalized reasoning layer for LLMs.
Your model's reasoning is trapped in prose: you cannot test one step on its own, reuse it tomorrow, replay it, or reopen it when a fact turns out to be wrong. This puts the reasoning outside the model — as typed facts and rules a machine can check — so it becomes something you can test, replay and reopen. It runs on your own local model. Nothing leaves the machine.
Active R&D. Some of this is measured and replayable, some is proven only structurally, and the demos publish the losses too. We believe the substrate is ideal for higher-level reasoning strategies, so the strategy here is to improve concept grammars, the providers and the prompts they generate to get what we want.
Every tab below is a real run, captured from the code as it stands — not a mock-up and not prose written about it. They are deterministic: no model, no GPU, no network. Clone the repo, type the command shown, and you get the same thing back, word for word.
Each measured on real runs, with negative controls and deterministic re-runs. The crippled 9.5 GB model is the showcase because it is the starkest case — not the ceiling.
The task is cut into steps, and each step sees only what it asked for — never the whole dossier.
Method shapes mined from a checker steer the output on covered questions — a generic mechanism, most dramatic on a weak model.
A late correction retracts what depended on it — and a withdrawn value reopens the finished task, with the reason.
The model proposes; the graph refutes with the reason and the admissible options; the model revises.
How to read this: we take questions that have a known right answer, ask the same 9.5 GB model the same question two ways, and count how many it gets right. Higher is better — every bar is "how often it was right".
Each row is a measured delta or a checked absence — never a vibe. The last column is the part most comparisons quietly drop.
| Instead of… | you'd get | skynet-graph gives | …and does not claim |
|---|---|---|---|
| a bigger / frontier model — or a closed reasoning layer that wraps one | more raw capability, at API cost, off your machine | typed gates + deterministic replay on your own local model; nothing leaves the machine | that it out-reasons a frontier model, or any big-model number we have not measured |
| a decomposition framework (LLMCompiler, ReWOO) | a task DAG | a typed DAG where each step sees only what it asked for, behind a gate that refuses instead of guessing | that a small model is any good at CUTTING the task up (a measured limit) |
| LLM-as-judge | a verdict, always | counts, coverage, and an honest "too close to call" — a verdict only when the margin earns it | a reliable verdict on free, uncertified content |
| a RAG skill-library | retrieved snippets | methods that un-learn when their premise drifts — the moat no index has | that novel, free-prose reasoning gets cheaper |
| the model's own "think" mode | a longer internal monologue | an outside critic that refutes with the reason and the options, and puts every argument on the record with the evidence under it | to weigh the arguments for you — that stays the model's job |
| a rules engine | deterministic rules | rules + truth maintenance: a falsified premise un-casts itself and everything built on it, with no rollback code | hand-encoded completeness — the rules are learned, and defeasible |
Or embed it — npm install skynet-graph — and boot a graph from plain folders of rules:
All of it is markdown in the repo — it ships in the npm package and renders on GitHub, so what you read is what the code carries. Start wherever your question is.
The practical guide: fromDirs, concept sets, providers, the sg CLI, plugins, distributed execution.
The 13 reasoning strategies as deposited concept sets on one kernel — a recipe each, and the honest scope.
Every feature with its maturity bar, its measured numbers, its negative controls — and its limits.
The engine, the core-vs-plugins line, the vision — and the honest limits, on the same page.
The public API: revisions, rollback, diff, fork/merge, the facts/prose contract.
The plugin contract: manifest, the two trust tiers, dependency rules, sg plugin.
The source of every demo on this page. Each prints the guarantee it demonstrates; the test suite runs them all.
The full model + roadmap, and concept-as-graph.md for where it is going.