Semantic Instruments · 0.0.41 reference slice

A labelled, sealed package of knowledge
and you choose whose rules to run.

A Semantic Instrument is a well-labelled package of runnable knowledge, not a black box. Before you use it, you can inspect its purpose, author, requirements, limits, and prohibited uses. Each run then creates a receipt that records what was used and what happened.

No instrument is imposed on you. A purpose may have several instruments, published by different people and organisations; you decide which to collect, trust, install, and run. You can also compare how more than one instrument evaluates the same situation. Once you enable an instrument for a Webizen/QualiaDB-powered agent, its declared rules bind that agent. The person chooses the rules; the machine must follow them.

One inspectable path

From a labelled rule to an accountable result

Every step stays separate: receiving a package is not trusting it, and trusting it is not running it.

Who makes them, who uses them

People write the rules — so we can share and use expertise, with technology

A doctor, teacher, accountant, lawyer, economist, or professional body can express a field rule as a Semantic Instrument: a precise, checkable definition of a judgement or calculation. Recipients can apply the same rule to their own information, in their own environment, and retain a receipt of the outcome. This is expert decision support for human-centric AI: the knowledge travels as a labelled tool while the data stays with the person using it.

Authorship itself is open. Anyone who can write down the rules of a domain — a professional, a community group, a hobbyist, an individual — can make an instrument. Credentials, not gatekeeping, are what distinguish whose rules you are choosing to run.

An author encodes. A professional, an organisation, or anyone with rules worth sharing turns a real rule — a guideline, an eligibility test, a formula — into an instrument with a declared purpose, inputs, and limits.

You receive and check it. Before running anything, you can read exactly what the instrument does, who authored it, and what it depends on — like reading a label before taking a product off the shelf.

It runs on your terms. You apply it to your own information locally, inside declared limits, and the receipt records precisely which instrument and inputs produced the answer.

How QualiaDB makes instruments possible

Human-centric, symbolic AI

Two capabilities inside QualiaDB do the heavy lifting: shared vocabularies that pin down what words mean, and built-in systems of logic that make the rules genuinely runnable — not just text describing them.

Ontologies: a shared dictionary of meaning

An ontology is a field's agreed vocabulary, written down formally — what "a dose", "a credit hour", or "a taxable invoice" actually is, and how those things relate to each other. QualiaDB is a semantic knowledge engine, so an instrument's definitions are written in that shared language and every instrument declares which ontology it relies on. The result: a term means the same thing to the author who wrote the rule, the recipient who runs it, and the machine that evaluates it — no silent reinterpretation along the way.

Ontologies are not exotic or new. Thousands have been published by organisations, governments, standards bodies, and public-interest projects — for medicine, law, education, finance, geography, and more — and most major websites already embed some level of ontology in their pages so that search engines and other machines can understand them. This machine-readable layer of meaning, sometimes called the Web of Data, is the foundation of symbolic AI — the branch of AI built on explicit, inspectable knowledge — on which much of the rest of AI is built.

Domain ontologies linked through shared logic Four domain vocabularies for health, learning, finance, and law connect to a shared semantic graph, which supplies clearly defined terms to an executable logic layer. Health ontology Learning ontology Finance ontology Law ontology Shared semantic graph terms · relations · meaning Declared logic runs bounded rules

Logic systems: the rules really run

The rules inside an instrument are written in logics built into the engine itself — not comments, not prose. That includes rules that can be strict or defeasible (a stronger rule can legitimately override a weaker one), shapes that check whether data fits the required form, norms for what is obligatory, permitted, or forbidden, and logics for time and for what is known or believed — twenty-one modalities in all, compiled to execute inside the Webizen VM under declared bounds.

Selected logic and analysis capabilities
AreaHigh-level support
Rules & shapesStrict and defeasible rules, plus SHACL validation for declared data requirements.
Norms & timeObligations, permissions, prohibitions, and bounded temporal trace evaluation.
Knowledge & contextEpistemic, paraconsistent, and spatio-temporal reasoning for scoped claims.
Clinical & life sciencesRisk and safety checks, alignment, protein and sequence-oriented analysis.
Chemistry & physicsMolecular properties, reaction measures, thermodynamics, and bounded numerical models.
EconomicsModelled indicators and bounded simulations such as Monte Carlo value-at-risk.

Available capability is not a claim that every instrument is suitable for a high-stakes decision; each package declares its own purpose, limits, and evidence.

In plain words

What it actually does

It declares itself

Every instrument carries a label you can read: its purpose, its author, its version, the inputs it needs, the things it depends on, and the uses that are explicitly off-limits. Nothing about what it claims to do is hidden inside the code.

It only runs complete

