Provable Benefits of In-Tool Learning for Large Language Models

TL;DR

This paper demonstrates that tool-augmented language models with external retrieval can recall facts unboundedly, outperforming models that rely solely on memorization within their weights, supported by theory and experiments.

Contribution

It provides the first theoretical proof that tool-use enables unbounded factual recall, surpassing memorization limits, and empirically validates the advantages of in-tool learning.

Findings

Tool-use models outperform memorizing models in factual recall.

Memorization capacity is limited by model parameters.

Teaching tool-use is more effective than finetuning facts into memory.

Abstract

Tool-augmented language models, equipped with retrieval, memory, or external APIs, are reshaping AI, yet their theoretical advantages remain underexplored. In this paper, we address this question by demonstrating the benefits of in-tool learning (external retrieval) over in-weight learning (memorization) for factual recall. We show that the number of facts a model can memorize solely in its weights is fundamentally limited by its parameter count. In contrast, we prove that tool-use enables unbounded factual recall via a simple and efficient circuit construction. These results are validated in controlled experiments, where tool-using models consistently outperform memorizing ones. We further show that for pretrained large language models, teaching tool-use and general rules is more effective than finetuning facts into memory. Our work provides both a theoretical and empirical foundation, establishing why tool-augmented workflows are not just practical, but provably more scalable.

Equations

$$Q=\underset{{\phi }_1(a)}{\underbrace{\text{Where was}}}\underset{{\phi }_2(n)=n}{\underbrace{\text{Thierry de Sienne}}}\underset{{\phi }_3(a)}{\underbrace{\text{born?}}}$$

$$A=\underset{{\psi }_1(n)=n}{\underbrace{\text{Thierry de Sienne}}}\underset{{\psi }_2(a)}{\underbrace{\text{was born in}}}\underset{{\psi }_3(v)=v}{\underbrace{\text{Germany}}}$$

$$T$$

$$\underset{{\chi }_2(n)}{\underbrace{\text{FOR Thierry de Sienne </DB>}}},$$

$$|\mathcal{M}|\ge |\mathcal{D}|.$$

$$P\ge \frac{|\mathcal{N}|}{b}\sum _{a\in \mathcal{A}}{\log }_2|{\mathcal{V}}_a|=c\cdot \#\text{Facts},$$

$$Q=\underset{{\phi }_1(a)}{\underbrace{\text{Where was}}}\underset{{\phi }_2(n)=n}{\underbrace{\text{Thierry de Sienne}}}\underset{{\phi }_3(a)}{\underbrace{\text{born?}}},$$

$$T$$

$$\xi (f,a,n)=\text{“Germany”},$$

$$A=\underset{{\psi }_1(n)}{\underbrace{\text{Thierry de Sienne}}}\underset{{\psi }_2(a)}{\underbrace{\text{was born in}}}\underset{{\psi }_3(v)}{\underbrace{\text{Germany}}}.$$

$$T={\chi }_1(a)\circ {\chi }_2(n)$$

$$Q={\phi }_1(a)\circ {\phi }_2(n)\circ {\phi }_3(a)$$

$$T$$

$$Q=\underset{{\phi }_1(a)}{\underbrace{\text{Where was}}}\underset{{\phi }_2(n)=n}{\underbrace{\text{Thierry de Sienne}}}\underset{{\phi }_3(a)}{\underbrace{\text{born?}}}.$$

Full text

\correspondence

Vivien Cabannes at

1 Introduction

Large Language Models (LLMs) have revolutionized artificial intelligence, redefining how machines understand and generate human language. Beyond this, LLMs are rapidly evolving from static predictors into dynamic, context-aware systems capable of reasoning, adapting, and acting over time. Coding assistants are accelerating software development and lowering the barrier to entry for programming, hinting at the emergence of highly automated, agentic workflows. This transformation is driven by advances in architecture and interaction design. Retrieval-augmented generation (RAG, Lewis et al., 2020b) enables models to access external knowledge in real time, grounding their responses in contextually relevant information. In parallel, memory augmentation, through the use of scratchpads or memory modules, empowers models to organize their reasoning, break down problems, iteratively refine outputs, and maintain coherence across extended sequences.

Together, these capabilities mark a shift away from purely in-weight learning, where all knowledge and reasoning must be encoded within the parameters of a model, toward more modular and interpretable systems that can utilize tools, access external information, and leverage structured memory. Our study investigates the theoretical foundation for why such tool-augmented approaches outperform traditional monolithic models. This evolution raises a fundamental question: What is the most efficient way for a model to acquire and utilize knowledge: should facts be internalized through parameter updates, or should models be taught to access and manipulate external sources of truth? At the heart of this question lies a core tradeoff between in-weight learning, where information is compressed into the model’s parameters during training, and tool-augmented learning (or in-tool learning), where the model learns to interact with external resources such as databases or APIs to retrieve information when needed. While the former is bounded by the model’s capacity and sensitive to forgetting, the latter offers the potential for open-ended knowledge access, generalization, and interpretability. In this work, we formalize this tradeoff and provide a rigorous theoretical framework for understanding the benefits of tool use in large language models.

Contributions.

Our main contributions are as follows:

We derive a theoretical lower bound showing that the number of distinct facts a model can store purely in its weights is fundamentally limited by its number of parameters. This highlights a structural bottleneck in relying solely on in-weight memorization. 2. 2.

We construct an explicit upper bound proving that tool-augmented models can, in principle, retrieve an unbounded number of facts by learning to interface with an external database. This result is supported by a formal circuit construction demonstrating the feasibility and efficiency of such tool use. 3. 3.

We validate these theoretical results in a controlled experimental setting, where models are trained from scratch either to memorize facts or to learn to use an external tool. Our findings empirically confirm the predicted scaling laws and memory limitations. 4. 4.

We demonstrate the practical implications of our findings for existing LLMs, showing that finetuning to learn new facts is significantly less effective than teaching models how to access structured tools or infer generalizable rules. This reinforces the argument that future LLM development should prioritize tool-use capabilities over rote memorization.

Together, these results provide both a conceptual and empirical foundation for understanding why models that use tools outperform those that attempt to internalize all the knowledge. Our study suggests a shift in model design philosophy: from training ever-larger monolithic models toward building modular systems that learn to query, not just to store information. Our codebase is freely available for researchers to further explore memory load in large language models111The code and reproducibility instructions are available at https://github.com/ambroiseodt/itl..

Related work.

Recent work has increasingly explored tool-augmented language models. This trend is evident in the open-source literature, with models such as Toolformer (Schick et al., 2023), ReAct (Yao et al., 2023), and HuggingGPT (Shen et al., 2023), as well as in industrial systems that now support function calling, enabling modular LLM-agent architectures. External memory mechanisms such as RAG (Lewis et al., 2020c), RETRO (Borgeaud et al., 2022), and retrieval-augmented transformers (Shao et al., 2024) serve as tools in their own right, enhancing knowledge access. In a similar spirit, scratchpads (Nye et al., 2021) and chain-of-thought prompting (Wei et al., 2022) externalize reasoning and expand model capacity (Besta et al., 2025). This is perhaps unsurprising, as several studies have quantified the limitations of in-weight knowledge (Hahn, 2020; Merrill & Sabharwal, 2024; Cabannes et al., 2025; Allen-Zhu & Li, 2025c), and highlighted interference during editing (Meng et al., 2022; Dai et al., 2022).

Taken together, these lines of research delimit a growing frontier that contrasts in-weight learning with increasingly sophisticated mechanisms for retrieval, reasoning, and tool use. This is the dichotomy we aim to investigate in our work, contributing to the broader effort to deepen the theoretical and empirical understanding of language models (see, e.g., Bietti et al., 2023; Zekri et al., 2025; Beirami et al., 2025). Additional related work can be found in Appendix A for the interested reader.

