os-taxonomy: An Open Learning Knowledge Graph for K-6

Plenty of education products talk about “personalized learning.” But when you try to make it real, you hit a very concrete question: how does the system know exactly where a child is stuck?

If a child struggles with fractions, the problem may not be fractions themselves — it may be that they haven’t yet grasped that “a whole can be split into equal parts.” If a child writes poor sentences, it may not be weak expression, but not yet understanding the difference between a complete sentence and a fragment.

So what an education system really needs isn’t just an AI teacher that can explain things — it also needs a learning map. That’s exactly what Marble’s open-source os-taxonomy provides.

What Is os-taxonomy

The formal name of os-taxonomy is the Marble Skill Taxonomy, an open learning-taxonomy dataset released by Marble.

It breaks primary and elementary learning content into fine-grained micro-topics, then connects them with prerequisite dependencies that capture which topics must come before others.

The current version is v1, and its core data includes:

• 1,590 micro-topics
• 3,221 prerequisite dependencies
• 8 subjects
• 3,261 curriculum standards
• 183 domain clusters

It is not an app and not a model, but a set of structured education data you can read, analyze, and build on directly.

Key Features

The project’s core value is turning course content from a “flat list” into a “learning graph.” Ordinary curriculum standards usually tell you what to learn, but rarely what to learn first, what counts as mastery, or how knowledge points connect. The Marble Skill Taxonomy does three extra things.

First, it breaks content into teachable micro-topics. For example, the README cites “Building sentences,” which sits under English / Grammar & Punctuation, for ages 4 to 6. It doesn’t just say a child should understand sentences — it spells out evidence of mastery, such as being able to distinguish a complete sentence from a fragment and to write a complete sentence with a subject and a verb.

Second, it links prerequisite relationships between topics. For instance, a topic about volume and vibration depends on a child first understanding that vibration produces sound. That dependency is recorded in dependencies.json, complete with a hard or soft strength marker and a reason.

Third, it aligns with formal curriculum standards. Micro-topics link to frameworks such as NGSS, Common Core, and the UK National Curriculum, so the dataset offers both fine-grained learning paths and alignment with official curricula.

Who Should Look at It

The most compelling thing about os-taxonomy isn’t that it open-sourced a pile of education data — it’s that it decomposes “learning something” into nodes, evidence, and paths.

If you work on AI education, course recommendation, learning-path planning, or education knowledge graphs, this project is worth studying. It isn’t the answer itself, but it makes an excellent underlying map. It also suggests a new product shape for education founders.

Data Structure

The core data lives in the data/ directory as UTF-8 JSON. The main files include:

• data/topics.json — micro-topics, i.e. the nodes in the graph
• data/dependencies.json — prerequisite links, i.e. the edges
• data/curriculum-standards.json — sources of curriculum standards
• data/clusters.json — domain summaries written for parents
• data/manifest.json — counts, checksums, and other metadata

The project also ships a schema/ directory that describes the data structure with JSON Schema.

If you view it as a graph, topics.json is the node table and dependencies.json is the edge table. Developers can index by topic id, then query which prerequisites a knowledge point depends on, or reverse-query which later topics it unlocks.

Put simply, it isn’t a syllabus — it’s a structural map of “how a child learns something, step by step.”

How to Use It

This project is a pure dataset, so no traditional installation is needed. You can clone the repo directly:

git clone https://github.com/withmarbleapp/os-taxonomy.git
cd os-taxonomy

Then run the validation script:

node scripts/validate.mjs

In JavaScript you can read the JSON directly:

import topics from './data/topics.json' with { type: 'json' };
import deps from './data/dependencies.json' with { type: 'json' };
const byId = new Map(topics.topics.map(t => [t.id, t]));
const prereqs = deps.dependencies
.filter(d => d.topicId === 'mt_N8CpN1EJrP')
.map(d => byId.get(d.prerequisiteId).name);

Good use cases include:

• Knowledge-point localization for AI tutors
• Personalized learning-path recommendation
• Education knowledge-graph visualization
• Curriculum design and competency breakdown
• Education-content grounding for RAG systems
• Student knowledge-gap analysis

Things to Keep in Mind

This project is not a complete AI education product. It does not provide student-mastery data and has not released semantic embeddings. The team explicitly notes that per-child / user data is not published.

The licensing also deserves a careful read. The database structure uses ODbL 1.0, while Marble’s own text content uses CC BY-SA 4.0. curriculum-standards.json contains third-party curriculum standards under different licenses depending on source — some are codes-only and do not include the original standard text.

If you plan to use it in a commercial product, read README.md, LICENSE, LICENSE-CONTENT, and PROVENANCE.md carefully first.

Project Links

• GitHub: github.com/withmarbleapp/os-taxonomy
• Live visualization: withmarble.com/curriculum
• License: ODbL 1.0 and CC BY-SA 4.0; curriculum-standards portions follow upstream licensing.