Blog
Most of us have experienced ending an interaction with an AI agent by desperately shouting “REPRESENTATIVE” into the phone or chat (repeatedly). Agents are commonplace now, but agents that work seamlessly are still hard to find. The models are good enough, the technology is good enough, and the timing is right. So why are so few teams seeing production-level, repeatable, success?
Agents are missing context, at the right time, remembered the right way, to deliver as-good-as-human outcomes. It’s also easy to turn dollars into AI, and much harder to turn AI back into dollars. The agents that are delivering value are doing so inefficiently: over-stuffed prompts, redundant LLM calls, and brittle custom integrations all cost more tokens and time than the value they return.
The real world is messy #
Humans don’t follow scripts. Inputs can seem random. Customers engage in multiple channels, agents are now communicating with other agents, and every handoff creates a potential breaking point to a successful interaction. This is why so many agents look great in a demo but can’t survive in production. In a demo, the data is clean, scoped, and preloaded. In real life, a user might ask a weird question (or ask a question weirdly) and without access to the context needed, or the ability to answer it in time, the user experience suffers, and the agent is retired.
The same points of failure show up consistently:
- Agents start from scratch, every time. A wealth advisory customer spends 30 minutes explaining their history. Two days later the agent remembers none of it.
- Agents remember the wrong things and forget the right ones. Preferences and history should carry over. A credit card or Social Security number should not.
- Agents work with incomplete context. A customer support agent that’s measured on customer satisfaction approved a $350 refund 45 days after a purchase when the policy explicitly states no refunds after 30 days.
- Agents solve $5 problems for $500. When every request is treated as though it's brand new, the agent rebuilds its context window, re-runs the LLM, and burns tokens on answers it should already have.
The problem isn’t that agents can’t reason or are lacking intelligence. The issue is that they don’t have the right context, fast enough, when the user needs it, without starting from scratch every time. Redis has been solving these problems for applications since before agents existed, and now, we’re solving those same problems for agents.
Why we built Redis Iris #
Redis Iris creates the layer of the AI stack that sits between an agent and the data and tools it needs to act. It delivers production-ready context, memory, and messaging on Day 1, with the customization to make your agents irreplaceable in production. Four principles guide how Iris is constructed:
- Navigable. Context delivers navigable systems, not silos. The best outcomes happen when agents can follow connections between the available data and tools. Context turns both into a connected system agents can explore and act on, not just query.
- Adaptive. Good memory is selective. Agents keep the preferences, decisions, and past outcomes that matter, and let go of what’s stale, superseded, or irrelevant. Remembering gives agents continuity, and forgetting keeps context relevant and governable.
- Efficient. Efficient context keeps costs in check. Every redundant LLM call, bloated prompt, and repeat lookup adds up. Agents that retrieve only what’s relevant and reuse the answers and procedures they’ve already generated cost less to run.
- Compounding. The context agents use must learn continuously and grow over time. It should get more relevant, personalized, and informed by past interactions, and for agents to get smarter over time, they need built-in memory, learning, and statefulness.
These principles aren’t just design goals, they’re shaping how teams build and run agents in production successfully today. Since the launch of Iris in May 2026, customers are already reporting what that looks like in practice:
“Everything you see in Paradigm is stored in Redis. It is the memory and orchestration layer that lets our agents work in real time, at a scale that wasn’t possible before.”
-June Lee, CTO, Paradigm
Next, let’s take a look at the capabilities that make building production-ready agents possible.
One engine, six capabilities, endless agent possibilities #
Redis Iris offers a set of highly customizable & composable capabilities within one runtime context engine (shown below in figure one). You can use the capabilities together or independently, depending on the agent you are trying to create and the solution you are trying to make. They’re built so your agents remember the right things, answer the right way, and are transparent in every action, all while delivering unmatched outcomes per token, powered by the Redis you already know and love.
- Intent Router (GA). People don’t ask for the same thing the same way twice, so why recompute the answer every time? Intent Router matches the meaning of a question, not its wording, and sends it to the right place: a remembered FAQ, an agent skill, a human, or an LLM. It also handles agent and model routing, guardrails, and “fuzzy” if-statements, so decisions aren’t limited to only true or false.
- Agent Playbooks (GA). The best agents are purpose-built: a returns agent for a retailer, an investing agent for a bank, a support agent for a telco. They’re asked to do the same things again and again. Agent Playbooks let you define which answers are stable and should be reused, and which need current data and a fresh run of the known procedure. And best of all - these get more thorough and accurate the more they’re run. Customers get faster resolutions, and you stop burning tokens at every step.
- Redis Agent Memory (GA). Users don’t want to repeat themselves. Agent Memory now builds memories from docs, knowledge bases, and other semi-structured data through MemoryETL, organizes them in hierarchies for finer-grained control, and gives you inspection, audit, and provenance so you can see where each memory came from. It can also forget what it has no business keeping, like PII.
- Context Gateway (GA). Enterprise context lives in many systems, and some of it should reach everyone while some should reach only the right people. Context Gateway is a single point of entry to all connected context sources. Bring your own MCP, cache which tools solve a given problem to cut token use, and build reusable results for consistency across sessions.
- Lens (beta). An agent shouldn’t be a black box. In regulated industries, “the agent did it” isn’t a defensible answer, and you can’t govern what you can’t see. With Lens, every outcome traces back to the skill, route, or FAQ that served it, the memory it learned from, and the source session. You get auditable evidence, plus visibility into task success, tokens per task, and latency.
- Agent Mesh (beta). In production, you can’t rely on a conversation that vanishes when a network drops. Agent Mesh lets agents communicate over ephemeral streams, buffers the stream, and reconnects automatically so agents pick up where they left off. Durable SSE streams keep responses flowing through interruptions, and A2A comms give agents a reliable channel to delegate and hand off work.
See Iris in action: chatbot customer service agent
[Figure Two still needed: Chatbot Agent Using Redis Iris] A customer asks a simple, vague question: “What’s the charge on my account?” Behind that one line, the Redis Iris capabilities go to work:
- Intent Router reads the meaning of the question and decides what kind of problem it is: a dispute, fraud, or a routine payment. The agent isn’t matching keywords. It’s classifying intent, so it can send the request to the right place without rebuilding the answer from scratch.
- Agent Playbooks checks whether there’s already an approved FAQ or a skill that solves this. Here, there’s a proven procedure for suspicious charges, so the agent doesn’t have to figure it out from scratch or burn tokens re-deriving it.
- Agent Memory retrieves what the agent knows about this customer. That’s how it can say the $89.99 charge is from a merchant the customer hasn’t used before, instead of just reading back a transaction.
- Context Gateway pulls the rest of the picture through one governed entry point: prior habits, the address on file, and anything else the agent needs from connected systems.
- The agent offers to freeze the card and open a dispute. The customer says yes. This is moving money, so Lens records the audit trail: which route was taken, which playbook ran, which memories were used, and why. If anyone asks later why the agent did what it did, the answer is auditable.
- Meanwhile, Agent Mesh runs in the background, ready to pick up the conversation with no interruption should any network drop occur.
In less than two minutes, the card is frozen, a replacement is on the way, the dispute is open, and provisional credit is applied. And nobody had to shout “REPRESENTATIVE.”
Turn the page with Redis Iris #
With Redis Iris, the conversation shifts from “Can we build an agent?” to “Can we operate an agent that is reliable, explainable, and increasingly valuable over time?” This is what Iris delivers: the reliable memory, context, and messaging that moves agents from model intelligence to operational success, so users stop shouting for human help and wonder instead: “wait, who was that helping me?”
Try Redis Iris today #
- [Explore Redis Iris](https://redis.io/iris/) .
- Get started with [5,000 free messages](https://redis.io/try-free/?rcplan=iris) .
- Read the [announcement blog](https://redis.io/blog/agents-are-software-introducing-the-next-chapter-of-redis-iris/) .
- Watch [Rowan Trollope, Redis | theCUBE + NYSE Wired: Mixture of Experts](https://www.youtube.com/watch?v=1yqmRL6mL_U) .
Join us live #
See Redis Iris in action at the release webinar.
Get started with Redis today #
Speak to a Redis expert and learn more about enterprise-grade Redis today.