2 Setting

To highlight the differences between in-weight memorization and tool-augmented reasoning, we introduce a family of factual recall tasks. Let ${\cal D}$ be a family of datasets, where each dataset $D\in{\cal D}$ is a finite collection of facts. Each fact is a triplet $(n,a,v)$ of strings, consisting of:

• •

a name $n\in{\cal N}$ (e.g., “Thierry de Sienne”),

• •

an attribute $a\in{\cal A}$ (e.g., “birthplace”), and

• •

a value $v\in{\cal V}_{a}$ (e.g., “Germany”).

Each dataset $D$ defines a mapping $V_{D}:(n,a)\mapsto v$, which assigns to each name–attribute pair its corresponding value. The goal of the recall task is to produce the ground-truth value $V_{D}(n,a)$ when given a query $(n,a)$.

Let ${\cal M}$ be a class of models, where each model $f\in{\cal M}$ implements a recall rule $R(f):{\cal N}\times{\cal A}\to\bigcup_{a\in{\cal A}}{\cal V}_{a}$. For instance, the model class ${\cal M}$ may be the set of all transformers with a given architecture, each model $f\in{\cal M}$ corresponding to a specific choice of weights, and the recall rule $R(f)$ being defined by prompting the model with a query asking for the value associated to a pair $(n,a)$ and parsing the text obtained by auto-regressively sampling from the model until an end-of-sequence token is emitted.

Definition 2.1** (Learnability).**

We say that the model class ${\cal M}$ can learn the recall task associated to a family of datasets ${\cal D}$ if, for each dataset $D\in{\cal D}$, there exists a model $f\in{\cal M}$ such that $f$ achieves perfect accuracy on the value recall task for $D$, i.e. $R(f)=V_{D}$.

Note that this definition abstracts away the process of training and does not account for sample efficiency or optimization difficulty.

Sentence format.

Our study is concerned with factual recall performed by LLMs via question answering. We define a dataset with a strict grammar that specifies the format of all question–answer pairs.

In the in-weight setting, the model is trained to directly generate the answer from its parameters. The user produces a query string $Q$ using the format $Q=\varphi_{1}(a)\circ\varphi_{2}(n)\circ\varphi_{3}(a)$, and the assistant must then generate the answer string $A$ in the form $A=\psi_{1}(n)\circ\psi_{2}(a)\circ\psi_{3}(v)$, where $\varphi_{i}$ and $\psi_{i}$ are deterministic string functions (i.e. templates) that encode the structure of the input and output, and $\circ$ denotes string concatenation. For example, given the previous fact example, we have:

[TABLE]

[TABLE]

In the in-tool setting, the model learns to issue a structured tool query that retrieves the value from an external database. The user query $Q$ remains unchanged, but the assistant must first produce an intermediate tool query string $T=\chi_{1}(a)\circ\chi_{2}(n)$, where the $\chi_{i}$ are deterministic string templates encoding the attribute and name in a format expected by the tool interface. This query is sent to an external retrieval system (e.g., a database or API), which returns the corresponding value $\xi(f,a,n)$, where $\xi(f,a,n)=v$ if the assistant correctly formats the query, and an error message otherwise. The assistant then produces the final answer $A$, reusing the same output grammar as in the in-weight case.

For example, using the same fact example, we have:

[TABLE]

This formal grammar establishes a controlled setting to characterize the information storage and retrieval capabilities of LLMs precisely. An example of queries formatted in JSON files can be found in Appendix C.1.

3 In-Weight Lower Bound

This section illustrates the limitations of in-weight learning through theoretical lower bounds. The following lemma provides a lower bound on the size of a model class that can learn a given family of datasets.

Lemma 3.1** (Capacity lower bound.).**

Let ${\cal D}$ be a family of factual datasets defined over a fixed set of names ${\cal N}$ and attributes ${\cal A}$. Let ${\cal M}$ be a model class that can learn ${\cal D}$. Then, we have

[TABLE]

Proof.

This follows from a simple enumeration argument, since the definition of learnability (Definition 2.1) is equivalent to the inclusion $\{V_{D}\,|\,D\in{\cal D}\}\subseteq\{R(f)\,|\,f\in{\cal M}\}$. Considering the cardinality of those sets concludes the proof. ∎

Lemma 3.1 implies a lower bound on the number of parameters required to define a class of models that could memorize a given set of facts. This allows us to provide an upper bound on the parameter requirement.

Theorem 3.2** (Parameter lower bound).**

Let ${\cal M}$ be a class of models with $P$ parameters, each quantized to $b$ bits. Let ${\cal D}$ be the family of all datasets defined over names ${\cal N}$, attributes ${\cal A}$, and value sets ${\cal V}_{a}$. Then, if ${\cal M}$ can learn ${\cal D}$ without accessing external tools (in-weight learning), the number of parameters must satisfy:

[TABLE]

where $\#\text{Facts}=|{\cal N}\times{\cal A}|$ is the number of facts, and $c$ is the average of $\log_{2}|{\cal V}_{a}|/b$ over $a\in{\cal A}$.

Proof.

This is a consequence of Lemma 3.1. The total number of distinct parameter configurations in the model family ${\cal M}$ is at most $2^{bP}$ (i.e., $|\mathcal{M}|\leq 2^{bP}$). Moreover, defining any dataset from ${\cal D}$ requires distinguishing between all possible assignments of values for the attributes of each name. For a single name, there are $\prod_{a\in{\cal A}}|\mathcal{V}_{a}|$ possible value assignments; for all $\mathcal{N}$ names, this yields $|\mathcal{D}|=\left(\prod_{a\in{\cal A}}|\mathcal{V}_{a}|\right)^{\mathcal{N}}$. Applying Lemma 3.1 with these quantities and taking the base-2 logarithm of both sides of the inequality completes the proof. ∎

Theorem 3.2 shows that the number of parameters needed to memorize arbitrary fact mappings grows linearly with the number of facts. It proves a hard capacity ceiling on in-weight learning: Once the number of facts exceeds a threshold determined by model size, memorization becomes impossible without architectural changes or external memory.

Note that Theorem 3.2 could be refined in two directions. First, the capacity of a model class does not necessarily grow exponentially with the number of quantization bits. In practice, empirical studies such as Allen-Zhu & Li (2025c) suggest that the effective representational capacity of language models is often much lower than the theoretical maximum–typically around 2 bits per parameter, meaning that $b$ could be replaced by $\approx 2$ in the theorem.

Second, in practice, facts are often highly structured and correlated. For example, knowing that someone is Japanese makes it more likely that they are older than 60 than if they were from Kenya, due to population-level age differences. These kinds of regularities mean that not all combinations of facts are equally likely. One can account for this by introducing a probability distribution over datasets in ${\cal D}$, and then asking: How many parameters are needed for a model to correctly learn the most likely $(1-\varepsilon)$ fraction of datasets? However, even with these statement refinements, the relationship between the number of parameters and the number of learnable “effective facts” still scales linearly.

4 In-Tool Upper Bound

In this section, we show that tool use allows models, and in particular transformers (Vaswani et al., 2017), to circumvent the limitations of in-weight learning and accurately recall an unlimited number of facts without needing additional parameters. More specifically, we exhibit an upper bound on the number of parameters needed for a transformer to implement the kind of database querying described in Section 2.

Let ${\cal D}$ be a family of factual datasets defined over some names, attributes, and value sets ${\cal N},{\cal A},\{{\cal V}_{a}\}_{a\in{\cal A}}$. We introduce the following notion of query-based learnability for a model augmented with access to an external database.

