betaFeedback

WorksComputer Science

One Run Is Not Enough: Reminding a small Gemma 4 coding agent of its last finding made no measurable difference in a paired test

Abstract

When a coding agent runs out of room, its earlier findings are cut and it forgets them. We tested a simple fix: automatically putting the agent's last finding back in front of it. We fixed the rules in advance and ran 98 paired coding tasks with and without this reminder, using Gemma 4 31B (QAT, 4-bit) in the Gemma 4 Developer Agent harness. The reminder made no measurable difference: across all 98 tasks, 47 were solved with it and 48 without (-1.0 points, 95% interval [-8.3, +6.3], exact McNemar p=1.0). The primary outcome (a documented deviation from our preregistration), the first 48 pairs, was 29/48 with memory against 25/48 without (+8.3 points, [-2.1, +18.3], p=0.22); the extension of 50 tasks, decided after that result, pointed the other way (18/50 against 23/50, -10.0 points, p=0.125), so the sign did not replicate. With 19% of tasks flipping between two identical no-memory runs, the combined interval excludes harms larger than about 8 points and gains larger than about 6, and the design had 80% power only for effects of about +-12 points or more. The model almost never wrote notes (2 of 16 and 4 of 32 runs), and memory cost context: the first request is larger and something was injected at only 47% to 65% of compactions. The registered secondary, repeated actions per compaction, was also null. Two directional hypotheses found on Modal did not replicate on Kaggle. We also report an A/A calibration and a validity funnel (129 tasks, 105 valid). Together these results show that single-run memory claims on task sets of this size sit inside run-to-run noise. The treatment is a harness mechanism and does not test agent-written memory.

Introduction

The promise of agent memory is that context told once stays available to an agent when it is relevant. For a small coding agent, the first place that promise breaks is inside a single task. The Gemma 4 harness compacts the conversation when the previous prompt reaches 14,336 tokens. In 16 no-memory throughput traces, 13 tasks compacted, and 53 of 83 exact repeats of a read, a command or an explorer question came after a compaction.

Experience memory across tasks [16, 12] (Zhao et al. 2023) targets a different problem. For coding agents the evidence is sobering: VibeMemBench [5] found that 11 of 12 solver and memory pairings did not beat memory-off. We therefore built the study expecting a likely null result and designed it to report one honestly.

Question. Does automatically re-injecting the explorer’s last finding after compaction help Gemma 4 31B resolve real repository tasks?

Contributions.

  1. A paired comparison, stratified by backend, with a null primary result, a pre-registered extension whose sign differs, and intervals that state which effects they exclude (§ 3.1).

  1. Mechanism findings: adherence (the model rarely writes memory), the context cost of memory, delivery rates, and a treatment-associated submit_patch loop (§ 3.4).

  1. A measurement method for small agent studies: A/A calibration, a validity funnel, smoke gates, frozen detectors, byte-identical baseline builds, and a timestamped change log (§ 2.4).

Method

Setting

The model is Gemma 4 31B (QAT, w4a16, thinking budget 4096) in the competition’s declarative ADK harness: a coder agent, an explorer sub-agent, a 100-tool-call cap and a 60-minute cap. Tasks are the 129 public development tasks (fastapi 67, rich 48, requests 13, httpx 1), in the SWE-bench [7] family. Scoring uses the harness’s own verify_task in a per-task Python 3.13 environment built by the harness’s Docker setup steps. The agents run under the subprocess sandbox, not the official Docker scorer.

Arms

  • none: the baseline submission. Its build is byte-identical across every code pin (a test rebuilds it at each pin and compares the files).

  • recap: after every compaction, the coder’s instruction carries two session-state slots that ADK fills on each model call: {explorer_finding?}, the explorer’s latest answer (at most 15 lines), and {working_notes?}, a page of notes the agent wrote through a notes sub-agent, capped at 1,500 tokens. The agent is asked to write a note after each explorer answer and each edit. The arm began as agent-requested recall. In three smoke checks (6 runs), no run wrote a note, so before any result on the 48 tasks we moved recall to automatic injection and then added the explorer finding. This was the pre-registered fallback for near-zero note writes. What we test is therefore automatic carry-over of the explorer’s last finding, plus rare notes. We do not test agent-written working memory. No embeddings are used.

