#20 Build With Intention | The 3 Layers of the Agent Stack

Hello Reader,

We have been having the same conversation in our engineering team and with other founders.

The AI product works great in a demo but struggles in real life scenarios.

We all have been thinking about the agent stack as two layers. It's actually three.

Intention

The two layers people do talk about are real, and they matter. Pick a model. Add tools. Wire up an agent or two. That'll get you a working demo.

But a demo is a controlled environment. The real world is where users do unexpected things, where one task requires three different specialised agents to coordinate, and where context from yesterday matters today.

That's where most AI products are failing. Not because the agents are bad. Because there's no third layer holding the system together.

Once you see the third layer, the whole picture changes. So does what you build.

Insight

Layer 1: MCP. How agents reach for tools.

This is the layer most people start with. MCP is the standard for how an agent calls an external tool. Read a file. Hit an API. Query a database. Send a Slack message.

Without MCP, every tool integration is bespoke. With it, agents have a clean way to act in the world.

This layer is real. It's working. Anthropic shipped it, the ecosystem adopted it, and most serious agent products use it now.

Layer 2: A2A. How agents talk to each other.

This is the layer people are starting to talk about. Once you have more than one agent, they need a way to communicate. Hand off work. Ask each other questions. Coordinate on who's doing what.

Google's A2A protocol is one answer to this. There will be others. The point is, this layer exists, and it's necessary the moment you stop thinking about a single agent and start thinking about a system.

Layer 3: Akashik. What agents share.

This is the layer I have been working on. And I believe it plays an important role in deciding whether your system actually works.

Tools and conversation aren't enough. Agents need a shared field. A place where what one agent learns becomes something every other agent can draw from. A memory that belongs to the team, not to any single member.

Without it, your agents repeat each other. They miss context. They redo work that was already done. They feel less like a team and more like five contractors who have never met.

This is the layer I'm building. The Akashik Protocol is my attempt to give multi-agent systems the shared field they're missing. I am currently in the middle of building the SDK v0.2 is coming out this week.
Github: https://github.com/akashikprotocol/core​

Why This Matters

If you're a founder thinking about AI in your product, here's the practical version.

Single-agent products are about to feel old. The interesting work for the next two years is in multi-agent systems. Teams of specialised agents that handle different parts of a workflow.

The companies that build those well will think about all three layers. Tools, communication, and memory. That's the exact shift we have made in Kiinara.

You don't need to use Akashik. You need to know that the memory layer exists, and that someone on your team should own it.

Action

Here's the question I want to leave you with.

If you mapped your AI system today, which layer is missing?

Not which model. Not which framework. Which layer. Tools, communication, or shared memory.

Whichever one you can't answer is probably the one quietly limiting what your product can do.

If you want to think about this together, just reply.

​

I hope this helps you in your journey of building something great.
Have a lovely week ahead and build with intention.

Sahil