Definition 4.1** (Query-based Learnability).**

For a factual dataset $D$, the associated retrieval system $R_{D}$ is a recall rule which can be queried in the manner described in Section 2 to retrieve any fact of $D$. We say that a tool-augmented model $f$ solves the recall task for a family of datasets ${\cal D}$ if, for any $D\in{\cal D}$, it achieves perfect accuracy on the value recall task for $D$ by querying $R_{D}$.

Note that Definition 4.1 is stronger than Definition 2.1, as a single model (rather than a family of models) is tasked with “learning” any dataset $D\in\cal D$, provided it has access to a correct retrieval system.

In the theorem below, we consider Llama3-like transformers (Grattafiori et al., 2024) with a fixed token vocabulary; we make a few mild technical assumptions, e.g. the queries and answers are shorter than the maximum model context length, which we detail in Appendix B, along with the proof of the statement.

Theorem 4.2** (Parameter upper bound).**

Let ${\cal D}$ be a family of factual datasets defined over some names, attributes, and value sets ${\cal N},{\cal A},\{{\cal V}_{a}\}_{a\in{\cal A}}$. Given $\cal R_{\cal D}=\{R_{D}\}_{D\in{\cal D}}$ a family of retrieval systems associated to $\cal D$, there exists a transformer with at most $8$ transformer blocks, an embedding dimension of at most $O(|{\cal A}|)$ and a total number of parameters at most $O(|{\cal A}|^{2})$ that can solve the value recall task for $\cal D$ if equipped with the ability to access ${\cal R}_{\cal D}$.

Proof sketch.

The proof consists of designing algorithmic mechanisms to auto-regressively generate the tool query $T$ and the answer $A$ in the string $Q\circ T\circ\xi\circ A$. At a high level, the transformer needs to: (i) parse the attribute $a$ from the user query $Q$; (ii) emit the corresponding $\chi_{1}(a)$; (iii) emit the suffix $\chi_{2}(n)$ of $T$ by copying the name part from the question $Q$; and (iv) perform a similar copying operation to emit the final answer $A$ after observing the value $v$ returned by the database.

Parsing the attribute from $Q$. First, one could reserve the first transformer block to retrieve absolute position encoding (see, e.g. Golkar et al., 2024, Proposition 2.2). Then, one can reserve $2|\mathcal{A}|$ attention heads in the second block, so that each head fires whenever the suffix of the input stream matches one of the fixed strings $\varphi_{1}(a)$ or $\varphi_{3}(a)$. The firing pattern can be written into a one-hot “attribute register” of dimension $2|\mathcal{A}|$ that is carried forward in the residual stream.

Emitting $\chi_{1}(a)$. The attribute $a$ can be retrieved from the attribute register, which in turn enables the transformer to auto-regressively output $\chi_{1}(a)$.

Emitting $\chi_{2}(n)$. The emission of $\chi_{2}(n)$ can be done by copying $\varphi_{2}(n)$. This requires parsing $\varphi_{2}(n)$, which can be done using the attribute register to identify the position of the token that starts $\varphi_{2}(n)$, followed by using an induction head to copy the full name. A mechanism such as counting the number of whitespace characters in $Q$ and subtracting the number of whitespace characters in $\varphi_{1}(a)\circ\varphi_{3}(a)$ can be used to determine when to stop copying (thus avoiding the inclusion of $\varphi_{3}(a)$ when emitting $\chi_{2}(n)$).

Emitting $A$. A similar construction allows copying the value $v$ returned by the database, as well as the name $n$, to emit the final answer $A$.

Overall, this construction uses embeddings of dimension $O(|\mathcal{A}|)$ with a constant number of layers, leading to a total number of parameters that scales as $O(|\mathcal{A}|^{2})$. ∎

Note that the bounds do not depend on the number of names or possible values. While our theoretical results provide foundational insights, empirical validation remains crucial, since Theorem 3.2 describes a worst-case scenario, and Theorem 4.2 is an existence result that does not account for optimization difficulty.

5 Controlled Experiments

This first experimental section investigates the difference between in-weight and in-tool learning by pretraining models from scratch on synthetic factual datasets. Our results support the theoretical insights: tool-augmented recall outperforms in-weight memorization in terms of the number of facts learned per parameter. Additional experimental details and results are provided in Appendix C.2.

Experimental setup.

To validate our theoretical findings, we place ourselves in a controlled setting. We construct synthetic biographical datasets from a fixed list of names ${\cal N}$ and four attributes ${\cal A}$: “birth place”, “birth date”, “current address”, “occupation”; which can take 7, 16800, 213, and 100 values respectively. This yields $4|{\cal N}|$ atomic facts per dataset instance. For each dataset size, we train a family of small Llama3-style transformer models (Grattafiori et al., 2024) with 2 layers, 2 attention heads, a vocabulary size of 260 (byte encoding with 4 special tokens), and a context window of 257. The embedding dimension ranges from 4 to 128, resulting in models with between 2K and 0.6M parameters. Our models are trained for up to $100{,}000$ steps using the AdamW optimizer (Loshchilov & Hutter, 2019), with a batch size of $128$ samples, a decoupled weight decay coefficient of $0.1$, and $(\beta_{1},\beta_{2})=(0.9,0.95)$. We use a cosine learning rate scheduler with a warmup phase of $50$ steps and a maximum learning rate of $0.001$, and a final learning rate ratio of [math].

We compare two training regimes, illustrated in Figure 1:

1. (i)

in-weight, where the model must directly generate the answer from its parameters, and 2. (ii)

in-tool, where the model first emits a structured lookup query to an external database, which returns the requested value that the model then formats into an answer.

Theory validation.

Our empirical results strongly support the theoretical predictions presented in Sections 3 and 4. As shown in Figure 2, the in-weight regime exhibits an unbounded increase in the number of required parameters as the number of facts grows. This behavior demonstrates the existence of a lower bound on parameter requirements, consistent with the general claim of Theorem 3.2. Note that the empirical scaling is slightly sublinear for small dataset sizes, approximately following a square-root trend. This suggests the presence of subtle phenomena not captured by the theorem, which we leave to future work. This confirms that parameter count imposes a hard limit on memorization-based learning. In contrast, the in-tool regime displays a clear transition: after a critical dataset size (around 1,000 facts in our setting), the parameter requirement saturates and remains nearly constant. This plateau confirms that the model has shifted from memorizing facts to delegating recall to an external database, in line with the existence results in Theorem 4.2.

From memorization to rule learning.

This transition in the in-tool regime reflects more than a capacity shift; it reveals a learning phase transition. Initially, models faced with tool-augmented recall resort to memorizing fact–answer pairs, similar to the in-weight regime. However, once exposed to a sufficient diversity of facts, the model discovers the underlying logic for constructing tool queries. As shown in Figure 3, where the best OOD accuracy achieved by in-tool models is displayed, this results in a dramatic improvement in generalization to out-of-distribution facts. This phenomenon mirrors the “grokking” effect observed in other settings: a delayed but sharp shift from brute-force memorization to systematic rule learning (Power et al., 2022; Nanda et al., 2023). Once the model learns the correct format for querying, retrieval generalizes across databases, decoupling recall accuracy from the number of stored facts.

What counts as a fact?

Our study so far assumes a clean distinction between facts (e.g., “Thierry de Sienne was born in Germany”) and rules (e.g., “birthplace queries can be answered by a lookup function”). In our attribution task, this boundary is sharp, but in broader domains such as mathematics or commonsense reasoning, the line between facts and rules is often ambiguous. Are theorems facts, or derived consequences of axioms? Ontologies may reveal intricate interdependencies that blur this distinction.