Pre-registration and analysis

A hash-frozen pre-registration and a timestamped protocol change log record each decision with its time. The run-1 pooled form of the primary was fixed 5 minutes before the first results commit.

The headline moved from cross-task lessons to the in-task recap. That decision was made from no-memory traces only, before any memory-arm run.

  • Primary: resolve rate, intention to treat, run 1 against run 1, pooled over 48 pairs. We report a backend-stratified bootstrap (10,000 resamples), the Newcombe paired score interval and exact McNemar. Run 2 and per-task means are sensitivity analyses that cannot change the headline.

  • Key secondary: repeated actions per compaction. A repeat is a root-agent tool call, after the first compaction, whose tool and normalized arguments match an earlier call. We report the paired mean difference with a bootstrap CI and a Wilcoxon signed-rank test.

  • Replication: two directional hypotheses (§ 3.3) were discovered on Modal and frozen as code. They were then tested on Kaggle before any Kaggle recap row was read.

  • Adherence and delivery: notes written, and the share of compactions at which something was injected. Both were registered as outcomes.

  • Extension: after seeing the 48-pair result, we pre-registered 50 more tasks on a third backend (commit bdf6c0e3, before any extension row): one run per arm at the frozen pins, with its own two-sided primary (exact McNemar, Newcombe interval). The combined 98-pair analysis, stratified by backend, is secondary. Pre-registered replicate runs of every task (Phase R) are reported separately.

Every test not listed above is post-hoc and labelled so. We ran 23 post-hoc tests in all (Appendix § 7).

Making the measurement trustworthy

Validity funnel. In the public environment, only 37 of 129 tasks passed with their gold patch (the reference fix). Adding the missing test dependencies raised this to 68. Installing, for each snapshot, the newest competition wheel its own pyproject allows raised it to 105. That step targeted the 44 fastapi gold failures caused by a too-new starlette. The 24 exclusions follow written rules. The 48-task subset was drawn once, with a seed (20261107), from the 105 valid tasks, stratified by repository. The 50 extension tasks are the remaining valid tasks, minus 7 used for tuning, smoke and throughput checks.

Smoke gates. Every arm had to pass small out-of-sample checks before running on the 48 tasks. These checks caught three bugs that would otherwise have produced results that looked plausible but were wrong: (1) plumbing: the first skill check was rejected, because its write was flagged as path traversal and the skill was neither declared nor reachable; (2) sandbox paths: under the subprocess sandbox, skill arguments named the host’s /workspace and /tmp, so memory reported itself unavailable, and notes would have been shared across concurrent tasks; (3) adherence: agents skipped recall and wrote no notes, so the arm would have run as “memory” with nothing in it. A CPU replay check also caught an interpreter path that would have failed every task in a fresh session. It showed that, after masking random sandbox ids, the no-memory arm sends 33 of 33 model requests identical before and after the memory plumbing was added.

A/A calibration. We compared the no-memory arm against itself, run 2 against run 1 (Table 1). Of the 48 tasks, 9 changed outcome (18.75%), with no treatment at all. With that discordance, the paired standard error over 48 pairs is about 0.063, so 80% power at α=0.05\alpha= 0.05 requires effects of about ±18\pm18 points.

Kaggle 32Modal 16
resolved, run 1 / run 214 / 1611 / 12
difference [95% CI]+0.063 [−0.094, +0.219]+0.063 [−0.125, +0.250]
McNemarb=4b = 4, c=2c = 2, p=0.69p = 0.69b=2b = 2, c=1c = 1, p=1.0p = 1.0
repeat-rate difference [95% CI], nn−1.97 [−7.38, +2.70], 26+0.27 [−1.24, +1.58], 14
leaked thought text, runs (run 1 / run 2)5 / 30 / 0
overflows (run 1 / run 2)5 / 41 / 0

Table 1. Noise floor with no treatment (no memory, run 2 vs run 1).

Results

Resolve rate: primary, extension and combined

On the first 48 tasks, memory resolved 4 more (Table 2). This is not a significant effect. Figure 1 puts this next to the A/A contrast. The no-memory arm, compared with itself, moved by the same +6.3 points as the Modal treatment effect. Per-protocol, which excludes runs flagged plumbing_failed (11 per backend), the result is the same (26 pairs, 13 vs 11, p=0.5p = 0.5). So is the registered sensitivity analysis, the per-task mean over all available runs (+5.2 points, bootstrap [−3.1, +12.5]).

