💻 computer science

A-tree: Agent Tree and Its Application to Patent Analysis

This paper introduces Agent Tree (A-Tree), an interpretable extension of Neural Network Trees that utilizes specialized agents and a one-step look-ahead mechanism to enhance decision transparency and accuracy in high-stakes domains, demonstrated through a successful application in classifying and mining innovation rules from computer-vision patents.

Original authors: Qiangfu ZHAO, Xiao Huang

Published 2026-09-07

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Qiangfu ZHAO, Xiao Huang

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the world of artificial intelligence, large language models have become remarkably skilled at generating text, solving problems, and offering advice. They can write stories, draft legal documents, and even help debug computer code. However, when these systems are used for high-stakes decisions—such as determining the value of a new invention or diagnosing a medical condition—a significant problem arises. The reasoning behind their answers is often hidden inside a complex web of numbers and weights that even their creators cannot fully trace. Furthermore, these models often struggle to recognize the limits of their own knowledge. When faced with a question that falls outside their training, they tend to guess confidently rather than admitting uncertainty. This opacity and lack of boundaries make it difficult to trust them in fields where the cost of an error is high, such as patent law, where a single misclassification can alter the course of an inventor's career or a company's future.

To address these challenges, researchers Qiangfu Zhao and Xiao Huang from Zhenjiang Normal University have proposed a new framework called the Agent Tree. Instead of relying on a single, massive model to make a final decision, they broke the task down into a hierarchical structure where each step is handled by a specialized, well-defined agent. Think of this structure as a decision tree where every branch point is a distinct expert, rather than a black box. Each expert is trained to understand only one specific concept, such as "image noise reduction" or "battery overheating," and is equipped with a collection of real-world examples to help it judge whether a new input belongs to its category. If the input fits, the process moves down the tree to a more specific expert; if it does not, the path stops, and the system explains exactly why. This design ensures that the entire reasoning process is transparent, traceable, and grounded in concrete evidence, rather than hidden statistical probabilities.

The researchers tested this approach using a corpus of two hundred and twenty-two computer vision patents, a selection drawn from a larger set of twenty thousand documents. They built two separate trees to analyze these patents: one focused on the technical problems the patents aimed to solve, and another focused on the specific technologies proposed to solve them. To construct these trees, they used a large language model to recursively analyze the patent texts, grouping them into increasingly specific categories based on their content. For instance, a patent might start in a broad category like "image processing," move to "object detection," and finally settle on "pedestrian detection." Crucially, the system was designed to retrieve relevant examples from a shared database for each decision point, allowing the agents to compare new patents against known cases to make their judgments. This method, known as structured retrieval, ensures that every agent has access to the right context without needing to store duplicate information, making the system efficient and scalable.

A key innovation in their work is a mechanism called one-step look-ahead inference. In a standard decision tree, the system might choose a path based on the immediate next step, potentially leading to a dead end where no further specific classification is possible. The new method allows the system to peek one step further down the tree before committing to a path. By evaluating not just the immediate child node but also the potential of its children, the system can avoid dead ends and reach more specific, meaningful conclusions. When the researchers compared this advanced method against a standard approach, they found that the one-step look-ahead significantly improved the depth of their analysis. For the problem-based tree, the average depth of the reasoning path increased from 2.4 steps to 2.7, and for the technology-based tree, it jumped from 1.6 to 2.4. This deeper classification meant that the system could identify more precise categories for the patents, moving beyond general labels to specific technical solutions.

The results of the experiment demonstrated the feasibility of this framework. Using the one-step look-ahead method, the system achieved an accuracy of ninety-six point four percent on the test set of patents. While the standard method produced fewer errors in some cases, it often stopped too early, leaving the patents in broad, unhelpful categories. The new method, by pushing the classification deeper, provided more actionable insights, even though it resulted in a slight increase in misclassifications, which the researchers noted could be managed with better thresholds. Beyond simple classification, the true power of the system emerged when the results from the two trees were combined. By pairing the problem a patent solved with the technology it used, the researchers could map out the landscape of innovation. They identified patterns such as strong associations, where certain technologies are consistently used for specific problems, and rare or missing associations, which represent potential opportunities for new inventions. For example, they could see which technologies were versatile enough to solve many different problems and which were highly specialized.

This work suggests a path forward for making artificial intelligence more trustworthy in critical fields. By replacing opaque, monolithic models with a structured hierarchy of specialized agents, the researchers have created a system that not only makes decisions but can explain exactly how and why it reached them. The agents do not just guess; they compare new inputs to concrete examples and signal when an input falls outside their expertise. The study validates that this approach can be implemented using current cloud-based language models and can handle the complexity of real-world data like patent documents. While the current test was limited to a specific subset of computer vision patents, the framework is designed to be adaptable to other domains, such as medical diagnosis or legal reasoning, where understanding the chain of thought is just as important as the final answer. The researchers conclude that this method offers a promising direction for building artificial intelligence that is not only powerful but also transparent and accountable.

Technical Summary: A-Tree: Agent Tree and Its Application to Patent Analysis

1. Problem Statement

The deployment of Large Language Models (LLMs) in high-stakes domains, such as patent analysis, is currently hindered by two fundamental limitations:

Opacity: The reasoning path of an LLM is hidden. While techniques like Chain-of-Thought (CoT) generate text that looks like reasoning, they are post-hoc reconstructions rather than transparent causal chains of the model's internal computation.
Boundary Blindness: LLMs lack explicit knowledge of the limits of their own concepts. When an input falls outside a concept's valid scope, the model often produces a probabilistic "best guess" rather than signaling uncertainty or recognizing the boundary.

