Scratch Tokens: A Multi-Domain Concept

• Scratch tokens are task-specific entities generated from scratch, serving as intermediate reasoning traces in LLMs, pseudo-tokens in inference-time prompt tuning, or ephemeral blockchain assets.
• They are developed using diverse methodologies—from token optimization during model inference and domain-specific tokenizer training to progressive re-tokenization in vision transformers.
• Across various applications, scratch tokens enable explicit efficiency and cost accounting, influencing trade-offs in accuracy, computational overhead, and security.

Searching arXiv for the cited work and related uses of “scratch tokens” across domains. “Scratch tokens” is not a single standardized technical term in the arXiv literature. It denotes several distinct objects and measurement regimes: model-generated intermediate reasoning traces in LLMs, disposable on-chain tokens with lifetimes under 24 hours, pseudo-tokens initialized and optimized from scratch during inference-time prompt tuning, domain-specific token vocabularies trained from scratch for scientific language modeling, and progressively re-tokenized image representations in vision transformers (Zhao et al., 23 Apr 2026). Across these usages, the term consistently marks entities created anew for a task-specific computational role rather than inherited unchanged from a fixed pretrained representation.

1. Terminological scope across research areas

The term appears in materially different technical settings, and its meaning must therefore be read relative to the modeling stack, data modality, and optimization objective.

Context	Meaning of “scratch tokens”	Representative paper
Reasoning LLMs	Completion tokens implementing intermediate reasoning traces	(Zhao et al., 23 Apr 2026)
EVM blockchains	Disposable ERC-20/BEP-20 tokens with lifetime under 24 h	(Cernera et al., 2022)
Zero-shot video captioning	Pseudo-tokens initialized at random and optimized from scratch	(Tewel et al., 2022)
Domain-specific NLP	Tokenizer vocabulary trained from scratch on neuroscience text	(Luo et al., 2024)
Vision transformers	Tokens produced by the Tokens-to-Token module during training from scratch	(Yuan et al., 2021)

In reasoning systems, the term is operational and cost-centric: “scratch tokens” are the generated tokens spent on intermediate deliberation. In blockchain analysis, it is lifecycle-centric: “scratch” or “disposable” tokens are identified by short on-chain existence. In prompt optimization and tokenization work, the term refers to representational units created or learned from scratch rather than inherited from generic pretrained vocabularies or prompts. This suggests that the phrase functions less as a stable ontology than as a recurring label for newly instantiated task-specific token objects.

2. Intermediate reasoning tokens in LLMs

In “Thinking with Reasoning Skills: Fewer Tokens, More Accuracy,” scratch tokens are defined as “the model-generated tokens that implement intermediate reasoning (‘thinking’) traces—i.e. the Chain-of-Thought (CoT) tokens” (Zhao et al., 23 Apr 2026). In practical API usage, the work does not distinguish thought tokens from answer tokens and instead proxies all model outputs as completion tokens. For a query $q$, the paper defines

$$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$

and

$$T_{\mathrm{TRS}}(q)=\text{number of completion tokens when using TRS skill injection}.$$

Under commercial billing, reducing scratch tokens is therefore equivalent to reducing $T(q)$, which directly reduces per-query cost and latency.

The method replaces “reasoning from scratch” with retrieval of reusable reasoning skills distilled from prior traces. Given source problems $D=\{(q_i,a_i)\}$, a reasoning model $M_r$ produces a trace $\tau_i$ and final answer $y_i$, with correctness label $c_i=\mathrm{Eval}(y_i,a_i)\in\{0,1\}$. A stronger summarizer $M_s$ then distills a compact skill card $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$0 and triggers $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$1 by minimizing

$$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$2

In practice, the summarizer emits a 5-field structured card, “Trigger/Do/Avoid/Check/Risk,” plus 10–20 keywords. Each skill is stored as a key–value pair $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$3 with $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$4 and $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$5. Retrieval may be dense, sparse BM25, or hybrid; for dense retrieval the score is

$$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$6