An instrument refuses to run until everything it declared it needs is actually present. If a required input or dependency is missing, it stops and says so — it never guesses, fills gaps silently, or invents a result.

It leaves a receipt

Each run produces a tamper-evident record binding the exact package, inputs, and outputs together. You can later prove what was run, on what, and what it produced — and a revoked instrument cannot quietly be used again.

Simple examples

The same pattern, many fields

In each case an expert writes the rules once, and recipients run those rules against their own information — with the label inspectable beforehand and a receipt afterwards.

A clinical guideline

A medical college publishes an instrument encoding a screening guideline. A clinic runs it against its own patient records — which never leave the clinic — and the receipt shows exactly which guideline version was applied and to what.

Prior learning, itemised

A training provider encodes how prior-learning evidence maps to a course unit's requirements. A learner submits their portfolio; the instrument reports each requirement as satisfied, equivalent, unresolved, or unmet — not an unexplained yes or no.

A tax rule, applied to your books

An accounting body encodes a deduction rule set. A small business runs it against its own ledger in its own environment, and the receipt binds the outcome to the exact ruleset version — ready to show an auditor.

Eligibility, without a phone call

A legal aid organisation encodes the eligibility criteria for a service. A community worker checks a client's situation against it locally, sees precisely which criteria are met or unresolved, and can show how that answer was reached.

A method others can reproduce

An economics institute encodes how an indicator is calculated. Other researchers run the identical method on their own datasets — same version, same definition — and can prove the figures were produced the declared way.

Classroom marking criteria

A teacher encodes the rubric for an assessment task. Students and moderators can inspect the criteria, apply them consistently, and retain a record of how each mark was derived.

Try the idea

Build a tiny Semantic Instrument label

Start with a familiar purpose, say what information it needs, and set a boundary. This is a learning playground: it creates a visual label and a mock receipt only. It does not save anything, inspect your data, or make a real-world decision.

Your instrument label

demo draft
Purpose
Check a learner's portfolio against a course unit's declared criteria.
Required information
Portfolio evidence and the course criteria
Boundary
Show satisfied, unresolved, and unmet criteria; do not award a qualification.
Identity
demo:learning · v0.1

Example run: held

The package is labelled, but the example record is incomplete. A real instrument should hold the run here rather than inventing an answer.

receipt: demo-held · input commitment: missing

From agreement to instrument

A shared rule can begin with several honest understandings

People making an agreement may bring different claims, references, responsibilities, and degrees of confidence. Instead of hiding those differences, an agreement ledger can preserve each party's position, identify what is shared, record what remains unresolved, and consolidate only the terms people have actually accepted.

The consolidated agreement can then be packaged as a Semantic Instrument: an inspectable rule set with declared inputs, boundaries, parties, dependencies, and receipts. It is not a machine deciding what people meant; it is a tool for making the agreed meaning visible and runnable.

An open format with accountable authorship

Anyone can write one — credentials say who did

Semantic Instruments are not a closed club. Anyone can author one: the format is open, the packaging is inspectable, and a homemade instrument works the same way as one from a national professional body. That openness is a safeguard, not just a courtesy — if only designated experts could define the rules, the power to define them would itself become a chokepoint worth capturing.

What distinguishes authorship is proof, not permission. The ecosystem is designed to work with W3C Verifiable Credentials (and Open Badges-compatible exports), so an instrument — and the credentials it produces — can carry cryptographically verifiable statements about who authored it, who reviewed it, and under what authority.

That is the point: when an expert organisation or licensed professional publishes an instrument, recipients — and the semantic and AI systems built on top — can check whose rules they are actually running. The human expert stays visible and accountable inside the machine's chain of reasoning, rather than being laundered into anonymous "the system says so" output.

Instruments designed this way are intended to keep the tools that AI and semantic systems rely upon human-centric: authored by identifiable people and bodies, bounded by declared limits, and auditable end to end.

The package at a glance

A label around the rules, not a claim of automatic authority

The package makes the important facts visible together: what the instrument says it does, what it contains, what it requires, and how a later result can be checked.

You still decide whether to collect, install, trust, or activate an instrument. Those are deliberately separate choices.

Why it is built this way

Tools stay tools; trust stays earned

A package, not a personality

An instrument is a labelled tool, never a peer person or an authority merely because it looks official. A signature or catalogue listing can show where it came from; it does not prove every claim is true. Collecting, installing, trusting, and running remain four deliberate decisions.

  • Purpose, prohibited uses, category, and version are written on the label.
  • Contents, dependencies, and a content digest can all be inspected.
  • Demo and reference packs stay labelled — a polished visual does not create trust.

Missing pieces are held, not invented