To explore how structure affects memorization, we introduce controlled correlations between facts using a parameter $\alpha\in[0,1]$. For each pair name-attribute $(n,a)$, we draw a Bernoulli variable $X\sim\text{Bern}(\alpha)$, and set $V_{D}(n,a)=V_{1}(n,a)$ if $X=1$, or $V_{2}(n,a)$ otherwise, where, $V_{1}$ assigns values based on the family name, while $V_{2}$ assigns values independently at random. As such, $\alpha=1$ amounts to family members sharing a birthplace, current address, and occupation, while $\alpha=0$ corresponds to the unstructured case used in earlier experiments. As shown in Figure 4, increasing the correlation reduces the number of parameters required for in-weight models to achieve high recall. This effect could be understood in light of Lemma 3.1: by introducing correlations, we constrain the set of possible datasets222This constraint applies in expectation: with high probability, the dataset is sampled from a smaller effective family, tightening the lower bound in expectation., thereby lowering the lower bound on model capacity. Our results suggest that transformers are able to adapt to this structure, effectively compressing related facts through shared patterns and achieving high recall with fewer parameters. This aligns with previous findings on how structural assumptions about the data influence learning in transformers and neural networks more broadly (Valvoda et al., 2022; Dziri et al., 2023; Arnal et al., 2024; Wang et al., 2025; Mahajan et al., 2025).

6 Large-Scale Experiments

This section investigates whether the limitations of in-weight learning persist in real-world settings involving pretrained multi-purpose language models. In particular, we show that while large models can store vast amounts of information in their parameters, introducing new knowledge through finetuning may interfere with existing capabilities due to finite capacity and training dynamics. In contrast, tool-augmented learning promises scalability without forgetting. We provide further related results in Appendix C.3.

Experimental setup.

We fine-tune instruction-tuned language models on the synthetic factual datasets from Section 5, ranging from 500 to 50k atomic facts. Models include SmolLM 2 Instruct (135M, 360M, 1.7B) (Allal et al., 2025) and Llama 3.1/3.2 Instruct (1B, 3B, 8B) (Grattafiori et al., 2024), each trained to reach at least 95% recall. We use the same training setup as in Section 5, with learning rates adapted to model size. For SmolLM models, we use the values reported in the original paper: $10^{-3}$ for 135M and 360M, and $3\cdot 10^{-4}$ for 1.7B. For Llama models, we scale learning rates $\eta$ with model size P, setting $\eta=2\cdot 10^{-5}$ at 8B, and following the established inverse power law $\eta\propto P^{-1/2}$ for stable updates, with $P$ the number of parameters (Kaplan et al., 2020; Gao et al., 2023).

Frequent checkpoints are saved to evaluate: (i) factual recall, (ii) HellaSwag accuracy, used as a proxy for general language abilities; this benchmark presents four candidate sentence completions, and the model is evaluated on its ability to select the most plausible one (Zellers et al., 2019), and (iii) Total Variation (TV) distance from the base model’s output distribution, estimated over 100 natural language prompts by generating completions with the base model and computing the mean token-level $\ell_{1}$ distance between base and fine-tuned output probabilities.

Overloading threatens general capabilities.

Motivated by our theoretical results, we now investigate whether the benefits of in-tool learning persist in large, pretrained language models. Figure 5 shows how HellaSwag accuracy evolves as models are trained to memorize increasing numbers of facts. In-tool learning (dashed lines) retains general performance across all scales, confirming that externalizing factual storage prevents interference. In contrast, in-weight learning (solid lines) shows a clear degradation, especially in smaller architectures. This supports our theoretical intuition: parameter-based memorization consumes capacity and risks overwriting prior knowledge. We note that larger models degrade more slowly, suggesting they can absorb new information with less interference. These results underscore the scalability advantage of tool-augmented learning for preserving general capabilities.

Token distribution change.

The differences between in-weight and in-tool learning can be further understood by measuring how much each method alters the model’s output distribution. As shown in Figure 6, in-weight learning leads to significant drift—especially in smaller models—with total variation (TV) distance growing sharply with the number of memorized facts. In contrast, tool-learning causes minimal divergence, even at large scales. This offers a complementary perspective on our results: in-weight learning requires shifting the next-token distribution to encode new information, while in-tool learning preserves the model’s original behavior by delegating recall.

Efficiency trade-offs.

Another advantage of in-tool learning is its training efficiency: As shown in Figure 7, models acquire the tool-use function call pattern in fewer than 20 steps, as soon as the set is large enough to elicit tool-use. In contrast, in-weight learning requires substantially more training to memorize individual facts. However, this efficiency comes with a trade-off: In-weight models support cheaper inference, producing answers directly without generating intermediate tool queries or relying on external calls. We also observe that tool-use can be slightly unstable to train; early stopping proved effective to prevent capability loss once the tool behavior was acquired.

7 Discussion

This work provides a unified theoretical and empirical account of the tradeoff between in-weight and in-tool learning. Theoretically, we establish that the number of facts a model can store in its parameters is bounded by its size, implying that scaling knowledge capacity through model enlargement is inherently inefficient. In contrast, models that learn to interact with external tools can access unbounded factual knowledge without increasing their parameter count. Controlled experiments confirm this sharp divide: while in-weight models require ever-larger architectures to memorize growing datasets, tool-augmented models exhibit a phase transition, rapidly shifting to rule-based querying once sufficient diversity is observed. This decouples memory capacity from model size. Large-scale experiments extend these findings to pretrained models, showing that in-weight finetuning for factual recall degrades general capabilities, a consequence of limited capacity forcing new information to overwrite prior knowledge. Tool-based approaches, by externalizing factual storage, preserve core skills, reduce training costs, and introduce minimal behavioral drift. These results underscore a key design insight: language models scale more effectively not by internalizing ever more information, but by learning to access and orchestrate it, emerging less as static predictors and more as systems capable of modular interaction with structured external resources.

Limitations.

While our analysis provides conceptual clarity and theoretical insight, it is grounded in idealized, controlled settings. Although insightful, such synthetic datasets may not fully reflect the complexity of real-world knowledge. Moreover, the optimization dynamics are not considered in our theoretical bounds, and the exploration of tool use is limited to factual recall via structured databases, excluding other important tools such as computer use, reasoning trace generation, or learnable memory modules integrated into the model architecture. Extending our analysis to these richer settings is a promising direction for future work.

Appendix A Extended Related Work

Memorization capabilities of language models.

The "Physics of LLMs" series (Parts 3.1–3.3) offers a comprehensive and theoretically grounded account of various aspects of memorization with LLMs. Part 3.1 (Allen-Zhu & Li, 2024) covers knowledge storage, distinguishing between the storage of facts and whether they are extractable in practice. With controlled experiments on synthetic biographies, the authors showed that training on diverse or augmented forms of facts (such as paraphrasing or sentence re-ordering) is crucial for facts to be recoverable via prompting. This is done with the use of linear probing to diagnose where facts are encoded in hidden states. Part 3.2 – Knowledge Manipulation (Allen-Zhu & Li, 2025b) extends this discussion beyond storage and extraction by evaluating whether LLMs can flexibly use stored facts for downstream reasoning. Four factual manipulation tasks are defined (retrieval, classification, comparison, and inverse search) to show that LLMs, including GPT-4, are competent only at direct retrieval. Lastly, Part 3.3 – Knowledge Capacity Scaling Laws (Allen-Zhu & Li, 2025a) quantifies the knowledge storage limits of LLMs, demonstrating a consistent capacity of  2 bits per parameter across various models. Their experimental design spans multiple architectures, quantization, and positional encoding methods.

