Hierarchical Domain-Task Ontology

• Hierarchical domain-task ontology is a structured framework that organizes broad domain concepts into finer task-specific elements to support reasoning and procedural correctness.
• It integrates formal ontologies, neural architectures, and workflow repositories to connect semantic categories with task feasibility and execution order.
• Applications span robotics, dialogue systems, and medical coding, demonstrating enhancements in predictive accuracy, efficient task planning, and robust system integration.

A hierarchical domain-task ontology is a structured representation in which domain abstractions, task decompositions, and execution constraints are arranged across ordered levels, so that coarse semantic categories constrain finer goals, actions, or predictions. In the literature, the term covers formal ontologies in OWL or RDF, ontology-like workflow repositories, neural architectures whose internal layers encode parent–child task structure, and hierarchy-aware embedding schemes over curated taxonomies. Across these formulations, the common objective is to connect domain semantics to task feasibility, execution order, or generalization under uncertainty, thereby supporting reasoning, reuse, and procedural correctness (Martorana et al., 26 Sep 2025, Liu et al., 2021, Chok et al., 14 Aug 2025).

1. Conceptual scope and defining characteristics

The central idea is a coarse-to-fine organization of knowledge. At the upper levels, a system represents broad domain entities, goals, or categories; at lower levels, it represents sub-goals, actions, slots, affordances, tool invocations, or code-level distinctions. In personal service robotics, this appears as a decomposition from task to procedure, step, action, affordance, and capability. In dialogue systems, it appears as domain-to-intent or goal-to-sub-goal structure. In specialized agents, it appears as a task-dependency graph stratified into sequential layers. In medical modeling, it appears as parent–child code ancestry in ICD-9, ATC, or SNOMED CT hierarchies (Martorana et al., 26 Sep 2025, Mo et al., 2024, Li et al., 21 Nov 2025, Liu et al., 8 Feb 2025).

A second defining feature is that the hierarchy is not merely taxonomic. Many of the cited systems connect semantic organization to operational consequences. OntoBOT links an embodied agent, a physically bounded environment, symbolic actions, affordances, and ROS-level capabilities, so that task feasibility can be inferred from embodiment and context (Martorana et al., 26 Sep 2025). BERT-Joint encodes the claim that intent recognition depends on domain recognition by learning domain representations in lower layers and intent representations in higher layers (Liu et al., 2021). HierTOD organizes enterprise workflows as goals, steps, and slots, allowing transitions between procedural guidance and slot-filling modes (Mo et al., 2024). HTAM structures multi-agent execution according to prerequisite constraints in a domain DAG, so that each layer consumes outputs from preceding layers (Li et al., 21 Nov 2025).

A third feature is heterogeneity of formal status. Some systems are explicit knowledge-engineering artifacts with classes, properties, and query semantics. Others are described more cautiously as ontology-like: they organize task knowledge hierarchically and operationalize it in retrieval or control, but do not define formal classes, properties, or axioms in an ontology language. This distinction is explicit in the literature on enterprise task-oriented dialogue and remote-sensing agents (Mo et al., 2024, Li et al., 21 Nov 2025). A plausible implication is that “hierarchical domain-task ontology” is best understood as a family of representational strategies rather than a single canonical formalism.

2. Recurrent representational patterns

Across the literature, several recurring hierarchy types appear: taxonomic hierarchies, procedural decompositions, dependency-layered workflows, and hierarchy-aware latent representations. They differ in syntax, but all impose an asymmetric relation between more general and more specific units.

Work	Hierarchical units	Formalization
OntoBOT (Martorana et al., 26 Sep 2025)	Activity → Procedure → Step → Action → Affordance → Capability	OWL; aligned with DOLCE, SOMA, PKO, ROS.owl
BERT-Joint (Liu et al., 2021)	Domain → Intent	Hierarchical multi-task neural model
HierTOD (Mo et al., 2024)	Goal/workflow → Step/sub-goal → Atomic action / slot	YAML goal repository; hierarchical finite state machine
Ontology-driven TAMP (Din et al., 2024)	Task / ActionPriority / Object → object subclasses	RDF ontology with SPARQL-guided prompt enrichment
HiRef (Chok et al., 14 Aug 2025)	ICD-9 / ATC parent–child code trees	Hyperbolic ontology encoder plus graph refinement
HTAM (Li et al., 21 Nov 2025)	DAG of tasks/tools → topological layers	Layered multi-agent architecture

Procedural hierarchies are especially prominent. OntoBOT treats a high-level task as a structured goal-oriented activity composed of procedures, ordered steps, and atomic actions, with each action constrained by a required affordance and corresponding capability (Martorana et al., 26 Sep 2025). HierTOD stores workflows as goal descriptions with sequential steps and optional slot constraints, allowing sub-goals to transition depending on dialogue progress (Mo et al., 2024). The semantic-parsing framework based on a domain ontology decomposes meaning representations into reusable fragments derived from domain-general rules, domain-specific predicates, and co-reference variables, then reconstructs them as recursive derivations (Cheng et al., 2018).

Taxonomic hierarchies are more salient in medical and ontology-learning settings. HiRef models diagnosis, procedure, and medication codes as rooted trees in which each node has only one parent, then embeds those trees in hyperbolic space to preserve ancestry (Chok et al., 14 Aug 2025). OntoTune relies on SNOMED CT, whose ontology structure consists primarily of hypernym relationships, synonym relationships, and definitions of concepts (Liu et al., 8 Feb 2025). hrLDA learns noun-phrase topic trees from heterogeneous documents and enriches them with relation triplets, yielding a terminological ontology rather than an explicit workflow ontology (Zhu et al., 2017).

3. Formal mechanisms for modeling and reasoning

In formal ontology engineering, OntoBOT is a paradigmatic example. It is implemented in OWL and reuses foundational and procedural vocabularies while adding “3 new classes and 7 new object properties.” Its core notions are Agent, Environment, Task, and Affordance. The ontology specifies that obot:Agent is a subclass of dul:Agent, prov:Agent, and foaf:Agent; that each agent is linked to ros:Nodes by obot:hasNode; that messages can evoke ros:Capability instances; and that OntoBOT connects those capabilities to affordances via obot:enablesAffordance. Task execution is represented as prov:Activity, associated with an executing agent by prov:wasAssociatedWith, and decomposed through pko:executesProcedure, pko:hasStep, pko:nextStep, pko:requiresActions, and obot:nextAction. This yields the explicit hierarchy Activity → Procedure → Step → Action → Affordance → Capability (Martorana et al., 26 Sep 2025).

Reasoning in OntoBOT is operationalized through SPARQL competency questions rather than extensive theorem-prover axiomatization. The six competency questions identify objects and affordances in a task, extract action sequences, retrieve required capabilities, determine which robot can execute all actions, test whether one robot can perform multiple activities, and identify missing capabilities and blocked steps. The cited example for “Prepare breakfast” traverses the chain from prov:Activity to procedure, step, action, object, and required affordance (Martorana et al., 26 Sep 2025).

Ontology-driven prompt tuning for TAMP uses a more compact RDF schema. The ontology defines three main classes—Task, ActionPriority, and Object—with Object specialized into FoodItems, BoxedFood, Crockery, Utensil, KitchenItems, and Container. SPARQL queries retrieve object types, priorities, and textual descriptions, and this information is converted into prompt guidance. For the put task, description-logic style rules encode that Crockery has priority 1 and FoodItem has priority 2, which is used to prevent semantically invalid action orderings in symbolic plans (Din et al., 2024).

Neural formulations encode hierarchy in latent space rather than in explicit class axioms. BERT-Joint computes an utterance representation $\bar{h}$ from BERT hidden states via average pooling, then derives a domain representation

$$s_d = \mathrm{ReLU}(W_d \bar{h} + b_d), \qquad d = \mathrm{LayerNorm}(s_d + \bar{h}),$$

followed by an intent representation

$$s_t = \mathrm{ReLU}(W_t (d + \bar{h}) + b_t), \qquad t = \mathrm{LayerNorm}(s_t + d).$$

The resulting hierarchy is $\bar{h} \rightarrow d \rightarrow t$, with domain in the lower layer and intent in the higher layer. Training uses a weighted sum of domain and intent cross-entropy losses, and a threshold-based post-processing rule marks an example as out-of-scope when the predicted intent probability is below $\tau$ (Liu et al., 2021).

HiRef introduces a hierarchy-aware encoder for medical codes in the Poincaré ball $$\mathbb B^n=\{\mathbf{x}\in\mathbb R^n:\|\mathbf{x}\|<1\}$$, with separate ontology trees $\mathcal T_*=(V_*,E_*)$ for diagnoses, procedures, and medications. Parent–child proximity is optimized in hyperbolic space, ancestor embeddings are aggregated by Möbius addition, and the resulting hierarchy-aware representation is fused with a sparsified EHR co-occurrence encoder through a learned convex gate (Chok et al., 14 Aug 2025). OntoTune uses ontology-guided in-context learning differently: for a concept $t$, it compares a response without ontology guidance, $y_t = f_\theta(x,t)$, to a response with ontology knowledge, $y_t^o = f_\theta(x,t,o_t)$, and adopts the alignment target

$$s_d = \mathrm{ReLU}(W_d \bar{h} + b_d), \qquad d = \mathrm{LayerNorm}(s_d + \bar{h}),$$0

Low-similarity cases are treated as uncovered concepts and selected for self-training (Liu et al., 8 Feb 2025).

HTAM formalizes domain structure as a DAG $$s_d = \mathrm{ReLU}(W_d \bar{h} + b_d), \qquad d = \mathrm{LayerNorm}(s_d + \bar{h}),$$1, where nodes are atomic operations, tools, or tasks and edges are prerequisite constraints. Topological stratification partitions the graph into layers $$s_d = \mathrm{ReLU}(W_d \bar{h} + b_d), \qquad d = \mathrm{LayerNorm}(s_d + \bar{h}),$$2 such that if $$s_d = \mathrm{ReLU}(W_d \bar{h} + b_d), \qquad d = \mathrm{LayerNorm}(s_d + \bar{h}),$$3 and $$s_d = \mathrm{ReLU}(W_d \bar{h} + b_d), \qquad d = \mathrm{LayerNorm}(s_d + \bar{h}),$$4, $$s_d = \mathrm{ReLU}(W_d \bar{h} + b_d), \qquad d = \mathrm{LayerNorm}(s_d + \bar{h}),$$5, then $$s_d = \mathrm{ReLU}(W_d \bar{h} + b_d), \qquad d = \mathrm{LayerNorm}(s_d + \bar{h}),$$6. Planning proceeds top-down through policy functions $$s_d = \mathrm{ReLU}(W_d \bar{h} + b_d), \qquad d = \mathrm{LayerNorm}(s_d + \bar{h}),$$7, while execution proceeds bottom-up through layer-wise functions $$s_d = \mathrm{ReLU}(W_d \bar{h} + b_d), \qquad d = \mathrm{LayerNorm}(s_d + \bar{h}),$$8, so that later layers operate only on outputs from earlier ones (Li et al., 21 Nov 2025).

4. Domain-specific realizations

In personal service robotics, the hierarchy binds symbolic plans to embodied execution. OntoBOT was motivated by domestic service settings in which robots assist older adults and people requiring support, yet deployments remain tightly coupled to specific platforms. By integrating DOLCE, SOMA, PKO, and ROS.owl, OntoBOT models not only tasks and environments but also the execution stack that realizes capabilities such as grasping, opening, pouring, or placing (Martorana et al., 26 Sep 2025).

In dialogue systems, hierarchical domain-task organization appears in two distinct forms. BERT-Joint treats domains as coarse semantic parents and intents as fine-grained children in out-of-scope classification, explicitly arguing against a brittle two-stage domain-then-intent pipeline (Liu et al., 2021). HierTOD, by contrast, addresses enterprise workflows that are multi-layered, poorly standardized, and partly implicit in expert practice. Its YAML goal repository stores high-level goals, sequential steps, and slots, while a hierarchical finite state machine switches between Goal Pending and Goal Execution and allows proactive transition from a handled sub-goal to a broader workflow (Mo et al., 2024).

In LLM-based planning, the hierarchy is used to correct semantic ordering. The ontology-driven TAMP framework introduces a kitchen ontology that classifies objects, assigns task-dependent priorities, and textualizes environment state from YOLO detections and FoundationPose estimates. Prompt construction combines user input, template text, ontology-derived guidance, and environment-state description before GPT-4 generates a symbolic plan whose actions are executed by RRTConnect (Din et al., 2024).

In medicine, two forms of hierarchy are emphasized. HiRef uses ICD-9 and ATC trees as structured priors for medication recommendation from longitudinal EHRs, specifically to handle rare and unseen codes (Chok et al., 14 Aug 2025). OntoTune uses SNOMED CT as a curated hierarchy of hypernyms, synonyms, and definitions, treating ontology as a “domain-specific mind map” for LLM alignment rather than as a mere source of triples (Liu et al., 8 Feb 2025).

In specialized agent systems, HTAM instantiates domain hierarchy directly in architecture. EarthAgent, its remote-sensing realization, has three layers: Data Acquisition and Preprocessing, Data Processing and Analysis, and Synthesis and Application. Sub-agents such as DataFetcherAgent, PreprocessingAgent, SemanticSegmentorAgent, ChangeDetectorAgent, and domain-facing experts such as AgriScoutAgent or CrisisCommanderAgent are assigned to those layers (Li et al., 21 Nov 2025).

The broader concept also includes ontology induction and ontology-guided language interpretation. hrLDA learns hierarchical terminological ontologies from raw heterogeneous documents by replacing unigrams with noun phrases and relation triplets, using ACRP and nested ACRP to construct topic trees (Zhu et al., 2017). The semantic-parsing framework derived from a domain ontology uses domain-general rules such as LookupKey, Filter(property), Comparative, and Superlative, along with domain-specific predicates, entities, and co-reference variables, to elicit data and train sequence-to-derivation parsers for compositional and sequential utterances (Cheng et al., 2018). This suggests that hierarchical domain-task ontologies can function both as explicit knowledge bases and as scaffolds for data generation, representation learning, or control.

5. Empirical evidence and evaluation regimes

The service-robotics evaluation of OntoBOT uses six competency questions across TIAGo, HSR, UR3, and Stretch. The capability summaries are differentiated: TIAGo supports grasping, holding, placing, pouring, and opening/closing drawers; HSR supports grasping, holding, placing, and opening drawers but not pouring; UR3 supports grasping, holding, placing, and pouring but not opening/closing; Stretch supports grasping, holding, and placing, but no verified opening/closing or pouring. For CQ4, only TIAGo can execute all actions for “Prepare breakfast,” while both TIAGo and HSR are sufficient for “Reorganise the kitchen.” For CQ5, only TIAGo can execute both activities. For CQ6, HSR cannot complete “Serve food” because it lacks soma:Pouring; UR3 lacks soma:Opening and soma:Closing; Stretch cannot complete any full step because it lacks soma:Holding; and TIAGo can perform all steps in both activities (Martorana et al., 26 Sep 2025).

The dialogue literature evaluates both predictive accuracy and interaction quality. On the OOS dataset with 10 domains and 150 intents, BERT improves from all Acc. $$s_d = \mathrm{ReLU}(W_d \bar{h} + b_d), \qquad d = \mathrm{LayerNorm}(s_d + \bar{h}),$$9 and OOS F1 $$s_t = \mathrm{ReLU}(W_t (d + \bar{h}) + b_t), \qquad t = \mathrm{LayerNorm}(s_t + d).$$0 to BERT-Joint with all Acc. $$s_t = \mathrm{ReLU}(W_t (d + \bar{h}) + b_t), \qquad t = \mathrm{LayerNorm}(s_t + d).$$1 and OOS F1 $$s_t = \mathrm{ReLU}(W_t (d + \bar{h}) + b_t), \qquad t = \mathrm{LayerNorm}(s_t + d).$$2; with thresholding, overall accuracy rises to $$s_t = \mathrm{ReLU}(W_t (d + \bar{h}) + b_t), \qquad t = \mathrm{LayerNorm}(s_t + d).$$3, OOS recall to $$s_t = \mathrm{ReLU}(W_t (d + \bar{h}) + b_t), \qquad t = \mathrm{LayerNorm}(s_t + d).$$4, and OOS F1 to $$s_t = \mathrm{ReLU}(W_t (d + \bar{h}) + b_t), \qquad t = \mathrm{LayerNorm}(s_t + d).$$5 (Liu et al., 2021). HierTOD is assessed by a human study with 5 annotators and 20 dialogues each, covering product platform operations, troubleshooting, and general tasks. Average scores on a 5-point Likert scale are Relevance 4.37, Coherence 4.31, Fluency 4.46, and Helpfulness 4.20 (Mo et al., 2024).

In TAMP, the ontology-driven prompt-tuning framework is compared against LLM-TAMP from Wang et al. (2024). For the inverted-order prompt in Scenario A, traditional LLM-TAMP obtains TPSR $$s_t = \mathrm{ReLU}(W_t (d + \bar{h}) + b_t), \qquad t = \mathrm{LayerNorm}(s_t + d).$$6, EXESR $$s_t = \mathrm{ReLU}(W_t (d + \bar{h}) + b_t), \qquad t = \mathrm{LayerNorm}(s_t + d).$$7, and average 8.6 LLM calls, whereas ontology-driven LLM-TAMP reaches TPSR $$s_t = \mathrm{ReLU}(W_t (d + \bar{h}) + b_t), \qquad t = \mathrm{LayerNorm}(s_t + d).$$8, EXESR $$s_t = \mathrm{ReLU}(W_t (d + \bar{h}) + b_t), \qquad t = \mathrm{LayerNorm}(s_t + d).$$9, and average 2.6 LLM calls. For a generic prompt such as “move crockery items to the correct table, move the boxed food items to the left table,” the baseline yields 0% TPSR and 0% EXESR, while the ontology-driven method achieves 50% TPSR and 50% EXESR (Din et al., 2024).

