CoRE Teaches AI to Choose Its Own Knowledge-Base Retrieval Rules Without Labeled Data

Retrieval over structured knowledge bases has long hit the same wall: for a model to find the right facts in a graph, someone has to tell it which rules to follow. The authors of arXiv paper 2610.14465 propose CoRE (Co-Adaptive Rule Routing and Constraining Retrieval), a method that teaches the system to do this on its own. It trains rule selection for a query and evidence retrieval under that rule at the same time, and it does so without pre-labeled query-rule pairs. The method was tested on three domains of the STaRK-QA benchmark: scientific discovery, biomedical reasoning and e-commerce knowledge management.

Why rule labeling became the bottleneck

Existing approaches fall into two camps. The first searches without constraints: the retriever roams the knowledge base freely and ranks everything, so entities that look close on paper but don't fit the meaning of the query end up in the results. The second relies on rules but requires predefined labels that say which rule matches which query. For scientific search, these are rules like "author — paper"; for precision medicine, rules like "anatomy — drug".

The problem is that such labels rarely exist. They have to be collected by hand, by experts in the specific field, and the work starts over for every new domain. CoRE removes this requirement: the rules stay in the system as a set of constraints, but the model finds the mapping from queries to rules by itself.

Two components that learn from each other

The architecture has two parts that depend tightly on each other.

• Rule router. Receives a query and selects a rule. Trained with reinforcement learning.
• Constrained retriever. For the selected rule, traverses the knowledge base and ranks only what satisfies the rule's conditions. Trained contrastively (contrastive learning).

This creates a chicken-and-egg problem: the router needs to know how well the retriever will perform under a rule, and the retriever needs correct rules to learn from. CoRE resolves this by alternating training phases. The rules chosen by the router serve as the training signal for the retriever. The quality of the retrieved evidence, in turn, becomes the reward for the router. The result is a closed loop in which each component adapts to the other without explicit supervision at the level of query-rule pairs.

What the experiments showed

The authors tested the method on STaRK-QA datasets covering three areas:

• scientific discovery (search over academic entities such as authors and papers);
• biomedical reasoning (relations between anatomy, diseases and drugs);
• e-commerce knowledge management (product queries).

Ablations confirm that the gain comes specifically from co-adapting the router and the retriever: if the loop is broken, quality drops. Two more findings matter in practice. Generation-based routing transfers across datasets. The best-performing setup is multi-domain pretraining followed by fine-tuning on the target dataset.

The authors also note a side effect: analyzing which rules are applied to queries, and how often, suggests ways to automatically refine existing rules and discover new ones. The rule set stops being a static construct and becomes something that can be improved iteratively from data.

Where this could be useful

For teams building RAG and agent systems on top of knowledge graphs, CoRE is interesting for three reasons. First, it lowers the cost of entering a new domain: an expert only needs to describe a set of rules rather than label queries for each of them. Second, restricting search by a rule narrows the candidate space and makes results easier to explain: you can see which rule the system followed and why. Third, the scheme of multi-domain pretraining followed by fine-tuning fits well with enterprise scenarios, where several knowledge bases with different structures coexist.

The limitations are also clear: the method still requires a predefined set of rules, and alternating training with RL is usually more finicky than a standard supervised pipeline. Still, the direction is straightforward: instead of expensive labeling of links between queries and rules, train the system to find those links itself through the quality of the final retrieval.