Links between memorization capacity and model size. Roberts et al. (2020) investigate the extent to which factual knowledge can be stored in model parameters by fine-tuning language models of varying sizes on closed-book QA tasks. They find that performance scales with the model size, with larger models being able to approach the accuracy of retrieval-based systems. Allen-Zhu & Li (2025a) present exhaustive experiments in a controlled setting by fine-tuning models on synthetic biographical datasets under different conditions (training duration, model architectures, quantization, and data augmentations) and conclude that most models achieve a knowledge capacity of 2 bits per parameter regardless of quantization.

Wider works on factual memorization. Early empirical studies establish that pretrained LMs encode relational and factual knowledge. Petroni et al. (2019) shows that BERT can answer cloze-style queries competitively with supervised baselines, even without fine-tuning. Radford et al. (2019) further demonstrates that autoregressive models like GPT-2 acquire zero-shot QA abilities through scale alone, with performance improving log-linearly with model size. Subsequent work formalizes these behaviors. Wang et al. (2024a) propose a taxonomy of memorization, comprehension, and application, highlighting the fragility of in-weight knowledge. Kadavath et al. (2022) show that, to some extent, LLMs can self-assess their factual correctness via self-evaluation metrics $P(\text{True})$ and $P(\text{I Know})$. Such estimations are found to improve with model size or with ensembles. These findings inform recent work on confidence modeling and selective generation. Leybzon & Kervadec (2024), the authors track training dynamics and find that factual memorization is highest early and late in training, with mid-training phases marked by forgetting. These observations have implications for curriculum learning and data curation strategies. Finally, Kandpal et al. (2023) links factual recall and the frequency of that information in pretraining corpora. The authors show that models underperform on rare facts, even at a large scale, pointing to a data coverage bottleneck and motivating retrieval-augmented approaches.

Knowledge extraction from LLMs. Prompt design plays a central role in retrieving stored knowledge. Jiang et al. (2020) shows that standard close prompts underestimate LLM knowledge and proposes automated prompt mining and paraphrasing to improve extraction accuracy on the LAMA benchmark. Similarly, Allen-Zhu & Li (2025c) demonstrates that without sufficient factual augmentation, stored facts may remain unrecoverable, highlighting a gap between memorization and extractability. Both works stress that retrieval performance depends on prompt diversity and internal representations.

Learning novel knowledge and avoiding forgetting. LLMs face challenges when integrating new knowledge post-pretraining. The authors of Gekhman et al. (2024) demonstrate that fine-tuning on novel facts is both inefficient and destabilizing: new knowledge is learned slowly. It increases hallucination rates, suggesting that fine-tuning may conflict with pre-trained knowledge. The study in Allen-Zhu & Li (2024) echoes this by showing that only sufficiently augmented knowledge is robustly encoded and extractable. The broader review in Zhang et al. (2023) surveys continual learning methods, emphasizing the need for non-destructive updates that preserve anterior capabilities. Collectively, these works highlight the fragility of in-weight representations when adapting to novel information.

Knowledge editing. Another line of research considers the editing of stored knowledge in LLMs via direct mechanistic intervention on the weights, aiming to alleviate the computational burden of retraining. A wide range of editing techniques is reviewed by Zhang et al. (2024). Wang et al. (2024b) frame editing techniques in terms of cognitive-inspired mechanisms (external injection, model merging, and intrinsic editing), and introduce a unified benchmark (KnowEdit) alongside analyses of knowledge localization. Huang et al. (2025) tackle the core question of whether knowledge editing can correct hallucinations, introducing HalluEditBench and evaluating editing methods along multiple axes such as locality and generalization. Their results underscore both the promise and limitations of editing techniques in practice. Complementarily, Part 3.2 of the Physics of LLMs series (Allen-Zhu & Li, 2025b) highlights a deeper structural limitation: even when facts are faithfully stored in the model, their downstream manipulation (e.g., comparison or inverse search) remains brittle—suggesting that editing alone may not grant models flexible reasoning over internalized knowledge.

Mechanistic understanding of memorization. A series of recent works uncovers the mechanistic basis of how transformers store and recall information, with a particular focus on two mechanisms: induction heads, which enable in-context learning by attending to repeated structures within a prompt, and associative memories, where weight matrices implicitly store token associations via outer products. Bietti et al. (2023) analyzes a simplified training setup, showing that transformers first learn global bigram statistics before gradually developing induction heads that enable pattern completion from local context. They also interpret certain weight matrices as associative memories formed during training. Building on this, Cabannes et al. (2024a) provides a theoretical analysis of gradient-based learning in associative memory modules, revealing oscillatory learning dynamics caused by imbalanced token frequencies and correlated embeddings. These oscillations affect how quickly and reliably memories are stored. Cabannes et al. (2024b) derive scaling laws for memory capacity and retrieval reliability, validating them empirically in small transformer models. Collectively, these works offer a theoretical and empirical foundation for how memorization emerges through optimization dynamics in LLMs.

Tool-use in large language models.

Retrieval-augmented generation (RAG) (Lewis et al., 2020a) represents an early and influential line of work that treats external tools (e.g., retrievers) as memory extensions, enabling LLMs to access factual information without storing it parametrically. More broadly, the recent survey (Qu et al., 2025) systematically categorizes tool-use into planning, selection, calling, and response stages, and highlights its promise for improving factuality, compositional reasoning, and generalization. A growing number of works explore how models acquire tool-use capabilities. Toolformer (Schick et al., 2023) introduces a self-supervised setup where LLMs learn when and how to call APIs (e.g., calculators, search) by generating and filtering synthetic training data. MetaTool (Wang et al., 2024c) introduces a benchmark to assess tool-use awareness and selection under realistic agent settings, showing that current LLMs still struggle with tool choice and reasoning under ambiguity. Houliston et al. (2024) offers a principled offline preference-based RL algorithm tailored to LLM alignment under ambiguous context by leveraging reward or preference uncertainty estimates - such a method could naturally extend to tool learning, where ambiguity in delegation decisions is a central challenge. Combining tool use with multi-step reasoning, ART (Paranjape et al., 2023) proposes a framework where LLMs write reasoning steps as executable programs that can call tools and integrate their outputs seamlessly. This work illustrates how tool use can serve as a functional memory system to complement and augment the limited and potentially brittle parametric memory of LLMs.

Appendix B Theoretical Details

In this section, we prove the bound from Theorem 4.2 on the number of parameters needed for a transformer to learn when and how to query a retrieval system. Using the same example and notations as in Section 2, given a question of the form

[TABLE]

the model $f$ must output a well-formatted string

[TABLE]

where <DB> and </DB> are special tokens which, when parsed, result in the query being provided to the retrieval system. Let us call this subtask the querying task. The retrieval system then returns a string

[TABLE]

containing the answer to $Q$. Then, given the context $Q,T,\xi(f,a,n)$, $f$ must return a well-formatted answer

[TABLE]

Let us call this second subtask the formatting task.

We only prove that the querying task, i.e., outputting $T$ as a function of $Q$, can be learnt by a transformer for which the bounds from Theorem 4.2 apply: similar arguments are enough to prove that the formatting task can be learnt as well (and simultaneously) by such a model.

Furthermore, we make the following simplifying assumptions:

The map $\varphi_{1}:a\mapsto\varphi_{1}(a)$ is injective. 2. 2.

The only question mark in each question $Q$ is at the very end of the string. 3. 3.

The string $Q$ is provided to the model’s tokenizer in such a way that each substring $\varphi_{1}(a),\varphi_{2}(n),\varphi_{3}(a)$ is separately tokenized, i.e., the tokenized version of $Q$ is such that no token contains characters belonging to several substrings. 4. 4.

