acceptodds
Under review as a conference paper at ICLR 2027

AFS: Towards an Agent-Native File System

Abstract

AI agents increasingly operate in file-rich workspaces that extend beyond a single context window. However, conventional file system interfaces are designed for humans, whose way of perceiving and navigating files differs fundamentally from that of LLMs. This mismatch severely limits the efficiency and speed of agent file access. We introduce AFS, an agent-native file system with three complementary designs. First, it uses offline preprocessing to organize files into identifiable source spans and builds reusable per-file key–value (KV) caches. Second, several parallel File Agents use continuous batching to inspect multiple files efficiently through shared model forward passes. Third, AFS decouples file inspection from reasoning, allowing File Agents to continue searching while the Main Agent reasons and to deliver selected original evidence, rather than entire files, to the Main Agent’s context. Together, these designs broaden file inspection without repeatedly requiring a new Main Agent decision or loading the full contents of every inspected file. Across Qwen3.5-9B and Qwen3.6-27B on LoCoMo, HotpotQA, and 2WikiMultiHopQA, AFS achieves the highest mean F1 score while admitting 77–88% less unique source text into the Main Agent’s context than Dynamic RAG. On 2WikiMultiHopQA with the 9B model, AFS improves F1 from 0.661 to 0.795 over Dynamic RAG while reducing mean online latency by 33.3%.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM Agent, Agent Harness, RAG

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_qHUQOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes AFS, an agent-native file system designed to improve file access efficiency for LLM agents. The framework uses a Main Agent for reasoning and multiple parallel File Agents for retrieving relevant evidence from files. It combines reusable per-file KV caches, continuous batching, and asynchronous evidence retrieval to reduce repeated computation and the amount of context passed to the Main Agent.

Critical strengths
  1. The use of a fixed file prefix allows the system to reuse KV caches across different queries, reducing repeated prefill computation and improving file inspection efficiency.

  2. The span selection mechanism substantially reduces the amount of evidence passed to the Main Agent. The ablation results show improvements in answer accuracy while using significantly fewer evidence tokens compared to full-file loading.

Critical weaknesses
  1. The baseline comparisons are not entirely convincing. AFS essentially uses a main agent and multiple parallel file agents for evidence retrieval, but the existing baselines are mainly based on sequential retrieval or conventional search tools. A more meaningful comparison would be against a standard multi-agent framework where a main agent delegates file inspection to multiple subagents in parallel. Without such a baseline, it is difficult to tell how much of the improvement comes from the proposed AFS design and how much simply comes from parallelizing the retrieval process.

  2. The methods explore substantially different numbers of files. For example, on LoCoMo, AFS inspects 27.78 files per question, compared to only 4.77 for Dynamic RAG and 14.37 for Grep-based Harness. This raises the question of whether the performance gains come from more effective evidence retrieval or simply from exploring more files. While the paper reports lower online latency, inspecting more files may also introduce additional computational costs. It would be helpful to compare these methods under similar file exploration or computational budgets to better understand the actual effectiveness and efficiency of AFS.

  3. The evaluation is limited to three QA benchmarks: LoCoMo, HotpotQA, and 2WikiMultiHopQA. While these benchmarks test evidence retrieval across documents, they do not fully reflect realistic file-intensive agent workflows. For example, it would be useful to evaluate AFS on code repositories, where agents need to navigate complex file structures and files may be frequently modified during execution. In such dynamic environments, it is unclear whether the proposed approach can still maintain its advantages, especially since its KV cache reuse relies on preprocessed file contents.

  4. It is unclear whether AFS can really be considered an agent-native file system. The proposed method mainly uses multiple file agents to retrieve relevant passages, together with existing techniques such as KV caching and continuous batching. This seems closer to a multi-agent retrieval framework than a general file system.

Questions for authors

How is the granularity of source spans determined? The paper does not clearly specify how files are divided into spans or how much surrounding context is included. Have the authors examined how different span sizes affect evidence recall, final answer quality, and retrieval efficiency?

5 comments
AuthorsOpenReview ↗

Author Rebuttal [Part 1]

