Foundations
From human scale to agent scale: what breaks first
How the request profile of a file estate changes when its readers are harnesses, and where the pressure shows up.
The previous post argued that a file system answers the wrong question for an agent: it can return the bytes at a path, and an agent needs the files a task requires. This post is about a second problem, which appears even where the first one has been solved. The estate is not only being asked the wrong question. It is being asked a great many questions, very quickly.
A word on terms. By harness I mean the runtime that sits around the model and actually issues the calls: the loop that lists directories, opens files, runs commands and writes results. The model decides; the harness is what storage sees.
A file share sized for a department was sized for people. A few hundred of them, each opening a handful of documents an hour, with long pauses in between while they read, write, think and attend meetings. Every assumption in the system reflects that: the caches, the capacity planning, the monitoring thresholds, the sense of what a busy afternoon looks like.
Put a few thousand harnesses on the same share and those assumptions are worth re-examining, even though nothing about the storage has changed.
The shape of the traffic
A harness working a task lists a directory to see what is there, retrieves metadata for a set of files to decide which are worth opening, opens several, discards most of what it reads, opens more based on what it found, writes an intermediate note, reads that note back, and continues until the task is done. Each of those is a request.
There are pauses between them, while the model decides what to do next, but they are machine pauses rather than human ones: no coffee, no meeting, no end of the working day. Unlike a person, a harness sustains long sequences of requests without the gaps a document-centric workflow leaves behind.
Multiply that by the number of tasks running at once. A human user typically generates intermittent request activity. A harness generates a request stream per task, and tasks are cheap to start, so an organisation that found agents useful last quarter is running more of them this quarter. A storage system can see its request volume grow substantially without any corresponding increase in provisioned resources.
Why adding throughput may not help
The instinct, when a share gets slow, is to look at bandwidth. It is the number everyone has on a dashboard, and for the machine workloads storage teams already know, such as backup sweeps, replication, simulation and media rendering, it is usually the right place to look. Those jobs move large files in long sequential runs, and additional bandwidth improves throughput directly.
Agent traffic tends to look different. Much of the request volume comes from metadata operations and from small, repeated reads: what is in this directory, does this file exist, how large is it, when did it change, may this identity see it, give me the first part of it. A storage team that adds throughput and sees no improvement has learned something useful, though it rarely feels that way at the time.
This is not a capacity problem that arrived early. It is a different workload, wearing the same protocol.
Storage vendors have begun saying something similar in public. Covering NetApp’s Insight conference this October, SiliconANGLE reported the company describing agentic workloads in which thousands of agents may need to access data at the same time, with permissions that are temporary and narrowly scoped, raising the volume of metadata operations alongside throughput demands. That is the same observation from the other side of the wire.
Where the pressure shows up
Which part gives first depends on the estate: the storage architecture, the metadata path, the network between the harnesses and the share, the identity system doing the permission checks, and the billing model if any of it is cloud-backed. These are the places worth watching.
Metadata paths. Listings and attribute lookups are the cheapest operations a file system offers and the easiest to issue in bulk. On many systems they are also the ones that queue behind each other, which is why an early symptom can be a directory listing that takes a second instead of a few milliseconds.
Caches. Cache effectiveness depends on locality and reuse. A harness exploring an estate tends to produce broad, shallow access with low locality, and many tasks competing for the same cache capacity can increase churn and reduce hit rates. The fall is invisible unless someone is watching that number specifically.
The people already on the share. The common case is not an outage. The share stays available while response times degrade for agents and people alike, including the people who were there first and have no idea that a new class of user arrived. This is the symptom that generates tickets, and it sits several steps away from the cause.
Cost. Every agent program added to the estate adds its own stream of requests, and in a cloud-backed estate many of those requests are billable. The line grows smoothly, which makes it hard to attribute to any single decision.
What to establish before scaling
Some of this load is simply the cost of doing the work, and no architecture removes it. An agent reading a contract for the first time has to read the contract.
Other activity introduces overhead that is hard to attribute to any individual task, and its magnitude depends on the workload, the storage architecture and the access patterns involved. Understanding those effects requires visibility beyond aggregate capacity and throughput. Many environments lack the task-level view that would be needed to tell routine application activity apart from the access patterns of agent workflows.
The question worth asking before scaling an agent programme is not how much capacity it will need. It is whether the characteristics being measured today are still the ones that matter.
Operation counts rather than bytes. Metadata rates alongside throughput. Concurrency by workload rather than by user. These are ordinary numbers, available in most environments, and they establish a baseline while the workload is still small enough to reason about.
The next post in the series looks at what happens when several harnesses work on the same files at the same time, which is where the problem stops being about volume and becomes one of coordination.
The series
Get the next post.
One email when the next piece in the series goes up. No product news, no sales follow-up.
Unsubscribe in one click. We do not share the list.