The paper also gives an explicit token-cost model. Let $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$7 and $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$8 denote billing rates per 1K input and output tokens, let $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$9 be the number of input tokens after skill injection, and let $$T_{\mathrm{TRS}}(q)=\text{number of completion tokens when using TRS skill injection}.$$0 be the number of output tokens generated by $$T_{\mathrm{TRS}}(q)=\text{number of completion tokens when using TRS skill injection}.$$1. Then

$$T_{\mathrm{TRS}}(q)=\text{number of completion tokens when using TRS skill injection}.$$2

The baseline and TRS costs are compared via

$$T_{\mathrm{TRS}}(q)=\text{number of completion tokens when using TRS skill injection}.$$3

along with the accuracy gain

$$T_{\mathrm{TRS}}(q)=\text{number of completion tokens when using TRS skill injection}.$$4

On the DeepMath benchmark with Gemini-3-Flash, direct reasoning achieves 94.8% accuracy with 7,490 average tokens and 100.0% relative cost, whereas TRS reaches 95.5% accuracy, 6,106 average tokens, and 82.5% relative cost, corresponding to $$T_{\mathrm{TRS}}(q)=\text{number of completion tokens when using TRS skill injection}.$$5 accuracy points, $$T_{\mathrm{TRS}}(q)=\text{number of completion tokens when using TRS skill injection}.$$6 tokens, and $$T_{\mathrm{TRS}}(q)=\text{number of completion tokens when using TRS skill injection}.$$7 cost (Zhao et al., 23 Apr 2026). On coding with Nemotron and Gemini-3-Flash, direct reasoning yields 72.0% accuracy with 20,206 average tokens, while TRS yields 71.7% accuracy with 17,072 average tokens and 85.2% relative cost, corresponding to $$T_{\mathrm{TRS}}(q)=\text{number of completion tokens when using TRS skill injection}.$$8 accuracy points and $$T_{\mathrm{TRS}}(q)=\text{number of completion tokens when using TRS skill injection}.$$9 tokens. On harder subsets defined by $T(q)$0, TRS maintains or improves accuracy by up to +1.8 points on hard math and cuts tokens by 20–60%, while budget-only, brevity-only, and decoding-only baselines suffer catastrophic accuracy drops on $T(q)$1-hard cases. The paper’s summary states that TRS can “break the traditional efficiency–accuracy trade-off” by achieving fewer generated tokens, lower cost, and equal or improved accuracy on challenging math and coding benchmarks (Zhao et al., 23 Apr 2026).

The work also emphasizes limitations. It relies on end-state correctness signals rather than fine-grained failures; retrieval and prompt inflation add overhead; and transfer to out-of-domain or non-reasoning tasks can slightly harm performance and always increases cost. For that reason, the authors recommend “selective deployment” only for queries expected to need deep reasoning. They further state that one-time library build cost $T(q)$2 must be amortized over many queries, with break-even on the order of $T(q)$3 to $T(q)$4 queries, after which per-query cost is reduced by 15–60% while preserving or boosting accuracy (Zhao et al., 23 Apr 2026).

3. Disposable blockchain tokens and one-day rug pulls

In blockchain analysis, “scratch” tokens are not reasoning traces but short-lived financial instruments. Cernera et al. define a “scratch” or “disposable,” “1-day” token as an ERC-20/BEP-20 token whose on-chain lifetime is under 24 hours, with

$T(q)$5

where $T(q)$6 is the block of token-contract deployment and $T(q)$7 is the last block in which the contract emits any ERC-20/BEP-20 event (Cernera et al., 2022). A special subclass is the “1-block” token, with lifetime approximately one block.

After filtering out LP-token contracts, the paper reports 1,078,016 total tokens on BSC and 323,863 on Ethereum. Of these, 167,318 BSC tokens (15.5%) and 104,836 Ethereum tokens (32.4%) are 1-block tokens; 638,703 BSC tokens (59.2%) and 187,378 Ethereum tokens (57.8%) are 1-day tokens (Cernera et al., 2022). The paper concludes that about 60% of all tokens on both chains vanish within 24 hours and that a non-negligible fraction never leave their creation block.

Creation behavior is highly concentrated. Out of approximately 140 million unique BSC addresses and approximately 190 million Ethereum addresses, only 0.33% on BSC and 0.07% on Ethereum ever created a token contract. Seventy percent of creators mint exactly one token, and 95% mint at most five tokens. Yet the top 1% of creator addresses account for 262,023 BSC tokens, or 24.3% of all BSC tokens, and 67,838 Ethereum tokens, or 20.1% of all Ethereum tokens. These “token spammers” mint on average 61 tokens on BSC and 51 on Ethereum, and roughly 60–65% of their tokens are 1-day tokens (Cernera et al., 2022).

The paper outlines a minimal “1-day rug pull” as a six-step process: deployment of disposable token $T(q)$8; creation of a liquidity pool $T(q)$9 where $D=\{(q_i,a_i)\}$0 is WBNB or WETH; provision of initial reserves $D=\{(q_i,a_i)\}$1; external traders swapping $D=\{(q_i,a_i)\}$2 and injecting $D=\{(q_i,a_i)\}$3; removal of approximately 100% of the pool share by burning LP tokens; and realization of net profit. In the simple case, profit is

$D=\{(q_i,a_i)\}$4

and in the more general case,

$D=\{(q_i,a_i)\}$5

Rug pulls are detected as 1-day tokens whose LP issued exactly one Mint event and one Burn event in which at least 99% of LP tokens are burned by the same address (Cernera et al., 2022).

Prevalence differs sharply by chain. Among 1-day tokens with liquidity pools, BSC has 471,385 such tokens, of which 266,340 (56.5%) are detected rug pulls and 104,404 (39.1%) are successful. Ethereum has 82,542 1-day tokens with LPs, of which 21,594 (26.2%) are detected rug pulls and 13,368 (61.9%) are successful (Cernera et al., 2022). The average setup cost is approximately 0.03 BNB, about $D=\{(q_i,a_i)\}$6400 USD, on Ethereum. Average profit per successful pull is 0.11 BNB, about $D=\{(q_i,a_i)\}$74,000 USD, on Ethereum. The estimated aggregate profit at March 2022 prices is about $D=\{(q_i,a_i)\}$854 million on Ethereum, for a combined total of about $D=\{(q_i,a_i)\}$9240 million generated by 1-day rug pulls, indicating that the broader longitudinal analysis attributes substantially larger profits to the phenomenon overall (Cernera et al., 2022).

The same paper introduces “SniperBots 2.0,” which monitor the mempool for add-liquidity transactions on newly created LPs and instantly inject a buy order to obtain the earliest tokens at pre-price-impact rates. On BSC, the empirical rule flags any swapper address trading in at least 100 distinct scam LPs with average $M_r$0, yielding 130 addresses; on Ethereum, the threshold is at least 10 distinct LPs with $M_r$1, yielding 64 addresses (Cernera et al., 2022). These addresses account for 86.5% of all scam LPs visited and 24% of all swap transactions on BSC, and 30% of scam LPs and 3.5% of swap transactions on Ethereum. Security implications in the paper include DEX warnings for LPs created by “token spammers,” standardized spammer-score or blacklist services, minimum time locks or gradual vesting of initial liquidity, and greater scrutiny of token contract addresses rather than symbols alone.

4. Tokens initialized from scratch during inference-time prompt optimization

In zero-shot video captioning, “scratch tokens” are prompt vectors rather than natural-language tokens. “Zero-Shot Video Captioning with Evolving Pseudo-Tokens” prepends a block of $M_r$2 pseudo-tokens before any generated text; their key/value pairs across all transformer layers, denoted $M_r$3, are initialized at random and optimized from scratch, while a small set of prefix tokens is sampled from a fixed set such as “Image of,” “Photo of,” and “Video shows” (Tewel et al., 2022). The generated sentence $M_r$4 is produced autoregressively by frozen GPT-2, and the next-token distribution at step $M_r$5 is

$M_r$6

The optimization signal is CLIP-based and sentence-level. Let $M_r$7 denote the top-100 vocabulary entries under $M_r$8. For each candidate token $M_r$9, the CLIP-guided target is proportional to the sum of image-text matching scores over sampled frames:

$\tau_i$0

The vision loss is

$\tau_i$1

and the language fluency loss is

$\tau_i$2

The total loss at each step is

$\tau_i$3

with $\tau_i$4 in the reported experiments (Tewel et al., 2022).

After generating a full sentence, the model computes one gradient of the total loss with respect to the pseudo-token cache and performs a single normalized update:

$\tau_i$5

with $\tau_i$6. The outer loop uses approximately $\tau_i$7 pseudo-tokens, $\tau_i$8 iterations, one random prefix per iteration, top-3 token sampling, and a maximum sentence length of 20. No gradient flows into PLM weights; only $\tau_i$9 evolves. The paper explicitly characterizes this as “inference-time prompt tuning” (Tewel et al., 2022).

The implementation samples video frames at 3 fps and then performs CLIP-distance subsampling, keeping the first frame and including later frames if the $y_i$0 distance in CLIP embedding space exceeds $y_i$1, typically yielding about 5–8 diverse frames. Using frozen GPT-2 and frozen CLIP, the method produces captions with CLIP-Score 0.775, BLIP-Score 0.675, VideoCLIP retrieval distance 0.504, and BERT perplexity 18.35, compared with 0.710, 0.623, 0.442, and 54.71 for ZeroCap, and 0.566, 0.575, 0.392, and 30.48 for MAGIC on MSR-VTT / MSVD zero-shot video captioning (Tewel et al., 2022). The method also uses approximately 4,372 unique words on MSR-VTT, whereas the supervised baselines use only approximately 400.

Here, scratch tokens are neither corpus tokens nor billing units. They are latent prompt-state variables optimized online to steer a frozen LLM toward visually grounded sentences. A plausible implication is that the phrase “from scratch” in this setting emphasizes initialization and adaptation regime rather than token semantics.

5. Tokens and token budgets in training-from-scratch language modeling

A distinct use of the term appears in domain-specific language modeling, where “Scratch Tokens” refers to a tokenizer trained from scratch on a specialized corpus. “Matching domain experts by training from scratch on domain knowledge” argues that generic tokenizers split rare neuroscience terms into many sub-tokens, fragmenting semantic signal, whereas a tokenizer trained on neuroscience text preserves whole specialized terms as single tokens and makes subsequent model training more efficient and effective on domain tasks (Luo et al., 2024).

The tokenizer is trained with standard Byte-Pair Encoding. Starting from a vocabulary of individual characters, the algorithm repeatedly selects the most frequent adjacent symbol pair,

$y_i$2

merges it into a new symbol, and re-segments the corpus. The study uses neuroscience literature from 2002–2022, largely from PubMed, publisher feeds, and open-access repositories, totaling 1.3 billion raw tokens. Cleaning includes deduplication, stripping figures, tables, and references, Unicode normalization, removal of non-English passages, sentence segmentation, lowercasing, and a 90/10 split for tokenizer/model training and validation (Luo et al., 2024). The tokenizer vocabulary size is 50,000 subword tokens, with approximately 49,500 BPE merges and minimum pair frequency threshold at least 1.

The downstream GPT-2 model replaces byte-level BPE with this neuroscience-trained BPE, initializes the embedding matrix randomly via

$y_i$3

and trains from scratch on the 1.3 billion neuroscience tokens under the standard next-token cross-entropy objective

$y_i$4

The reported optimization details are AdamW with weight decay, learning rate $y_i$5, batch size $y_i$6 grad-accum 8, cosine learning-rate schedule, and 5 epochs of training (Luo et al., 2024).

On BrainBench, GPT-2 trained from scratch with a generic WebText BPE achieves 58.0% accuracy, whereas GPT-2 trained from scratch with the neuroscience BPE achieves 63.0%; GPT-2 pretrained on WebText and finetuned on neuroscience reaches 63.5%; human neuroscientists reach 63.4% (Luo et al., 2024). The paper further reports that the neuro-tokenizer contains approximately 25.4% neuroscience-specific tokens versus 12.0% in the generic BPE and preserves domain terms that the generic BPE splits, such as “striato-pallidal.” In this usage, “Scratch Tokens” refers not to extra reasoning computation but to representational primitives adapted to a specialized corpus.

A related but separate use of “scratch” occurs in “Small LLMs: Pruning vs. Training from Scratch,” where the central variable is training-token budget rather than a token type (Xu et al., 12 Jun 2026). The paper studies pruning Llama-3.1-8B at $y_i$7 under two controlled token-matched regimes. In the equal-training-token-budget regime, the pruned pipeline and the random-initialized baseline each receive $y_i$8 retraining tokens, so $y_i$9. In the equal-total-token-budget regime, the pruning pipeline consumes $c_i=\mathrm{Eval}(y_i,a_i)\in\{0,1\}$0 billion tokens in total, and the scratch baseline is also allowed $c_i=\mathrm{Eval}(y_i,a_i)\in\{0,1\}$1 billion tokens (Xu et al., 12 Jun 2026).

The performance function is written as $c_i=\mathrm{Eval}(y_i,a_i)\in\{0,1\}$2, with gap

$c_i=\mathrm{Eval}(y_i,a_i)\in\{0,1\}$3

For depth-pruning at $c_i=\mathrm{Eval}(y_i,a_i)\in\{0,1\}$4 and $c_i=\mathrm{Eval}(y_i,a_i)\in\{0,1\}$5, the equal-training comparison is 64.4% average downstream accuracy for pruning versus 60.7% for scratch; in the equal-total-token regime the comparison is 64.4% versus 66.2% (Xu et al., 12 Jun 2026). More generally, in the equal-training setting the advantage of pruning shrinks as $c_i=\mathrm{Eval}(y_i,a_i)\in\{0,1\}$6 grows: $c_i=\mathrm{Eval}(y_i,a_i)\in\{0,1\}$7, $c_i=\mathrm{Eval}(y_i,a_i)\in\{0,1\}$8, $c_i=\mathrm{Eval}(y_i,a_i)\in\{0,1\}$9, and $M_s$0. In the equal-total setting, structured pruning loses its lead at coarser granularity, whereas sparse pruning retains a small positive $M_s$1 even when scratch receives all 250B tokens. This work does not define “scratch tokens” as a token class, but it clarifies how “from scratch” training should be normalized against pruning by explicit token accounting (Xu et al., 12 Jun 2026).

6. Progressive re-tokenization in vision transformers

In computer vision, “scratch tokens” refers to learned visual tokens produced by the Tokens-to-Token module of T2T-ViT. The paper argues that vanilla ViT’s simple tokenization fails to model local structure such as edges and lines among neighboring pixels and that its attention backbone is redundant for fixed compute budgets and limited training samples (Yuan et al., 2021). T2T-ViT addresses this by progressively “re-tokenizing” an image through local-neighbor grouping plus self-attention before the final transformer stack.

Let $M_s$2 be the input image, and let $M_s$3 denote the token sequence at stage $M_s$4. A SoftSplit operation unfolds overlapping windows, applies LayerNorm, multi-head self-attention, and linear projection, and produces the next stage:

$M_s$5

with

$M_s$6

The reported configuration uses three stages: $M_s$7, $M_s$8, and $M_s$9 (Yuan et al., 2021). For a $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$00 image, this yields approximately $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$01, $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$02, and $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$03 tokens. The summary states that the total token count shrinks rapidly from approximately 50K to 3,136 to 729 to 169 while preserving edges, lines, and other structural cues through local attention.

After the T2T module, the resulting sequence is linearly embedded and passed through a “deep and narrow” transformer backbone. T2T-ViT-14 uses embedding dimension $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$04, 6 heads, depth $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$05, 21M parameters, and 4.6 GFLOPs; T2T-ViT-19 uses $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$06, 8 heads, depth 19, 39M parameters, and 8.1 GFLOPs; T2T-ViT-24 uses $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$07, 12 heads, depth 24, 64M parameters, and 12.6 GFLOPs. By contrast, ViT-B/16 has approximately 86M parameters and 17.6 GFLOPs (Yuan et al., 2021). The attention cost scales as $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$08 and the MLP cost as $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$09, so smaller $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$10 and $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$11 reduce compute.

Training is performed from scratch on ImageNet-1K using AdamW with $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$12, $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$13, batch size 1,024, learning rate 0.001 with linear warm-up for 5 epochs and cosine decay over 300 total epochs, weight decay 0.05, RandAugment, label smoothing 0.1, and stochastic depth up to 0.1 (Yuan et al., 2021). The reported results are 81.5% Top-1 and 95.4% Top-5 for T2T-ViT-14/224, 82.3% Top-1 and 95.7% Top-5 for T2T-ViT-19/224, and 83.3% Top-1 for T2T-ViT-19/384. The paper states that T2T-ViT reduces the parameter count and MACs of vanilla ViT by half while achieving more than 3.0% improvement when trained from scratch on ImageNet (Yuan et al., 2021).

Ablations reinforce the role of re-tokenization. Removing the T2T module and using direct patch embedding drops Top-1 by approximately 1.5–2.0%; using one, two, and three tokenization stages yields approximately 79.4%, 80.7%, and 81.5% Top-1 respectively; and T2T-ViT already outperforms a ViT-B/16 trained for 300 epochs when both are examined under 100-epoch sample-efficiency comparisons (Yuan et al., 2021). In this context, scratch tokens are image-derived representations learned end-to-end during training from scratch rather than symbolic vocabulary items.

7. Comparative interpretation and recurring design patterns

Across these literatures, “scratch tokens” refers to at least three analytically distinct categories: computational expenditure, representational primitives, and ephemeral assets. In reasoning LLMs, the token is a unit of generated deliberation whose count determines latency and billing (Zhao et al., 23 Apr 2026). In blockchain ecosystems, the token is an externally tradable contract whose brief lifetime can be exploited in rug pulls (Cernera et al., 2022). In zero-shot captioning, domain-specific tokenization, and vision transformers, the token is a learned representational unit created or adapted from scratch for a task-specific objective (Tewel et al., 2022).

Despite this heterogeneity, a recurring pattern is explicit accounting. The reasoning work formalizes token usage through $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$14, $$T_{\mathrm{base}}(q)=\text{number of completion tokens when reasoning from scratch},$$15, and per-query cost models (Zhao et al., 23 Apr 2026). The pruning study normalizes comparisons by equal-training-token and equal-total-token budgets, making “from scratch” a token-budgeted baseline rather than a rhetorical foil (Xu et al., 12 Jun 2026). The neuroscience tokenizer work ties tokenizer design directly to corpus tokenization efficiency and downstream next-token prediction (Luo et al., 2024). The video-captioning system constrains pseudo-token adaptation with a joint vision-language loss and a fixed number of iterative updates (Tewel et al., 2022). The blockchain study measures lifetime, creator concentration, LP events, and profits to convert “scratch” from an intuitive descriptor into a detection criterion (Cernera et al., 2022).

Another common pattern is selective utility. In reasoning LLMs, reducing scratch tokens improves cost and often accuracy on tasks requiring deep reasoning, but can harm out-of-domain or non-reasoning queries, motivating selective deployment (Zhao et al., 23 Apr 2026). In pruning, the advantage of not training from scratch depends on whether the comparison is equalized by retraining tokens or by total pipeline tokens, and on pruning granularity (Xu et al., 12 Jun 2026). In neuroscience language modeling, a tokenizer trained from scratch helps when domain terms are frequent and semantically important (Luo et al., 2024). In blockchain systems, the very disposability of scratch tokens is part of the attack surface rather than a modeling benefit (Cernera et al., 2022).

The literature therefore does not support a single universal definition. Instead, it presents “scratch tokens” as a family resemblance term for token objects created anew—during inference, model training, representation learning, or on-chain deployment—and then evaluated by domain-specific criteria such as cost, accuracy, lifetime, or exploitability.