Announcing SemType

Today we’re launching semtype.org — the home of an open standard for describing the entities and "things" that matter to you, in a way that other people, AI agents, and software can all understand and use.

Why semtype

Data has a shape. Some of it has a schema. But almost none of it has meaning that travels with it beyond the application that created it, except that might be contextually infered.

When a "Person" from one piece of software meets a "Customer" in another, the two records may map cleanly onto one another, or share no overlap at all — and generally there’s no good way to tell, ahead of time, without writing code. The same is true of fields within those records: one app’s email is another’s contact_email is another’s primary_address. AI agents asked to reason across these systems hit the same wall, just faster and more expensively.

SemType addresses these mismatches at their source: by giving definitions themselves — not the data — first-class identity, structure, and reuse.

What it is

A SemType is a versioned, structured definition of a kind of thing, an attribute of a thing, or a relationship between things. The SemType specification describes four types:

• Data types constrain the values a property can take — text, numbers, dates, URIs, units of measure, and so on, with constraints attached.
• Property types describe semantic attributes of entities, backed by data types. Reusable across many entity types, so a single canonical Email property can flow between everyone who uses it.
• Entity types describe what something is — a Person, a Building, a Company — by specifying the properties it can or must have.
• Link types make relationships first-class: a ShareholderIn link can carry its own properties (share count, share class, acquisition date) and point between typed endpoints.

Types can inherit from one another, can be versioned and evolved independently, and can be published to a public registry for discovery, reuse, and cross-walking between organizations. They’re also designed to be human-readable: every type carries names, descriptions, and documentation that flow through to end-user interfaces, eliminating the gap between technical schemas and what users actually see.

A Block Protocol module, now a standalone spec

SemType is the direct descendant of the Block Protocol’s Graph Module — a specification that originally set out to describe the interchange format between blocks and the applications hosting them. The Graph Module had two intertwined goals: making the capture of structured data by non-technical end-users easier, and enabling decentralized collaboration between users who, working independently and without coordination, might each conceptualize the same semantic entities slightly differently. The type system at its core was the part that made both possible — and is, with refinements, what we now call SemType.

That type system has been in active use inside HASH for more than five years, sitting at the heart of our platform — underpinning every entity, every link, every dashboard, and every AI workflow our users have built. It has been hardened against real-world data through years of incremental refinement, and proven out across use cases we never initially had in mind.

Today we're extracting SemType from the Block Protocol’s broader concerns, as well as from HASH’s implementation specifics, into a formal, standalone specification of its own that can be adopted independently — by other applications, other ecosystems, and other graphs.

Where to find it

The full specification, an explanation of the different kinds of types, the rationale behind the design, and links to get started all live at semtype.org:

• Specification — the canonical definition of the type system and data model.
• Type Registry — coming soon, via supporting applications.
• Get Started — pick the layer that fits your stack, or adopt the full HASH platform end-to-end.

SemType powers HASH, and is the foundation of a small stack of open-source projects we’ll be talking about in upcoming posts: hGraph, the multi-temporal graph store; HashQL, a typed query language; and HaRPC, a typed, versioned transport. Each layer extends the same discipline — semantic types that travel with the data — into a different part of the stack.

Get involved

SemType is published as a free, open-source standard and dually licensed under both the MIT and Apache 2.0 licenses (at your option). If you build with it, find sharp edges in the spec, or want to publish types of your own, we’d love to hear from you — drop us a line at hash.ai/contact, or open an issue against the HASH repository on GitHub.