Thank you for the constructive review and for recognizing the benefits of file prefix reuse and selection that preserves the original source.

W1. How does AFS compare with standard parallel subagents using the same reader?

A1. Thank you for the suggestion. We added a baseline in which the Main Agent delegates file inspection to parallel subagents. It uses Qwen3.5-9B on the same H200 service as AFS and receives the same questions, prompts, routing summaries, cache preparation, worker limit, and final answering procedure.

The subagents use the same file reader as AFS. They return the same kinds of source addresses, which are expanded into original text using the same rules. The Main Agent selects a batch of file requests and waits for that batch to complete. In AFS, the inspection queue replenishes independently while the Main Agent reasons and can request further focused reads.

Table 1. AFS and parallel subagents with matched readers on the same 20 questions per dataset.

DatasetParallel subagentsAFS
LoCoMo0.30370.3706
HotpotQA0.62150.7143
2WikiMultiHopQA0.66670.7417
All 60 questions0.53060.6088

W2. What does AFS gain when file exploration or compute budgets are comparable?

A2. Thank you for the comment. Table 5 in the paper fixes the inspected files, focused requests, and final decoder. It changes only the evidence delivered to the Main Agent.

Reviewer Qc7g calls this "a useful controlled result" and states that it "supports selective delivery of original evidence." We agree with the reviewer's qualification that this experiment alone does not validate the complete architecture. It tests evidence selection with exploration held fixed.

Table 2. Evidence selection with identical file inspection on 100 LoCoMo questions.

Evidence delivered to the Main AgentSource tokensAnnotated evidence recallAnswer F1
Complete inspected files27,6901.0000.323
Dense-retrieved spans8060.5100.383
Original records selected by File Agents8920.9170.411

At similar text budgets, File Agent selection retains more annotated evidence than dense span selection. Recall is 0.917 compared with 0.510, and F1 is 0.411 compared with 0.383. Relative to complete files, it reduces delivered source text by 96.8% and improves F1. On the 73 questions with evidence annotations, F1 is 0.276 for File Agent selection, 0.209 for dense spans, and 0.237 for complete files.

W3. How might AFS’s read design carry over to code repositories where files change during a task?

A3. Thank you for the suggestion. This paper focuses on file reading and evidence acquisition. Evaluating code repositories requires suitable tasks for repository navigation and validation of the final result. We plan to explore this setting in future work. We have clarified this scope in the “Limitations and Future Work” paragraph of Section 6 (Conclusion). The revision specifies that our evaluation covers file reading and evidence acquisition over static corpora and describes what a code repository evaluation would require.

AuthorsOpenReview ↗

Author Rebuttal [Part 2]

W4. What makes AFS an agent-native read design beyond parallel retrieval?

A4. Thank you for your comments. We use "agent native" to describe file access organized around model computation. AFS makes each file independently inspectable and reusable, while the Main Agent maintains its global reasoning history.

A read takes a file identity and an information request and returns source addresses. The runtime resolves these addresses into original text with provenance. Later requests can reuse the fixed file prefix without placing the file after the Main Agent's accumulated history.

Reviewer Qc7g recognizes that "The serving and access mechanisms are concrete." Reviewer bbij also values retrieving "the original text with its source locations" instead of generating summaries. These comments concern the file reading design that we evaluate.

Table 3. File reading mechanisms and their controlled measurements.

DesignComputational purposeSupporting evidence
Fixed file prefix before the changing requestReuse file input computation independently of the Main Agent's history while residentMean time to first token is 919.7 milliseconds cold and 297.7 milliseconds warm
Lightweight File Agents on a shared continuously batched serviceExecute independent local inspections concurrentlyInspection throughput increases from 2.64 to 4.27 calls per second with one and three workers
Source addresses resolved to original recordsAvoid regenerating long passages and limit unnecessary source deliveryDelivered source text falls from 27,690 to 892 tokens. Recall is 0.917, and F1 increases from 0.323 to 0.411.

Retrieval discovers candidate sources. AFS also specifies how a located file is inspected, how its computation is reused, and how original evidence reaches the reasoner while inspection continues. It uses existing cache and batching mechanisms to execute this design. The current implementation covers reading; writes and operating system semantics remain outside the evaluated scope.

