---
title: "Episode Guide | Building Stacklist | Why We Built ACP"
url: https://stacklist.com/card/5174ed20-72b2-415e-8e3a-c9536c53ac85
stack: https://stacklist.com/c/podcast/stack/08366f96-08ae-47df-8254-17a1ba4937df
summary: "Building Stacklist Season 2 Episode 1 explores the Atomic Content Protocol (ACP), an open-source protocol designed specifically for AI agents to read and understand content more efficiently. The episode discusses how ACP reduces token consumption by 84%, solves the problem of agents repeatedly parsing unstructured content, and functions as a foundational protocol layer similar to SMTP for email."
tags: "acp, atomic-content-protocol, ai-agents, stacklist, protocol, token-optimization"
key_entities: "Kyle Hudson (person), Martina Zrnec (person), Ivanha (person), Stacklist (organization), Atomic Content Protocol (technology), JSON-LD (technology), MCP (technology), token-economics (concept), agent-readability (concept), Claude (technology)"
classification: "transcript"
content_hash: "sha256:653ed99c958c294ef56ed2c5d74fe99cd333af8034b1f67209df754fad2015cf"
acp_version: "0.2"
token_counts_approximate: 6702
visibility: public
agent_accessible: true
status: "final"
---

# Episode Guide | Building Stacklist | Why We Built ACP

# Building Stacklist — Season 2, Episode 1: Why We Built ACP