There does not exist $a,a^{\prime}\in{\cal A}$ such that $a\neq a^{\prime}$ but $\varphi_{1}(a)$ is a substring of $\varphi_{1}(a^{\prime})$. 5. 5.

The number of tokens in the questions and answers does not exceed a given constant.

The first, second, and third assumptions are reasonable and could be relaxed at the cost of a more complex proof. Some variant of the fourth assumption cannot be avoided without additional constraints on the names $\cal N$, as two distinct pairs $(a,n),(a^{\prime},n^{\prime})$ could otherwise be mapped to the same question $Q$. The last condition forces the number of tokens in the names, attribute,s and values to be less than some large number, e.g., 10k. This weak constraint is essentially a technicality linked to the limitations of positional embeddings, hence to the context length of any transformer, rather than a true algorithmic constraint.

Theorem B.1** (Parameter Upper Bound, querying task).**

Consider a finite set $\cal A$ of attributes and a set $\cal N$ of names. Then there exists a transformer with at most $8$ transformer blocks, an embedding dimension of at most $O(|\cal A|)$, and a total number of parameters at most $O(|{\cal A}|^{2})$, which can achieve perfect accuracy on the querying task, i.e., that outputs

[TABLE]

as a function of

[TABLE]

for any $a\in{\cal A},n\in{\cal N}$.

Proof.

We focus on the most informative elements of the proof and omit some tedious details.

Given a transformer with $L$ layers and $k\in\{1,\ldots,L\}$ and internal dimension $D$, we let $a_{k}\in{\mathbb{R}}^{D}$ denote the input of the feedforward network of the $k$-th transformer block (i.e. the renormalization of the sum of the output of the multi-head attention and the residual connection), and $y_{k}\in{\mathbb{R}}^{D}$ denote the output of the $k$-th transformer block (i.e. the renormalization of the sum of the output of the feedforward network and of the block’s second residual connection, see Figure 8 for an illustration of a Transformer block).

In what follows, we mean by “the vector $a_{k}$ above the $i$-th token of sequence $S$” the vector $a_{k}$ found within the $k$-th layer of the transformer and to which a direct line of residual connections starting at the embedding of the $i$-th token leads (and same for $y_{k}$).

By “an encoding of $X$”, for some quantity or object $X$ that can take values in some set $S$, we mean the image of $X$ by some injection $I:S\rightarrow{\mathbb{R}}^{n}$.

Committing a minor abuse of conventions, we say that a vector $v\in{\mathbb{R}}^{m}$ (e.g. $a_{k}$) “contains” another vector $u\in{\mathbb{R}}^{n}$ (e.g. an encoding of some object) if the coordinates $u$ are a subset of the coordinates of $v$, i.e. $u=\pi(v)$ for some orthogonal projection along a sub-family of the orthogonal basis. By convention, whenever we state that a vector $v$ contains several vectors $u_{1},\ldots,u_{l}$, the dimensions in which those vectors are contained do not intersect, i.e. $v=\{u_{1}\}\times\ldots\times\{u_{l}\}\times\{w\}$ for some vector $w$ and up to some permutation of its coordinates.

When we say that a vector $a_{k}$ or $y_{k}$ above a given token contains “a flag” corresponding to a certain condition on the token and its predecessors, we mean that one of the coordinates of the vectors (without overlap with the coordinates used to store other information) is equal to $1$ if this condition is fulfilled (the flag is raised), and to [math] otherwise.

Remember that we must design a transformer that outputs the sequence

[TABLE]

when provided with

[TABLE]

Concretely and due to the auto-regressive nature of transformers, the model will progressively concatenate tokens to $Q$ until a joint string $Q\circ T$ has been produced.

We are going to show that there exists a transformer with $8$ layers and embedding dimension $C|\cal A|$ for $C>0$ large enough such that for any input question $Q=\varphi_{1}(a)\circ\varphi_{2}(n)\circ\varphi_{3}(a)$ (for some $a\in{\cal A},n\in{\cal N}$), the following facts hold simultaneously333In the proof, approximating functions, for instance needed to compute the absolute position, amounts to a perfect approximation on a finite subset using the fact that the set of tokens is discrete.

$\blacktriangleright$ Fact: any $y_{k}$ above any token contains an encoding of the absolute position of the token within the entire sequence. The positional encodings, which contain the desired information, are added to the tokens’ learned embedding to form the input to the model’s first transformer block. For a large enough embedding dimension and a judicious choice of learned embeddings, and as long as the number of tokens does not exceed a given limit, the absolute position can be recovered by the first transformer block (using the fact that two-layer neural networks are universal approximators and assuming again that the embedding dimension is large enough). This information can then be stored in some of the coordinates of $y_{1}$, and be passed to all consecutive $y_{k}$ (e.g. using the residual connections and trivial attention heads). Note that the embedding dimension needed does not depend on $\cal A$ or $\cal N$.

$\blacktriangleright$ Fact: $y_{3}$ contains one flag per attribute $a^{\prime}\in{\cal A}$. The flags corresponding to $a^{\prime}\neq a$ are never raised, and the flag corresponding to $a$ is only raised above the last token of $\varphi_{1}(a)$.

At any step, let $t$ denote the last token of the currently processed sequence, and let $p$ be its absolute position. As stated above, $y_{1}$ contains an encoding of $p$. It can also contain an encoding of $t$ (using similar arguments).

The attention layer of the second transformer can then pass this information to its feedforward network. Using again the approximation properties of neural networks, for each $a^{\prime}\in{\cal A}$ there can be a dedicated entry $v_{a^{\prime}}\in{\mathbb{R}}$ in the network’s output $y_{2}$ such that:

• •

if $p>\text{len}(\varphi_{1}(a))$, then $v_{a^{\prime}}=-2$,

• •

if $p\leq\text{len}(\varphi_{1}(a))$ and $t$ is not equal to the $p$-th token of $\varphi_{1}(a)$, then $v_{a^{\prime}}=-2$.

• •

if $p\leq\text{len}(\varphi_{1}(a))$ and $t$ is equal to the $p$-th token of $\varphi_{1}(a)$, then $v_{a^{\prime}}=1/\text{len}(\varphi_{1}(a))$ and

In the third attention layer, the coordinates $v_{a^{\prime}}$ corresponding to each $a^{\prime}\in{\cal A}$ can be summed. If $a\neq a^{\prime}$, this sum is strictly negative. If $a=a^{\prime}$, then:

• •

if $p<\text{len}(\varphi_{1}(a))$, then the sum is positive but strictly smaller than $1$,

• •

if $p=\text{len}(\varphi_{1}(a))$, the sum is exactly $1$, and

• •

if $p>\text{len}(\varphi_{1}(a))$, the sum is strictly negative.

Hence, all cases are differentiated. The following feedforward network can then output within $y_{3}$ a flag for all $a^{\prime}\in{\cal A}$, which is raised only if $a=a^{\prime}$ and the current token is the last token of $\varphi_{1}(a)$. As the lengths of the substrings $\{\varphi_{1}(a^{\prime})\}$ are bounded, this can be done with an embedding dimension in $O(|\cal A|)$.

$\blacktriangleright$ **Fact: $y_{1}$ contains a flag that is only raised above the question mark at the end of $\varphi_{3}(a)$, and another flag that is raised above every token after the question mark. **

This is essentially trivial (using our second assumption).

$\blacktriangleright$ Fact: $y_{4}$ contains a vector that encodes the length in tokens of $n$ above every token after the question mark at the end of $\varphi_{3}(a)$.