Q1. “How is the granularity of source spans determined? The paper does not clearly specify how files are divided into spans or how much surrounding context is included. Have the authors examined how different span sizes affect evidence recall, final answer quality, and retrieval efficiency?”

QA1. Thank you for the question. Each source span is a nonoverlapping group of four lines, with a shorter final group when needed. A File Agent can select multiple spans, including spans that are not adjacent. Four lines therefore defines an addressable unit, not the maximum evidence length.

The resolver returns original text and its locations using the declared expansion rules. LoCoMo includes bounded neighboring context for image sharing records.

Table 4. Span size sensitivity on the same 20 LoCoMo questions.

Lines per anchorAnswer F1Annotated interval recallOriginal source tokens delivered to Main Agent
20.30110.5714860
40.37060.61901,377
80.39110.61902,104
160.38830.61902,744

We hope these component experiments and the parallel baseline address different parts of the attribution question.

AuthorsOpenReview ↗

Gentle Reminder

Dear Reviewer qHUQ,

Thank you for your response and for your positive assessment of our work. We have incorporated your feedback into the revised manuscript, and we will continue to improve the paper with respect to your remaining concerns. Please let us know if you have further concerns.

Authors

Reviewer_Qc7gOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces AFS, a file access architecture for language model agents. AFS preprocesses static files into addressable spans, embeddings, and reusable per-file KV caches. During inference, several File Agents inspect different files through continuous batching while a Main Agent reasons over selected original evidence. File Agents return span identifiers rather than regenerated text, and newly selected evidence is delivered to the Main Agent through asynchronous updates. The evaluation uses Qwen3.5 9B and Qwen3.6 27B on a 20 percent subset of LoCoMo and the LongBench versions of HotpotQA and 2WikiMultiHopQA. AFS generally obtains higher F1 than one-shot retrieval, sequential reading, Dynamic RAG, and a grep based harness. It also exposes less source text to the Main Agent. Additional experiments examine KV reuse, File Agent concurrency, evidence coverage, and span selection.

Critical strengths
  1. The serving and access mechanisms are concrete. Per-file KV reuse reduces mean TTFT from 919.7 to 297.7 milliseconds in Table 3. File Agent execution overlaps Main Agent execution for 4.13 of its 4.19 active seconds per question. Table 4 also reports the saturation point honestly. Increasing File Agent concurrency from three to seven changes throughput only from 4.27 to 4.31 calls per second while increasing median decode latency from 180 to 525 milliseconds.

  2. Table 5 provides a useful controlled result. With the inspected files, focused requests, and final decoder fixed, span selection retains 0.917 gold recall while reducing evidence from 27,690 to 892 tokens per question. F1 rises from 0.323 to 0.411. This supports selective delivery of original evidence, although it does not by itself validate the complete AFS architecture.

Critical weaknesses
  1. The main comparisons are not sufficiently controlled, and the reported efficiency excludes a large part of the system cost. AFS receives much more detailed instructions than the baselines. Its LoCoMo prompt contains provenance rules, relation checking guidance, a mandatory initial routing action, and an 80 word limit on intermediate thinking. The baseline prompts do not receive equivalent guidance. On 2WikiMultiHopQA, AFS also receives a specialized final response contract. On HotpotQA, AFS can pass a candidate answer from evidence acquisition into final decoding, while the baseline answer payload is explicitly discarded.