Author, reviewer, publisher, instrument, result, and capability credential are separate records. If a required input or dependency is absent, the run is held rather than fabricated. Revocation blocks new reliance without erasing receipts for past runs.

  • Collection, installation, trust, and activation are distinct decisions.
  • Required inputs or dependencies that are missing are held, not invented.
  • Revocation prevents new reliance without erasing historic receipts.

The Studio authoring rail

Seven deliberate stages, reachable by keyboard

01

Flow

Choose the bounded lifecycle and entry-point intent.

02

Select

Choose a labelled demo or reference starting point.

03

Shapes Canvas

Inspect and edit the declared semantic shape.

04

Manufacture

Build the inspectable collectable and check publication readiness.

05

Receipts

Review the chain of executions and their commitments.

06

Inspect

See purpose, dependencies, provenance, limits, and held state before use.

07

Run

Execute only a closed, preflighted installation and retain a receipt.

Gate

Human UAT

Live accessibility, security, and human walkthrough evidence remains the SI-12 release gate.

Under the hood

For technical readers

The collectable: a Hyper Media Container

Each instrument ships as a Webizen/Qualia Hyper Media Container (HMC): one archive that can bundle its HCF description, N3 definition graph, manifest, accessible 10d visual, and — on native builds — an optional compact Q42 graph. Supporting material, including vocabulary ontologies, can be included directly. Assets too large to bundle, such as substantial Q42 volumes, appear as declared dependencies on the label rather than being silently assumed.

Validate, resolve, preflight

SHACL shapes and package inspection reject incomplete material. Resolution creates a dependency lock, distinguishes optional from required dependencies, detects revoked entries, and supports a closed offline install. Preflight requires a closed installation before dispatch.

Receipts & attestation

Each outcome binds release, package digest, dependency-lock digest, entry point, input/output commitments, and optional parent receipt. Native, W3C VC, and Open Badges-compatible exports are supported as credential envelopes.

Layer 4 · Formal Specification · Identifier Fabric (IDF-01–IDF-05)

Semantic Instruments on the Four-Plane Identifier Fabric

Every Semantic Instrument executes within the Four Disjoint Planes defined in ontologies/identifier_fabric_shapes.ttl so that tools, credentials, network channels, and human beings remain structurally distinct:

1. Entity (Who Plane)

NaturalAgent (living-SHACL), LegalEntity, and SystemAgent. Never merged by similarity, handle, wallet, location, or biometrics; owl:sameAs is forbidden on the Who plane (SameAsError::WhoPlaneForbidden).

2. Claim Plane

Scoped, signed assertions (VerifiableCredential, idf:ClaimOpinion, idf:AccountabilityArtifact, deontic/epistemic norms) with provenance and expiry. VCs prove cryptographic origin integrity of an issuer's statement, not universal ontological truth.

3. Handle Plane

Revocable, rotatable network or directory locators (idf:SpatiotemporalHandle, DNI, DNS, email, did:qi endpoints). Revoking a handle closes the channel without erasing the Entity.

4. Instrument Plane

Cryptographic keys, hardware tokens, and software tools (SemanticInstrument, idf:Instrument, idf:AiAgent) classified by InstrumentProofClass (CryptographicOriginIntegrity, HardwareChannelPossession, SemanticClaimEvaluation) and closed KeyRole (IdentityAssertion, CredentialSigning, TransportHandshake, StorageEncryption, RecoveryBootstrap).

Typed Cross-Plane Evidence Morphisms Statements link planes explicitly via idf:supportedByInstrument, idf:assertedAbout, and idf:observedAtHandle rather than collapsing tool receipts into actor identity.
F5 & F6 Anti-Feature Firewalls Both the F5 (compile-time VibeScript) and F6 (runtime ingress/query) firewalls reject person_score, identity_confidence, and same_person.

Honest release boundary

Reference runner, not a deployed decision service

The 0.0.41 reference slice has package, validation, registry, resolution, receipt, attestation, RPL, and Studio workflows with scripted conformance coverage. The boundaries below are stated plainly so a demo is never mistaken for a deployed decision service.

Current reference behaviour

  • Only the labelled assess and recognise demo entry points are dispatched.
  • The reference transform is deliberately simple, making its input and output commitments inspectable.
  • Cancellation, resource limits, unknown entries, and unclosed installs are refused.
  • Empty required input produces a held receipt rather than a fabricated result.

Not claimed by this page

  • No generic Host-ID dispatch and no production clinical, legal, or employment determination is implied.
  • Native Q42 content may be held in WASM with an explicit degradation notice.
  • SI-12's live security, accessibility, and human-UAT matrix is not represented as complete.

Follow the 0.0.41 record

The release page gives the wider milestone; the source tree and conformance suite remain the technical authority.