While researching earlier work in ontology-driven knowledge management, we rediscovered On-to-Knowledge — a 1.3M euro EU project that built, twenty-four years ago, almost exactly the architecture Totem Protocol arrived at independently.
Jonny Dubowsky has been building toward Totem Protocol for over twelve years. The work spans brand marketing, interactive design, art, and music — NRDC campaigns, Download Music Festival, policy advocacy bridging corporate sponsors and communities. Each domain presented the same structural problem: how do groups manage shared resources, make collaborative investment decisions, and synthesize collective intelligence across different contexts?
The core insight, arrived at through practice rather than theory: ontology design is the key. Self-sovereign identity leads to personal knowledge systems. Personal knowledge systems enable sharing solutions through contextual templates. The question was always how to formalize this without losing the flexibility that real creative work demands.
While researching earlier approaches to this same problem, we rediscovered On-to-Knowledge (OTK) — an EU-funded research project (IST-1999-10132) that ran from 2000 to September 2002 under the Fifth Framework Programme. Led by Frank van Harmelen, Dieter Fensel, and Rudi Studer, it received 1.3 million euros to build a comprehensive ontology-based knowledge management architecture.
The architecture maps almost exactly to what Totem Protocol independently built.
OTK decomposed knowledge management into extraction, structuring, storage, inference, editing, sharing, search, and presentation. Totem Protocol performs every one of these functions — through different tools, with different technology, but following the same architectural logic.
| OTK Layer | OTK Function | Totem Protocol Equivalent |
|---|---|---|
OntoWrapper / OntoExtract |
Web document metadata extraction + NLP entity extraction to RDF | Session transcripts → InfraNodus entity extraction + Claude LLM-based extraction |
Sesame |
RDF data repository with RDFS inferencing and SPARQL querying | InfraNodus knowledge graphs + Obsidian vault (YAML frontmatter) |
OIL |
Ontology Inference Layer — formal semantics for machine reasoning | Layered Ontology Architecture (CLAUDE.md schemas + frontmatter type system) |
OntoShare / Spectacle / OntoEdit |
Knowledge sharing, presentation portals, collaborative ontology editing | MCP servers + Cloudflare Pages editorial sites + Obsidian vault tools + skill system |
Both architectures follow the same pipeline: Extract → Structure → Store → Query → Share → Present. The difference is that OTK built each function as a separate specialized tool, while Totem Protocol uses general-purpose AI agents that perform multiple functions through different modes of interaction.
Totem Protocol is a 2026 re-implementation of the OTK architecture. But it is not a replica. Three fundamental shifts in technology transform the same architecture into a categorically more capable system.
OTK was right about the architecture and wrong about the implementation technology. It tried to solve the knowledge management problem with specialized tools and rule-based NLP at a time when neither the tools nor the NLP were sufficient. Twenty-four years later, the architecture holds. Every individual tool has been superseded. And LLMs have solved the extraction and querying problems that limited the original system.
The gap that remains — formal semantic infrastructure (RDF, OWL, SPARQL, SHACL) — is real but addressable. Adding a lightweight semantic layer does not require abandoning the current stack. It means building a bridge between the AI-native tools Totem uses today and the formal semantic standards the OTK community developed twenty-four years ago. The bridge is Perceptagon.
Tracing each tool from its 2002 origins through its modern successors, and mapping it onto Totem Protocol's current stack.
OTK built eight specialized components covering extraction, storage, inference, editing, sharing, search, and presentation. Two survive in evolved form. The rest are extinct — but their functions live on in modern tools and in Totem Protocol's architecture.
extractEntitiesOnly + analyze_text + Claude zero-shot extraction. Strong functional coverage.search / retrieve_from_knowledge_base + Obsidian search. Strong coverage across multiple surfaces.The eight OTK components map onto Totem Protocol with varying degrees of coverage. Strong coverage in extraction, search, and presentation. Weak coverage in formal inference and RDF storage — the gaps Perceptagon is designed to fill.
| OTK Component | Function | Totem Equivalent | Coverage | Gap |
|---|---|---|---|---|
OntoWrapper |
Web metadata → RDF | InfraNodus fetch + Claude WebFetch | Partial | No RDF/OWL output |
OntoExtract |
NLP entity extraction | InfraNodus + Claude LLM extraction | Strong | No formal ontology output |
Sesame |
RDF repository + SPARQL | Obsidian vault + DEVONthink + InfraNodus | Partial | No RDF triplestore |
OIL |
Ontology inference | YAML schemas + InfraNodus graph structure | Weak | No DL reasoning |
OntoShare |
Knowledge sharing | Skills + Slack + templates + 3x3 Framework | Moderate | No formal semantic matching |
RDF Ferret |
Semantic search | DEVONthink + InfraNodus + Obsidian search | Strong | No SPARQL queries |
Spectacle |
Presentation portal | Cloudflare Pages editorial sites + Bases | Strong | — |
OntoEdit |
Ontology editor | Obsidian + CLAUDE.md + Claude Code | Moderate | No visual ontology editor |
A 2025 research project arrived at nearly identical architecture to Totem Protocol, without knowledge of either OTK or Totem. Three systems, twenty-four years apart, converging on the same design.
OntoRAG (2025) builds ontology-augmented RAG systems using Schema Cards for governance, content-addressable Document Transfer Objects for provenance, and MCP servers for agent access. Its architecture independently mirrors both OTK's design and Totem Protocol's implementation.
The same functional requirements produce the same architectural decomposition across two decades and three independent teams. The table below maps each function across all three systems.
| Function | OTK (2002) | OntoRAG (2025) | Totem Protocol (2026) |
|---|---|---|---|
| Extraction | OntoWrapper + OntoExtract (rule-based NLP) | DTO pipeline + LLM extraction proposals | Claude + InfraNodus (LLM zero-shot + graph analysis) |
| Repository | Sesame (RDF + RDFS inferencing) | rdflib / Blazegraph (SPARQL endpoint) | InfraNodus graphs + Obsidian vault (YAML frontmatter) |
| Inference | OIL (Description Logic + frame syntax) | Schema Card + deterministic merge | Layered Ontology Architecture (CLAUDE.md schemas) |
| Access | OntoShare, Spectacle, RDF Ferret | MCP servers (Knowledge + Ontology) | MCP servers + editorial sites + vault tools |
| Provenance | Manual tracking | SHA-256 content hashing per DTO | Git trailers + session hashes |
| Governance | None (beyond OTKM methodology) | Schema Card review checkpoint | Letta Witness Agent + "Schema is law" principle |
If the system cannot explain what it knows, where it comes from, and why it changed, it is not a knowledge system. It is a data store with pretensions.
OntoRAG introduces four mechanisms that Totem Protocol should evaluate for adoption. Each addresses a specific gap in the current stack.
The remaining gap in Totem Protocol is semantic middleware — the layer between vault files and knowledge graphs. OTK called it OntoWrapper + OntoExtract. We call it Perceptagon.
OTK's OntoWrapper and OntoExtract formed a two-stage pipeline: crawl/ingest documents, then apply NLP to extract entities, relationships, and concepts as RDF metadata linked to source documents. This pipeline — document-level ontology annotation — is precisely what Totem Protocol lacks.
InfraNodus extracts entities and relationships as network graphs (nodes and edges with weights). Claude performs zero-shot extraction through prompting. But neither produces formal ontology output. Neither performs incremental knowledge graph construction from text. Neither resolves the same entity appearing across multiple documents into a single canonical representation.
Perceptagon is designed to fill this gap. Its planned functions map directly onto the OTK extraction pipeline, upgraded with modern approaches drawn from iText2KG, OntoGPT, KONDA, and ODKE+.
OTK's OntoShare used vector cosine matching to connect knowledge supply (what people share) with knowledge demand (what the community needs). This is the same problem the 3x3 Framework addresses — matching Skills, Strategies, and Solutions across people's knowledge bases to find fits for unsolved problems.
| 3x3 Dimension | OntoShare Equivalent (2002) | Modern Implementation |
|---|---|---|
| Skills | User competency profiles | OWL-based skill ontology + embedding-based matching |
| Strategies | Ontological class hierarchies | Strategy templates with semantic annotations |
| Solutions | Shared information resources | Deliverable artifacts with frontmatter metadata |
The modern approach combines three matching methods that did not exist together in 2002:
Combining these three methods produces a matchmaking system that neither OTK nor any single modern tool achieves alone: formal precision from SPARQL, semantic breadth from embeddings, and creative opportunity discovery from gap detection.
Express CLAUDE.md frontmatter schemas as SHACL shapes. Run deterministic validation as a Claude Code skill. Add OntoGPT for domain-specific entity extraction grounded to formal ontologies.
Effort: Low-medium. pySHACL exists. OntoGPT is pip-installable. Schemas are already well-defined.
Evaluate OntoRAG's extraction pipeline for adoption. Add Oxigraph as a lightweight local SPARQL endpoint alongside Obsidian. Export frontmatter to RDF triples. Evaluate Cognee as complement to Letta for evolving knowledge graphs.
Effort: Medium. Multiple components to integrate. Oxigraph has Python bindings. The frontmatter-to-RDF mapping uses vocabulary that CLAUDE.md schemas already provide.
Full extraction + annotation + resolution + matching pipeline. Express the Totem Agent Framework (9 agents, 23+ skills, 22 capabilities) as an OWL 2 ontology. Federated SPARQL across all knowledge stores. 3x3 Framework formalized as OWL with matching rules.
Effort: High. Multi-month project. But it gives Totem Protocol what OTK never achieved: a truly integrated semantic knowledge management system powered by modern AI.
The Totem Protocol architecture with OTK insights integrated. Perceptagon serves the function that Sesame + OIL served in OTK: a unified semantic layer that all components read from and write to.
OTK was right about the architecture and wrong about the implementation technology. Twenty-four years later, the architecture holds. The individual tools have been superseded. And LLMs have solved the extraction and querying problems that limited the original system. The bridge between AI-native tools and formal semantic standards is Perceptagon.
The semantic web promised enterprise-grade knowledge intelligence. It delivered — but only for organizations that could spend millions on implementation. AI changed the equation. Totem Protocol is the result.
Between 1998 and 2008, the European Union invested billions of euros in research-meets-enterprise programs designed to commercialize semantic web technologies. Projects like OTK received targeted funding — 1.3 million euros in OTK's case — to build tools that would make knowledge management ontology-driven, machine-readable, and semantically interoperable.
The technology worked. The economics didn't.
Implementation required ontology designers, data scientists, RDF specialists, and integration engineers. Schema consensus alone could take months. Enterprise deployments ran six to seven figures. The OntoRAG team — building a comparable system in 2025 — spent over $1 million in development costs. Target customers would spend another $200,000 to $500,000 in agency fees, consulting, and internal time to deploy it.
The result: semantic technologies became the exclusive province of governments, defense contractors, and Fortune 50 companies. Everyone else got keyword search and spreadsheets.
The semantic web didn't fail because the architecture was wrong. It failed because the implementation cost exceeded the ROI for all but the largest organizations on earth.
Concepts leaked into the mainstream — Google adopted RDF and Linked Data, JSON-LD became a web standard, Wikipedia structured its data as Wikidata, machine learning models started using data cards. But the full promise of semantic intelligence — structured knowledge that machines can reason over, share, and compose — remained locked behind enterprise budgets.
Between 2022 and 2026, large language models broke the cost barrier. Not by making semantic web tools cheaper — by making them unnecessary as standalone products.
Every knowledge worker now has access to what OTK's target customers — special projects cohorts, enterprise ontology teams, consulting firms — used to spend hundreds of thousands of dollars to provision: an entity extraction engine, a reasoning system, a natural language query interface, a document synthesis pipeline, and a presentation layer. All running through general-purpose AI agents that require no RDF expertise, no SPARQL training, and no six-month taxonomy workshops.
The EU spent billions funding research into tools that would let organizations manage knowledge semantically. Twenty-four years later, every knowledge worker has their own personal collection of agencies and consultants — they just don't know it yet.
| Capability | OTK Era (2001) | Enterprise Era (2015) | AI-Native Era (2026) |
|---|---|---|---|
| Entity Extraction | Rule-based NLP (Text-to-Onto) | Trained ML models ($500K+) | Zero-shot LLM prompting (pennies per document) |
| Knowledge Structuring | Manual ontology editing (OntoEdit) | Enterprise taxonomy platforms ($200K/yr) | InfraNodus + Claude Code skills (included) |
| Semantic Storage | Sesame RDF repository (custom deploy) | Neo4j / Stardog ($50K-500K/yr) | Obsidian vault + Letta memory (free / $20/mo) |
| Querying & Reasoning | SPARQL + OIL inference rules | GraphQL + custom reasoning engines | Natural language via Claude / MCP servers |
| Knowledge Sharing | OntoShare (vector matching) | Confluence / SharePoint ($10-50/user/mo) | Skills + editorial sites + Slack pipelines |
| Presentation | Spectacle (custom portal) | Tableau / PowerBI ($15-70/user/mo) | Generated editorial sites (minutes, not weeks) |
| Total Implementation | $1.3M+ (research project) | $500K–$10M (Palantir-class) | $5K–$50K (Totem Protocol + ShurIQ engagement) |
Both OTK and Totem Protocol follow the same six-stage pipeline. The architecture is identical. The implementation is completely different.
OTK built each stage as a separate specialized tool, each with its own interface, data format, and deployment requirements. Totem Protocol uses general-purpose AI agents that perform multiple functions through different modes of interaction.
The critical difference: OTK required a different specialist for each stage. An ontology engineer for Structure. A Sesame administrator for Store. A SPARQL developer for Query. A web developer for Present. Totem Protocol runs the entire pipeline through a single agent session, with Claude Code orchestrating specialized tools via MCP.
Palantir Technologies is the closest commercial analogue to what Totem Protocol delivers. Their pitch: enterprise ontology + data integration + custom deployment = actionable intelligence. Their price: $1 million to $10 million per engagement. Their customers: governments, intelligence agencies, Fortune 50.
Shur Creative Partners delivers the same architecture to the next tier down. Fortune 500 companies and nimble brands who need the same quality of insight but cannot justify Palantir's price tag.
The positioning is precise: clients don't just get a report. They get a new way of seeing their business, their market, and the attention flows around them. That is the experiential differentiator from Palantir's black-box model. Palantir tells you what happened. ShurIQ shows you why it matters and what the negative space reveals.
Totem Protocol has reduced decades of semantic web research — billions of euros in EU funding, thousands of PhD dissertations, hundreds of commercial failures — into a substrate for encoding high-performing expertise-based work. Not by reimplementing the research. By recognizing that LLMs made the implementation layer disposable while the architectural layer remained timeless.
There are dozens, if not hundreds, of businesses, products, and services that can be derived from various combinations of Totem Protocol's capabilities. ShurIQ is the first. It won't be the last.
The formula works because the components are general-purpose:
This is the business case that OTK's consortium never cracked: how to take a research architecture and make it commercially viable without requiring enterprise-scale implementation budgets. The answer turned out to be — wait twenty-four years for AI to make the specialized tools unnecessary, then rebuild the architecture with general-purpose agents.
Between the late 1990s and mid-2000s, the European Commission funded hundreds of semantic web projects through the Fifth and Sixth Framework Programmes. The strategy was deliberate: direct graduate students toward commercializable tools, fund consortia that mixed academic research with industrial partners, and measure success by spin-off companies and self-sustaining products.
The success rate was roughly 10% to self-reliance. OTK's components mostly didn't survive independently — but their DNA is everywhere. Sesame became RDF4J. OIL became OWL. OntoEdit became semafora systems. The research ROI was real. The distribution was the bottleneck.
| Era | Investment | Output | Bottleneck |
|---|---|---|---|
| FP5 (1998–2002) | ~€3.6B across IST | OTK, SWAP, KAON, Knowledge Web | Implementation cost per customer |
| FP6 (2002–2006) | ~€3.6B across IST | SEKT, KnowledgeWeb, SIMILE | Talent scarcity + schema governance |
| FP7 (2007–2013) | ~€9B across ICT | LOD2, LIDER, xlime | Enterprise adoption / ROI justification |
| Horizon 2020 (2014–2020) | ~€6B KET + data | Eurostars, KG-based innovation pilots | ML/deep learning pivot; KG deprioritized |
| AI-Native (2023–) | LLM training costs absorbed by labs | OntoRAG, OntoGPT, iText2KG, Totem Protocol | None — the architecture is now accessible |
Totem Protocol sits at the end of this arc. Not as a single breakthrough, but as a convergence point — where twenty-five years of architectural research meets the AI capabilities that finally make the architecture cheap to implement. The semantic web's promise was always real. The cost was the only thing standing in the way. That barrier is gone.
The semantic web didn't die. It went underground, evolved through academic research and enterprise consulting, and resurfaced in 2026 as AI-native knowledge architecture. OTK planted the seed. Totem Protocol is the harvest.