The available routing information is also different. Sequential Read receives opaque file identifiers and limited metadata. AFS appears to receive manifest summaries, although it is instructed not to answer directly from them. These differences can affect both F1 and latency. The evidence metric counts only source text visible to the Main Agent. It excludes the full files processed by File Agents. On LoCoMo, AFS inspects 27.78 files per question. Table 5 indicates that the inspected files contain about 27,690 tokens, which File Agents still process. Offline KV construction, cache memory, cache misses, embeddings, and manifest generation are excluded from online latency. The paper reports neither cache residency requirements nor cold-cache performance. The claimed 77 to 88 percent token reduction therefore does not represent total model computation.

  1. The contribution is not clearly positioned against either memory systems or semantic file systems. LoCoMo is widely used to evaluate Mem0, A-MEM, MemGPT, Zep, and related memory systems. AFS also describes its input as saved conversation and memory records. Yet none of these systems appears in the comparison, and only 20 percent of LoCoMo is evaluated. Without these baselines, it is unclear whether AFS improves memory access beyond established memory pipelines or only improves over the authors' retrieval harnesses. The distinction from LSFS is also underdeveloped. LSFS supports semantic indexing, retrieval, file operations, rollback, and sharing. AFS provides a read only evidence access and inference runtime. A direct retrieval comparison would clarify whether AFS improves semantic file access. If such a comparison is outside scope, the paper should avoid presenting AFS as a general file system. The experiments do not test writing, updates, permissions, cache invalidation, file consistency, or mixed file types. They also use only two models from one family and static question answering corpora that appear to fit within the configured 262,144 token context. A full-context baseline is therefore necessary. Current evidence does not show that AFS scales to a workspace containing thousands of files or to data exceeding the context window.
Questions for authors
  1. Can the authors rerun Table 1 with matched prompts, routing metadata, thinking limits, and final answer handoffs? In particular, can the baselines receive the same Main Agent reasoning rules and can AFS be tested with the shorter baseline prompts?

  2. What is the total system cost per question after including File Agent prefill and decoding, embedding computation, offline KV construction, cache memory, and cache misses? Please report cold-cache latency, warm-cache latency, GPU seconds, total processed tokens, peak memory, and throughput under concurrent user queries.

  3. Why are Mem0, A-MEM, MemGPT, Zep, ReadAgent, and LSFS absent from the main comparison? Can the authors evaluate full LoCoMo by question category with a full-context baseline, representative memory systems, and an LSFS semantic retrieval configuration connected to the same final decoder?

  4. Can the authors provide end-to-end ablations that remove asynchronous execution, prebuilt KV caches, initial ranking, and span selection separately? A synchronous subagent baseline with the same File Agent prompt would help determine whether the gains come from evidence filtering or from the serving architecture.

3 comments
AuthorsOpenReview ↗

Author Rebuttal [Part 1]

Thank you for your careful review and for recognizing the concrete serving mechanisms and the controlled evidence selection result.

W1. Do AFS’s gains hold with matched instructions and settings, and with a shorter AFS prompt?

A1. Thank you for your comments. We ran both requested controls. The baselines receive the same Main Agent reasoning instructions and routing metadata. We also evaluated AFS with the shorter acquisition prompt used by the baselines.

All conditions use the same local Qwen3.5-9B service and the same 20 questions from each dataset. Main Agent thinking and sampling settings are matched. The final answering instructions are also shared, and the answer proposed during evidence acquisition is excluded from final decoding.

Table 1. Results with common instructions and with the shorter AFS acquisition prompt.

MethodLoCoMoHotpotQA2WikiMultiHopQA
One-shot RAG, one retrieved item0.46240.15000.0833
One-shot RAG, four retrieved items0.56620.59070.4670
Sequential Read0.43110.69480.5853
Dynamic RAG0.48710.68650.6245
Grep-based Harness0.42140.62760.5585
AFS with common acquisition instructions0.50690.72060.6300
AFS with shorter acquisition instructions0.54660.69500.6196

The prompt changes preserve favorable AFS results in this sample. On LoCoMo, AFS scores 0.5069 with the common instructions and 0.5466 with the shorter guide. Its LoCoMo result therefore does not depend on the longer acquisition guide. The effect of the prompt varies across datasets.

Table 5 in the paper provides a separate control for evidence selection. With the inspected files, focused requests, and final decoder fixed, selected original evidence yields 0.411 F1, compared with 0.323 when complete files are delivered. Annotated evidence recall is 0.917. This experiment tests the selection mechanism, while the prompt experiment addresses the fairness of the task comparison.

W2. What are the full system costs, including preparation, model compute, and cache memory, under cold, warm, and concurrent access?

