SemanticOS ingests a company’s real sources, resolves the entities behind the words, grows its own ontology under review, and answers questions by traversing the graph and reporting the path it took.
Designed and built by Julian Hernandez, data engineer. Neo4j, Python and Kafka, over about a year.
Ask a question and the path lights up hop by hop, naming the relationship it crosses at each step. Every answer carries the nodes it used, and when the graph does not hold one, it says so.
Loading the graph…
Loading the graph…
The graph above is sized to stay readable. Pointed at a real Notion workspace and left to run, the same pipeline produced the figures below.
Five stages between a raw source and a grounded answer. Each one validates before it writes, so what reaches the graph is typed, deduplicated and traceable back to the page it came from.
Airbyte OSS → Kafka → governed sink
Sources stream in as change events. Every record passes through a sink that validates it against what the graph is allowed to contain before anything is written.
LLM extraction + embeddings
Entities and the relationships between them are pulled out of the text. Each one carries a pointer back to the page it came from, so every fact stays traceable.
name + context canonicalization
The same thing said five ways collapses into one node. Scoring is lexical-dominant, so an embedding can raise a pair for review but never merges one on its own.
LLM proposes, validator disposes
A model may propose a type from the material; only deterministic code writes one into the schema. Unknown types are quarantined and promoted once they recur past a threshold.
Neo4j traversal, grounded
Questions are answered by traversing the graph and reporting the path taken. A temporal filter drops superseded edges, so an answer reflects one point in time.
Every stage, with the decision behind it and the trade-off it carries→
The graph model is source-agnostic: anything reducible to entities and relationships can be ingested. Notion is the connector built and run end to end so far.
Every figure below comes from a run on real data, recorded in the project’s own reports and readable in the repository. Where a result is narrow, it says so.
Pointed at a Notion workspace with two languages mixed and templates cloned two to four times, it drained ~14.4k page records down to 9,430 unique pages and built a 12,936-node graph. 92.8% of it is governed by the ontology, and quarantine settled at 81 nodes across a single type.
Six types were seeded by hand. The other 74 were proposed from the material and placed into multi-level taxonomies the system derived on its own: Thing › Product › Feature › Attribute, and Event › Process › Automation. A skeptic agent reviewed the uncertain band and rejected six proposals as noise.
The first large page minted 508 canonical entities and merged 427 surface variants, 46% duplicates on contact with real data. By the third pass a cloned template produced 11 new entities against 223 merged. The graph recognises what it already holds.
Precision and recall of 1.0 on a labelled spike set, with zero incorrect merges. The design came out of a measurement: bare-name embeddings scored AuraDB/Aura at 0.69 and Aurora/Aura at 0.70, one hundredth between a correct merge and a catastrophic one. Name-plus-context embeddings separate them at 0.865 against 0.650.
Twenty thousand nodes at 1024 dimensions, 200 queries over two passes, against a 0.95 target. Latency came in at 225ms p95 against a 150ms target, and the cold/warm two-pass design traced that to a ~205ms cross-region network floor, identical warm and cold, so neither the index nor TLS.
Questions about content that had never been ingested were answered with an honest refusal and zero fabrication. Nine defects were found and fixed in the same sessions, including a tenant bootstrap that silently reset the evolved ontology on every pass. Fixed in three places, with the damaged meta-graph repaired in place.
The repository underneath it: 6,266 lines of tests against 5,428 of authored source, with a vendored MIT library excluded from the count.
Each of these as a full study, with the method and what it settled→
One more, with its scope stated: on a controlled evaluation over edge-only facts, graph retrieval scored 1.000 where flat RAG scored 0.000, with a bootstrap confidence interval whose lower bound clears zero. That is mechanism validation on a small, deliberately narrow set rather than a broad benchmark.
The five that come up most often from people who build these systems.
Search returns links and a knowledge base stores static pages. SemanticOS builds a governed semantic graph of entities and the relationships between them, so an answer carries its sources, respects the permissions on the data, and leaves an audit trail. That grounding is what makes the graph safe for an agent to query, not only a person.
Mostly from the data, under one rule: the LLM proposes and a deterministic validator disposes. A small set of types is seeded by hand. The rest are proposed by a model as it reads the corpus, quarantined on arrival, and promoted only once they recur past a threshold, so a model never writes a type into the schema directly. A skeptic agent reviews the types left below the threshold, and its verdicts pass through the same validator.
It says so. The retrieval layer is built to abstain rather than guess: when the graph does not hold an answer, the system names what it does hold and offers the closest path instead of inventing an entity, a person or a number.
The graph model is source-agnostic: anything reducible to entities and relationships can be ingested. Notion is the connector built and run end to end so far, through Airbyte and Kafka into a governed sink. Other systems reach the graph the same way, one connector at a time.
Phase 1 is validated and the system runs. Ingestion, entity resolution, ontology evolution and retrieval all work end to end on a real corpus, with each result written down in the project reports. It is paused there while I gather the resources and the people a system this size needs, and the quickest way to see where it stands is a live walkthrough.
Something not answered here? Ask me directly.
SemanticOS is an independent project, paused between phases while I look for the resources and the people to carry it further. The problem it addresses does not pause with it: an organisation’s knowledge has to be modelled before anything built on top of it can be trusted. If your team is working on that, for retrieval or for agents, I would like to hear about it.
Goes to info@semanticos.io, which I read myself. Happy to give a live walkthrough of the system and the reports behind it.