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.
1. Inspect the label
Read the purpose, author, version, limits, and dependencies before deciding whether it belongs in your environment.
2. Preflight the package
Check that required inputs, dependencies, and trust decisions are present. Missing pieces put the run on hold.
3. Run on your terms
Apply the declared rules to your own information within the instrument's stated bounds.
4. Keep the receipt
Retain a tamper-evident record linking the package, inputs, dependency lock, and outcome.
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.
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
Area
High-level support
Rules & shapes
Strict and defeasible rules, plus SHACL validation for declared data requirements.
Norms & time
Obligations, permissions, prohibitions, and bounded temporal trace evaluation.
Knowledge & context
Epistemic, paraconsistent, and spatio-temporal reasoning for scoped claims.
Clinical & life sciences
Risk and safety checks, alignment, protein and sequence-oriented analysis.
Chemistry & physics
Molecular properties, reaction measures, thermodynamics, and bounded numerical models.
Economics
Modelled 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.
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.
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.
Semantic Instrument
Inspectable before execution
version + digest
Label
Purpose, author, category, and version.
Rule graph
Definitions and executable logic in a shared vocabulary.
Requirements
Declared inputs and dependencies, resolved before use.
Limits
Prohibited uses and execution bounds remain explicit.
Credentials
Evidence of authorship or review — not permission by itself.
Receipts
Run records that link the package, commitments, and result.
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.
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.