A2. Thank you for the question. Table 2 separates cache preparation from the recorded online stages. The cost of preparing an unchanged workspace is allocated across its evaluated questions.

Table 2. Cache preparation.

ModelDatasetQuestionsWorkspacesCache preparation per questionOnline stages plus cache preparation
Qwen3.5-9BLoCoMo397100.16025.29
Qwen3.5-9BHotpotQA2002002.75826.59
Qwen3.5-9B2WikiMultiHopQA2002002.76921.33
Qwen3.6-27BLoCoMo397100.22150.97
Qwen3.6-27BHotpotQA2002004.50335.47
Qwen3.6-27B2WikiMultiHopQA2002005.33431.39

We also measured cache behavior on 260 paired inspections. Mean time to first token is 919.7 milliseconds with a cold prefix and 297.7 milliseconds with a reused prefix. Batch wall time falls from 35.54 to 12.38 seconds. The separate prefix construction takes 36.96 seconds. A cache pressure experiment also tests eviction and refill. The H200 generation cache pool is 103.67 GiB. Sampling every five seconds records a maximum simultaneous footprint of 137.54 GiB for the owned generation and embedding processes, including weights and reserved pools.

AuthorsOpenReview ↗

Author Rebuttal [Part 2]

W3. How does AFS differ from memory and semantic file systems, and what would a matched comparison on full-context baseline?

A3. Thank you for your comments. AFS studies how agents read files using reusable model computation. Fixed instructions and source text precede the changing information request, so file inspection can reuse its prefix independently of the Main Agent's history. Lightweight File Agents inspect files on a shared batched service and return source addresses. The Main Agent reasons across the resolved originals while further inspections continue.

The other reviews recognize these properties. Reviewer bbij describes selection that preserves the original source as "a useful design choice." Reviewer qHUQ notes that the fixed prefix allows the system to "reuse KV caches across different queries." These observations identify the reading mechanism that we position alongside memory systems and semantic file systems.

Mem0, A-MEM, MemGPT, and Zep address what agents should retain across interactions and how to make that information available again. ReadAgent uses gists to guide access to original passages, and LSFS exposes semantic operations over files. We study a related question that arises once the source files already exist. How much model computation can be reused across different requests to the same file, and how many files can the agent inspect while reasoning continues? Our controlled experiments measure prefix reuse, inspection throughput, and the effect of delivering selected original text to the Main Agent. We briefly explain this distinction in Section 5 (Related Work). The “Limitations and Future Work” paragraph in Section 6. Please check our new manuscript.

We also include a full-context baseline using 9B model on the same questions with common prompts and final answering instructions.

Table 3. AFS and full context answering with common prompts.

DatasetAFSFull context
LoCoMo0.50690.4371
HotpotQA0.72060.6694
2WikiMultiHopQA0.63000.5646

Q1. “Can the authors provide end-to-end ablations that remove asynchronous execution, prebuilt KV caches, initial ranking, and span selection separately? A synchronous subagent baseline with the same File Agent prompt would help determine whether the gains come from evidence filtering or from the serving architecture.”

QA1. Thank you for the suggestion. We added a parallel subagent baseline with the same reading configuration as AFS. We also re-report separate controls for evidence selection, prefix reuse, and inspection concurrency.

Table 4. Evidence selection with the same inspected files, requests, and final decoder.

Evidence delivered to the Main AgentSource tokensAnnotated evidence recallAnswer F1
Complete inspected files27,6901.0000.323
Dense-retrieved spans8060.5100.383
Original records selected by File Agents8920.9170.411

Selecting original records reduces delivered source text by 96.8% relative to complete files while improving answer F1. Because file inspection is fixed, this result isolates the effect of the evidence supplied to the Main Agent.

Table 5. Prefix construction takes a separate 36.96 seconds.

Cache conditionMean time to first token, millisecondsBatch wall time, seconds
Cold prefix919.735.54
Reused prefix297.712.38

The reused prefix reduces inspection startup time while the cache remains resident.

Table 6. Inspection throughput with a fixed request panel. Each worker count is evaluated over three cycles.

