Open Compressed Knowledge Graph standard · Patent-pending engine
Own the knowledge layer. Rent the model.
The problem was never the AI or your knowledge — it's the space between them. Graphify.md compresses your domain into a typed graph the agent reads before it acts: ~269 tokens, portable across any model, owned by you.
54 live, interactive CKGs · 12,978 nodes · open, reproducible benchmark · runs on a local 8B — no cloud.
CKG Explorer — live, interactive, in your browser
Try it live → Free CKG Library · 61 domains · drag to explore · no signup
For investors
Own the layer the frontier can’t reach.
Every model release torches a layer of startups built on the model. Graphify.md sits in the one place the next release can’t kill — the knowledge layer above it.
Own the knowledge layer. Rent the model.
An 8B model on a laptop, reading a Graphify.md CKG, scored 0.471 Macro-F1 — and climbed to 0.772 on 5-hop questions where RAG sits at 0.170. The graph does the hard part; the model just reads it. Swap the engine next quarter — the owned, portable knowledge layer doesn’t move.
The method, not the model.
Three provisional patents on automated structure discovery + compression, and an open, reproducible benchmark anyone can clone — 7,928 queries, 45 domains. We don’t out-compute the frontier; we make it cheaper to rent.
Early — by design.
Pre-revenue pilots, one open benchmark, a category still being named. Active conversations across enterprise data, supply chain, and compliance. That’s the entry point.
Book 20 minutes →Why now — the tailwinds we sit on
The model layer is commoditizing. Value lodges in the knowledge layer above it.
Open, small models are everywhere and up to ~100× cheaper to run — but only as smart as the knowledge they reason over. We're that layer: we make an 8B punch above the frontier.
~95% of execs call owned / sovereign AI mission-critical. The knowledge layer is the asset they own — not rented from a frontier lab.
Models get deprecated, nerfed, and pulled — a frontier model was force-disabled worldwide in June 2026. An owned, portable layer is the backstop no external directive can switch off, and no one can blackball.
As $/token falls, value moves to whatever decides which tokens you needed. 11× fewer tokens, ~42× retrieval density — the cheapest correct answer.
~4× the accuracy of RAG, multi-hop that rises with complexity, 0% hallucination by construction — open, reproducible benchmark.
Fewer tokens = less compute = less energy per correct answer. Cognition per watt — as AI's power draw becomes a board-level line item.
ckg-mcp) and a knowledge layer that stands up in hours, not quarters. Cheapest, best, fastest, owned — and deplatform-proof.Every number traces to the open benchmark (v0.6.2): Macro-F1 0.471 vs 0.123 (RAG) · 269 vs 2,982 tokens/query · $7.81 vs $76.23 run cost. See the benchmark →
Knowledge architecture · vs the LLM Wiki
The LLM Wiki beats RAG. A Compressed Knowledge Graph beats the wiki.
The field just agreed a folder of plain-text files outperforms a vector database. They're right — and that's the floor, not the ceiling. The rung above it: a typed, deduplicated, provenance-tagged graph your agent traverses deterministically.
One ladder, three rungs
Not three competing camps — three rungs of one staircase, each fixing the failure mode below it.
The vector database
Chunk, embed, similarity-search, hope. Right for a 10M-document archive; overkill and opaque for everything smaller. You can't read it, audit it, or debug a wrong answer.
The flat folder of files
Plain Markdown an agent loads selectively — deterministic at the file level, readable, Git-versionable. A real step up. But it's a pile: links are implicit, facts repeat, nothing's deduplicated, and "load the whole file" wastes tokens as it grows.
The engineered layer
The wiki's instinct, engineered: typed nodes and edges, deduplicated, dependency-ordered, every claim provenance-tagged. The agent traverses to the exact sub-graph — node-and-edge precision, not whole-file loading — and you can still read every line. Deterministic and dense.
What breaks in a flat wiki
We like the pattern enough to be honest about its ceiling. Four things degrade as a folder of files grows:
- Redundancy compounds — the same fact in five files; the agent loads all five.
- Relationships stay implicit — a
[[link]]says two pages relate, not how (depends-on, contradicts, supersedes, causes). The reasoning lives in edges a flat wiki doesn't have. - Retrieval is whole-file — you wanted one fact; you loaded the whole page. Fine at 20 files, expensive at 500.
- No provenance, no audit — which source backs this line? For regulated work, "the agent read it somewhere" isn't an answer.
RAG vs. LLM Wiki vs. CKG
The popular comparison stops at two columns. Here's the third.
| Factor | RAG | LLM Wiki | Compressed Knowledge Graph |
|---|---|---|---|
| Storage | Opaque vector embeddings | Flat .md files | Typed graph, written as readable .md |
| Retrieval | Probabilistic similarity | Deterministic, whole-file | Deterministic traversal — node & edge |
| Relationships | None (lost in vectors) | Implicit [[links]] | Typed edges: depends-on, contradicts, causes… |
| Redundancy | Re-embedded everywhere | Repeats across files | Deduplicated & compressed (~88%) |
| Auditable / provenance | No | Partial | Yes — every edge cites its source |
| Accuracy vs RAG (F1) | baseline | better | ≈ 4× RAG (independently verified) |
| Chained reasoning (5-hop F1) | 0.170 | flat · no depth signal | 0.772 — rises with depth (v0.6.2) |
| Retrieval density (RDS) | baseline | — | 42× vs RAG (v0.6.2) |
| Token cost | High | Lower | ≈ 11× fewer than RAG |
| Failure mode | Silently wrong | Loudly missing | Loudly missing — never silently wrong |
| Best for | 10M-doc archives | Personal notes, one codebase | Vertical enterprise reasoning, correctness-critical |
F1/token figures from third-party benchmarking; RDS and 5-hop from the open benchmark v0.6.2. "GraphRAG" without compression benchmarks close to vanilla RAG — the gain is in the compression and typing, not the word "graph."
Two products people confuse — and shouldn't
A thing a developer runs
Auto-extracts a graph from your own codebase and local docs. Developer-facing, code-centric, free DIY — you run it, tune it, own the upkeep. Great for giving a coding assistant memory of one repo.
Intelligence you plug in
Delivers pre-built, verified vertical CKGs — finance, healthcare, manufacturing. No pipeline to run; drop the file in. Deterministic, auditable, benchmark-verified by construction. For a CIO who needs the answer right and provable, not just fast.
Plainly: a code tool turns your repo into a graph. Graphify.md turns an entire industry into reasoning-ready, verifiable intelligence. One is a utility; the other is the substrate enterprise AI reasons on.
When to use each — honestly
- RAG — millions of documents, approximate recall acceptable.
- LLM Wiki — personal notes or a single codebase you maintain by hand.
- Compressed Knowledge Graph — when the answer must be right, dense, and defensible: regulated industries, high-stakes reasoning, anywhere a silently-wrong answer is a liability.
Frequently asked
Isn't this just RAG with extra steps?
The opposite. RAG retrieves probably-relevant chunks from opaque vectors and can be silently wrong. A CKG traverses a readable, typed graph to the exact nodes and edges — deterministic, and when it doesn't have something it says so instead of hallucinating.
Isn't this just the Karpathy LLM Wiki?
The wiki is the folk version — a flat folder you hand-pile. A CKG is the engineered version: deduplicated, typed edges that carry the relationship, dependency-ordered, provenance-tagged, benchmarked. Same instinct, one rung up.
Isn't this just Graphify / the open-source graph tools?
Those are tools you run to graph your code. Graphify.md is a delivered product: finished, verified, vertical knowledge graphs for regulated enterprise reasoning — no pipeline to operate. A utility vs. an outcome.
Won't million-token context windows make this obsolete?
They make it better, not obsolete. Bigger windows let you load more of the right context — but dumping everything still costs tokens and buries the model in noise. Loading the precise, dense sub-graph wins on cost and accuracy regardless of window size.
Can I actually read and audit it?
Yes — it's Markdown. Every node and edge is human-readable and stamped with its source. Open it, diff it in Git, trace any claim to where it came from.
Stop piling files. Start reasoning on a graph.
See a Compressed Knowledge Graph next to your current RAG or wiki — and the benchmark behind it.
About Graphify.md
The problem was never the model. It's the space between.
A large model is brilliant at language and unreliable at truth — it has no verifiable memory to reason over, so it guesses, can't show its work, and can't tell you when it's guessing. The reflex has been to make the context window bigger. But the window was never the bottleneck: in a typical agent deployment, rules, orchestration, and RAG chunks consume ~85% of the budget before your company's actual knowledge enters the room. Graphify.md closes that gap — a compressed, owned, verifiable knowledge layer the model reads before it acts.
Structure beats scale for truth
No amount of model scale produces grounding, provenance, or the right to refuse — those come from structure. A Compressed Knowledge Graph carries typed edges, provenance, and calibrated confidence, so an answer is traceable, not merely plausible.
We don't ship unverified claims
Every number on this site traces to an open, reproducible benchmark. A CKG can't assert what it can't support — refusal-with-evidence is a feature, not a failure. We hold our own output to the standard we sell.
Open standard, owned by you
The format, client, free CKGs, and benchmark are open — adopt them at no cost. The engine that turns your corpus into a faithful, current graph is what we sell. You own the layer; you rent the model.
ckg-mcp, the production server distributing CKGs across dozens of domains. Graphify.md's context-budget thesis — the 25 / 30 / 30 / 15 breakdown — was recently featured by EnterpriseDB in CIO Dive.Baseline knowledge layer · token-optimized · model-agnostic
Instant corporate context. Your knowledge layer, in days.
A quick, model-agnostic knowledge layer — drop it into any model and your AI knows your domain the moment it answers. Your enterprise layer for better answers: agents 90% cheaper and 4× more accurate, and far stronger on chained reasoning — the linked, multi-fact questions where RAG breaks. Your knowledge already has a structure; we surface it, compress it, and you own it.
The issue · context-window bloat
Your knowledge fights for ~15% of the window.
Every agent call re-ships the same overhead — rules, orchestration, retrieved chunks — before your domain knowledge even gets a seat. That's the bloat. A CKG compresses what matters into a few hundred tokens, so your knowledge isn't what gets squeezed out.
The window fills with the same chunks every call — your knowledge gets squeezed.
A dense, sourced graph — the window stays open for actual reasoning.
~85% overhead before your knowledge enters the room (the 25 / 30 / 30 / 15 context budget). A CKG hands the model ~269 dense, sourced tokens instead — your knowledge, not the bloat. Cheaper to run, and the model reasons better with room to spare.
For the two who carry it
Need it now. Own it now.
Two people feel this before anyone else — the one who signs for the spend, and the one who gets paged when the agent is wrong. This is for both of you.
"AI cost is the one line I can't forecast — and it climbs every month."
It climbs because the model re-ships the same context on every call. Compress it once into a knowledge layer you own — instant corporate context, a fraction of the tokens, predictable spend, no lock-in. Your IP, on your books, enabled in days.
"Right at hour one. Confidently wrong by hour three."
That's drift and hallucination — a model guessing with no grounded memory. A CKG gives it one: 0% hallucination by construction, no context bloat, no drift. Deterministic traversal over a graph you start and manage — the inference you actually need. Sovereign: Claude, GPT, or a local model.
Need it, own it, right away — your context, your IP. An instant corporate-context layer you start and manage; sovereignty and agent success, by construction — without the bloat, the anxiety, the hallucination, or the drift.
Why now — and who feels it
Three forces, three needs, one layer.
Get the answer right first — then make it cheap, then make it yours. Accuracy, cost, ownership: for two years separate problems, now one layer that sits above the model. Each lands on a different desk.
Similarity isn't truth — and truth comes first
If the answer is wrong, cheap doesn't matter. RAG's documented failure is chained reasoning, relational reasoning — vector search finds similar text, not required text, and every hop compounds the error.
→ Traverse explicit edges: higher F1, accuracy that rises with complexity.
See it run →Then it has to be cheap
AI bills for every query, and re-loading the same domain context on every call compounds until teams hit the wall by project five.
→ Compress it once: ~90% cheaper per answer — the context window stays free.
See the cost model →And it has to be yours
As access tightens — retention, shifting policy, capability gating — routing every workload through a single external model concentrates risk prudent teams won't carry.
→ Own a portable layer: run it on Claude, GPT, or a local model.
See the architecture →Compress your context — own the knowledge layer. Rent the model.
Came from Karpathy’s LLM Wiki? See where the ladder leads — RAG → Wiki → CKG →
Open · documented · attested
A knowledge layer you can trust — and run yourself.
An owned layer earns trust three ways: the format is open, the build is documented, and the truth is signed by a human. Not a black box you rent.
CKG Spec 1.0
The format is an open, ownable standard — typed nodes & edges, CSV / MD / TTL / JSON-LD. No lock-in: fork it, run it anywhere.
Read the standard →Two lines to context
pip install ckg-mcp, four tools, the real schema, benchmark repro — live in Claude today.
L2, signed by a human
A named domain authority reviews, prunes, and signs the graph — versioned, provenance-tracked, certified. Your name on the truth; the anti-black-box.
See attestation →Featured & heard
“Your AI agents are operating on 15% of the information they need.”
EnterpriseDB Postgres AI feature on the agent context-budget problem — citing founder Dan Yarmoluk’s 25 / 30 / 30 / 15 split (rules / orchestration / RAG / your domain).
Read the article →The token-burn thesis — cost, structure, and owning the knowledge layer.
The issue · agents break down
Right at hour one. Confidently wrong by hour three.
It isn't a weak model — it's dark uncertainty: valid SQL, correct data, wrong answer, and no trail to debug. Agents drift as the session grows and re-guess on every hop. The fix isn't a bigger model; it's giving the agent a layer it traverses instead of a context pile it improvises over.
Drifts as context grows · re-guesses each hop · valid SQL, wrong answer · no audit trail — you're debugging a black box.
Traverses declared, typed edges · cites every node · holds at depth · 0% hallucination by construction — and you can read the path it took.
A CKG is pre-action context — deterministic traversal, not generation. The agent stops guessing and starts citing. Same model, grounded. Watch it below — same 8B, same laptop, the only variable is the layer.
See it run — local, $0, no data egress
Same 8B model. Same laptop. The only variable is the knowledge layer.
We ran an open 8B model (qwen3:8b) on an Apple M4 / 16 GB — no internet, no cloud — and asked one hard, chained reasoning hardware-security question twice: once raw, once with a 9,377-token Compressed Knowledge Graph in context.
Q: How does a hardware attacker get modified firmware to run past secure boot? 1. Secure Storage --[exfiltrated]--> Attacker 2. Attacker --[signs]--> Modified Firmware 3. Modified Firmware --[loaded]--> Bootloader Tool: JTAG Debugger Countermeasure: TPM + signing checks✗ Invented structure · generic · not grounded
Q: How does a hardware attacker get modified firmware to run past secure boot? FI1 --[defeats]--> BR14 --[enables]--> GA4 fault-inject the signature check, then load the patched image Lab tool: LAB4 (ChipWhisperer) Countermeasure: HHC7 (Protect/Detect/Respond) Every hop is a sourced edge.✓ Grounded · traceable node IDs · 0% invented
brew install ollama # one time (or ollama.com) ollama pull qwen3:8b # ~5 GB · runs on an M-series Mac / 16 GB python3 demo.py # same question — with vs. without the CKG
No GPU, no cloud, no API key — nothing leaves your machine. demo.py + the CKGs ship in the bundle and the benchmark repo. Prefer zero setup? Paste a free CKG into any model and ask a hard question — or run the full open benchmark across 45 domains. If you can install one app, you can reproduce this.
Raw, the model improvised — generic, ungrounded, impossible to trace to a source. With the compressed knowledge layer it answered along the graph's explicit edges and cited every node, so you can check each one against the file. Fully local: nothing left the machine, cost ≈ $0. That is "own the knowledge layer, rent the model" — running on a laptop.
Architecture · how it works
A layer above the model — not more context inside it.
The context window is finite and metered, so the answer isn't a bigger window — it's denser knowledge, put where it belongs: above any model, owned by you, and delivered before the agent acts.
One question, two ways.
"Does your service work mid-onboarding with compliance requirements?"
Finds chunks about onboarding + compliance + services, then synthesizes a link that was never stated. The model invents the relationship.
Walks explicit, typed edges. The answer cites its path — every hop is a sourced edge.
query_ckg
Typed nodes + edges, not prose.
get_prerequisites
Dependency chains, resolved.
traverse
Walk N hops from any node.
validate_ckg
Check against a profile (see Certification).
See the discipline — interactive
Watch the architecture form, then compress.
Drag the meter: raw corpus → discovered ontology → typed dependencies → a CKG that compresses to a fraction of the tokens as the context window literally opens. Same graph, fidelity intact.
Open proof, not claims
Open benchmark: 7,928 queries, 45 domains, reproducible.
Macro-F1 across Track 1's 44 domains (45 with the GLP-1 transfer track), fully reproducible. Code, data, and paper public — run it yourself before you talk to us.
What good looks like — the rubric
Don't grade on one number. Judge the whole ladder.
RAG → GraphRAG → DAG → CKG. Correctness, cost, energy, depth, and trust — together. (CKG / RAG / GraphRAG from benchmark v0.6.2; DAG = the structural rung a CKG perfects.)
| Metric | "Good" = | RAG | GraphRAG | CKG |
|---|---|---|---|---|
| Accuracy — Macro-F1 | right, not just fluent | 0.123 | 0.120 | 0.471 |
| Tokens / query | dense, minimal | 2,982 | 3,450 | 269 |
| Cost / query | cents, predictable | ~$0.0106 | ~$0.0166 | ~$0.0010 |
| Cost per finished task | bounded, one pass | compounds/hop | compounds/hop | one traversal |
| Retrieval Density Score (RDS = F1 ÷ tokens) | high signal / token | 1× | <1× | ~42× |
| Intelligence per watt | more answer / joule | baseline | worse (+tokens) | ~11× fewer tokens† |
| Inference | fast, deterministic | embed + top-k | + community search | deterministic traversal |
| Depth (multi-hop F1) | holds / rises with hops | flat ~0.07–0.23 | — | 0.37 → 0.77 |
| Semantics — BERTScore | fluent ≠ correct | 0.817 | — | 0.857 |
| Hallucination | zero by construction | unbounded | invents edges | 0% |
| Traceability | node-level citation | ✗ | partial | ✓ |
| Reproducibility | clone & re-run | — | — | ✓ open |
| Ownership | portable, local | pipeline | pipeline | ✓ |
†Intelligence-per-watt is directional (fewer tokens → proportionally less inference energy); a metered watts-per-answer figure is in measurement — we won't quote one we haven't run. RDS isn't a third trophy — it's F1 × token-efficiency on one axis (≈ 3.8 × 11). BERTScore near-parity is the point: both sound right; Macro-F1 is where "is right" diverges. Figures v0.6.2 (Macro-F1 = Track 1, 44 domains); cost & 5-hop per-query. Re-run: github.com/Yarmoluk/ckg-benchmark.
Reading the ladder — and the "GraphRAG is cheaper" myth
RAG → GraphRAG → DAG → CKG: what each actually is.
Retrieve text chunks by embedding similarity. No structure — the model re-reasons over a pile of prose every call.
Dynamically extracts a graph from text at index time (LLM entity extraction + community detection), then retrieves over it. Real and shipped — but the structure is derived, not known.
The architectural shape good structured knowledge takes: a directed acyclic graph of typed concepts. A target, not a vendor.
The DAG done right: pre-structured (declared, not extracted), compressed, and attested. No derivation step to pay for.
The ruler, not the promise. Like NVIDIA rates silicon by performance-per-watt — a ruler, not a guarantee — judge a knowledge layer by intelligence per token (RDS) and per watt: efficiency you can measure, on your own corpus. The rubric is the ruler; your data is the verdict.
| Metric | CKG | RAG | GraphRAG |
|---|---|---|---|
| Macro-F1 | 0.471 | 0.123 | 0.120 |
| Tokens per query | 269 | 2,982 | 3,450 |
| Run cost · full benchmark | $7.81 | $76.23 | $44.43* |
| F1 at 5-hop complexity | 0.772 | 0.170 | — |
| Hallucination rate | 0% by construction | unmeasured | unmeasured |
GraphRAG burns more tokens than the RAG it claims to replace (3,450 vs 2,982) — traversal overhead eats the gains. *Its lower run total is a 15-domain subset, not apples-to-apples. Retrieval Density Score: ~42× over RAG.
The Structure Paradox
More structure should mean more rigidity. Instead, accuracy rises with complexity.
Answers become overdetermined, not uncertain. Every hop makes RAG guess again; every hop makes CKG more certain.
The harder the question, the wider the gap
| By question type (CKG vs RAG) | CKG | RAG |
|---|---|---|
| Dependency | 0.634 | 0.078 |
| Chained-reasoning path | 0.660 | 0.201 |
| Category aggregation | 0.964 | 0.286 |
Also scored with semantic BERTScore F1 (roberta-large): 0.857 vs 0.817 (RAG) — a tighter spread because the metric is lenient. The exact Macro-F1 above is the harder, more honest number.
Energy & inference
<100 ms
p95, live POC. Graph traversal is cheap deterministic compute — not another generation pass.
~11× fewer tokens
= proportionally less inference energy per correct answer. A metered watts-per-answer figure is in measurement — we won't quote one we haven't run.
8B · on a laptop
An 8B model + a CKG out-reasons a far larger model on chained reasoning — fully offline, ≈ $0, no data egress.
What we're still measuring
A metered intelligence-per-watt figure · GraphRAG on the full 45-domain set (current is a 15-domain subset) · BERTScore reconciliation to v0.6.2. We publish what's measured and flag what isn't — that discipline is the product.
Three ways in · one knowledge layer
Same layer. Three doors — because you're not all here for the same reason.
A marketer tired of being invisible to AI. A developer who's watched RAG drift. A platform owner who needs governance, not a demo. The CKG underneath is identical — walk through the door that's yours.
"AI answers questions about our category — and never names us."
Be the source the models cite, not the page nobody clicks. Publish your knowledge as a CKG surface AI retrieves first. White-label for agencies.
Make it AI-discoverable →"I've shipped RAG. I've watched it drift by hour three."
Context that just shows up — no pipeline, no embeddings to tune. pip install ckg-mcp and the tools appear inside Claude (Desktop & Code) today.
"I can't put a science project into production."
Keys, tiers, metering, SLAs, audit logs — the same engine behind a governed HTTP surface you can take through security review.
Get an API key →Developer docs
Two lines to first context.
MCP is live today (pip install ckg-mcp). The REST surface is provisioned per engagement — same core, same method, behind a key.
Developer docs
Two lines to first context.
MCP is live today (pip install ckg-mcp). A CKG ships as typed CSV / Markdown — query it from Claude (Desktop & Code), or over REST per engagement. Same core, same method, behind a key.
1 · Install & connect
2 · The four tools
list_domainsWhat knowledge is available — the bundled catalog of domains.
query_ckg(domain, concept, depth)Traverse the graph — returns typed nodes + edges, not prose.
get_prerequisitesWhat must be understood first — dependency chains, resolved.
search_conceptsFind the right entry point across the ontology.
3 · REST (provisioned per engagement)
4 · Formats & conformance
Every CKG exports as .md, .ttl (RDF/Turtle), or JSON-LD — readable, Git-versionable, model-agnostic. validate_ckg checks output against a conformance profile: pass = L1 (structurally valid); a domain authority reviews & signs = L2 (certified). The discovery/compression method stays server-side — you get results and format, never the recipe.
5 · Power users — the ontologist's loop (approve, don't extract)
Your job is approval, not extraction — the engine handles discovery. Author a conformance profile (the rules your domain must obey), then review the engine's output in the console: validate_ckg confirms structural conformance (L1); you approve · edit · prune · add — every node carries confidence + provenance — then sign for L2, named and versioned (e.g. pursuit-ckg@1.2). The anti-black-box: nothing ships that you didn't see.
6 · The CKG format — the open standard
A CKG is a directed acyclic graph (DAG) of typed concepts with explicit prerequisite edges — declared, not inferred. No graph database, no embeddings. It serializes as plain-text CSV or Markdown (exportable to RDF/Turtle and JSON-LD): readable, Git-diffable, model-agnostic.
Query types the standard supports: T1 entity lookup · T2 direct dependency · T3 multi-hop path · T4 category aggregate · T5 cross-concept relationship. Conformance: L0 raw → L1 structurally valid (validate_ckg against a profile) → L2 authority-signed.
7 · Reproduce the benchmark
Scope: 45 domains · 7,928 queries (Track 1: 44 educational, 7,758 q; Track 2: GLP-1, 170 q) · Macro-F1 0.471 / 0.123 / 0.120 (Track 1) · RDS ~42× (mean of per-domain F1÷tokens) · pre-print in preparation.
Context Architecture · company-owned AI infrastructure
Your context architecture — owned, not rented.
One context layer above every model and agent — open, governed, portable, and a Compressed Knowledge Graph underneath. Adopt it through whichever door fits your team; the infrastructure is yours.
Token Economics
Stop re-billing the same context every call. Compress domain knowledge once; up to ~42× more token-efficient per query.
See the cost model →Agent Reliability
Your agent is right at hour one, confidently wrong by hour three — and you can't debug a black box. Give it a CKG as pre-action context: deterministic traversal, every answer cited. No drift, no context rot, 0% hallucination by construction.
See it run on a local 8B →Context Conformance
Don't rebuild graphs by hand — we run the discovery engine for you. You review, prune, and certify the output in a console: you sign, it ships L2. Your name on the truth, none of the grunt work.
See the review console →GEO — Generative Engine Optimization
Be the source LLMs cite, not the page they skim. Publish your knowledge as a CKG surface AI retrieves first. (patent-pending)
Make it AI-discoverable →Semantic Substrate
One owned, model-agnostic layer above every model and agent — open format, governed, auditable, no single point of failure.
See the architecture →Automated Discovery — the Engine
Point it at your corpus; get a faithful, traceable CKG in a session, not eight days. .md / .ttl / JSON-LD.
Open by design — CKG Spec 1.0 · ✓ OKF-conformant
Open the standard. Keep your knowledge. Build what you can't.
Graphify.md is open-core, with a hard line down the middle: the format is an open, ownable standard; the hard part — turning a corpus into a faithful, current graph — is the patent-pending engine we run for you.
See it — OKF in, CKG out
Left: a Google OKF doc — portable, but prose. Right: a CKG — same frontmatter (a plain OKF reader, including Google's Knowledge Catalog, ingests it unchanged), plus typed edges, confidence, and provenance. Portable on the outside; deterministic + sourced inside. Download this sample →
OKF documentation & announcement. Google Cloud announced the Open Knowledge Format on June 12, 2026 (Sam McVeety & Amir Hormati, Data Cloud) — the announcement · the spec & sample bundles. Our documentation — a compressed knowledge graph that is itself a valid OKF bundle: OKF × CKG (.md) ↓.
Part one — the open standard
Yours to own, fork, run anywhere.
- ▸CKG format / spec — typed nodes & edges,
.md+.ttl+JSON-LD. - ▸Reference client & validator —
ckg-mcp. - ▸The benchmark — code, data, paper.
- ▸Free starter CKGs — no email gate.
Part two — the engine
The part you can't build yourself.
- ●Automated ontology discovery + compression — corpus → CKG in one session.
- ●Fidelity & grounding — every node traceable to source.
- ●Premium domain CKGs — curated, cross-document.
- ●Enterprise serving — private, hosted, fresh, governed.
ckg-mcp client, free CKGs, and 54 bundled domains. CKG Spec 1.0 is in final review ahead of public release — the paper is the canonical reference until it ships.Trust on demand — the authority in the loop
Auto-discovered, expert-certified.
Automated discovery gives you a scaffold; a semantic authority makes it trustworthy. Graphify.md turns that into a configuration surface — so the ontologist becomes a certifier, not a from-scratch builder. Assistance, not replacement — made mechanical.
Conformance Profile
The authority authors the rules once: vocabulary, SHACL shapes, ontology alignment, domain axioms.
Conformance check
The engine's CKG is validated against the profile → a SHACL-style report (conforms: true). Only findings need review.
Signed certification
The authority certifies it. The signed certification travels inside the CKG — verifiable offline by any consumer or auditor.
Core
Valid format + provenance. What the engine emits.
Conformant
Machine-validated against a Conformance Profile (SHACL conforms).
Certified
Signed by a semantic authority / data steward. The tier enterprises buy.
The discipline
Automated ontology discovery + compression.
Not prompt-stuffing. Not chunk-and-pray. A repeatable method: discover the ontology latent in a corpus, map explicit typed dependencies across documents, and compress to a fraction of the tokens with fidelity intact.
Surface the ontology
The structure documents imply but never state.
Typed dependencies
Explicit, sourced edges — including cross-document links RAG can't see.
Distill with fidelity
~269 tokens/query of bounded, traceable context.
Ground to source
Every node carries provenance. 0% hallucination.
The proof of rigor underneath: three peer-style intelligent textbooks (Context Engineering · Agent Memory Patterns · Ontology Engineering — 540+ concepts) and an open, reproducible benchmark. By Daniel Yarmoluk with Dan McCreary (creator of intelligent textbooks). The engine is patent-pending; the format it produces is open.
Free CKG Library — 53 ship in ckg-mcp · 45 benchmarked · no gate
Open your window. Dozens of free knowledge graphs.
Every graph here is free — render it in the viewer, grab one as a .md (no signup), or pip install ckg-mcp for all 53 (45 formally benchmarked, v0.6.2 — clone & re-run; the rest staged). Paste it into Claude, ChatGPT, Gemini, or a local model, or let it appear as an MCP tool. (What is paid is the engine that turns your corpus into the next one.)
Drag to explore · scroll to zoom · pick from the dropdown, or click any card below.
Part 2 · Get started
Get your knowledge layer running in days.*
Start free with the open standard and a CKG; bring the engine in when you want your own corpus turned into a faithful, current, certified graph. Own the standard. Own your knowledge. Rent the model.
* A scoped, single-domain CKG — running in days. Auto-discovery does the heavy lifting in a session; you review and certify (L2); production hardening follows. Not a year-long platform project.
Where to start · how to evaluate · live in days
Start narrow. Evaluate hard. Ship in days.
One pressing domain — the proposals, the support corpus, the spec library that hurts most. We map it free (a Domain Context Audit) and show the delta on your data, not a slide.
Don't take our word — run the bake-off. On your hardest multi-hop questions, compare LLM-only / RAG / GraphRAG / CKG on accuracy (F1, groundedness, citations), tokens/query, cost per correct answer, and whether it holds at 5 hops. We hand you the harness; demand the same of any vendor.
Auto-discovery builds the graph in a session; you review & certify; it drops into any model — pip install ckg-mcp, plug and go. Days, not years. Way fewer tokens, way lower cost, owned by you.
The standard
Read the paper, run the benchmark, grab a free CKG, pip install ckg-mcp. (CKG Spec 1.0 in final review.)
The engine
Turn your corpus into a CKG via API — `.md` / `.ttl` / JSON-LD, on any model.
Talk to us →L2 graphs
Private, hosted, governed, and certified by a semantic authority. No data egress.
Book a pilot →Graphify.md · Compressed Knowledge Graphs · Patent-pending engine (US utility applications filed) · hello@graphifymd.com