Your Cache Is Cold Every Morning: Why Prompt Caching Can't Replace Agent Memory

A quick experiment you can run without touching a line of code: look at what the model providers promise about prompt caching, and look at what your scheduled agents actually need. Then compare the two lists.

The provider promises cheaper reprocessing of identical text, for a few minutes at a time. Your agent needs to wake up tomorrow and still know what it learned today. Those are not the same thing, and no amount of caching turns one into the other.

Caching is a discount on repetition, not a record of anything

Strip prompt caching down to what it mechanically does. A model API is stateless. Every request carries the whole prompt: instructions, tool definitions, whatever context you attached, the conversation so far. The provider notices that the beginning of your prompt is byte-for-byte identical to something it processed recently, and instead of recomputing it, it reuses the cached computation and charges you less for those input tokens. Anthropic discounts cached reads to about a tenth of standard input pricing. OpenAI's newer models document a similar structure, with a small premium on the first write and a steep discount on every reuse.

For a long-running agent loop, where turn 40's prompt is 95% identical to turn 39's, this is genuinely significant money. It is also, and only, a discount on repetition.

Both providers say so themselves, almost in the same breath. Anthropic's line: "Prompt caching has no effect on output token generation." OpenAI's: "Prompt caching does not change how the model generates output tokens." Read that carefully. Caching changes what the input costs. It changes nothing about what the model produces. It cannot make the model know something it was never told in this request. It cannot return a stored answer from yesterday. It is not memory in any sense that matters to an automation.

Scheduled agents live on the wrong side of the cache lifetime

Now add the second problem, which is specific to how automation operators run agents. A cache entry is temporary. Anthropic's lives for roughly five minutes. OpenAI's newer models keep one for a minimum of 30 minutes after the last reuse.

Your Make scenario runs every four hours. Your Zapier zap fires twice a day. Your nightly cleanup agent runs once, at 2 AM, and sleeps the rest of the day. In every one of those cases, the gap between runs is far longer than any cache lifetime on the market. The provider's cache is stone cold when the agent wakes up. Every run pays the full price for its stable prefix: the instructions, the tool schemas, the context you attach. Turn it off or leave it on, the per-run bill looks nearly identical.

The much-advertised 90% savings assume a specific shape: a long session with dozens of turns, each minutes apart. That is a chatbot shape, or a coding-agent shape. Scheduled automation is the opposite shape: short runs, far apart, each one an isolated session. Caching optimizes within the run. It is blind to everything between runs, which is exactly where scheduled agents lose their minds.

Rephrase the question and the cache misses twice

There is a third gap that rarely gets mentioned. Prompt caches match exact prefixes. Change one token near the front and everything after it gets recomputed. That means caching never recognizes that this morning's request is semantically the same as last week's. Different wording, different language, reordered fields: full price, full recompute, and still no memory of last week.

So you can end up in the worst of both worlds. The agent asks the same operational question in slightly different words each run, pays full price each time because the prefix never matches, and still learns nothing between runs because there is no durable store. Caching did not cause this, but it is easy to mistake its presence for progress on the problem it cannot solve.

What a scheduled agent actually needs at 6 AM

The fix is not complicated; it is just a different layer. Each run should start by reading the agent's accumulated knowledge from somewhere durable: the standing facts about the business, the preferences it has picked up, the full history of what previous runs did and decided. That read happens at wake-up, from a store that outlives any single run and any single machine.

Then, and only then, caching earns its keep. A long run that re-reads the same retrieved context across many turns is exactly the shape caching rewards: keep the retrieved block stable at the front, append the new stuff at the end, and let the provider discount every repeat read.

The two layers have distinct jobs. The memory layer decides what the agent knows. The cache decides how much it costs to re-read that knowledge inside a run. Teams that invest only in the second one get cheaper runs and an agent that still wakes up knowing nothing.

The shared-memory version of this stack

Vilix AI is the memory layer in this stack. It is cloud-hosted, so there is no database to run and no memory files that disappear when a runner is recycled. Your agents retrieve what they know at the start of every run over MCP, and because the memory lives in the cloud rather than inside any one tool, it is the same memory on n8n, Make, Zapier, Claude Code, and your phone apps. One memory, every tool, no silos.

It keeps full conversation history rather than compressed summaries, so a future run can read what actually happened instead of inheriting a summary's mistakes. And the friction is near zero: export everything or wipe it any time in a portable format, keep a free plan forever, and try Pro for 7 days without handing over a credit card.

This is the pairing that makes scheduled agents both smart and cheap: durable, shared memory retrieved at wake-up, with prompt caching layered underneath to make the re-reads inside each run cost almost nothing.

The bottom line

Keep prompt caching. It is free money on long runs, and leaving it on the table makes no sense. But do not mistake it for memory. It expires in minutes, matches exact text, and changes nothing the model knows. Your agents wake up hours or days apart with a cold cache and an empty head. Only a real memory layer fixes the empty head. Everything else is just a cheaper way to process the same blindness.