File Agent workersCompleted inspections per secondAnnotated evidence recall
12.640.906
34.270.906
74.310.910

Throughput increases from one to three workers and then largely saturates. Adding more File Agents therefore has a measured limit.

For the task comparison, the parallel baseline shares AFS's Main Agent and File Agent prompts, routing summaries, original text expansion, cache preparation, worker limit, and final answer handoff. Its Main Agent delegates a batch and waits for it to finish. AFS replenishes the inspection queue while reasoning continues.

Table 7. AFS and parallel subagents with matched readers on the same 20 questions per dataset.

DatasetParallel subagentsAFS
LoCoMo0.30370.3706
HotpotQA0.62150.7143
2WikiMultiHopQA0.66670.7417
All 60 questions0.53060.6088

AFS has higher F1 point estimates in these three samples. This comparison changes delegation and queue progression together and shows the associated quality.

We hope these component experiments and the parallel baseline address different parts of the attribution question.

AuthorsOpenReview ↗

Gentle Reminder

Dear Reviewer Qc7g,

Thank you for your positive feedback and for reconsidering our work. Your comment has helped us make our paper clearer. Please let us know if you have further concerns.

Authors

Reviewer_bbijOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents AFS, an agent-native file system that separates file inspection from the Main Agent's reasoning. It combines reusable per-file KV caches, continuously batched File Agents, and asynchronous evidence delivery to improve file access efficiency. Experiments on three QA benchmarks with two Qwen models show that AFS generally achieves higher F1 scores and lower online latency while reducing the amount of evidence passed to the Main Agent.

Critical strengths
  1. The experimental results show improvements in answer quality and online latency across multiple settings, and the additional analyses help explain the benefits of the individual mechanisms.
  2. The source-preserving evidence selection is a useful design choice. Instead of having File Agents summarize the retrieved content, AFS uses span IDs to retrieve the original text with its source locations. This avoids potential information loss from LLM-generated summaries while reducing the amount of text passed to the Main Agent.
Critical weaknesses
  1. The reported end-to-end latency does not include the time spent building per-file KV caches. This matters because the upfront cost only pays off if the same files are reused across enough queries. The paper does not show whether this kind of reuse is common in its target agent file access workloads, especially since some benchmark questions (e.g., LongBench HotpotQA and 2WikiMultiHopQA) come with their own per-question document contexts. As a result, it is hard to tell whether AFS actually reduces total latency or simply moves part of the computation offline.
  2. The evaluation does not fully reflect the file-rich workspaces that motivate AFS. In real-world agent workspaces, there may be hundreds or thousands of files, most of which are unrelated to the task at hand. The paper does not provide sufficient evidence that AFS can maintain a significant advantage over the baselines in terms of answer quality and end-to-end latency in such settings.
  3. Although AFS is framed as an "agent-native file system" and motivated by coding agents (e.g., Claude Code, Codex), it operates as a strictly static, read-only retrieval and inference runtime. Unlike OS-level agent file systems such as YoloFS—which address stateful file system semantics including write staging, copy-on-write snapshots/rollback, and access control—AFS does not handle file mutations. In real agentic workflows, agents frequently edit, create, or delete files mid-task. Any modification to a file ff alters Mark(f)\text{Mark}(f) and immediately invalidates its precomputed span index SfS_f, dense embedding efe_f, and per-file KV cache Kf=KVθ(Pf)K_f = \text{KV}_\theta(P_f), reintroducing online prefill overhead. Moreover, the paper assumes per-file KV caches remain resident in memory without reporting their GPU HBM / host memory footprint or evaluating cache eviction and offloading overheads when a workspace exceeds GPU memory capacity.
  4. AFS reduces single-query wall-clock latency by running up to seven parallel File Agents continuously in the background while the Main Agent reasons. Because File Agents speculatively inspect queued files without waiting for the Main Agent's decisions, AFS executes substantially more total model forward passes and token operations per query than the serial baselines. The evaluation measures single-query latency on a dedicated NVIDIA H200 GPU, where idle compute and memory bandwidth can absorb seven background workers. In a realistic multi-query or multi-user serving environment, spawning up to B=8B=8 concurrent requests per query would saturate continuous batching slots and KV-cache capacity, likely degrading aggregate system throughput and increasing queuing delays.
  5. During asynchronous background inspection of the initial queue Q0Q_0, each File Agent inspects a single file in isolation conditioned only on the original question qq (Xf,q,r=Pf⊕[q;r]X_{f,q,r} = P_f \oplus [q; r]) and with model thinking disabled. In multi-hop tasks or code navigation, recognizing that a span in file fBf_B is relevant often requires knowing an intermediate bridge entity, function signature, or state discovered in another file fAf_A. If a File Agent inspects fBf_B before the Main Agent has identified that bridge entity, it may fail to select the needed spans (false negatives), either losing critical evidence or forcing redundant re-inspections of the same file in later turns.