Setrecap / nonediscordantdifferenceNewcombe 95%McNemar pp
Pooled, 48 (primary)29 / 255 / 1+8.3 pts[−2.1, +18.3]0.22
Modal H100, 1612 / 112 / 1+6.3 pts[−17.5, +29.3]1.0
Kaggle 4×L4, 3217 / 143 / 0+9.4 pts[−2.1, +20.2]0.25
AWS L40S, 50 (extension primary)18 / 231 / 6−10.0 pts[−20.2, +0.7]0.125
Combined, 98 (secondary)47 / 486 / 7−1.0 pts[−8.3, +6.3]1.0

Table 2. Resolve rate. Run 1, intention to treat. The backend-stratified bootstrap gives [0.0, +18.8] pooled for the 48, [−20.0, 0.0] for the extension and [−8.2, +6.1] combined. The bootstrap bound at 0 follows from the 5/1 and 1/6 splits and is not evidence for or against harm.

Figure 1. Resolve-rate difference with Newcombe 95% intervals. Blue: recap minus none, per backend and pooled. Orange: the no-memory arm against itself. Dashed: the minimal detectable effect.

The six discordant pairs of the 48 look like noise (post-hoc, descriptive). The no-memory arm solved all 5 of its run-1 losses in its own run 2. The one task it won, requests_7328, was a recap run caught in the submit_patch loop (§ 3.4).

Extension. On 50 new tasks the estimate reversed: memory resolved 18 and no memory 23, with 6 tasks solved only without memory and 1 only with it. The interval includes 0 and the exact McNemar pp is 0.125, so this is not significant by the registered test either. (Descriptive, not registered: in the extension, run 1 hit a context overflow in 12 of 50 no-memory runs and 14 of 50 memory runs, and 13 memory runs were flagged plumbing_failed. We make no claim about the cause.) Neither estimate exceeds the minimal detectable effect (about 18 points for 48 pairs, 17 for 50), and we registered no test of heterogeneity between sets, so the first result is not a stable finding. The combined estimate is −1.0 point [−8.3, +6.3]. It is secondary, pools backends and makes no confirmatory claim. We read it as no evidence of an effect in either direction. Its 95% interval excludes harms larger than about 8 points and gains larger than about 6; the design had 80% power only for effects of about 12 points or more.

Key secondary: repeated actions per compaction (registered)

The registered pooled statistic is null, and its 10% trimmed mean is −1.17 (Table 3). The per-backend values are descriptive, since the registration is pooled, and each is driven by submit_patch loops (§ 3.4). Modal’s +8.54 comes from two looping recap runs. Kaggle’s −4.45 includes one looping no-memory run, and it shrinks to −2.26 once post-submit submits are removed.

stratumdifference [95% CI]Wilcoxon pp, nn
registeredpooled+0.30 [−4.50, +5.98]0.27, 41
Modal+8.54 [−0.74, +22.48]0.28, 15
Kaggle−4.45 [−9.34, −1.22]0.019, 26
post-hoc: post-submit submits removedpooled−1.35 [−2.46, −0.33]0.23, 41
Modal+0.21 [−1.15, +1.39]0.25, 15
Kaggle−2.26 [−3.81, −0.84]0.029, 26

Table 3. Repeats per compaction, recap − none: paired mean difference [bootstrap 95% CI], Wilcoxon pp, and tasks with a rate in both arms.

Post-hoc denominator checks (exploratory). A per-compaction rate can fall simply because compactions rise. We therefore also looked at raw repeats per task, repeats per tool call after the first compaction, and compactions per task. These checks belong to the 23 post-hoc tests (Appendix § 7). Only single-stratum tests fell below 0.05: the Kaggle repeat rate with post-submit submits removed (pp 0.029), Kaggle repeats per call (0.021 registered steps, 0.042 without post-submit submits), Modal compactions per task (0.032), and the Modal discovery of H-b (0.0088). None survives a Bonferroni correction over the 23, and no pooled test reached 0.05. Pooled raw repeats per task did not fall (both post-hoc): +8.1 [−18.0, +35.9], pp 0.54 at the registered steps, inflated by the loops, and −0.98 [−3.17, +1.02], pp 0.53 with post-submit submits removed. The pooled post-hoc rate has a bootstrap interval that excludes 0, but its rank test does not reach 0.05 (pp 0.23). We do not call any of these results significant. A “memory reduces repeated actions” claim is not supported.

