#19 Build With Intention | What Do Your Agents Remember Together?

Hello Reader,

There's a quiet question I've been sitting with for months. One that I think is going to matter more than most of the AI conversations happening right now.

This week, I finally started building the answer to it.

Intention

Everyone's talking about AI agents now. Every founder I speak to wants to know how to use them. Every engineer I know is testing them. The conversation is loud, and it's everywhere.

But here's the question I believe is worth asking.

What do the agents remember together?

We talk about which model to use. Which framework. Which tools to give them? We talk about how agents communicate with each other.

We talk less about what they share.

And without that, agents don't work as a team. They work as expensive parallel processes that keep forgetting what the others just did.

Insight

Think about it like a team of people.

If you hired five smart engineers but gave them no shared notes, no shared history, no shared sense of what's already been decided, you wouldn't have a team. You'd have five people doing similar work in different rooms.

That's most multi-agent systems today.

There are two layers people are building right now. MCP is how agents reach for tools. A2A is how agents talk to each other. Both matter.

But there's a third layer underneath both of them. The layer that holds what the team has learned, decided, and noticed. The memory layer.

That's the one I'm building.

I called it the Akashik Protocol. The name comes from an old idea ~ a shared field of knowledge that everyone draws from. That's exactly what agents need.

I spent the last few weeks working on the SDK. The first piece of code anyone can pick up and use. And this week, I started testing it on something I already run.

Muse.

Muse is my own multi-agent newsletter system. Six agents, each with a job. One captures ideas. One does research. One thinks about strategy. One writes. One publishes. One keeps everything coordinated.

Before this week, those agents were good but lonely. Each one did its job and handed off what it had. None of them really knew what the others were learning.

Now they share a memory layer.

The capture agent notices something interesting on Tuesday. By Thursday, the strategist already knows about it. By Saturday, the writer is using it. Nobody had to tell anyone. The memory was just there for whoever needed it.

That's what changes when agents share memory. They stop repeating each other. They stop missing context. They stop feeling like five tools and start feeling like a team.

Action

If you're building anything with AI agents, or thinking about it, here's the question I want you to sit with this week.

What's the memory layer in your system?

Not which database you use. Not which vector store. Not which tool the agents call.

What do your agents share, and how do they stay coordinated when one of them learns something new?

If you don't have an answer, that's not a small gap. That's the gap.

It's also the thing I'm spending the next few months on. Akashik will be open source. The SDK is being tested right now, on Muse. If you want to follow along or build with it, just reply and let me know.

A Tool Worth Knowing

Since I'm building in the open here, I'll share something practical.

The tool I'm using to run Muse is Trigger.dev.

When you build with multiple agents, the agents aren't the hard part. The hard part is everything around them. Scheduling. Retries. Long-running jobs. Background work that needs to survive a deploy.

Trigger.dev handles that layer. Muse runs on it.

If you're building anything serious with agents, you need an orchestration layer that thinks in jobs, not requests. That's the shift.

Hope this gives you something to think about. Let me know what you are building with intention this week?

Sahil