Questions for authors
  1. How much time is spent building the per-file KV caches, and how often are these caches reused across queries in the evaluated workloads? Are the reported online latency savings sufficient to offset the offline preparation cost?
  2. How well does AFS perform in larger file-rich workspaces with hundreds or thousands of files, where most files may be irrelevant to a given question? Can the authors provide evidence that AFS maintains its advantages over the baselines in answer quality and end-to-end latency in such settings?
  3. The Introduction motivates AFS by pointing to the limitations of file access workflows in tools such as Claude Code and Codex. However, the Grep-based Harness baseline is a simplified agent with only glob, grep, and read tools. Could the authors compare AFS against Claude Code and Codex using the same underlying language model on representative file-rich tasks? Such a comparison would help clarify the practical advantages of AFS over existing agent systems.
  4. How does AFS handle dynamic workspaces where agents create or modify files during task execution, invalidating the precomputed span indices and per-file KV caches? How do the authors position AFS relative to write-aware agent file systems like YoloFS, and what is the memory footprint and eviction/offloading overhead when the per-file KV caches exceed available GPU HBM?
  5. What is the total compute cost per query (e.g., total prefill and decode tokens processed across all File Agents and the Main Agent, or total GPU-seconds) compared to Dynamic RAG and the Grep-based Harness? How does AFS perform when multiple user queries arrive concurrently on the same GPU endpoint and compete for batch capacity?
  6. When File Agents inspect files asynchronously using only the initial question qq and without thinking, how often do they miss second-hop or bridge-dependent evidence that only becomes identifiable after reading another file? How frequently does the Main Agent have to re-queue already inspected files with a new focused request rr?
3 comments
AuthorsOpenReview ↗

Author Rebuttal [Part 1]

Thank you for the constructive review. We appreciate your supportive feedback.

W1 & W4. How much does cache preparation cost, and when does reuse pay off?

A1. Thank you for your comments. AFS separates preparation from online access, much as retrieval systems separate index construction from retrieval. We report the preparation cost here so that its contribution to latency is clear.

Table 1. KV cache preparation.

ModelDatasetQuestionsWorkspacesCache preparation per question (s)Online stages and cache preparation (s)
Qwen3.5-9BLoCoMo397100.16025.29
Qwen3.5-9BHotpotQA2002002.75826.59
Qwen3.5-9B2WikiMultiHopQA2002002.76921.33
Qwen3.6-27BLoCoMo397100.22150.97
Qwen3.6-27BHotpotQA2002004.50335.47
Qwen3.6-27B2WikiMultiHopQA2002005.33431.39

The same prepared file can serve different information needs. Its fixed preparation cost is spread across the queries that reuse it. Table 1 reports the recorded cache preparation and online stages under this accounting.

LoCoMo and 2WikiMultiHopQA have different opportunities for reuse. In LoCoMo, 397 questions share 10 workspaces, each containing 19 to 32 files. Charging one cache preparation per unchanged workspace gives a total of 63.54 seconds for Qwen3.5-9B and 87.85 seconds for Qwen3.6-27B. This amounts to 0.160 and 0.221 seconds per question, respectively.

