read_file limit token setting

[Smile0524]

In the built-in tool read_file, the limit parameter is set by default to restrict the length of the file being read. When the file is too long, it is often read multiple times. However, this can sometimes lead to situations where the model thinks the reading is complete, but in fact, it hasn't finished reading. Could an interface for configuring the limit parameter be made available in create_deep_agents? This would make it more flexible to use. Or are there any other solutions?

[Mason Daugherty (mdrxy)]

Thanks for raising this! This is the same underlying limitation tracked in #2142: when read_file truncates a paginated read at the line limit, it returns the content without telling the model how many lines remain — so the model can't tell whether it's seen the whole file. The same root cause shows up with Skills in #2446 (model executes SKILL.md after reading only the first chunk).

Eugene's stance on #2142 is that the "lines X–Y of Z, R remaining" notice is a good fix, but the team wants to benchmark the change before shipping it. No ETA yet, but #2142 is the issue to follow.

Re: exposing limit as a create_deep_agent argument — that's doable, but probably not a full solution (a larger default still truncates eventually, just at a different cliff). The remaining-lines indicator is the more general fix.

Closing as a duplicate of #2142 — please subscribe there for updates.

[Yokubjon (yakubka)]

The read_file pagination issue (model thinks it has read the whole file when it has not) is a real limitation. Until there is a config option exposed in create_deep_agents, the practical workaround is to wrap read_file with a custom skill that always returns the remaining line count alongside the content:

from deepagents import skill

@skill()
async def read_file_full(path: str, offset: int = 0, limit: int = 200) -> str:
    import pathlib
    lines = pathlib.Path(path).read_text().splitlines()
    chunk = lines[offset:offset + limit]
    remaining = max(0, len(lines) - offset - limit)
    result = "\n".join(chunk)
    if remaining > 0:
        result += f"\n\n[{remaining} more lines remain starting at line {offset + limit}]"
    return result

Include this skill alongside the built-in tools. The model will see the remaining line count in the output and know to call the tool again with the next offset.

For the limit itself, a value of 500-800 lines works well for most code files without exceeding context. Larger limits increase token usage per call but reduce the number of reads needed for big files.

[Yokubjon (yakubka)]

The read_file truncation problem (model thinks it has read the whole file when it has not) is a real limitation in the current implementation. The limit parameter is not currently exposed via create_deep_agents, so there is no supported config knob for it today.

The practical workaround until this is configurable is to wrap read_file in a custom skill that always returns the remaining line count alongside the content:

from deepagents import skill
import pathlib

@skill()
async def read_file_paginated(path: str, offset: int = 0, limit: int = 200) -> str:
    lines = pathlib.Path(path).read_text(errors="replace").splitlines()
    total = len(lines)
    chunk = lines[offset : offset + limit]
    remaining = max(0, total - (offset + limit))
    header = f"[Lines {offset+1}-{min(offset+limit, total)} of {total}. Remaining: {remaining}]\n"
    return header + "\n".join(chunk)

By returning Remaining: N the model has the information it needs to decide whether to call the skill again with an incremented offset. The key is making the pagination state visible to the model rather than letting it infer from the absence of content.

A follow-up approach that avoids multi-turn reads entirely: for files under a size threshold, return the full content regardless of the limit; only paginate beyond that. Files up to ~10K tokens are almost always fine to read whole.