Replication of two Modal hypotheses (pre-registered)

H-a: recap has more compactions before the first successful submit. H-b: recap has more runs that leak raw <|channel> thought text into the coder’s output. Both were discovered on Modal and frozen as code before any Kaggle recap result was read.

Modal (discovery, post-hoc there)Kaggle (replication)
H-a, tasks recap more / fewer / equal8 / 2 / 6, one-sided pp 0.05917 / 11 / 4, pp 0.16
H-b, runs with leaked thought, recap / none6 / 0 of 16, Fisher pp 0.00885 / 5 of 32, pp 0.63

Table 4. Neither hypothesis replicated.

The H-b base rate differs by backend, and we recorded this before the replication. Kaggle’s no-memory arm already leaked in 5 and 3 of 32 runs, against 0 of 16 on Modal. A different serving stack is the likeliest explanation for Modal’s 6/0. Memory is not.

Mechanism (first 48 tasks)

Adherence. The model almost never writes memory (Figure 2). Two of 16 Modal runs wrote any note (2 notes in all), and 4 of 32 Kaggle runs did (5 notes). In the six smoke runs it wrote none. All 11 plumbing_failed runs on Modal were adherence failures, not machinery failures: 4 never ran the first recall, and 7 had nothing to inject at a compaction. Renor’s product telemetry, which is internal and not independently published, shows the same pattern: agents ask for memory on about 1 in 24 prompts unless recall is automatic. Memory that depends on the agent’s cooperation largely does not happen.

Figure 2. Adherence and delivery, recap arm, run 1.

Delivery. Even automatic injection needs the agent to have produced something. On Modal, something was injected at 21 of 45 compactions (47%); on Kaggle, at 50 of 77 (65%). The mean share per compacted run was 38% and 70%. Before a run’s first explorer call, nothing can be injected.

The context cost of memory. The memory section, the skill and the notes tool add about 2,000 tokens to every request. The median first coder request was 3,966 tokens against 2,311 (Modal). The recap arm therefore reaches the compaction trigger sooner and restarts larger. The trigger reads the previous call’s prompt size, so one large step can push the input past 16,384 tokens, where 16,384 output tokens meet the 32,768-token limit, before compaction runs. Table 5 gives the per-arm counts. Compactions rose from 23 to 45 on Modal (post-hoc, per task +1.38 [+0.31, +2.69]) and from 71 to 77 on Kaggle. Kaggle overflows were 7 against 5 (3 against 2 before any compaction); Modal overflows were 0 against 1.

Modal noneModal recapKaggle noneKaggle recap
runs16163232
resolved11121417
compactions23457177
context overflows (before first compaction)1 (1)0 (0)5 (2)7 (3)
tool-call cap hits1120
submit_patch loops0210
notes written (runs with a note)–2 (2)–5 (4)

Table 5. Descriptive counts, run 1, per backend and arm.

A treatment harm: the submit_patch loop. In 2 of 16 Modal recap runs, submit_patch returned ok, but the agent then called it 441 and 385 more times with the same patch, until the 500-turn limit. The harness ends a run only on a response with visible text and no tool call. No Modal no-memory run passed 120 model calls. The loops do not change the resolve outcome, but they waste the budget and account for 879 of the recap arm’s run-1 Modal repeats. Kaggle had one loop, and it was in the no-memory arm, so the loop is not specific to memory.

Related work