In 2WikiMultiHopQA, each of the 200 questions has its own workspace and therefore bears the full construction cost. For Qwen3.5-9B, adding cache preparation to the recorded online stages gives 21.33 seconds, compared with Dynamic RAG's recorded online time of 27.81 seconds. The difference is 23.3% under the original configurations.

W2. How well does AFS handle larger workspaces with many irrelevant files?

A2. Thank you for the comment. Our evaluation includes workspaces of different sizes, as shown in Table 2.

Table 2. Files available to each question.

DatasetEvaluated questionsFiles available per question
LoCoMo39719 to 32
HotpotQA2002 to 10
2WikiMultiHopQA2006 to 10

These counts describe the available file pool, but not all of them are relevant. Each method decides which files to read. The results support AFS within this tested range; workspaces with hundreds or thousands of files require a separate evaluation.

The contribution of evidence selection can also be tested without changing the file pool or exploration budget. Table 5 in the paper fixes the inspected files, focused requests, and final decoder. File Agent selection reduces the original text delivered to the Main Agent from 27,690 to 892 tokens, retains 0.917 annotated evidence recall, and improves F1 from 0.323 to 0.411.

W3. How does AFS’s read path relate to YoloFS, and what happens when files change or GPU cache space runs out?

A3. Thank you for your comments. AFS organizes reading around how language model agents process files. Reading produces model computation that can be reused. Independent file inspections can share batched execution, while the Main Agent reasons over the selected evidence.

AFS places fixed instructions and file content before the question and its focused request. The file prefix can then be reused even when the Main Agent's interaction history changes. File Agents inspect files on the same continuously batched service as the Main Agent and return source addresses. The runtime resolves those addresses to original text and delivers the results before the Main Agent's next generation. Inspection can continue while the Main Agent reasons.

Reviewer Qc7g also recognizes that "The serving and access mechanisms are concrete," citing file cache reuse, overlapping inspection and reasoning, and the measured saturation point. The controlled experiments test these mechanisms separately. Reusing a prefix reduces mean time to first token from 919.7 to 297.7 ms. Increasing File Agent workers from one to three raises throughput from 2.64 to 4.27 inspections per second. The evidence selection experiment is discussed in A2.

The implemented operation is reading original files with their source locations preserved. Writes and access control add further requirements. They do not determine whether this reading mechanism is effective.

AuthorsOpenReview ↗

Author Rebuttal [Part 2]

W5. How often does early inspection miss evidence needed for a later reasoning step, and how often does AFS revisit files?

A5. Thank you for raising this point. The Main Agent can revisit a file after learning an intermediate entity or relation. It issues a new focused request, and the File Agent can reuse the fixed prefix while it remains cached.

Across 60 AFS task traces, there were 130 reinspection requests. Of these, 27 returned original lines that earlier completed inspections of the same file had not returned.

Table 3. Reinspection requests and calls returning new original lines across all 60 traces.

DatasetReinspection requestsCompleted reinspections returning new original lines
LoCoMo447
HotpotQA4511
2WikiMultiHopQA419
Total13027

For example, the first inspection of the Tom Tykwer file returns career information but omits his birth date. The Main Agent then requests "Tom Tykwer birth date." The File Agent returns the original lead containing "born 23 May 1965," and the Main Agent uses it before answering "Winter Sleepers." This focused call reuses 1,584 cached input tokens.

Q1. “Could the authors compare AFS against Claude Code and Codex using the same underlying language model on representative file-rich tasks?”

QA1. Thank you for the suggestion. We evaluated Claude Code v2.1.89 with the same local Qwen3.5-9B model, original files, and routing summaries. Both methods use the same 20 questions from each dataset. AFS has a higher F1 score than Claude Code on each sampled dataset.

Table 4. Answer F1 on the same 60 questions.

DatasetAFSClaude Code
LoCoMo0.37060.3665
HotpotQA0.71430.6539
2WikiMultiHopQA0.74170.6033
All 60 questions0.60880.5412
AuthorsOpenReview ↗

Gentle Reminder

Dear Reviewer Bbij,

Thank you for your positive feedback and for reconsidering our work. Your comment has helped us make our paper clearer. Please let us know if you have further concerns.

Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.