**Recorded:** May 6, 2026
**Host:** Ivanha, Head of Marketing at Stacklist
**Guests:** Kyle Hudson (CEO, Stacklist) and Martina Zrnec (CTO, Stacklist)
**Topic:** ACP — the Atomic Content Protocol, open sourced for the first time
**Resource:** [atomiccontentprotocol.org](https://atomiccontentprotocol.org)

---

## Major Themes

**1. The internet was built for humans, not agents.** The fastest-growing users of the internet are now AI agents, and they're reading the same pages over and over, burning tokens trying to figure out what each piece of content actually is. JSON-LD and schema.org solved part of the problem for crawlers, but agents are a different category of reader with different needs. ACP is the layer of enrichment built specifically for them.

**2. A protocol, not another app.** Stacklist could have stayed at the app layer — a better place to put your saved markdown files, AI outputs, and links. But that solves the problem for one product. The deeper insight was that nothing on the internet speaks a shared language to agents, and a protocol — like SMTP did for email — is the only thing that scales across systems. ACP is the standard; Stacklist is just the first app built on it.

**3. Token economics as the unlock.** Every time an agent reads unstructured content, it spends tokens trying to figure out what the content is before it can use the content. Martina's live benchmark showed an 84% token reduction on the second read of an ACP-enriched card. At network scale, that's not a minor optimization — it's the difference between agentic search being affordable and being a luxury.

**4. The personal chaos that made the problem visible.** Kyle's downloads folder became a graveyard of markdown files: AI outputs he asked for, downloaded, and never found again. Notion, Obsidian, bookmarks, a thousand Chrome tabs — every tool a different language, every save a future search problem. The personal version of the problem is the friendly on-ramp; the systemic version is what ACP solves.

**5. JSON-LD is for crawlers; ACP is for agents.** Both layers matter. ACP doesn't replace existing standards — it adds an enrichment layer specifically for agent-readability, with confidence scoring and structural metadata that crawlers don't need but agents do. The two layers stack.

**6. Open source as the only honest path.** A proprietary protocol isn't a protocol — it's a moat. Kyle and Martina were clear that for ACP to do what protocols are supposed to do (let different systems talk to each other), it has to be open. The success metric isn't Stacklist adoption; it's whether other developers and platforms find it useful enough to build on.

---

## Key Takeaways

- **The downloads folder is a symptom; standardization is the disease.** The relatable version of the problem (where did I save that markdown file?) and the systemic version (why are agents wasting tokens reading the same pages over and over?) are the same problem at different scales. ACP solves both.
- **The SMTP analogy is the cleanest way to explain why a protocol matters.** Before SMTP, email providers were walled gardens that couldn't talk to each other. After, email became a network. ACP wants to do the same thing for content that agents read.
- **84% token savings is a benchmark, not a marketing claim.** Martina demoed it live: nine cards enriched once, then re-read by an agent. The reduction comes from the agent already knowing what the content is and not having to re-parse the body every time.
- **A Stacklist card is already ACP-enriched by default.** When you save something to Stacklist via the MCP, the URL extension, or the app, the card automatically picks up the structure agents need. This is why Kyle and Martina describe Stacklist as "LLM delicious" — it's not a marketing line, it's a structural property.
- **Stacklist's MCP is live and free to try.** Drop the URL into Claude or Claude Code and you can start enriching content and watching token consumption fall in real time. The playground supports your own Anthropic API key, stored only in the local session.
- **Success looks like Wikipedia, not a brand.** Martina's framing: if ACP works, people won't think about it — they'll just use it. The win condition is invisible infrastructure, not category dominance.

---

## Notable Quotes

- **On the core problem** *(09:19)* — "Internet was designed for humans, and the fastest-growing users of the internet today are AI agents."
- **On token waste** *(09:19)* — "AI agents read the same pages that we do over and over again, but they're wasting a lot of tokens asking what is this content about."
- **On the SMTP analogy** *(08:23)* — "If AOL and Gmail and Hotmail and Yahoo had all had their own different languages and ways of speaking, it would be so inefficient to try and send mail to each other."
- **On the downloads folder** *(01:41)* — "It writes this markdown file and I say, great. And then I download it and it goes into my downloads folder, which is just a dumpster fire."
- **On the standardization gap** *(03:11)* — "There's also no standardization across anything. So how Notion does it, how Obsidian does it, how any of the tools that you use when you're calling data back and forth — they're all kind of speaking a different language."
- **On the library analogy** *(11:43)* — "If you walked into a library and you had never been there before and you had to wander through all the sections to figure out where everything was — having an instruction manual is the difference between knowing where to go and going into it with amnesia every single time."
- **On the 84% benchmark** *(10:31)* — "When you enrich something and when you see the content being re-read second time and it actually consumes 200 tokens instead of 20K tokens, then it's like, okay, this makes sense."
- **On crawlers vs. agents** *(16:48)* — "JSON-LD and schemas — that's all built for crawlers, for Claude crawlers, for ChatGPT crawlers. But it's not built for agents."
- **On the open source goal** *(23:38)* — "It would be like Wikipedia. You don't think about it, you just use it."
- **On building for scale early** *(15:44)* — "It's almost prepping us for being Facebook, Instagram size and thinking about that early versus trying to bolt it on later."
- **On honest expectations** *(27:07)* — "It's out there. If people use it, fine. If not, also fine. We'll use it and Stacklist will be built on this."

---

## Key Facts & Timeline

- **The origin moment:** Kyle was working with Claude on Stacklist messaging, downloading the resulting markdown files into his downloads folder, and realizing the AI outputs were ending up in the same chaos as everything else. The personal version of the problem made the systemic version visible.
- **The pivot to protocol:** Once Stacklist's MCP was live, the team realized that a connector for one app didn't solve the underlying issue — agents would still need to re-parse every other system on the internet. The protocol layer became the next obvious move.
- **Live benchmark on the episode:** Martina demoed nine cards being enriched and re-read. The first read consumed thousands of tokens per card; the second read consumed a fraction of that, with consistent ~84% reduction across the set.
- **Stacklist as first app on ACP:** Stacklist's stacks and cards are structured with ACP enrichment baked in by default — including ID, parent relationships, public/private flags, agent-readability flags, token consumption metadata, and a confidence layer.
- **The MCP and playground:** Both shipped at the time of recording. The MCP can be added to Claude or Claude Code by URL. The playground accepts a user's own Anthropic API key, stored only in the local session.
- **Open sourced at:** atomiccontentprotocol.org. NPM package shipped. Setup guide live.
- **What the team wants next:** External contributors, real-world adoption beyond Stacklist, and feedback from developers who think ACP could work better in some other way. Open source is invitation, not announcement.

---

## Full Transcript

**Speaker 0 = Ivanha (Host)**
**Speaker 1 = Kyle Hudson**
**Speaker 2 = Martina Zrnec**

---

**Ivanha (00:34)**
Hey, welcome back to Building Stacklist. If you're new here, this is a show about what it actually looks like to build a startup in real time. Not the polished version — the actual version. Today, I have both of our co-founders with me, Kyle and Martina, and we're going to pull back the curtain on something we've been heads-down on. It's called ACP, the Atomic Content Protocol. We built it while building Stacklist, we're open sourcing it, and this is the first time we're going to talk about it publicly.

Here's the short version of why it exists. Think about the last time you saved something because you genuinely didn't want to lose it — an article, a recommendation, an AI answer that was actually useful. Where is it now? Probably buried somewhere you'll never find again. We kept running into that problem while building, not just for our users, but for our own AI tools. And at some point, Kyle and Martina decided the fix wasn't another feature. It was a standard. So they built one.

Kyle, Martina, let's get into it. Where does your knowledge actually go?

**Kyle (01:41)**
I'll come at it from the user experience perspective. As of, you know, mid last year — it was two years ago that ChatGPT came out and we all started using it — but I really think this year is one of those years where more people are adopting AI into their daily lives.

One of the things I find is that as I'm working with Claude, I'll work on a hard problem and then say, "Can you compress that into a final output I can take and work on elsewhere or send to somebody else?" So it writes this markdown file and I say great. And then I download it and it goes into my downloads folder, which is just a dumpster fire.

By the end of the day, I've got eight or nine markdown files, which are the culmination of a bunch of work I've done. And then you go: where do I put these? Do I just make a random desktop folder that says "stuff I'm working on"? You've also got Notion or Obsidian — and the same is true with bookmarks — typically a place where you can dump stuff, but it takes a lot to organize and keep up to date.

Putting it in a Stacklist felt natural as the one place where you can put anything and everything about your life. But there's also no standardization across anything. How Notion does it, how Obsidian does it, how any of the tools you use when you're calling data back and forth between all these different systems — they're all kind of speaking a different language. So that was the goal: what happens if you standardize it?

**Ivanha (03:41)**
So the problem isn't really that we're not saving things. It's that we're not saving them in a way where anything else can find those things.

**Kyle (03:49)**
I don't think anybody — it's the same problem we're trying to solve with Stacklist. People just get used to the fact that their stuff lives in a million different places. They're used to going, "Yeah, hold on, let me get that for you in my thousand tabs on Chrome." And in that moment, you don't realize you can't search at a macro level and recall it. You have to manually go click and drag and find. All of that organization and recall actually happens in your head. There's so much mental overhead from doing that. It should be easy enough that you can open a global search bar and say, "Find that thing I was working on," and it finds it. That's the beginning of what we're trying to solve.

**Martina (04:45)**
I'd expand this a bit more from a developer's perspective. When we were thinking about how Stacklist content appears in any type of element — that's the first time I started to think about this on a different level.

I started using a Claude cost status bar where I tracked how many tokens in and out, usage, everything. And that got me thinking — we're so used to just spending all those tokens. "Charge me more, charge whatever, I don't care, I'll pay. Stacklist, just go overboard."

**Kyle (05:23)**
Token maxing.

**Martina (05:26)**
And then it hit me — that could really be dropped if there's some kind of uniform language. Kyle made a point that really stuck with me: imagine if we were on this podcast and speaking different languages. We could understand each other through hand gestures, but we'd spend a lot of energy. The same thing happens with agents. If they speak different languages, they spend a lot of energy — tokens, in that case. That's when my brain started turning.

**Kyle (06:23)**
One little piece on that — think about, we get so excited about something. I'm working with Claude and it just figured out how we should talk about Stacklist at a macro level. This is so great. And it says download MD. And I do it. But I don't stop in that moment to go, am I actually putting this anywhere where anybody can get to it?

One of the things Martina built is an awesome MCP — basically a connector into Stacklist that Claude can read. I can just say, "Now go put that in my Stacklist," and it just does it. So now it's in a place that is refindable, searchable, shareable. I'm not putting it into my downloads dumpster fire. I'm putting it into a place that Claude can find, ChatGPT can find, Stacky the agent inside Stacklist can find. We're putting it into a place that can be searched and organized.

**Ivanha (07:40)**
We've been talking about this problem of knowledge — where to put it, how to find it, having it in one centralized place, all these markdown files. And Stacklist is the answer to that. But ACP is not an app. It's a protocol. It's what Stacklist is built on. So you guys solved it in this Stacklist way — here's an app — but then you thought, that's not enough, we need standardization. Why ACP? What's our point with it? What do we want people to do?

**Kyle (08:23)**
From a layperson's perspective: think about SMTP. It's what we use to send email back and forth — Simple Mail Transfer Protocol. If AOL and Gmail and Hotmail and Yahoo had all had their own different languages and ways of speaking, it would be so inefficient to try and send mail to each other. Having a simple protocol for email to go back and forth made it so everyone can send email to everyone else.

That's how I'd explain it to my aunt. You have to have some way to talk between these systems. If you don't, you're just wasting time having each system try to learn each other's language for every simple call.

**Martina (09:19)**
A bit more technical from my side. Think about it: the internet was designed for humans, and the fastest-growing users of the internet today are AI agents. AI agents read the same pages we do over and over again, but they're wasting a lot of tokens asking, "What is this content about?" That's the end goal — what is this content? They sometimes need to read a lot of data to figure out if that's actually the answer to the user's question.

Imagine Wikipedia for content, but on the agent level. You enrich once, you store it, and every other time an agent reads it, it's 90% lower token usage because it knows exactly what the content is about.

**Kyle (10:24)**
I think we solve internet. That's shooting for the moon.

**Martina (10:31)**
But that itself is pretty significant. When you enrich something and you see the content being re-read a second time and it actually consumes 200 tokens instead of 20K tokens — okay, this makes sense.

**Ivanha (10:51)**
You ran a test recently. I think it was 84% token savings following the ACP protocol. Is there any way we can do this live? Can we see it?

**Martina (11:04)**
Oh my god, I didn't prepare for that. Yes, let me — Kyle, just...

**Kyle (11:11)**
This is the loading state. Loading demo. Usually demos, like 99% of the time, won't work when you try to do it live. We'll see how it goes.

**Kyle (11:43)**
A good analogy while Martina pulls it up: if you walked into a library you'd never been to before, you'd have to wander through all the sections to figure out where everything was. Once you leave and come back, you know where the history section is — you cut right to it. If there's no instruction manual, it's like going in with amnesia every single time. You have to scan every section versus having a map right to where you want to go.

**Martina (12:22)**
What's actually fascinating is that with Claude, you can build pages like this in no time. There's documentation on the protocol, how it works, the problem, everything, and how to connect.

**Kyle (12:35)**
There we go.

**Martina (12:39)**
Yeah, so connect to Claude. What I built is — I'd say — the very first alpha version of an MCP that anybody can use. It's at this URL. Basically, if you put it into Claude or Claude Code, you can start using it and see how enrichment works for yourself. There's also a playground where people can go and try with their own Anthropic API keys — not stored anywhere, just locally to the session. You can try to see how the enriched data comes back.

About token usage — I'll share my chat. When you load it, you can ask what tools are in there, and it tells you which tools and what each one does. What I asked was: take my Stacklist stack and enrich my nine cards inside. So it took nine cards and enriched them, and it gave a per-card breakdown — how many tokens were used the first time, and how many every sequential time when it reads the same card.

This is the benchmark. It's not 100% — the 84% is consistent because it truncates the body. Maybe one is higher, one is lower. But you get a sense of how many tokens can actually be reduced if you enrich the content.

**Ivanha (14:05)**
So essentially, if everybody started formatting their content with ACP, then everybody would be saving a bunch of money with AI.

**Martina (14:15)**
Essentially, yes. Token usage is something that would drop. Imagine how much faster you'd get a reply if there's an open database with content that AI can just go through and say, "Confidence of this content is 95%. Here it is in a second."

**Kyle (14:40)**
It's like having lots of little treasure maps saying exactly what something is. If you just need to read what something is about — this is about books, this is about favorites, this is about restaurants — if you can read just the headers, you don't have to read the full contents. You don't have to read the full magazine article. You can get the TL;DR on everything. That's not only less expensive, it's also faster — quickly scanning the headers. Okay, found what I needed. And if you standardize that, every system that comes in knows exactly what headers to scan and what they're going to get. Faster lookups, fewer tokens.

**Ivanha (15:31)**
And so Stacklist is basically the first app built on ACP. What does that actually look like for a real estate agent, or honestly just for me trying to organize my stuff?

**Kyle (15:44)**
At a macro level, imagine the goal is: I want to search for restaurants, or clothes, or new AI apps, between me and Martina and our team. As I search that on Stacklist, the system doesn't have to go into everybody's profile and try to read everything. We can hit only the relevant parts. That pulls it back to me better and enriches the whole platform.

What we're trying to do is make this quicker, better, faster. Imagine that at network scale. It's almost prepping us for being Facebook, Instagram size and thinking about that early versus trying to bolt it on later.

**Martina (16:48)**
Everybody's heard about AI indexing — how AI crawls through your page, how you need JSON-LD, schemas, and so on. That's all built for crawlers. For Claude crawlers, for ChatGPT crawlers. But it's not built for agents. We're not replacing anything. We're just adding one layer of enrichment of data that's specific for agents.

So imagine having the JSON-LD schema and everything around crawlability, plus the agent layer where it can be easily found. Imagine search — search will be blown out of proportions when you search for real estate agents that have local expertise in Atlanta. That's how we think about it.

**Kyle (17:45)**
Think about how inefficient it is right now when I connect up services. I have this personal operating system agent, Virgil, that I built just for me, because I end up drowning. When I sit down in the morning, I've got my coffee and I'm like, okay, let me check Todoist and Slack and email and calendar, my Granola notes from yesterday, my Lightfield CRM for opportunities. Let me scan all this stuff.

This agent connects to all that, but every single thing is built in different ways. So it's piecing things together. Imagine if, when it connected up to Notion, Notion was built so the agent could just hit the headers of everything and have a map of what to do. It would be faster and use fewer tokens for me, fewer tokens for Notion. With standardization, all of that happens more efficiently versus an agent learning 12 different languages every time it makes calls.

**Ivanha (19:01)**
Can we show this? A Stacklist card and how it's structured versus something unstructured — that's why Stacklist is such a good platform for AI discoverability. I want to show people.

**Kyle (19:20)**
Martina, I have those two slides if you want to show them — the high level, card versus what AI sees.

**Martina (20:13)**
Okay, here it is. This is the card — a single piece of content. It has the ID, when it's created, parent or child, can the agent read it, is it public, how many tokens consumption, and the confidence layer. That's the basic structure of enrichment, which I added more data to.

Unstructured would just be the idea of the card — notes and whatever's in there. Having the enrichment is where Stacklist's MCP comes in really handy. If you use our MCP, our extension, or whatever, we have all those enrichments built in. Whenever you save something — from a Claude session, a URL, through Stacky — it automatically gets enriched and picks up all the data.

Our structure of stacks and cards is, of course, a normal ID with notes and the author and everything around it, but also JSON-LD baked in, ACP baked in. So we are what we like to call LLM delicious.

This is the structured card. And this is the structured stack — the container over the card. It has the same enrichment but also consumes how many children are inside.

**Kyle (21:27)**
That's good Stacklist.

**Martina (21:42)**
What is the structure? What's the relationship? What's the confidence that this actually answers somebody's question? That's the structured data.

**Ivanha (21:51)**
So basically a Stacklist card is already formatted the way AI systems want to cite things, without you or me or anybody having to do anything extra.

**Martina (22:00)**
Yes — AI and agents.

**Kyle (22:09)**
What I love about this is, one — thinking ahead and getting to a place where we identified, through real research, that this seemed like a big white space. People are still so enthralled by building. We built an MCP, which is step one. But thinking at a macro level, when you get to a place where you have agents helping you run your life and they're interacting with — is my agent going to interact with all 100 logins I use throughout the week? They're all talking different languages.

That's where, hopefully, we lead the way. Thinking about this early will help not only Stacklist adoption, but hopefully it solves a problem other people are going to be trying to solve here soon.

**Ivanha (23:04)**
And if ACP really succeeds, what does the world look like?

**Kyle (23:13)**
With hats and t-shirts and "I ❤️ ACP." No, really — open source, it's giving back to the community. I'd imagine, Martina, at some point you'd have contributors and managers on the open source project, and people taking it even further than we've thought about.

**Martina (23:38)**
The whole goal with open source — I imagine if people actually start to use it, I'd be over the moon. For me personally, that would be huge. But it would be like Wikipedia. You don't think about it, you just use it. You have an open-source library database of content that agents can crawl and read. It would be a much faster, more streamlined process, especially for developers. Nothing dramatically world-changing, but — what's the saying? Small moment for the world, big for me.

**Ivanha (24:22)**
And where can people go and start trying this? How do they do that today?

**Martina (24:29)**
atomiccontentprotocol.org.

**Ivanha (24:34)**
atomiccontentprotocol.org. We'll put that large in the video.

**Kyle (24:38)**
We should make a quick stack on this — link to the app, link to the npm package to install it. Maybe a quick markdown file in that package as a Stacklist markdown card with how to get started, or a quick scaffold for Claude.

**Ivanha (25:08)**
Last question — last thoughts. One thing from each of you that you want people to walk away knowing.

**Kyle (25:21)**
Don't offer Martina pizzas, because she won't take them.

For me, I love this moment we're in. It's important for everyone — whether or not you're dug into any of this, whether you understand it, whether you're in it or not — everyone's going to need to be in that place where you're interacting with these tools at some point. Using Claude or Claude Code in this way is going to be like learning Office at some point. You can't be like, "I don't know Word and I don't know Excel." It doesn't mean you have to implement this stuff right now or master it. But be around it, explore, be curious, because stuff is changing so much, and this is how the world is going to run soon. And reach out to Martina and me if you've got questions. We love collaborating and pointing people in the right direction.

**Martina (26:37)**
Reach out also if you think this is all bullshit. If it can actually be better in some other way, that's also legit. I'd like to hear all opinions. That's why open source — because you can take it, explore, see how it behaves. Maybe somebody somewhere has a billion-dollar idea that will unlock something amazing.

I built this and I'm really excited. I can see the potential. I can see how it benefits everyone. But at the same time, I need to ground myself. It's out there. If people use it, fine. If not, also fine. We'll use it, and Stacklist will be built on this. So there will be signs that it actually can improve all the agentic stuff — reaching, reading, and so on. That's enough for me.

**Kyle (27:46)**
Open source is great. Just please don't rename it Atomic Content Pizza. Try to keep the spirit of the protocol, please.

**Ivanha (27:51)**
Thank you so much, guys. This was really fun.