Medical evaluations emphasize robustness to sparsity and transfer. In the unseen-code setting, HiRef attains the highest target-medication F1 for all three target drugs: R03A: 0.9768, N03A: 0.8186, and C01C: 0.7938. Ablations show that removing the hierarchical encoder degrades performance relative to the full model, while removing the co-occurrence encoder causes a larger drop, indicating complementarity between semantic hierarchy and empirical graph structure (Chok et al., 14 Aug 2025). OntoTune reports state-of-the-art performance on in-ontology hypernym discovery and out-of-ontology medical QA, and is reported to preserve original LLM knowledge and jailbreak safety better than the direct ontology injection baseline TaxoLLaMA* (Liu et al., 8 Feb 2025).

For specialized agents, EarthAgent is evaluated on GeoPlan-bench, which contains 1,244 unique tasks across 7 sub-domains and 3 difficulty levels. Its reported overall scores are approximately Recall$\bar{h} \rightarrow d \rightarrow t$0 0.66, Precision$\bar{h} \rightarrow d \rightarrow t$1 0.65, F1$\bar{h} \rightarrow d \rightarrow t$2 0.63, Structural 0.68, and Holistic 1068.27, outperforming CoT, ReAct, Plan-and-Execute, Debate, and AFlow (Li et al., 21 Nov 2025). In ontology learning, hrLDA achieves the best precision and F-measure on corpora about European Capital Cities, Office Buildings in Chicago, and Birds of the United States, with F-measure values 91.2 / 82.6 / 82.9 (Zhu et al., 2017). In ontology-guided semantic parsing, the sequence-to-derivation parser outperforms sequence-to-sequence and sequence-to-tree baselines across six single-turn domains; in the restaurant domain, for example, S2D achieves 47.2 ExM / 49.5 SeM, compared with 25.4 / 35.9 for S2T and 21.3 / 29.0 for S2S (Cheng et al., 2018).

6. Limitations, boundary cases, and recurring misconceptions

A persistent misconception is that every hierarchical representation of domain and task knowledge is a formal ontology in the OWL/RDF sense. The literature is more differentiated. OntoBOT is explicitly such a formal ontology (Martorana et al., 26 Sep 2025). HierTOD explicitly states that it does not present a formal ontology in the strict knowledge-representation sense, even though its hierarchy of goals, sub-goals, steps, and slots behaves like one in practice (Mo et al., 2024). HTAM likewise functions as a hierarchical ontology of tasks in a practical sense, but it is presented as a task-centric multi-agent architecture derived from a DAG, not as an ontology language (Li et al., 21 Nov 2025). BERT-Joint embeds the ontology idea into network structure rather than symbolic axioms (Liu et al., 2021).

Another misconception is that hierarchy by itself guarantees portability or complete reasoning coverage. The ontology-driven TAMP framework uses a simple kitchen ontology, which gives strong performance in kitchen-like manipulation tasks but has limited direct portability unless new ontologies are built. It also incurs prompt-construction overhead from SPARQL querying and textualization, remains vulnerable to very generic or ambiguous prompts, and does not eliminate motion-planning failures caused by unreachable targets or blocked paths (Din et al., 2024). The semantic-parsing framework requires a domain ontology, type checking, and only models a limited set of discourse structures—Exploitation, Exploration, Merging, and Unrelated—while context provides only small gains (Cheng et al., 2018).

The ontology-learning literature draws a further boundary between terminological and task ontologies. hrLDA induces hierarchies of noun-phrase concepts and relation triplets, but the “task” aspect is only indirect: it does not explicitly represent task goals, procedures, workflows, or action schemas, and it is not designed for formal reasoning (Zhu et al., 2017). Conversely, systems such as OntoBOT or HTAM foreground task execution and feasibility, but may rely on relatively compact extensions or architectural constraints rather than exhaustive axiomatization. OntoBOT itself does not present many explicit logical axioms in theorem-prover style, instead formalizing commitments through class/property assertions and competency questions (Martorana et al., 26 Sep 2025).

A final distinction concerns the role of hierarchy in generalization. HiRef and OntoTune use curated medical ontologies to transfer information through shared ancestors or ontology-guided self-training, but both assume the availability of a high-quality standardized ontology such as ICD-9, ATC, or SNOMED CT (Chok et al., 14 Aug 2025, Liu et al., 8 Feb 2025). This suggests that the effectiveness of a hierarchical domain-task ontology depends not only on the existence of a hierarchy, but also on how completely that hierarchy captures the semantics, constraints, and edge cases of the target domain.