The facts above state that $y_{3}$ contains an encoding of the absolute position of the current token, a flag $f_{a}$ corresponding to $a$ that is only raised above the last token of $\varphi_{1}(a)$, a flag $f_{?}$ that is only raised above the question mark at the end of $\varphi_{3}(a)$, and a flag $f_{\geq?}$ that is raised above every token after the question mark (these two flags are passed from $y_{1}$ to $y_{3}$).

At each token, two non-trivial queries are made in the fourth attention layer if and only if $f_{\geq?}$ is raised. The first non-trivial query matches only with a key generated from $f_{a}$ and its output value is an encoding of the position of the last token of $\varphi_{1}(a)$ as well as an encoding of the value of $a\in\cal A$. The second non-trivial query matches only with a key generated from $f_{?}$ and its output value is an encoding of the position of the question mark at the end of $\varphi_{3}(a)$. The fourth feedforward network then takes these two positional encodings and the identity of $a\in\cal A$, and outputs (in some subset of the coordinates of $y_{4}$) the distance between the last token of $\varphi_{1}(a)$ and the question mark, minus the length in tokens of $\varphi_{3}(a)$. This is precisely the length in tokens of $n$. This can be done with an embedding dimension in $O(|\cal A|)$.

$\blacktriangleright$ **Fact: the model successfully outputs $\chi_{1}(a)\circ\text{``FOR''}$ after $Q$. **

A non-trivial query is made in the second attention layer if and only if the flag $f_{\geq?}$ is raised. This query matches the flag $f_{?}$ and brings to $y_{2}$ an encoding of the position of the question mark. $y_{2}$ also contains an encoding of the position of the current token, and a copy of the flag $f_{\geq?}$. This information is passed to $y_{3}$. The fourth attention layer can match the flag above the last token of $\varphi_{1}(a)$ which describes the value of $a\in\cal A$ and pass this value to the fourth feedforward network, along with the encoding of the position of the question mark, the encoding of the position of the current token and the copy of the flag $f_{\geq?}$. If $f_{\geq?}$ is raised, then the fourth feedforward network can compute the distance $l$ between the question mark and the current token, and output an encoding of the $l$-th token of $\chi_{1}(a)\circ\text{``FOR''}$ (or a flag saying that no token should be output if $l$ is larger than the length of $\chi_{1}(a)\circ\text{``FOR''}$). This can be done with an embedding dimension in $O(|\cal A|)$. This encoding can then be passed to the following layers, until the correct $l$-th token is output.

$\blacktriangleright$ Fact: $y_{5}$ contains a flag that is only raised above the last token of $\chi_{1}(a)\circ\text{``FOR''}$.

This follows from the same arguments as the previous fact.

$\blacktriangleright$ Fact: above every token after $\chi_{1}(a)\circ\text{``FOR''}$, $y_{6}$ contains an encoding of the distance between the current token and the last token of $\chi_{1}(a)\circ\text{``FOR''}$.

The sixth attention layer can match with the flag from the previous fact to pass its position to the sixth feedforward layer, as well as the position of the current token. These can be processed by the feedforward layer to output the desired distance.

$\blacktriangleright$ Fact: above every token after the last token of $\chi_{1}(a)\circ\text{``FOR''}$, $y_{5}$ contains an encoding of the distance $d$ between the first token of $\varphi_{2}(n)=n$ and the last token of $\chi_{1}(a)\circ\text{``FOR''}$.

This distance is equal to the length of $n$ plus the length of $\varphi_{3}(a)\circ\chi_{1}(a)\circ\text{``FOR''}$. The length of $n$ is encoded in $y_{4}$ above every token after the question mark at the end of $\varphi_{3}(a)$ (using an earlier fact). This quantity can then be passed to the fifth feedforward network. $y_{3}$ contains a flag corresponding to $a$ above the last token of $\varphi_{1}(a)$ (using an earlier fact again), which is raised nowhere else. This quantity can be passed to $y_{4}$, queried by a dedicated attention head in the fifth attention layer, and passed to the fifth feedforward network. As there are finitely many $a^{\prime}\in\cal A$, the fifth feedforward network can memorize every length $\varphi_{3}(a^{\prime})\circ\chi_{1}(a^{\prime})\circ\text{``FOR''}$ with an embedding dimension in $O(|\cal A|)$. It adds the length of $\varphi_{3}(a^{\prime})\circ\chi_{1}(a^{\prime})\circ\text{``FOR''}$ to that of $n$, and encodes it into $y_{5}$.

$\blacktriangleright$ **Fact: the model successfully outputs $n$ after $\chi_{1}(a)\circ\text{``FOR''}$, and $y_{7}$ contains a flag that is only raised above the last token of (this copy of) $n$. **

For every token after $\chi_{1}(a)\circ\text{``FOR''}$, the sixth layer can use the encoding of the distance $d$ from the previous fact and the encoding of the position of the current token to output an encoding of the position $p$ of the token that is $d$ entries before the current token. The seventh attention layer can then use this encoding to match the token at position $p$ (which is part of $n$) and get its value $t$. We know that $y_{6}$ also contains an encoding of the distance $d^{\prime}$ between the current token and the last token of $\chi_{1}(a)\circ\text{``FOR''}$. If $d^{\prime}$ is smaller than the length of $n$, the seventh feedforward network outputs a copy of $t$, which lets the model output $t$. If $d^{\prime}$ is exactly the length of $n$ (i.e., the current token is the last token of the copy of $n$), the seventh feedforward network outputs a flag within $y_{7}$. If $d^{\prime}$ is greater than $n$, the flag is not raised. Hence the model does output $n$ after $\chi_{1}(a)\circ\text{``FOR''}$.

$\blacktriangleright$ Fact: the model successfully outputs </DB> after $n$, and thus successfully outputs $T$ in response to $Q$.

The eighth attention layer matches the flag in $y_{7}$ that is raised above the last token of $n$. It passes the existence of this flag, the position of the last token of $n$, and the position of the current token to the eighth feedforward network, which computes the distance $d^{\prime\prime}$ between the two positions and outputs an encoding of the $d^{\prime\prime}$-th token of </DB>, which the model can then output.

The combination of these facts is enough to complete the proof of Theorem B.1. ∎

Appendix C Experimental Details

In this section, we provide details on our experimental setup, specifically regarding the database construction, language modeling pipeline, and training runs. We also provide additional results in both controlled and large-scale settings. Seeds, when provided, are relative to distinct data generation and network initialization, and as such, results are presented with the standard deviation across runs (e.g., we conducted 10 different runs to obtain Figure 2).

Reproducibility.

The code and reproducibility instructions can be found at https://github.com/ambroiseodt/itl. We provide in the main paper and the appendix all the details needed to reproduce our results. Experiments were conducted using high-performance GPUs such as NVIDIA V100 and A100. Our implementation supports distributed training, but we have also ensured that it can be run on a single device.

C.1 Factual Recall Database

In our experiments, we construct synthetic biographical datasets using a fixed list of names ${\cal N}$ (each name is a pair {first name-last name}) and four attributes ${\cal A}$: “birth place”, “birth date”, “current address”, “occupation”; which can take 7, 16800, 213, and 100 values respectively. This yields $4|{\cal N}|$ atomic facts per dataset instance. We present in Figure 9 an example of such a dataset, where we query the birth date of Kenny McRoy, comparing the in-weight and in-tool settings. We adopt a dialog format, with a chat template. We design our tokenizer to take care of the special tokens needed (see Appendix C.2). We can see that the in-weight setting leads to a single-turn dialog for the LLM while the in-tool one requires a multi-turn dialog.

C.2 Controlled Experiments

In our experiments of Section 5, we train small Llama3-style language models (Grattafiori et al., 2024) from scratch. To that end, we build a language modeling pipeline following the literature standard (Videau et al., 2024). Below, we provide details on the tokenization, the architecture, and the training setup, alongside further results.

