{"id":6477,"date":"2026-07-02T09:13:37","date_gmt":"2026-07-02T13:13:37","guid":{"rendered":"https:\/\/www.webperformance.com\/load-testing-tools\/blog\/2026\/07\/the-more-you-use-the-ai-the-less-it-runs\/"},"modified":"2026-07-02T10:26:01","modified_gmt":"2026-07-02T14:26:01","slug":"the-more-you-use-the-ai-the-less-it-runs","status":"publish","type":"post","link":"https:\/\/www.webperformance.com\/load-testing-tools\/blog\/2026\/07\/the-more-you-use-the-ai-the-less-it-runs\/","title":{"rendered":"The More You Use the AI, the Less It Runs"},"content":{"rendered":"

Every AI product now claims it learns. But look closely and what most of them mean is that somewhere a text file is getting longer. The agent hits a problem, works something out, and appends the lesson to an instructions file (CLAUDE.md, AGENTS.md, a “memory” store) that gets stuffed into the prompt on every subsequent call. That is the industry’s default memory architecture: a diary the model re-reads, at your expense, every single time it does anything.<\/p>\n

The problem is that it degrades. In 2025, researchers at Chroma measured what they named “context rot”<\/a> across 18 frontier models, including GPT-4.1 and Claude 4: accuracy falls continuously as prompt length grows, with drops of 20 to 50 percent on long inputs. An earlier paper, Lost in the Middle<\/a>, showed that models reliably miss information buried in the middle of a long context. Put those together and the standard “learning” architecture has a design flaw you can state in one sentence: the more the product knows, the worse it behaves.<\/p>\n

When a shiny new AI hammer comes along, every problem looks like a nail. I designed WPLoadTester 7 to use AI for what it does best, leaving everything else to boring, deterministic, testable algorithms. When our AI Assistant solves a problem, it doesn’t write the lesson into a prompt. It writes the lesson into a rule, hands the rule to a deterministic expert system, and gets out of the way. The expert system applies everything it has accumulated to every future recording before the AI is invoked at all. The result is a product where the relationship runs backward from the rest of the industry: the more you use the AI, the less it runs.<\/p>\n

A rubric for thinking about AI and data<\/h2>\n

Here is the mental model behind that decision. When I evaluate any AI-and-data problem, I place it on two axes. One axis: is the data structured<\/strong> (fields, tables, name-value pairs) or unstructured<\/strong> (raw text, HTML, a wall of HTTP traffic)? The other: is the processing deterministic<\/strong> (same input, same output, every time) or non-deterministic<\/strong> (statistical, sampled, calculated, never quite the same twice)?<\/p>\n

\n
The AI-and-Data Rubric<\/div>\n
Create knowledge in the expensive quadrant. Store it in the cheap one.<\/div>\n

\n The AI-and-data rubric: solve in the expensive quadrant, store in the cheap one<\/title>\n \n <\/rect>\n <\/rect>\n <\/rect>\n <\/rect>\n \n <\/line>\n <\/line>\n \n Deterministic<\/text>\n Non-deterministic<\/text>\n Structured<\/text>\n Unstructured<\/text>\n \n Rules engines · databases<\/text>\n Cheap. Testable. Identical every run.<\/text>\n ASM’s 300+ detection rules live here.<\/text>\n \n Statistical models<\/text>\n Forecasts, anomaly detection.<\/text>\n \n Parsers · regex<\/text>\n Predictable but brittle.<\/text>\n \n LLMs<\/text>\n The only tool that works here.<\/text>\n Costs tokens per use. Answers vary.<\/text>\n \n \n \n <\/path>\n <\/marker>\n <\/defs>\n <\/path>\n <\/rect>\n The AI writes the rule<\/text>\n <\/svg>
Web Performance<\/span>  ·  Solved problems move down-right to top-left: the AI figures it out once, the expert system applies it forever.<\/figcaption><\/figure>\n

The bottom-right quadrant is the interesting one. Before large language models, nothing handled unstructured data non-deterministically in a useful way; now it is the hottest quadrant in software, and every vendor is racing to move their whole product into it. That is the mistake. The bottom-right quadrant is where hard problems get solved<\/em>, because an LLM can read a wall of raw HTTP traffic and reason about what it means. It is a terrible place for solved problems to live<\/em>, because everything in it costs tokens per use and carries a small probability of coming back different. An LLM’s ability to give different answers to the same question looks like creativity when generating images, but it is a liability for correlations, math, or processing large datasets.<\/p>\n

The rubric gives you the rule: create knowledge in the expensive quadrant, store it in the cheap one.<\/strong> A prompt-file memory violates this rule. It creates knowledge in the expensive quadrant and then leaves it there, paying rent on every call.<\/p>\n

The expert system the AI teaches<\/h2>\n

WPLoadTester’s cheap quadrant has a name: Application State Management, or ASM. It is a rules-based expert system we have been refining since 1999, and it exists because of a problem every load tester knows. You record a user session as HTTP traffic, you replay it with a thousand virtual users, and it breaks immediately, because the recording is full of values that were only valid for the original session: JSESSIONID cookies, CSRF tokens, ASP.NET VIEWSTATE blobs, OAuth Bearer tokens. Finding every dynamic value, tracing where it originates, and wiring the extraction used to take days of an engineer staring at headers.<\/p>\n

ASM automates the well-known cases. It ships with over 300 detection rules encoding 27 years of correlation work: framework rules for ASP.NET, Spring, Rails, and PHP; protocol rules for cookies and cache headers; 14 rules for OAuth token flows alone. It runs automatically after every recording and handles roughly 95 percent of the common patterns before a human, or an AI, looks at anything.<\/p>\n

The AI Assistant covers the long tail: the proprietary framework, the unusual token scheme, the field that only reveals itself as a runtime failure during replay. This is exactly the bottom-right-quadrant work the rubric prescribes, reasoning over raw, unstructured traffic to figure out what a never-before-seen application is doing. On a recent case, the assistant spent four attempts refining a regex to extract a JWT from an escaped Next.js streaming payload. It ran the same loop a senior engineer would, but finished in seconds.<\/p>\n

Here is the part where our AI strategy really pays off. When the assistant cracks a problem like that, it doesn’t just patch the test case. It writes the solution as a new detection rule: a plain properties file with an extraction pattern and a context scope, saved straight into ASM’s rule store. The next recording you make gets that rule applied during ASM’s up-front scan. Zero tokens. Identical, verified<\/em> behavior. No context to rot.<\/p>\n

A rule does not get into the store just because the AI wrote it. The assistant tests the extraction in isolation against the recorded traffic, applies it to the test case, then replays the whole scenario end to end to confirm the fix holds in practice. It usually takes a few tries, a small tweak and another replay, before everything passes. Only then does the rule earn its permanent spot.<\/p>\n

What this is not<\/h2>\n

To be clear, this is not machine learning. No model weights change. The AI does not get smarter; the system around it<\/em> accumulates knowledge, in a form you can open in a text editor and read.<\/p>\n

The research world has been here. Voyager<\/a> (2023) had an LLM agent build a permanent library of Minecraft skills. ExpeL<\/a> (2023) extracted reusable insights from an agent’s successes and failures. DreamCoder<\/a> (2021) grew libraries of program abstractions before LLMs made it fashionable. We did not invent the idea of an AI that writes down what it learned. The difference is where the learning goes: every one of those systems retrieves its accumulated knowledge back into the prompt<\/em>, where it costs tokens and competes for the model’s attention. Ours compiles it out of the prompt entirely<\/em>, into a deterministic engine that runs before the model. The research field calls this general direction neuro-symbolic AI. I call it not paying for tokens to solve the same problem over and over again.<\/p>\n

The economics<\/h2>\n

An OAuth login flow that takes two hours of manual correlation typically configures in about four minutes with the assistant. That is the first encounter. The second encounter is handled automatically by the expert system’s up-front scan. Your AI spend concentrates on problems nobody has seen before, which is the only work an LLM should be doing anyway.<\/p>\n

Meanwhile the prompt-file architecture pays in the other direction: every lesson learned makes every future call slightly larger, slightly slower, and, per the context-rot data, slightly less reliable.<\/p>\n

The AI Assistant is the most impressive thing in WPLoadTester 7, and the entire architecture is designed to need it less every week you use it. Both are useful, but I think the second one is the better feature. One trend I’m seeing with AI adoption is the more people use it, the more they come to rely on it and use it more. I would rather give you an AI implementation that you’ll need to use less and less.<\/p>\n","protected":false},"excerpt":{"rendered":"

Every AI product now claims it learns. But look closely and what most of them mean is that somewhere a text file is getting longer. The agent hits a problem, works something out, and appends the lesson to an instructions file (CLAUDE.md, AGENTS.md, a “memory” store) that gets stuffed into the prompt on every subsequent call. That is the industry’s default memory architecture: a diary the model re-reads, at your expense, every single time it does anything.
\nThe problem is that it degrades. In 2025, researchers at Chroma measured what they named “context rot”<\/a> across 18 frontier models, including GPT-4.1 … Continue reading »<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[365,8],"tags":[],"class_list":["post-6477","post","type-post","status-publish","format-standard","hentry","category-ai","category-load-testing"],"_links":{"self":[{"href":"https:\/\/www.webperformance.com\/load-testing-tools\/blog\/wp-json\/wp\/v2\/posts\/6477","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.webperformance.com\/load-testing-tools\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.webperformance.com\/load-testing-tools\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.webperformance.com\/load-testing-tools\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.webperformance.com\/load-testing-tools\/blog\/wp-json\/wp\/v2\/comments?post=6477"}],"version-history":[{"count":2,"href":"https:\/\/www.webperformance.com\/load-testing-tools\/blog\/wp-json\/wp\/v2\/posts\/6477\/revisions"}],"predecessor-version":[{"id":6480,"href":"https:\/\/www.webperformance.com\/load-testing-tools\/blog\/wp-json\/wp\/v2\/posts\/6477\/revisions\/6480"}],"wp:attachment":[{"href":"https:\/\/www.webperformance.com\/load-testing-tools\/blog\/wp-json\/wp\/v2\/media?parent=6477"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.webperformance.com\/load-testing-tools\/blog\/wp-json\/wp\/v2\/categories?post=6477"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.webperformance.com\/load-testing-tools\/blog\/wp-json\/wp\/v2\/tags?post=6477"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}