The next chapter of Redis Iris: what agents need to work in the real world

The other day, I was chatting with a customer support AI agent dealing with a cancelled flight. The experience was terrible. You could tell the agent realistically only had a few functions, and this was clearly not one of them. I’m sure when the developers presented it internally, the demo looked awesome. But in reality, the experience ends up being me, sitting in the airport, yelling “REPRESENTATIVE” at an LLM.

The curious part is that models are smart enough, but users are still not achieving production-level, repeatable success. As agents face more of the real world, and more failures, builders encounter a problem: the agent didn’t work, so now what? The unfortunate answer we keep reaching for is to just keep appending the prompt, or shove more data in and hope for the best. As Mike Tyson once said, “everyone has a plan until they get punched in their agentic mouth.” (Or something like that.) Agent builders need the tools to make their agents more reliable, accurate, and efficient at scale. And now they can with Redis Iris.

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 interactions are canned and the data is clean. 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. The first time an agent sees a problem, and the 100th time, it starts from scratch. It reads all the same context, re-learns all the same things, and to make it worse, it tends to do it a little differently every time leading to inconsistent outcomes.
• 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 has to re-figure out all the things it already knew from scratch, re-run the LLM, and burn 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 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, ParadigmNext, 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.

The Redis Iris Reference Architecture: one engine, six capabilities

• Intent Router: Agent builders need to be able to cheaply and quickly classify a user’s intent to be able to build adaptive workflows and agents. WIth Intent Router, you can define your own intents and use them to build things like model routers, agent routers, guardrails, or “fuzzy” if statements.
• Agent Playbooks: 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 - it comes with a learning loop so the playbooks 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: 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, and iIt works across multiple agents and multiple channels.
• Context Gateway: 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. It handles identity and authorization, making your agents accurate, secure, and efficient. 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. This means you iterate on your agents proactively, and users don’t have to come yell at you.
• Agent Mesh (beta): Agents need fast, lightweight, and durable communication streams between other agents and users. But most agents and protocols like A2A run over SSE, which doesn’t provide that. Agent mesh provides durable SSE streams to 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: 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 and build more complex workflows.
• 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 and allowing the agent to communicate reliably to sub-agents when needed.

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?”. And at the very least, the result is one less unhappy person like me, yelling like a crazy person to an LLM in a public airport.

Try Redis Iris today

• Explore Redis Iris.
• Get started with 5,000 free messages.
• Read the announcement blog from Redis CEO, Rowan Trollope.
• Watch our Redis Iris demo video and register for our upcoming webinar.
• Watch Rowan Trollope, Redis | theCUBE + NYSE Wired: Mixture of Experts.

Join us live

See Redis Iris in action at the release webinar.

Join us live