Wink Pings

Redis's New Cache Doesn't Store Answers—It Stores Steps

Semantic cache hits are fast, but after the refund status changes, it still says processing. Redis Iris takes a different approach: it caches the steps that generate the answer and computes the result with real-time data each time. In Akshay's test, it was about 2× faster than a regular agent, and it was the only approach that got both rounds right.

Redis has released Iris, a real-time context engine for production agents. It aims to solve a very specific problem: semantic cache hits are fast, but the answer may already be out of date.

Redis Iris homepage image

In a customer support scenario, a user asks “Where is my refund?” and several rephrasings still express the same intent. A semantic cache matches these phrasings to the same old reply. The reply says “processing.” A few minutes later the refund has arrived, but the cache still returns “processing.” The user sees a confident, stale answer.

A regular agent runs the full reasoning process every time. The answer is correct, but it has to re-plan the steps each time, burning tokens. Iris changes what is cached: instead of storing the answer, it stores the steps that generate the answer. Akshay Pachaar put it clearly in his tweet: semantic cache reuses the answer while Iris reuses the steps.

The flow works like this: the Intent Router first identifies similar requests, then pulls the corresponding Agent Playbooks. The Playbook does not store the final reply; it stores steps, such as look up the order, check the refund status, and reply using a template. The agent executes the steps, skipping re-planning, and fetches the live refund status once more before sending the reply. This saves the planning call and avoids falling back on an old answer.

Akshay built a small app to compare three approaches: a regular agent, semantic caching, and an Iris-backed agent. First, he asks about refund progress while the status is processing; then he changes the status to refunded and asks again with a different phrasing. Test data:

  • Question 1, status processing: regular agent made 2 LLM calls, 9.4 seconds, correct; semantic cache missed, 2 calls, 10.2 seconds, correct; Iris made 1 call, 5.9 seconds, correct.
  • Question 2, status refunded, rephrased: regular agent made 2 calls, 12.7 seconds, reply did not confirm the status; semantic cache hit, 0.5 seconds, returned the stale processing answer; Iris made 1 call, 5.6 seconds, correct.

Iris eliminated the planning call and was about 2× faster than the regular agent; it was also the only approach that answered both rounds correctly. Below is the demo video. Akshay notes that this demo was done in collaboration with the Redis team and that the trial link is a promotional link.

Avi Chawla's article divides LLM caching into four layers and explains it in more detail:

  • KV cache stores the attention tensors for each token in a single request, reducing repeated computation during decoding.
  • Prefix caching keeps KV blocks after a request ends and uses a token hash chain for prefix matching, reusing them across requests.
  • Prompt caching is a cloud vendor's billed version of prefix reuse; for Anthropic, writes cost 1.25× the base input price, and reads cost 0.1×.
  • Semantic cache stores already-generated reply strings and matches them using embedding cosine similarity.

The first three layers use exact matching and are correctness-neutral; a miss only affects cost and latency. Semantic caching uses fuzzy matching, and on a hit it skips the model entirely, saving output tokens as well. The problem is that it does not know whether the old answer is still correct. Avi gives a direct example: “How do I reset my password?” and “How can I reset my password?” have a similarity of 0.961 and should share an answer; “Is the API rate limited?” and “Is the API not rate limited?” have a similarity of 0.952, differ only by a negation, and have opposite answers. Raise the threshold and the hit rate falls; lower the threshold and wrong answers increase. A reader under Avi's article said time-sensitive content needs a hard TTL before the similarity check. That lesson is closer to production than tuning thresholds.

Redis Iris announced six capabilities this time: Intent Router, Agent Playbooks, Agent Memory, Context Gateway, Lens, and Agent Mesh.

Intent Router diagram

Intent Router routes by intent so similar questions do not have to be recomputed every time.

Agent Playbooks diagram

Agent Playbooks reuse answers and flows; the core is storing the steps.

Agent Memory diagram

Agent Memory handles short-term and long-term memory, preserving preferences and decisions across sessions.

Context Gateway diagram

Context Gateway connects to data sources through MCP, letting the agent fetch real-time information such as orders and tickets.

Lens diagram

Lens records agent decisions so that when something goes wrong, you can check why it took a particular step.

Agent Mesh diagram

Agent Mesh keeps agents communicating when connections drop; streams can be buffered and reconnected.

Combined, these capabilities show Redis's intent to move caching up from the response layer to the workflow layer. This is a valuable direction because in many production problems the answers change while the steps are relatively stable. But step caching has its own risks: if a Playbook is wrong, the error will reproduce reliably; if a Playbook becomes outdated, the workflow will consistently go off track on every request. Version management and rollback cannot be skipped. Semantic caching at least fails randomly; step caching can fail in a very orderly way.

If your business answers change over time, do not treat semantic caching as the default first. Ask one question: are you reusing an answer, or the process that generates the answer? The Redis Iris trial entry point is here: http://fandf.co/3XbeaVc. Avi's original article is at https://x.com/i/article/2093210840468189184, and Akshay's tweet is at https://x.com/akshay_pachaar/status/2123393434732122604.

发布时间: 2026-11-19 21:27