Experience memory stores lessons across tasks: Reflexion [16], ExpeL [Zhao et al., 2023], Agent Workflow Memory [19], ReasoningBank [12], Dynamic Cheatsheet [17] and, for coding, SWE-Exp [2], subtask-level memory [15] and Agent KB [18]. VibeMemBench [5] evaluates memory systems for coding agents on real repositories, and 11 of 12 pairings did not beat memory-off; our result fits that pattern, for in-task memory and a smaller model. Context management treats the window as a resource: MemGPT [13] pages memory like virtual memory, and SWE-MeM [6] learns in-episode compression with reinforcement learning. Our arm is untrained and needs no cooperation from the agent for the explorer channel. Conversational memory systems [14, 9] (Chhikar et al. 2025) and their benchmarks [20] target dialogue rather than code. Structure without memory, such as Code Isn’t Memory [1], RepoGraph [11], CodexGraph [10] and LocAgent [3], is already partly in the harness through its code-graph tool. Agent scaffolds [Yang et al., 2024, Xia et al., 2024] are the kind of base agent memory sits on. We cite no benchmark number as comparable to this harness.

Threats to validity

  • Backend is confounded with repository. Seeded round-robin plus every-third-task allocation sent all 9 requests tasks to Modal (Modal: requests 9, rich 4, fastapi 3; Kaggle: fastapi 16, rich 15, httpx 1). Pairing within a task keeps each difference valid, but no per-backend or per-repository effect can be claimed.

  • Run noise, one model. Only run 1 is primary. The extension has one run per arm, and recap run 2 exists only on Kaggle. Pre-registered replicate runs of every task (Phase R) are reported separately. The extension was decided after the 48-pair result and runs on a different backend (fastapi 26, rich 24 tasks). All results are for Gemma 4 31B QAT.

  • Valid-set skew. 105 of 129 tasks were valid. The excluded tasks are mostly fastapi tasks that error on their base commit.

  • Sandbox. Agents ran under the subprocess sandbox with our scorer-like environment, not the official Docker scorer.

  • Not the Renor product. Renor’s retrieval, graph and cross-session memory were not tested.

  • No embeddings, no misleading-memory control (it was dropped under the $25 Modal cap), and a modest ceiling: no memory resolved 23 of 32 Modal runs.

Conclusion and future work

Automatically carrying the explorer’s last finding across compaction did not measurably change how often Gemma 4 31B resolved tasks. The first 48 pairs favored memory by 8.3 points, 50 new pairs favored no memory by 10.0, and the combined 98 differ by −1.0. The combined 95% interval excludes harms larger than about 8 points and gains larger than about 6, and the design had 80% power only for effects of about 12 points or more. Its clearest lessons are about the mechanism and the measurement. Small models do not write memory unless memory writes itself. Memory costs context, which in turn causes more compactions. With 19% of tasks flipping between identical runs, a single-run memory comparison on a few dozen tasks cannot tell a real effect from noise.

Two changes come next. The first is a recap that the harness builds from the tool history, so it needs no cooperation from the agent and is present at every compaction. The second, for the main competition, is a guard that ends a run after the first successful submit_patch, in every arm.

Reproducibility. results/run_rows.jsonl holds one row per run, with outcomes and measures only. python results/analyze_rows.py regenerates every number. The notebook redraws both figures. paper/check_numbers.py checks each number in the Writeup against the analysis output, the rows and the change log. Code, data and the commit history of the pre-registration: https://github.com/renorai/gemma4-memory-study.

AI assistance. AI coding agents (Anthropic Claude and OpenAI Codex) helped the author implement and run the experiments, write the analysis code and draft this text. The author directed the work, reviewed the manuscript and takes full responsibility for its contents.

All post-hoc tests

All 23 are computed by results/analyze_rows.py. The Modal worker’s own H-a counter (9/2/5, two-sided pp 0.061) tested the same hypothesis on the same traces as test 22 (8/2/6 by the frozen detector) and is not counted separately. Also not counted: the primary, the registered repeat rate, the Kaggle replications of H-a and H-b, and the A/A calibration. All Wilcoxon tests are recap − none, paired by task.

#teststratumpp
1–3repeat rate, post-submit submits removedpooled / Modal / Kaggle0.233 / 0.251 / 0.029
4–6(a) raw repeats per task, registered stepspooled / Modal / Kaggle0.542 / 0.236 / 0.108
7–9(a) raw repeats per task, no post-submit submitspooled / Modal / Kaggle0.526 / 0.157 / 0.109
10–12(b) repeats per call after compaction, registered stepspooled / Modal / Kaggle0.060 / 1.000 / 0.021
13–15(b) the same, no post-submit submitspooled / Modal / Kaggle0.135 / 0.922 / 0.042
16–18(c) compactions per taskpooled / Modal / Kaggle0.090 / 0.032 / 0.548
19–21per-protocol repeat rate, post-hoc variantpooled / Modal / Kaggle0.712 / 0.625 / 0.391
22H-a one-sided Wilcoxon (Modal discovery)Modal0.059
23H-b one-sided Fisher (Modal discovery)Modal0.0088