Existing interpretability methods (e.g., LIME, SHAP, attention visualization) provide approximations or visualizations but do not offer a traceable, human-readable causal chain of the decision-making process. Furthermore, while Multi-Agent Systems (e.g., AutoGen, CrewAI) enable collaboration, they typically lack individual agents with strict concept localization and boundary awareness.

2. Methodology

2.1 Core Concept: Well-Defined Agent (WD-Agent)

The paper proposes the Well-Defined Agent (WD-Agent) as the foundational building block. A WD-Agent is a specialized, boundary-aware reasoner that:

Is confined to a single concept (Functional Localization).
Leverages Descriptive Information (DI) stored in external retrievable storage, including representative positive examples and boundary negative examples (Information Externalization).
Can recognize whether an input falls inside or outside its concept and signal uncertainty near boundaries.

2.2 The A-Tree Architecture

The Agent Tree (A-Tree) extends the classical Neural Network Tree (NNTree) by replacing numerical Multi-Layer Perceptrons (MLPs) at internal nodes with WD-Agents.

Structure: A rooted tree where the root represents a general concept and child nodes represent increasingly specific sub-concepts.
Inference: An input traverses from the root downward. If a node's agent rejects the input, traversal stops; otherwise, it proceeds to child nodes.
Interpretability: The path from the root to the final node constitutes a natural, traceable reasoning chain. Each step is justified by the specific WD-Agent's decision, grounded in external DI.

2.3 Key Mechanisms

Structured Retrieval: To ensure scalability and reduce storage redundancy, the authors propose a shared external database where each training example is stored once with a path annotation. Nodes retrieve data based on path filtering, allowing agents to access positive examples (same path) and hard negative examples (sibling paths) efficiently.
One-Step Look-Ahead (OSLA): To improve inference depth and avoid "dead-end" branches, the OSLA mechanism evaluates not just the immediate child node but also the best outcome among its children (grandchildren). A composite score is calculated:
$score(c) = \alpha \cdot \mu_c(x) + (1 - \alpha) \cdot \max_{g \in children(c)} \mu_g(x)$
This allows the system to bypass low-confidence intermediate nodes to reach more specific concepts.
LLM-Based Construction: The tree structure is constructed recursively using an LLM. The LLM analyzes training examples, defines concept boundaries, generates agent prompts, and partitions data into subgroups, creating a JSON specification for the multi-agent system.

2.4 Application to Patent Analysis

The framework is applied to patent analysis using two independent A-Trees:

Problem-based A-Tree: Classifies patents by the technical problem they solve (e.g., "Battery overheating").
Technology-based A-Tree: Classifies patents by the technical solution proposed (e.g., "Phase-change material").
Aggregating the outputs of both trees yields structured <Problem, Technology> pairs, which are mined to extract innovation rules (e.g., strong associations, rare associations, missing associations, and versatile technologies).

3. Key Contributions

Agent Tree (A-Tree): A novel hierarchical classification architecture that extends NNTree by integrating WD-Agents, ensuring the inference path itself serves as the explanation.
Well-Defined Agent (WD-Agent): A formalization of a specialized agent with explicit boundaries and externalized descriptive information, serving as a building block for interpretable agentic systems.
Structured Retrieval: A scalable retrieval mechanism that uses path annotations to share a single knowledge base across all nodes, eliminating redundant storage and enabling boundary-aware learning via hard negatives.
Prototype Implementation: A cloud-based multi-agent system implemented with Qwen-Max, validated on a corpus of 222 computer vision-related patents.

4. Experimental Results

The framework was validated on a dataset of 222 computer vision patents (166 for training, 56 for testing).

Accuracy: The OSLA-based inference achieved 96.4% accuracy on the test set.
Inference Depth: OSLA significantly improved the average inference depth compared to normal greedy inference:
- Problem-based A-Tree: Increased from 2.4 to 2.7 (+12.5%).
- Technology-based A-Tree: Increased from 1.6 to 2.4 (+50%).
Trade-offs: The improvement in depth came with a slight increase in misclassification rates (from 1.8% to 3.6% for both trees), attributed to OSLA "forcing" deeper classification even with lower confidence. The authors note this can be mitigated by introducing confidence thresholds for child selection.
Innovation Rules: The system successfully extracted structured <Problem, Technology> pairs, demonstrating the feasibility of mining innovation rules such as "Strong Association" (dominant solutions) and "Cross-Domain Transfer" (technologies applicable to structurally similar problems).

5. Significance and Claims

The paper claims that A-Tree offers a promising direction for interpretable AI in high-stakes domains. Its significance lies in:

Design-Level Interpretability: Unlike post-hoc explanation methods, A-Tree is interpretable by design. The reasoning path is inherent to the architecture, providing a traceable chain of decisions grounded in natural language and concrete examples.
Boundary Awareness: By explicitly training agents to recognize concept boundaries and using sibling nodes as hard negatives, the system can signal uncertainty, addressing a critical flaw in standard LLMs.
Scalability: The structured retrieval approach allows the system to scale to large corpora without the exponential storage costs associated with maintaining independent retrieval indices for each agent.
Domain Agnosticism: While demonstrated on patent analysis, the authors assert the framework is applicable to other domains requiring structured, transparent classification, such as medical diagnosis and legal reasoning.

The authors remain modest regarding the current scale, acknowledging that the prototype used a limited corpus (222 patents) and that future work requires validation on larger datasets, dynamic refinement capabilities, and the integration of more complete patent data (e.g., claims and summaries) to enhance classification accuracy.