Everything the tags can carry
Core ontology
Four knowledge primitives — entity, relationship,
fact, rule — cover things, the links between them,
assertions about them, and the conditional statements that connect assertions.
Provenance
<aodm:source> records where a statement came from, with a URI,
a title, when you retrieved it, and separately when the source itself made the
claim.
Confidence
<aodm:confidence> carries a value from 0.0 to 1.0, optionally
tagged with the method that produced it, so uncertainty travels with the data
instead of being lost at the boundary.
Structured measurement
<aodm:value> expresses a quantity as a number with a unit and
an optional tolerance, or as a min/max range. Units follow UCUM codes. No
regex parsing magnitudes out of prose.
Temporal validity
valid-from and valid-to bound when an assertion holds.
Superseded knowledge is excluded from current queries but retained for audit,
never silently deleted.
Polarity
polarity="negative" states that something is known to be false,
which is a different claim from having no information. Both the format and the
rules keep the two apart.
Derivation tracking
derived-from records which rule and which facts produced an inferred
statement, so you can answer “why is this believed?” and trace every
conclusion that rests on a given source.
Content hashing
Self-describing digests (sha256:…) let the same fact arriving
from two pipelines be recognised as one fact rather than ingested twice.
Dual serialisation
Every document can be written as XML or as JSON, with a field-for-field mapping between them. Both forms have a published, tested schema.
Documented validation rules
Referential integrity, cardinality, measurement, temporal and provenance rules that no schema language can express are specified separately, with two named conformance levels.
Online validator
Paste a document and check it against every rule in the specification, in the browser. Nothing is uploaded and nothing is stored.
Reference parsers
Open implementations in Python, JavaScript, Java and C#, each dependency-free. They read AODM, enforce every validation rule, and write it back out. Four independent implementations is also how the specification itself gets tested.
XBRL converter
Complete support for the XBRL 2.1 instance syntax, so financial filings become AODM without re-authoring anything — periods, units, dimensions, tuples, footnotes and stated accuracy all carried across.
Self-generated knowledge
origin="generated" marks a claim a system proposed
rather than observed, and <aodm:evidence> quotes the
passage that prompted it, with a locator. A proposal can be reviewed in
seconds instead of re-reading the source.
Graph compiler
Compiles to Neo4j, RDF Turtle, GraphML and Graphviz. Facts, rules and sources become nodes — which is what makes “what rests on this source?” a single traversal rather than a full scan.
Inference engine
Forward chaining with confidence propagation, time-scoped evaluation, explanation and retraction. Evaluation semantics are specified, so two conformant engines reach the same conclusions.
LLM context builder
Renders a document into prompt-ready context that carries the trust signals with it, so a model can hedge accurately instead of stating everything with equal confidence.
HTML embedding profile
One data-aodm attribute annotates an existing page in place, with
no runtime dependency and no effect on rendering. The online validator extracts
it straight from a live page.
Citable by AI search
Generative engines repeat claims they can attribute. A fact carrying its source, confidence and validity window is one an engine can verify rather than paraphrase, and the markup adds no script and no render cost.
Every element and attribute is defined in the documentation, with the full reference tables and a worked example for each.
What changes once it is running
AI cites you
A claim an engine can attribute and date is one it can repeat in its own answer, with your name on it, rather than working around you for a source it can verify.
Data arrives usable, not just parsed
A consumer that receives a source, a confidence and a validity window can decide how much weight to give a claim.
Superseded figures stop circulating
Expired knowledge drops out of present-tense queries while staying on record, so “what did we believe last March, and on what basis?” is now answerable.
Unit confusion becomes impossible
A quantity arrives as a number, a unit and a tolerance rather than a string every consumer parses for itself, differently, and occasionally wrongly.
Systems decline instead of guessing
“Does not require coolant” and “no information about coolant” stay distinct. A processor must honor that distinction or reject the document.
A retracted source takes its consequences with it
Invalidating an input finds every conclusion that transitively rests on it, instead of leaving them scattered with nothing linking them back.
Automated deduplication occurs upstream
The same statement arriving from two pipelines is recognised as one, so deduplication is not re-invented at every entry point.
Nothing has to execute
A few hundred bytes per tag, read by XPath, DOM parsers, lxml or any JSON library. No runtime dependency, no effect on page speed.
Adoption can be incremental
The quality features are optional attributes, so a consumer that ignores them still parses correctly. Start with entities and facts; add provenance and validity as your pipeline learns to use them.
Start in about ten minutes
- Download the package.
- Generate AODM from what you already have — a web page, Schema.org JSON-LD, a CSV or an XBRL filing — or tag content by hand.
- Check it in the browser validator before you publish.
Or have us implement it
The specification is free and stays free. Your time is not. Ten minutes covers a page — a catalogue, an archive, a documentation set or a filing pipeline is a project, and we will take that on as one.
- Your content mapped, not rewritten. Entities, facts, relationships and rules derived from what you already publish, in the structure it already has.
- Markup on the pages that display it. Using the HTML embedding profile, so the human-readable and machine-readable versions cannot drift apart later.
- Provenance wired to real sources. Confidence, validity windows and derivation tracking set against where your claims actually come from — the part that separates AODM from ordinary structured data, and the part most easily got wrong.
- Validated, and left maintainable. Everything passes the conformance suite, and your team gets the conventions written down so the next hundred pages match the first.
- Long-term support, if you want it. Best value when your data moves — prices, availability, measurements, anything restated often. On a retainer we keep the markup current as the content changes, so every claim carries a confidence and a validity window that are true on the day someone reads it. When the specification itself moves, migrating your markup to the new version is included at no extra charge for as long as you are on support. Available from the start or added later.
Give us the address and we read the site: the price follows the amount of content on it and the types of content it turns out to be. Nothing is changed and nothing is stored but the measurements. Prefer to ask a person? Support@FucaSpark.com. Implementation and support are the only things here that cost anything: the specification, the schemas, the reference parsers and the validator are Apache 2.0, and that does not change.