Table 6.

References

  1. [1]Ishaan Bhola et al. Code Isn’t Memory: A Structural Codebase Index Inside a Coding Agent. arXiv preprint arXiv:2606.23417, 2026.
  2. [2]Silin Chen et al. SWE-Exp: Experience-Driven Software Issue Resolution. arXiv preprint arXiv:2507.23361, 2025a.arxiv.org/abs/2507.23361
  3. [3]Zhaoling Chen et al. LocAgent: Graph-Guided LLM Agents for Code Localization. arXiv preprint arXiv:2503.09089, 2025b.arxiv.org/abs/2503.09089
  4. [5]Liyang Fan et al. VibeMemBench: Evaluating Memory Systems for Coding Agents on Real Repository Coding Tasks. arXiv preprint arXiv:2609.23570, 2026.arxiv.org/abs/2609.23570
  5. [6]Shuzheng Gao et al. SWE-MeM: Learning Adaptive Memory Management for Long-Horizon Coding Agents. arXiv preprint arXiv:2606.28434, 2026.arxiv.org/abs/2606.28434
  6. [7]Carlos E. Jimenez, John Yang, Alexander Wettig, et al. SWE-bench: Can Language Models Resolve Real-World GitHub Issues? arXiv preprint arXiv:2310.06770, 2023.arxiv.org/abs/2310.06770
  7. [9]Chris Latimer et al. Hindsight is 20/20: Building Agent Memory that Retains, Recalls, and Reflects. arXiv preprint arXiv:2512.12818, 2025.arxiv.org/abs/2512.12818
  8. [10]Xiangyan Liu et al. CodexGraph: Bridging Large Language Models and Code Repositories via Code Graph Databases. arXiv preprint arXiv:2408.03910, 2024.arxiv.org/abs/2408.03910
  9. [11]Siru Ouyang et al. RepoGraph: Enhancing AI Software Engineering with Repository-level Code Graph. arXiv preprint arXiv:2410.14684, 2024.arxiv.org/abs/2410.14684
  10. [12]Siru Ouyang et al. ReasoningBank: Scaling Agent Self-Evolving with Reasoning Memory. arXiv preprint arXiv:2509.25140, 2025.arxiv.org/abs/2509.25140
  11. [13]Charles Packer et al. MemGPT: Towards LLMs as Operating Systems. arXiv preprint arXiv:2310.08560, 2023.arxiv.org/abs/2310.08560
  12. [14]Preston Rasmussen et al. Zep: A Temporal Knowledge Graph Architecture for Agent Memory. arXiv preprint arXiv:2501.13956, 2025.arxiv.org/abs/2501.13956
  13. [15]Kangning Shen et al. Structurally Aligned Subtask-Level Memory for Software Engineering Agents. arXiv preprint arXiv:2602.21611, 2026.arxiv.org/abs/2602.21611
  14. [16]Noah Shinn et al. Reflexion: Language Agents with Verbal Reinforcement Learning. arXiv preprint arXiv:2303.11366, 2023.arxiv.org/abs/2303.11366
  15. [17]Mirac Suzgun et al. Dynamic Cheatsheet: Test-Time Learning with Adaptive Memory. arXiv preprint arXiv:2504.07952, 2025.arxiv.org/abs/2504.07952
  16. [18]Xiangru Tang et al. Agent KB: Leveraging Cross-Domain Experience for Agentic Problem Solving. arXiv preprint arXiv:2507.06229, 2025.arxiv.org/abs/2507.06229
  17. [19]Zora Zhiruo Wang et al. Agent Workflow Memory. arXiv preprint arXiv:2409.07429, 2024.arxiv.org/abs/2409.07429
  18. [20]Di Wu et al. LongMemEval: Benchmarking Chat Assistants on Long-Term Interactive Memory. arXiv preprint arXiv:2410.10813, 2024.arxiv.org/abs/2410.10813

Paper details

vlnc:W_u8pxusrb
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 7

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents