Paper Overview
Field: NLP / Agent Memory Authors: Lucheng Fu, Kejing Xia, Yiyang Wang, Yiqiao Jin, Jinjin He, Xiyuan Yang, Haoxin Liu, Ye Yu, Haibo Jin, Yijia Xiao, Wenke Lee, B. Aditya Prakash, Haohan Wang Institutions: Georgia Tech / UIUC / UCLA arXiv: 2610.02150 Code: github.com/luchengfu6/SourceLearn Website: sourcelearn.github.io
---
How Do You Actually Learn a Manual?
Imagine joining a company and receiving a 500-page internal API document. The first time you hit a problem, you flip to page 137 for the answer. The second time a similar question arises, you flip to page 137 again. The third time... the fourth...
Do you keep re-flipping to the same page forever? No. You remember "page 137 covers authentication" and jump straight there next time. Later still, you don't just remember the page number—you grasp that "this document's authentication section always explains tokens before refresh." You've built a structural understanding of the manual.
But today's LLM agents don't work this way. Every problem is met like a first encounter with the manual—retrieve, read, answer, forget. The next similar question starts from scratch.
This is the core problem identified by the Georgia Tech and UIUC team in *From Knowledge Access to Source Learning*: we treat "repeatedly accessing the same knowledge source" as repetitive labor rather than a learning opportunity.
From Knowledge Access to Source Learning
The paper introduces the concept of source learning: when an agent repeatedly uses the same knowledge source (a document, codebase, or API reference), it shouldn't just retrieve repeatedly—it should progressively build a structural understanding of that source: how knowledge is organized, explained, and applied.
This understanding is represented as a persistent source model—not a copy of the raw text, but a distilled, reusable knowledge structure extracted from the source.
The SourceLearn architecture combines two complementary learning mechanisms:
1. Self-Directed Source Learning
The agent actively identifies "what haven't I understood yet" and adaptively revisits the source. Like a reader who realizes a concept in chapter three is unclear and goes back to reread it.
2. Task-Guided Source Learning
While completing downstream tasks, the agent discovers "so this is how the knowledge should be organized to be useful." For example, after several authentication-related tasks, you notice you always need to combine token and refresh information—so you update your knowledge structure and store it as an "authentication pair" next time.
The shared principle: the learning signal decides what needs rethinking, while persistent updates are always rebuilt from the authoritative source. This means the agent never fabricates knowledge—every update is traceable.
The Numbers
Across 15 settings covering 5 benchmarks and 3 LLM backends, SourceLearn achieved the best result in 13 settings, outperforming Hybrid RAG by up to 22.6 points.
What does this mean? Picture two agents handling the same sequence of knowledge-intensive tasks. One uses traditional RAG, the other SourceLearn. The first task may look similar—but by the fifth or tenth task, SourceLearn's advantage grows larger and larger, because it's *learning* the source, not just *accessing* it.
How It Fundamentally Differs from Existing Methods
| Method | What it does | What it lacks | |--------|--------------|---------------| | RAG | Retrieves relevant snippets | No accumulated understanding | | Long-context | Fits the whole source into context | No distilled structure | | Agent Memory | Stores past interactions | Stores experiences, not source understanding | | SourceLearn | Builds and iterates a structural understanding of the source | — |
The key distinction: RAG optimizes *how to find*, Agent Memory optimizes *how to remember*, while SourceLearn optimizes *how to understand*. It's not an improvement at the retrieval level—it's accumulation at the cognitive level.
A Deeper Insight
A fitting analogy: RAG is "looking up a dictionary"; SourceLearn is "learning a language."
A dictionary user flips through it for every unfamiliar word—efficient, but never improving. A language learner builds an understanding of structure—roots, affixes, collocations—and can guess new words on sight.
SourceLearn's persistent source model is essentially learning "the language of the source": its knowledge structure, organizational logic, and application patterns. Once established, this understanding benefits not just the current task but all tasks that touch the same source.
This also explains why SourceLearn's advantage widens with more tasks—it's compound learning. Every use deepens understanding of the source, and deeper understanding makes every subsequent use more efficient.
An Honest Assessment
The paper has limitations. First, the source model itself requires storage and maintenance—possibly unsuitable for rapidly changing sources like live data streams. Second, the experiments focus on document-type sources; effectiveness on structured sources like codebases or API docs needs further validation. Finally, the boundary between "source learning" and "fine-tuning" is worth debating—if the agent's understanding of a source is deep enough, should it be consolidated into model weights?
But these issues don't diminish the core contribution: SourceLearn reframes "repeated access" as a "learning opportunity"—a paradigm-shifting insight.
---
Paper: arxiv.org/abs/2610.02150 Code: github.com/luchengfu6/SourceLearn Project page: sourcelearn.github.io