Split the Catalog, Not the Hierarchy

TL;DR for operators

Large product catalogs, document collections, and knowledge inventories eventually reach a scale where asking one model to reason over every label at once becomes difficult. Splitting the labels into smaller groups solves part of the input problem, but it creates another one: the pieces still have to reconnect into a coherent hierarchy.

SPARROW¹ addresses that second problem explicitly. It builds local taxonomies inside bounded blocks, then performs a separate global reconciliation step rather than treating each block’s parent-child decisions as final. On a 10K-concept MeSH benchmark with GPT-5, it reaches an Ancestor F1 of 0.487, compared with 0.011 for TaxoGPT and 0.015 for Chain-of-Layer. Ancestor F1 measures whether the complete chain of higher-level categories is recovered correctly, not merely the immediate parent.

For an operator maintaining a large hierarchy, the architectural implication is more useful than the headline score: local classification and global placement can be different computational jobs. Cheap or bounded local processing can generate plausible structure; additional model reasoning can then be concentrated on the places where blocks have to reconnect.

The boundary is equally important. The paper evaluates benchmark taxonomies, assumes the concept inventory is complete, and models the output as a single-parent tree. It does not establish that the same design will directly handle missing intermediate concepts, multiple inheritance, or production taxonomy maintenance.

Splitting labels solves the input problem, not the hierarchy problem

Imagine maintaining thousands of product categories or knowledge labels. Dividing them into smaller groups is operationally attractive: prompts stay manageable, local relationships become easier to inspect, and each model call has less material to reason over.

But a hierarchy is not a collection of independent batches. A real parent-child edge can cross the boundary between two groups. A parent that looks correct inside one group can also belong higher, lower, or elsewhere once the full tree is visible.

That is the distinction SPARROW is built around. The method separates local semantic abstraction from global structural reasoning. Instead of asking the model to construct one large taxonomy in a single reasoning space, it first forms locally coherent blocks, induces a taxonomy within each block, and then incrementally reconciles those local structures into one global tree.

The resulting scalability claim is therefore stronger than “smaller prompts work better.” The paper argues that the partition must preserve usable hierarchical structure, and the merge must be able to repair structure that the partition inevitably cuts.

The partition is designed to preserve connections, not just similarity

SPARROW embeds every concept, constructs a sparse nearest-neighbor graph, and applies spectral clustering to form non-overlapping blocks. The design favors graph connectivity rather than simply putting concepts near a common centroid.

The distinction matters because taxonomies are relational objects. Two concepts can belong to the same hierarchical branch without forming the tightest semantic cluster in embedding space.

The paper evaluates this partitioning stage with two structural measures. Intra-block Edge Retention measures the share of true taxonomy edges that remain inside blocks. Block-normalized Intra-edge Density adjusts retained structure for block size, discouraging a trivial solution in which very large blocks preserve more edges simply because less is being divided.

On the 1K CCS experiment, overlapping K-means at $\tau=0.60$ retains more true edges, with an edge-retention score of 0.902. Non-overlapping spectral clustering retains 0.766 but produces the highest block-normalized density, 0.149. The choice is therefore not based on spectral clustering winning every partition metric. It reflects a balance between retaining structure and keeping blocks compact enough for local induction.

Additional embedding analysis supports the same mechanism. Gold taxonomy subtrees are connected in the SPECTER2 nearest-neighbor graph far more often than size-matched random groups: 90.8% versus 13.9% on CCS and 92.2% versus 14.0% on Google. That makes graph connectivity a plausible signal for deciding what should remain together before the LLM starts assigning parents.

Local parents become constraints, not permanent edges

The more distinctive part of SPARROW appears during fusion.

After local taxonomies are built, the largest block initializes the global tree. Other blocks are inserted incrementally. When an incoming node already has a local parent, SPARROW does not simply copy that edge into the global hierarchy.

Instead, the local relation narrows the search. Candidate global parents are drawn from the already placed subtree associated with the local parent, while subtrees associated with local siblings are excluded. Embedding similarity then retrieves likely candidates, and the LLM selects among them using the candidate’s full taxonomy path and child context.

A second decision asks whether the incoming node should sit beside existing children or become an intermediate parent above some of them. This is the mechanism that allows the system to repair what the paper calls parent displacement: a locally reasonable relationship that would occupy the wrong position if imported unchanged into the global tree.

