# The Cost of Acceleration Multi-agent work turns a single answer into a continuously running execution system. Cost spreads beyond tokens into networks, storage, compute, service limits, and account reputation. ## Metadata - HTML: https://glenzli.com/en/notes/cost-of-acceleration/ - Markdown: https://glenzli.com/en/notes/cost-of-acceleration.md - Collection: Notes - Language: en - Published: 2026-07-27 - Updated: 2026-08-17 - Tags: ai, agents, software-engineering, infrastructure, costs, judgment ## Content I recently had several agents working in parallel on an image-processing project. In less than two days, one metered network resource moved more than 200 GB of traffic. That was not my idea of a personal project. ## Start With the Security Incident I treated it as a security problem first. Had the environment been attacked? Was an unknown process uploading data? Had something downloaded or leaked what it should not? Those were the right first questions. Once the obvious signs of intrusion were gone, I turned to the multi-agent setup. Were agents synchronizing the same resources, moving test data repeatedly, or preserving a "complete environment" in ways that made local sense and economic nonsense? An executor that cannot see which state is shared, which data can be rebuilt, and which resource is metered can make the correct local move while getting the global cost badly wrong. The deeper problem was not one rogue agent. My own model of AI cost was too narrow. I wrote a small traffic-analysis tool and sampled processes. An active agent moving tens of megabytes in ten minutes was ordinary. In some intensive tasks, one Codex agent approached a gigabyte in forty minutes. For a rough estimate, I used a more conservative 50 MB per ten minutes. The project created seven primary agents. Some launched more than ten subagents. Even if each primary carried only four or five concurrent subtasks across several four-hour stretches, the number of active executors quickly reached the dozens. Traffic in the hundreds of gigabytes no longer required a mysterious process. That is not a forensic account of every gigabyte. Tasks idle and retry. Context sizes and synchronization paths vary. The order of magnitude is enough. ## Tasks Reproduce Concurrency is only one multiplier. Tasks keep dividing during execution. One complex GPU-pipeline task launched as many as eighty subagents over its lifetime. I cannot say how many overlapped, and the count does not translate into eighty times the traffic. It does show that cost depends on more than the number of agents online at one instant. It depends on how often work is decomposed, reinterpreted, and handed off. Several primary agents may inspect the same difficult region of code and each create subtasks to rebuild the background. A RAW pipeline can be analyzed repeatedly from the algorithm, processing, and implementation sides. Humans skip peripheral logic because time and attention are scarce. Agents do not share that default pressure to contract. If another analysis might reduce uncertainty, they can keep expanding. Without shared conclusions, explicit scope, and cost feedback, reasonable local decomposition accumulates into repeated context loading, tool calls, transfer, and compute. The security question became an operating question: > What does a continuously running, repeatedly decomposed, multi-agent system actually consume? ## Tokens Are One Page of the Ledger Model price and token counts are the obvious costs of AI. For a single answer or completion, they may dominate. Multi-agent engineering is not a single answer repeated several times. Agents read, edit, verify, synchronize, wait, and recover. Remote environments, state copies, build artifacts, test data, and handoffs enter the system. The ledger looks closer to this: ```text AI operating cost = model inference + movement of state and data + builds, tests, and compute + networks, storage, and copies + elapsed runtime + human review, recovery, and decisions + service quotas, reputation, and availability ``` The proportions change by task. Tokens may dominate pure text. Networks and synchronization catch up quickly in long-running engineering with remote state and large files. No individual action needs to be spectacularly expensive. Cost rises with concurrency, duration, copy count, and task decomposition. Past a threshold, this is no longer "a few extra chat windows." It is an execution system consuming physical resources. Speed lets one person command the execution capacity of a team. The bill learns to look like a team's bill too. ## Access Is Consumable Money is not the only cost. I once let agents call the GitHub CLI at high frequency and triggered a GitHub risk flag. Each call was ordinary maintenance. The material change was that AI turned a low-frequency human action into a persistent automated pattern. The appeal is still unresolved. Platforms do not see the full collaboration behind a request. They see frequency, source, access pattern, and history. Individually justified calls can still form exactly the pattern risk controls should stop. Home broadband and shared infrastructure carry similar limits. Sustained traffic may trigger abnormal-use policies and damage availability, not merely increase a bill. Continuous AI consumes CPU, disk, and bandwidth. It also consumes quotas, account reputation, and access. Technically able to continue is not the same as safe to continue. A prompt cannot carry that judgment alone. ## Acceleration Multiplies Everything Agents can run all day and keep spawning work to remove uncertainty. A cost intuition formed around chat is poor preparation for the multiplication of reads, synchronization, validation, retries, and external calls. Faster models and tools fit more actions into the same hour. The cost of speed lands far beyond inference. At scale, the effect moves beyond personal bills: more resident tasks, more copies, more upstream traffic, and more automated behavior colliding with third-party rate limits and risk systems. Locality, incremental synchronization, shared caches, attribution, rate limits, and quotas can change the outcome. They need to become part of agent infrastructure before an incident writes the requirement for us. Scaling AI means scaling networks, storage, identity, reputation, and service availability—not only inference. ## Let AI See the Cost The incident did not make me reject multi-agent work. It added a condition to autonomy: the environment must expose cost and consequence. "Finish the RAW pipeline" is not enough. The executor should know which data must remain local, how much network and compute budget remains, which resources and conclusions are already shared, which copies can be rebuilt, whether a service is near a quota or risk boundary, and when to degrade, pause, or ask. That information need not prescribe every step. It should put price, remaining capacity, and consequence inside planning. Budgets and external access belong with permission, evidence, and high-impact approval. Paths can remain flexible. Boundaries cannot remain invisible. Workflows built around a model weakness may disappear as models improve. Observability, attribution, hard quotas, human confirmation, and recovery records connect to real consequences. They are not scaffolding. With honest cost signals, AI may avoid copying state, choose incremental synchronization, move computation closer to data, or change course near a service limit. Showing "30 GB remaining" does not guarantee a good decision. Measurement, task attribution, and non-bypassable limits still matter. An environment contract does not remove constraint. It makes constraint real outside the prompt. ## The Ledger Is Still Open I still do not know exactly which paths, tasks, and copies carried all the traffic, which transfers were valuable, which budgets should be negotiable, or what the true unit cost of multi-agent completion should be. The incident did turn vague common sense into a number. I knew scale multiplied cost. I had never done the multiplication. Tokens are a useful approximation when AI answers once. When it works continuously, collaborates, and touches infrastructure, cost spreads across networks, storage, compute, services, and human attention. A task can finish beautifully and still leave a cost nobody agreed to bear. AI needs to understand the goal. It also needs to see what pursuing the goal is consuming. Otherwise acceleration only consumes resources faster. ## Related Notes - [Occam Has His Work Cut Out](/en/notes/occam-is-busy/) - [When Speed Changes the Shape of Exploration](/en/notes/speed-matters/) - [The Half-Life of AI Scaffolding](/en/notes/half-life-of-ai-scaffolding/) - [Software Beyond the Manual](/en/notes/software-beyond-the-manual/)