Controlled Knowledge Engineering for Taxonomy Induction with Tool-Grounded LLM Agents and Runtime-Adaptive Policies

Jonas Limniatis, Bennet Schaarmann, Georg Reuber, Robert StahlbockarXiv 2026 · arXiv

This paper, recently uploaded to arXiv, introduces TIGA (Taxonomy Induction with Tool-Grounded Agents), a framework that treats building a taxonomy not as a creative writing task, but as a rigorous engineering process.

TL;DR

TIGA moves taxonomy construction away from "free-form" LLM generation toward a controlled, state-based engineering process. By using tool-calling agents that maintain an explicit memory and a self-authored "policy," TIGA achieves significantly higher structural completeness and F1 scores than standard prompting, though it comes with a higher computational price tag.

What Problem Does This Paper Address?

Taxonomies—hierarchical trees like "Fruit > Citrus > Lemon"—are the backbone of semantic search and product organization. While Large Language Models (LLMs) are great at identifying relationships, they struggle with the "big picture" of a taxonomy.

When you ask an LLM to generate a large hierarchy in one go, it often suffers from:

  1. Hallucinations: Inventing entities that weren't in the source list.
  2. Omissions: Forgetting to include half the required items.
  3. Structural Failures: Creating loops (A is a parent of B, B is a parent of A) or giving one item multiple parents when a simple tree is required.

Existing iterative methods try to fix this with more prompts, but they lack a "persistent state"—the model doesn't have a formal record of why it made previous decisions or a consistent set of rules to follow across a long session.

Methods

The authors introduce TIGA, which formulates taxonomy induction as an iterative decision process. Instead of writing a text tree, the agent interacts with a "workspace" using specific tools:

  • Explicit State: TIGA tracks the current taxonomy ($T$), the list of pending entities ($V$), a dynamic policy ($P$), and a tool-interaction memory ($M$).
  • Constrained Action Space: The agent cannot just "type" the taxonomy. It must call tools like add_entity, remove_entity, or view_subtree. This ensures that every change is structurally valid (e.g., you can't add a child to a non-existent parent).
  • Runtime-Adaptive Policy: This is the "secret sauce." The agent can call update_policy to write its own rules (e.g., "Sausages should be grouped by meat type, not processing method"). It refines these rules as it learns more about the specific dataset.
  • Tool-Interactive Memory: TIGA records not just the action, but the agent's rationale and the environment's feedback.
  • Global Reviewer: Once the tree is "finished," a separate LLM pass checks the entire structure against the candidate set and the agent's own policy to flag inconsistencies for revision.

Datasets

The researchers evaluated TIGA across four distinct benchmarks to test its versatility:

  • WordNet: Small, shallow sub-taxonomies (animal taxa, artifacts).
  • DBLP: A computer science taxonomy derived from paper abstracts.
  • TExEval-2: Domain-specific taxonomies covering Environment, Food, and Science.
  • Google Product Taxonomy (GProd): A complex, real-world e-commerce classification system.

Key Insights and Ideas

  • Engineering vs. Generation: The core "aha moment" is that taxonomies are data structures, not stories. By forcing the LLM to use an API (tools) to build the structure, you eliminate the "format drift" that plagues standard prompting.
  • The Bimodal Policy Pattern: The authors found that agents update their "rules" mostly at the very beginning (planning) and the very end (consolidation/cleanup), with a quiet period in the middle. This mimics how human experts work.
  • Precision vs. Recall: Standard LLM prompts are "conservative"—they only predict edges they are very sure of, leading to high precision but low recall (many missing items). TIGA is "braver"; its tool-based nature ensures every entity gets placed, leading to much higher recall and overall F1 scores.

Key Results

  • Superior Quality: TIGA achieved the highest F1 scores in 7 out of 8 experimental settings.
  • Recall Boost: On the Google Product Taxonomy, TIGA improved recall by 8.1 percentage points over the strongest baseline.
  • Model Efficiency: Interestingly, the open-weight Gemma-4-31b backbone was often more cost-effective and accurate in this agentic setup than the proprietary GPT-5.4-mini.
  • The Cost of Quality: TIGA is expensive. It requires roughly 6.3x more API calls than iterative prompting. The authors frame this as a "quality-cost trade-off"—TIGA is for when the cost of a broken taxonomy is higher than the cost of the tokens to build it.

Limitations and Future Work

  • Computational Overhead: The high token consumption and inference time make TIGA less suitable for real-time applications.
  • Tree Constraint: Currently, TIGA is designed for "rooted trees" (one parent per node). It doesn't yet support "poly-hierarchies" where a "Lemon" could be under both "Fruit" and "Yellow Things."
  • Reviewer Budget: The global reviewer is capped at three rounds; the authors noted that complex taxonomies sometimes need more "thinking time" than the current budget allows.
  • Human-in-the-loop: Future work could involve using TIGA's explicit rationales to let human experts "audit" the agent's logic mid-process.

For more details, you can find the full paper under the title "Controlled Knowledge Engineering for Taxonomy Induction with Tool-Grounded LLM Agents and Runtime-Adaptive Policies."

Summary updated

Abstract

Taxonomies are structured knowledge representations that support semantic search, recommendation, product catalog organization, and retrieval-augmented generation. Their automated construction from a fixed set of candidate entities requires more than plausible text generation: the resulting hierarchy must be complete, structurally valid, and semantically coherent. Large Language Models (LLMs) are promising for this task, but iterative free-form generation remains vulnerable to omitted or hallucinated entities, invalid hierarchical relations, and inconsistent organizational principles. We introduce TIGA (Taxonomy Induction with Tool-Grounded Agents), a knowledge-engineering architecture that formulates taxonomy induction as an iterative decision process over an explicit state and constrained action space. TIGA combines executable taxonomy-editing tools, an memory that records tool calls, rationales, and outcomes, and a runtime-adaptive organizational policy that the agent revises during inference. An optional global reviewer evaluates the constructed taxonomy against the candidate set and the active policy. We evaluate TIGA on four benchmark taxonomies using two LLM backbones and compare it with single-shot and iterative prompting-based baselines. TIGA achieves the strongest structural-quality results in most evaluated configurations, but does not dominate on every precision measure. The gains are accompanied by substantially higher token consumption, API-call volume, and inference time. Ablation results show consistent benefits from the policy and interaction-memory components, whereas the effect of global review depends on the dataset and the available revision budget. These findings characterize tool grounding and runtime policy adaptation as promising but costly mechanisms for improving the controlled construction of structured knowledge representations.
BibTeX
@misc{limniatis2026controlled,
  author = {Jonas Limniatis and Bennet Schaarmann and Georg Reuber and Robert Stahlbock},
  title = {{Controlled Knowledge Engineering for Taxonomy Induction with Tool-Grounded LLM Agents and Runtime-Adaptive Policies}},
  year = {2026},
  eprint = {2611.13966},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.13966},
}
Figure