The merge-stage ablation shows why these steps matter. On 1K Google, full SPARROW reaches an Ancestor F1 of 0.744 in the component ablation. Removing structural candidate scoping reduces it to 0.484. Similarity-only parent selection falls to 0.374, while always treating the incoming node as a sibling reaches 0.504.

The source package also reports that removing candidate scoping uses roughly 6.7 times as many tokens. Constraining the search space is therefore doing two jobs: preserving structural information and preventing global reconciliation from becoming an unrestricted search over the entire taxonomy.

The merge stage is where path-level quality appears

The stage ablation is especially useful because it separates the benefit of smaller local problems from the benefit of repairing the global hierarchy.

On 1K Google, moving from one-pass induction to split-only processing increases Node F1 from 0.896 to 0.977. Yet Ancestor F1 falls from 0.619 to 0.587. Local recovery can improve while the complete category paths become worse.

Adding the fusion stage changes that result. Ancestor F1 rises to 0.745.

CCS shows the same broader direction from another starting point: Ancestor F1 moves from 0.397 without division or merging, to 0.465 after division, and then to 0.623 after fusion.

This is the paper’s most operationally relevant evidence. If the downstream system only needs an immediate label, local metrics may be sufficient. If search, recommendation, routing, governance, or analytics depend on where an item sits throughout the hierarchy, then immediate-parent accuracy does not capture the whole failure mode.

The scale results reinforce that point. At 10K MeSH concepts, SPARROW records Node F1 of 0.902, Edge F1 of 0.360, and Ancestor F1 of 0.487. TaxoGPT and Chain-of-Layer fall to Ancestor F1 scores of 0.011 and 0.015 respectively. The paper does not show that SPARROW dominates every local metric in every setting; its most consistent advantage is recovery of globally coherent ancestor structure.

More reasoning is spent in narrower places

The fusion stage is not free. On 1K CCS with GPT-5, SPARROW uses 62,312 API tokens: 10,254 for local induction and 52,058 for merging.

That total is almost identical to Chain-of-Layer’s 62,038 tokens, but the corresponding Ancestor F1 values are 0.623 for SPARROW and 0.271 for Chain-of-Layer. LLMscorer reaches 0.476 while consuming 407,518 tokens. TaxoGPT is substantially cheaper at 9,813 tokens, but reaches 0.397.

The useful comparison is therefore not simply which method consumes the fewest tokens. SPARROW reallocates a large share of computation toward the stage where local decisions have to be reconciled into globally valid paths.

For enterprise systems, Cognaptus interprets this as an architectural option: perform local classification within constrained neighborhoods, then invoke more expensive reasoning selectively when a node’s placement must be reconciled with the existing hierarchy. Whether that reduces actual latency or operating cost will depend on deployment details that these benchmarks do not measure.

Where this architecture does not transfer cleanly

Three boundaries should affect implementation decisions.

First, SPARROW produces a single-parent rooted tree. Many enterprise ontologies and product systems allow multiple inheritance. The paper does not establish that its fusion rules extend to those DAG structures.

Second, the method assumes the input concept inventory is complete. If an intermediate category is absent, even a structurally careful merger can be forced into an incorrect placement because the required parent does not exist.

Third, fusion still depends on candidate retrieval and semantic disambiguation. The reported qualitative failure case shows that a concept can be scoped into the wrong subtree when retrieval or local semantics are misleading. Controlled partition-noise experiments show that fusion remains beneficial even with a 50% Cut Edge Ratio, but that is a robustness test of the mechanism, not evidence that candidate errors disappear in production.

These constraints point toward governance requirements rather than a universal taxonomy engine: operators would still need policies for missing concepts, multiple inheritance, ambiguous labels, and human review.

Separate the semantic work from the structural work

SPARROW’s broader contribution is an allocation decision. Large hierarchy construction does not require every reasoning step to operate over the entire label space.

The paper shows that bounded local induction can recover useful structure, but that local success should not be mistaken for a finished global taxonomy. The structure that comes out of each block is more valuable when treated as evidence that constrains later reasoning than when treated as immutable truth.

For teams building large catalog, document, or knowledge hierarchies, that suggests a practical design principle: distribute the semantic classification work, then centralize the structural reconciliation required to preserve complete paths.

That distinction matters most when the hierarchy itself is part of the product.

Cognaptus: Automate the Present, Incubate the Future.