Tokenizer.

Transformer models (Vaswani et al., 2017), like most neural networks, operate on numerical data, and in particular, sequences of vectors. To perform language modeling, a given sequence is mapped to a sequence of numerical vectors by first splitting it into words or subwords and then encoding each word or subword into a vector. This process is referred to as the tokenization process and is typically performed using tokenizers. Most state-of-the-art language models have an associated pre-trained tokenizer; it is also possible to encode text using their byte representation. Since we pretrain our model from scratch, we considered the latter byte tokenizer to avoid potential bias from pretrained tokenizers. It simply splits words into single-character tokens and maps each of them to their raw byte representation (taking values in $[0,256)$). It results in a vocabulary space of size $256$ for the byte encoding ($256=2^{8})$, which can be augmented by adding special tokens. The vocabulary size reaches $260$ with the addition of $4$ special tokens: ** <user>, ** <assistant>, ** <database>** and ** <eod>**. Each plays a specific role during the dialog between a user and a language model assistant:

• •

The ** <user>** token marks the beginning of the dialogue by the user,

• •

The ** <assistant>** token marks the language model assistant turn, which can either answer directly or make a call the the tool,

• •

The ** <database>** token marks the beginning of the database result to the request,

• •

The ** <eod>** token indicates the end of the dialog.

Chat templates.

We model the factual recall task as a dialog between a user and a language model assistant. The user asks questions about a given person, for instance, their date of birth, birthplace, occupation, or current address. The assistant can then either answer directly using the information contained in its weights (in-weight learning) or make a call to a tool, implemented in our code as an SQL agent that has access to a database of biographies of persons. To decode such interactions, we implement a wrapper around the tokenizer to allow for dialog interactions, akin to the HuggingFace chat templates.

Online generation of batches.

Data is organized into subsets that each represent a source of data. It follows the standard in the literature, which accounts for the fact that, in practice, pretraining data aggregates texts from different sources like Wikipedia or arXiv. To optimize data generation, batches are created on the fly by sampling with pre-defined proportions from the different subdirectories. Text is tokenized also on the fly by iterating through each line of the sampled JSONL files.

Transformer architecture.

Our models are small transformer decoders following the Llama3 implementation (Grattafiori et al., 2024) with Rotational Positional Embedding (Su et al., 2024), Flash Attention (Dao et al., 2022), efficient attention for prefilling and token generation, gated linear units (Dauphin et al., 2017; Shazeer, 2020) with a SiLU activation (Hendrycks & Gimpel, 2023), RMSNorm layers (Zhang & Sennrich, 2019), and KV caching (Pope et al., 2022) for the inference. The feed-forward hidden dimension is fixed to $4$ times the embedding dimension. For each dataset size, we train a family of small Llama3-style transformer models (Grattafiori et al., 2024) with 2 layers, 2 attention heads, a vocabulary size of 300, and a context window of 257. The embedding dimension ranges from 4 to 128 (to ensure that ROPE constraints between the number of heads and the embedding dimension are met), resulting in models with between 2K and 0.6M parameters.

Training.

Our models are trained for up to $100{,}000$ steps using the AdamW optimizer (Loshchilov & Hutter, 2019), with a batch size of $128$ samples, a decoupled weight decay coefficient of $0.1$, and $(\beta_{1},\beta_{2})=(0.9,0.95)$. We use a cosine learning rate scheduler with a warmup phase of $50$ steps and a maximum learning rate of $0.001$, and a final learning rate ratio of [math].

Evaluation and inference.

At inference time, we need to generate tokens sequentially, which is known to be slow. To optimize it, we make use of the standard practices in the literature, like KV caching. To evaluate the factual recall of our model, we feed it prompts to be completed. We implement additional attention modes, such as prefilling and generation, to decode the dialog and allow interacting with the agent. These operations are parallelized by defining a specific prompt loader during evaluation. It efficiently deals with queues of prefilled tokens to generate prompt completions.

Tool implementation.

In our work, the tool is an SQL agent relying on sqlite3 to access a database containing biographies of people with their first name, last name, date of birth, place of birth, occupation, and current address. The language model assistant can learn to make queries to this database thanks to in-tool learning. The SQL agent can be used to create the database and insert new elements in it, and has agentic capabilities not only to execute a query and return a result but also to parse instructions from an LLM prompt, execute them, and answer in natural language to the language model assistant.

Further results.

In the experiments displayed in Section 5, the recall accuracy is fixed at $95\%$. To better understand how it can impact the parameter requirement, we display in Figure 10 the minimum parameter requirement as a function of the factual recall for 4 different numbers of facts. We notice that the higher the recall, the bigger the models, and that this increase is steeper when the number of facts to retrieve increases. This can be explained from Theorem 3.2, which makes the dependency between the model size and the number of facts explicit. Given that tool use enables the retrieval of an unbounded number of facts without the need to increase the number of parameters, as shown in Figure 2, this implies that in-tool learning is all the more beneficial when one wants a more effective model on a bigger dataset. This follows the increasing trends of toll use in the literature for harder benchmarks such as mathematics.

C.3 Large Scale Experiments

In this section, we provide additional results related to Section 6.

HellaSwag performance relative to base model.

Figure 5 in the main section of the paper displays the absolute HellaSwag accuracy attained by different models finetuned on datasets of increasing size. To complement this, we examine the relative drop in HellaSwag performance from the base model as the memorization load increases, in Figure 12. This perspective offers a clearer view of the dynamics by which larger models maintain their prior capabilities under heavier memorization loads. Tool-learning (dashed line representing the worst performance over all tool-models) preserves general capabilities almost perfectly across model and dataset sizes. In contrast, in-weight learning leads to noticeable degradation, especially for smaller models and larger factual loads. This supports our theoretical prediction that parameter-based memorization causes interference and loss of prior capabilities, due to finite capacity and update interference. Larger models are more robust to such forgetting, but still exhibit performance decay beyond 10K facts.

A simplified intuition helps interpret the consistent ordering across model sizes: larger models possess more "capacity volume," so absorbing a fixed amount of new information replaces a smaller fraction of prior knowledge. While this view captures the trend, it likely omits key confounding factors: larger models are typically trained with more compute and data, and more complex architectures may also be more brittle to local updates—suggesting the optimization dynamics themselves differ in important ways.

Total variation versus memorization load.

The intuition laid out above is also observed in the TV distance suffered by models as the memorization load grows: larger models diverge less than smaller counterparts. Figure 12 depicts the Total Variation of finetuned models from their base-model, for different memorization loads. The figure shows the same results as Figure 6 for in-weight models but replaces in-tool data by the highest (worst) TV achieved (by SmolLM 135M), represented as the dashed baseline. We notice in-tool TV baseline is constant across dataset sizes, and is lower than in-weight learning deviations - this is due to tool-use mastery unlocking unbounded factual recall. Overall, bigger models deviate less from their base model for the same in-weight memorization load. The distance is dramatically greater for smaller models on bigger datasets close to 50k facts.

Training dynamics.

For databases of 500K and 50K facts, we display the recall accuracy, the HellaSwag performance, and the total variation attained by checkpoints throughout training until complete memorization in Figures 13 and 14. Across model scales, we observe that recall accuracy improves rapidly during early training, with most models nearing saturation within 30–40 steps. However, a substantial number of additional steps are spent refining the final few percent of recall, suggesting that later training primarily sharpens the output distribution rather than acquiring new associations. Notably, most of the degradation in HellaSwag performance and increase in total variation occur early in training, indicating that the bulk of distributional shift and capability loss is incurred in the initial stage of training for memorization, while later steps have comparatively minor effects.