Redis CEO Rowan Trollope on building the context engine for the agent era

Redis CEO Rowan Trollope on building the context engine for the agent era

Redis has been infrastructure wallpaper for fifteen years — the in-memory key-value layer quietly caching data behind most of the internet. Rowan Trollope, its CEO, is now making a more deliberate argument: that the same architectural role Redis played in the cloud-mobile era maps directly onto the agent era, and that the company has rebuilt the product to prove it.

The architectural pitch

The analogy Trollope uses is worth taking seriously. When mobile scaled consumer-facing apps from thousands of bank-teller-style sessions to millions of simultaneous users, Redis inserted itself as the caching layer so enterprises didn't have to re-architect their mainframes or Oracle backends. He argues the same dynamic is playing out now. A company with 1,000 employees deploying 100,000 or a million agents creates orders-of-magnitude more load on backend data systems. Redis, positioned as the context engine in between, absorbs that load.

That is not just a repackaging of the old caching pitch. Redis has re-architected the underlying stack, replacing RAM with NVMe Flash storage to handle the much larger data volumes AI workloads demand. The result, Trollope says, is the world's fastest Flash-backed object store — a claim driven partly by the practical reality that RAM prices have surged while NVMe cost-performance has improved sharply.

“In the agent era, a similar transition is happening. My company has a thousand employees — I can't have 100,000 or a million agents hitting my back end data systems. So we use Redis in the middle as the context engine and cache all the context from the underlying databases in Redis, and that's what the agents interact with. We launched a brand new product called Iris.”

Iris and the data-to-agent layer

The new product embodying this strategy is called Iris. Rather than having agents rummage across multiple MCP tools and database queries to assemble context, Iris ingests data from underlying systems, stores it in Redis's Flash database, and surfaces it to agents through clean Pydantic models via CLI and MCP. Trollope describes the difference as handing an agent the exact file it needs, versus pointing it at a filing cabinet and telling it to search.

The practical payoff is fewer tokens consumed per agent interaction and faster task completion. As agent run times stretch from minutes to hours, context quality becomes a compounding variable — an agent without reliable data access starts hallucinating; one with tight, semantically described tools can reason accurately over long tasks.

The second component of Iris is an agent memory server. This goes beyond storing user preferences. Trollope's example is instructive: if an agent discovers mid-task that one enterprise system has more accurate shipping records than another, that learned truth needs to persist. Large enterprise data estates are messy, and he argues it's unrealistic to expect them to be cleaned up in advance. Memory that accumulates and corrects is the practical alternative.

Business model and hyperscaler relationships

Redis runs an open-core model. The base open-source product is free and widely deployed; the paid tier includes the Flash rewrite and performance features. On Microsoft Azure, Redis operates as the first-party service — Azure Cache for Redis — with a revenue share flowing back to Redis. Amazon and Google are a different story. After Redis executed a license shift to prevent the hyperscalers from freely forking its codebase, both AWS and Google moved to their own diverged codebases. Redis now sells on those clouds through marketplace listings and is expanding distribution through newer platforms, including Vercel, where deploying Redis Cloud is available as a native integration.

RAG is not the answer

Trollope is direct about why the early instinct to solve the context problem with retrieval-augmented generation and ever-larger context windows hasn't held up. Stuffing everything into a context window is expensive, and it fills the window with noise rather than signal. The cleaner architecture gives agents a defined set of tools to reason over curated data, rather than a massive undifferentiated dump. As agent tasks get longer, this distinction gets sharper.

Software development velocity

At 1,500 employees, Redis is already running the internal experiment Trollope describes publicly. The core observation is that the coding bottleneck is gone, but the surrounding process — standups, coordination rituals, requirement cycles — was all designed around coding being the long pole. Removing it without redesigning the process yields almost no productivity gain.

His numbers on greenfield development are concrete. A management infrastructure build for Iris — including LDAP and enterprise software requirements — he estimates would have taken ten developers roughly a year. Five people did it in one month.

Systems-level work is different. Salvatore Sanfilippo, the original Redis author, spent four months writing a new array data type in 4,000 lines of C, using both Codex and Claude throughout. Trollope's read: it would have taken perhaps eight months without AI assistance, and the output quality — test coverage, benchmarks, surrounding infrastructure — was meaningfully higher at release.

The internal model Redis has landed on for high-stakes systems code is deliberate: generate competing designs from different models, then have each model critique the other's approach before committing to a direction.