I built an agentic thing for an upcoming livestream that I'll be on. While building that agentic thing, I learned a lesson. I already knew the lesson. But I didn't know that I knew the lesson. Pretty sure this is called an epiphany. You probably know it too and might benefit from the epiphany. So, I'm gonna share it and then shamelessly plug the livestream.
The thing I built is called Earshot. Earshot consists of three agents: two listeners—one on a microphone, one on my ham radio—that transcribe whatever they hear, decide if it needs any correction, and write it down. And a chatbot that reads what they wrote and lets you, well, chat about it. That's the whole app.
Here's the cool bit. These three agents never talk to each other. The listeners don't know the chatbot exists. The chatbot doesn't know the listeners exist. They just read and write the same shared memory. Ain't nobody wired to anybody.
If that sounds familiar, it should. It's decoupling. The same decoupling we've done with message queues and shared databases and job tables for decades—producers on one side, consumers on the other, some sort of store in the middle. Neither end holding a reference to the other. I reached for it intuitively without realizing I was implementing the same distributed-systems pattern I've used scores of times in the past.
And since this isn't really new, the tradeoffs are the same. No delivery guarantees, no ordering. Things happen when they happen if they happen. Decoupling buys you flexibility at the cost of certainty, same as ever.
But that flexibility is so, so nice. It lets you scale and it lets you extend. Since nothing is wired together, you can add more listeners and more types of listeners, more chatbots and more types of chatbots. Potentially a lot more if your shared state can scale with them.
In Earshot, I used Redis for the shared state, specifically Redis Agent Memory. It was easy to use and gives me scaling, scaling that my toy agents don't really need. But your agents, which do real work for real users, will totally need it. Probably sooner than you think.
I built all of this in VS Code and used GitHub Copilot to assist. In particular, I used Redis' set of agent skills so that Copilot would know how, and more importantly when, to use Redis Agent Memory's APIs.
I plan to demo it all on VS Code Live this Thursday, June 4 at 9am PT. Join
@ReynaldAdolphe and me as we take a chatbot that starts with no memory and, one capability at a time, learns to listen to what is in earshot.
Livestream:
youtube.com/watch?v=DyAxSCk-…
GitHub repo with the demo:
github.com/redis-developer/r…
Redis Agent Skills:
github.com/redis/agent-skill…
Redis Agent Memory & Redis Iris:
redis.io/agent-memory/
redis.io/iris/
@Redisinc @code @GitHubCopilot