Semantik Architect is a deterministic multilingual rendering and natural-language generation layer for structured knowledge.
It can be used as a general rule-based NLG toolkit for structured data, with inspiration from Abstract Wikipedia and Wikifunctions. In the kOA ecosystem, it also acts as the rendering surface for Kristal v5: turning structured, scoped, traceable knowledge into readable multilingual text without flattening uncertainty, authority, or disagreement.
Its job is not to invent facts.
Its job is to render what the selected input and reader policy allow, while preserving meaning, labels, and traceability.
Semantik Architect turns structured meaning into human-readable language.
It can render:
The output should remain:
Structured knowledge is only useful if people can read it.
Projects like Abstract Wikipedia and Wikifunctions show the importance of representing meaning independently from language, then rendering that meaning into many languages. But multilingual generation only works at scale if the system is:
Semantik Architect is a concrete architecture for doing that.
It treats language generation as reusable infrastructure instead of one-off text generation.
Note: Semantik Architect is not an official Wikimedia component. It is an independent experimental architecture designed to learn from that ecosystem while remaining usable outside it.
Instead of building “one renderer per language,” Semantik Architect separates meaning from language-specific realization.
It uses:
Kristal v5 compiles Structured Epistemic States into portable, verifiable artifacts.
Semantik Architect renders those artifacts into language.
In a Kristal context, Architect should preserve:
validated_as mode;Architect does not decide what is true.
It renders the material selected by the active reader policy.
For example, a validated-only reader policy may allow a claim validated as a high-confidence fact, a mythological corpus validated as mythology, or a technical declaration validated as a publisher declaration. Architect must not collapse those into the same kind of “truth.”
When used with Kristal v5, Semantik Architect follows a simple contract:
validated / policy-selected structured input
+ render profile
+ language
+ reader policy
= deterministic rendered output
+ trace metadata
Architect should not introduce factual claims that are not present in the input.
This includes:
Architect may add:
If the input is ambiguous, disputed, uncertain, fictional, mythological, symbolic, or authority-scoped, the output must preserve that status when the render profile requires visible labels.
Think of it as a pipeline:
Structured meaning
-> semantic frames
-> sentence plan
-> language-family engine
-> language profile / lexicon
-> surface text
-> trace map
Inputs may come from:
Semantic frames represent meaning in a language-neutral form.
Examples:
Constructions decide what to say and how sentence parts relate.
A construction may define:
Language-family engines implement shared grammar logic.
Examples:
The family engine handles reusable structure; language cards provide local differences.
Language cards define language-specific settings such as:
Lexicon entries provide the features languages need to produce grammatical output.
A lexicon entry may include:
When rendering from Kristal or other provenance-bearing inputs, Architect should output trace metadata showing which rendered segment came from which structured claim, evidence reference, or assertion.
This makes rendered language inspectable instead of opaque.
Konnaxion provides distribution, access, coordination, reader surfaces, and runtime activation for knowledge artifacts and civic processes.
Semantik Architect fits as the language layer:
In short:
Konnaxion distributes and presents governed knowledge surfaces; Semantik Architect renders structured knowledge into multilingual narrative.
Orgo is the workflow and governance control plane.
It may coordinate:
Semantik Architect can render Orgo-managed structures into readable summaries:
SenTient helps resolve and normalize meaning before rendering.
It may support:
Architect should not silently resolve ambiguity that SenTient preserved.
If the input says a subject is ambiguous, Architect either renders the ambiguity or refuses to render the ambiguous claim as a settled fact, depending on the active render profile and reader policy.
engines/ family engines
morphology/ inflection and agreement modules
constructions/ sentence templates
semantics/ frame types and normalization bridges
lexicon/ lexeme types, loaders, and indices
discourse/ topic, salience, and referring expressions
render_profiles/ output profiles and constraints
trace/ trace-map structures and helpers
qa/ test suites
qa_tools/ regression runners
router.py internal routing and entry points
# Pseudocode-level illustration.
# API details may vary by repository version.
bio = BioFrame(
name="Douglas Adams",
profession="writer",
nationality="British",
)
result = generate(
lang="en",
frame=bio,
render_profile="short_biography",
)
# "Douglas Adams was a British writer."
# Pseudocode-level illustration.
# The renderer receives policy-selected structured input and must preserve labels.
result = architect.render(
language="en",
render_kind="summary",
reader_policy="validated_only",
input_bundle=runtime_pack_query_result,
template_id="assertion_summary_card",
)
# Output:
# {
# "rendered_text": "...",
# "trace_map": [...],
# "render_metadata": {
# "reader_policy": "validated_only",
# "language": "en",
# "template_id": "assertion_summary_card"
# }
# }
Semantik Architect should be expressive, but not imaginative about facts.
It may make language beautiful, clear, and multilingual.
It must not make unsupported factual claims.
When rendering from Kristal, the core invariant is:
A rendered statement must never appear more certain, more validated, more recognized, more factual, or more universal than the structured input and reader policy support.