Content Teams Don't Need "Use AI More"—Ahrefs Built 16 Tools in 5 Days, and Here's How BeeOS Turns Content Agents Into a Real Pipeline

Most content teams get told to “use AI more.” What they get isn’t direction — it’s anxiety.

Then they open LinkedIn, where everyone is showing off their AI stack: “I built an agent that compressed my workweek to four hours.” “This workflow completely changed my team.” Every post implies the same thing: everyone else figured it out already. You’re the only one who hasn’t.

The Ahrefs content team did the opposite. They didn’t ask anyone to “use AI more.” Content director Ryan Law dropped one message in Slack: no writing this week. Instead, use Agent A to build a tool that automates or speeds up whatever part of your role you find most painful. Five days later, four people delivered 16 working tools.

You’ve probably been told to “use AI more.” Your team is discussing how to embed AI into content workflows. But the biggest trap isn’t “AI isn’t smart enough.” It’s not aiming AI at the real bottlenecks, and not making the tools talk to each other.

Who should read this? Content marketing leads and operators, SEO teams experimenting with AI agents to accelerate production, and anyone wondering “what can AI actually do in a content team — and where do I start?”

After reading, you should be able to answer three questions:

1. What 16 tools did Ahrefs build in 5 days—and why were the most successful ones not the "smartest" but the ones that "wrapped existing habits"?
2. What three structural gaps do these 16 tools expose: platform lock-in, tool silos, and no approval layer?
3. How does BeeOS's MCP + A2A + OpenAPI turn content agents from "one person's toolbox" into "a reusable collaboration pipeline"?

Zero: The Facts

Let’s lay out the hackathon’s outputs and categories.

• Fact: Team size — Value: 4 people — Notes: Ahrefs content team (including content director Ryan Law)
• Fact: Duration — Value: 5 days (Mon announcement → Fri demo) — Notes: Entire week blocked — no writing, only building
• Fact: Constraint — Value: “The more specific your goal, the better the outcome” — Notes: Not “use AI more”
• Fact: Platform — Value: Agent A (Ahrefs AI marketing agent) — Notes: Shared workspace
• Fact: Total tools — Value: 16 — Notes: Across 4 categories
• Fact: Research library — Value: Scrapbook (URL→structured notes), SavedIn (Chrome extension scraping LinkedIn Saved) — Notes: Mateusz and Louise independently built similar tools
• Fact: Topic ideation — Value: Keyword Research Hub (4-tab workflow + tier classification), Entity Gap Finder (finds frequently-mentioned entities without dedicated pages), Trending Keywords (daily trend radar) — Notes: Includes cosine distance automatic tiering
• Fact: Radar/listening — Value: Reddit listener ×2 (Mateusz and Louise built independently on the same day), SEO Experiment Tracker (LLM verdict on experiments), News Aggregator — Notes: Two independent Reddit listeners show how badly the team wanted one
• Fact: Pipeline — Value: Editorial Pipeline (brief→publish, 7 stages), Data Refresh (quarterly data update automation), WP Processor (draft→WordPress-ready HTML) — Notes: Editor includes built-in Refine chat loop
• Fact: Hidden gem — Value: index.json auto-indexing + lightweight reference file — Notes: Mateusz’s context management: agent indexes first, fetches on demand

Data from Ahrefs Blog “We Ran an AI Hackathon for Our Content Team” (link, 2026–05–25), by Si Quan Ong. Elena Verna quote from original LinkedIn post.

One: The Best Tools Weren’t the Smartest — They Wrapped Existing Habits

Sixteen tools sounds like a lot. But if you re-sort them by “why they succeeded,” a counterintuitive pattern emerges.

Category 1: Tools that wrapped existing habits.

SavedIn is a Chrome extension Louise built. Its function is simple: scrape her LinkedIn “Saved” list, export author, headline, body, and URL into a dashboard.

This tool creates zero new behaviors. Louise was already saving LinkedIn posts. She just realized that digging through her Saved list, re-finding what she wanted, and manually pasting it into notes was excruciating. What SavedIn does: auto-scrape → structured storage → searchable. The “save posts” habit didn’t change. The execution time went from an hour to seconds.

Scrapbook is the same idea. Mateusz had always been collecting URLs and text snippets — articles he’d read, data points, quotes he wanted to reference. What Scrapbook does: paste a URL or text → AI reads it → auto-generates structured notes (summary, key bullets, claims-with-sources, 3 article ideas). The “collect URLs” habit didn’t change. The output went from “an unsorted bookmarks folder” to “a searchable research library you can query across articles.”

Building with Agent A is addictive in a way using ChatGPT isn’t. — Mateusz Makosiewicz

Using ChatGPT feels like asking a smart friend for a favor. Building a tool feels like hiring someone. Once you’ve hired one and watched it work, you start scanning your week for the next thing to hand off.

Category 2: Tools that solved “things you do every day but never document.”

Data Refresh is what Si Quan built — automated quarterly data post updates. “Every quarter, refresh the data in our data-driven posts” is something every content team does, but almost no one writes it into a formal workflow. Si Quan’s pain was specific: pull data → filter → create tables → paste back into WordPress. It sounds simple. It takes an entire day. Data Refresh turned it into: Pull → Filter → TablePress-ready.

SEO Experiment Tracker is the same. Every SEO runs experiments — change a title, add schema, adjust internal links — but most people’s “conclusions” rely on gut feel: “I think this helped.” Mateusz’s tool makes experiments structured: set hypothesis → snapshot baseline → periodic snapshots → LLM verdict (Worked/Didn’t Work/Inconclusive/Too Early). Not “I think.” “The data says.”

Category 3: Things you already did, turned into pipelines by agents.

Ryan ported his blog pipeline from Claude Code to Agent A without a hitch. Louise’s Editorial Pipeline goes further: brief → outline → draft → edit → polish → verify → publish — 7 stages, each output is editable before proceeding to the next. Writing was already happening. The pipeline just turned “one person writing from scratch” into “agent does 80%, human reviews and refines the remaining 20%.”

The common thread across all three categories: not one tool asked anyone to learn a new habit. Every tool accelerated a behavior that already existed and already caused friction.

That’s why “use AI more” as a directive is hollow — it implies you need to invent new AI use cases. In practice, the most effective AI use cases are things you’re already doing. You just haven’t handed them off to an agent yet.

One underrated detail: Louise added a “Scrap trends” tab on top of SavedIn — a weekly LLM report that runs across her entire research library, extracting themes, pain points, trends, and 5–10 ready-to-brief article ideas. The clipping tool quietly became an editorial calendar engine. “Save my posts” upgraded to “tell me what to write based on what I’ve been saving” — and it only took a few days because it built on habits and data that already existed. Nothing was built from scratch.

Two: Three Structural Gaps — Platform Lock-In, Tool Silos, No Approval

Producing 16 tools in 5 days is an impressive result. But it also exposes three problems — not “what they did wrong,” but “under what conditions this approach hits a wall.”

Gap 1: All tools locked into Agent A and Ahrefs data.

All 16 tools were built inside the Agent A workspace, with deep dependency on Ahrefs API. Keyword Research Hub’s four-tab workflow runs on Ahrefs data. The Reddit listener scrapes Reddit but executes within Agent A. Entity Gap Finder scans the Ahrefs blog.

This isn’t a problem today — they all use Ahrefs data, and that’s perfectly reasonable. It’s a problem tomorrow: if this team wants to add Google Search Console (for existing ranking data), LinkedIn API (to pull post bodies directly rather than via Chrome extension), or an arXiv digest for technical content inspiration (completely outside the Ahrefs data ecosystem), what do they do?

The answer: write new glue code. Every new data source means new integration code, new permission configuration, new maintenance overhead. There’s no unified tool discovery mechanism, no standard tool invocation protocol.

This isn’t just “inconvenient.” It creates implicit switching costs. Once a team has built 16 tools inside Agent A, deeply wired into Ahrefs API, the cost of switching platforms or adding new data sources increases exponentially. Platform lock-in isn’t “you can’t leave.” It’s “leaving costs too much.”

Gap 2: Tools are silos.

This is the most easily overlooked fracture.

Mateusz’s Keyword Research Hub produces keyword lists with tier classification — Tier 1 through Tier 4. Si Quan’s Entity Gap Finder needs to know which entities matter most — it should prioritize by tier. If these two tools could talk, Entity Gap Finder would consume Keyword Research Hub’s tier data to rank entities by priority. But they can’t — they’re two independent tools running in two different Agent A sessions.

Direct evidence: Mateusz and Louise independently built Reddit listeners on the same day. Two people building the same thing — proof that “monitor Reddit” was a shared team need. But because there’s no agent-to-agent discovery mechanism, Louise didn’t know Mateusz was building one, and Mateusz didn’t know Louise was building one. Result: two independent, functionally overlapping listeners.

In a system where agents self-declare via Agent Cards, the first person who deploys a Reddit listener has their agent automatically discovered by others. The second person who wants Reddit monitoring doesn’t need to rebuild — they just subscribe to the first listener’s output.

Gap 3: No approval layer for publish.

Louise’s Editorial Pipeline is comprehensive — brief → outline → draft → edit → polish → verify → publish, 7 stages. The final “publish” step produces WordPress-ready HTML.

During the hackathon, this publish was manual — Louise clicked publish in WordPress herself. But in a system trending toward automation, publish is the last write operation no one touched.

“Agent auto-publishes to WordPress live site” sounds great. But in a real content operations context: if draft generation is agent-operated and publish is also agent-operated — that’s zero approval layer. WPProcessor generates HTML, pushes directly to production, and no content manager ever said “this version is ready to go live.”

This isn’t a flaw in Louise’s design. In an Agent A workspace, permission boundaries aren’t part of the hacking scope — they’re infrastructure.

Three: “Use AI More” Is Wrong — Aim at Friction

Elena Verna (Lovable CMO) posted on LinkedIn something worth quoting again:

Everyone has a system, a stack, a workflow that supposedly changed their life, cured burnout, and maybe whitened their teeth. It creates the illusion that everyone else has it figured out. So you hesitate to ask basic questions, because it feels like you’re the only one who doesn’t get it.

That post resonated hard because she named the silent majority — people being told daily to “use AI more” who don’t know where to start, and are afraid to ask.

The Ahrefs hackathon gave a more grounded answer than any AI stack manifesto ever could.

Step one isn’t “pick an AI tool.” It’s write a frustration list.

Si Quan later admitted they didn’t do this before the hackathon, but if he were running it again, he’d have everyone write down, before touching any agent, the manual operations they repeat every week that they hate most. Not vague words like “research” — but specifics like “Every Monday I spend two hours digging through my LinkedIn Saved posts and pasting the good ones into a doc.” The more specific, the better.

That’s why SavedIn, Scrapbook, the Reddit listener, and Data Refresh succeeded. Their briefs weren’t “use AI for content research.” They were “eliminate a specific, recurring friction that I already feel.”

Step two isn’t “build the smartest tool.” It’s “wrap an existing habit.”

If your team already saves LinkedIn posts, collects URLs, lurks on Reddit, manually refreshes data posts every quarter — start from those behaviors. Build a tool that accelerates them 10x. Don’t invent new habits. Remove the friction from old ones.

Step three: Give agents memory.

Si Quan highlighted something underrated in his post: Mateusz’s index.json auto-indexing + lightweight reference file pattern.

The logic is simple: every repo has an index.json that auto-updates whenever a file is created, edited, or deleted. From this index, a lightweight reference file is regenerated — a plain-text summary the agent reads at the start of any conversation. The agent knows what exists without fetching anything, and only pulls full content when it actually needs it.

This solves the foundational problem of agent context management: not loading everything at once (that’s impossible with token limits), but indexing first, pulling on demand.

Mateusz said: “Memory and context matters more than word generation.” Everyone knows AI can write. The unlock is the agent being able to pull up the right facts — old drafts, saved research, your internal style guide, what you already rank for — without you pasting them in every time.

BeeOS: Turning Content Agents Into a Pipeline, Not a Personal Toolbox

Let’s connect the three conclusions:

• 16 tools built in 5 days. The core logic: wrap existing habits, eliminate manual friction, give agents memory.
• Three gaps prevent these from graduating from personal toolboxes to team production systems: platform lock-in (all tools bound to Agent A + Ahrefs data), tool silos (Scrapbook can’t feed the Pipeline; two Reddit listeners are duplicated work), no approval (publish lacks human-in-the-loop).
• Correct AI adoption isn’t “use AI more” — it’s aim at friction, build the memory layer first, then automate.

The missing bridge: how to turn 16 isolated tools into a reusable, composable, approvable agent collaboration pipeline. BeeOS’s three entry points answer this.

MCP Layer: Decoupling Tools from Data Platforms (ContentResearch)

Ahrefs’s 16 tools all depend on the Agent A execution environment and Ahrefs API. Want to add Google Search Console for search performance, LinkedIn API for post bodies, or Reddit API for real-time discussion? Write glue code. Every new data source is a new integration project.

MCP flips this. The ContentResearch agent doesn’t need to know which platform hosts which data source. It discovers all available data source tools at runtime via MCP tools/list, and invokes them through a unified tools/call interface. New data sources (GSC, Reddit API, LinkedIn API, arXiv) are added as MCP servers. The agent gains access automatically—no code changes needed.

ContentResearch agent
  → MCP tools/list discovers available data sources
    ├── Ahrefs API (keywords, competitor data, rankings)
    ├── Google Search Console (search queries, clicks, impressions)
    ├── Reddit API (posts, discussions, trends)
    ├── LinkedIn API (saved posts, feeds)
    └── Custom scrapers (any URL)
  → MCP tools/call: unified invocation interface, every call with audit trail

The content team is no longer locked into one vendor’s data ecosystem. SEO data from Ahrefs, social trends from Reddit API, search performance from GSC — all in the same agent’s MCP toolbelt, invoked through the same protocol.

A2A Layer: Agent-to-Agent Task Collaboration (BriefGenerator + DraftWriter + WPProcessor)

The hackathon’s biggest fracture: tools don’t talk to each other. Scrapbook produces structured notes that the Editorial Pipeline can’t see. Keyword Research Hub produces tier-classified keywords that Entity Gap Finder can’t consume for prioritization. Two Reddit listeners were built on the same day because no one knew someone else was already building one.

A2A turns every agent into a node that self-declares via Agent Card, sends structured tasks via JSON-RPC, and pushes real-time status via SSE.

ContentResearch agent (MCP layer, multi-source data collection)
  │
  ├──→ A2A SendMessage → BriefGenerator agent
  │       task: generate brief from research artifacts
  │       input: structured research artifact
  │       output: brief with topic, angle, keywords, tier, sources
  │
  ├──→ A2A SendMessage → DraftWriter agent
  │       task: generate draft from brief
  │       SSE streaming: real-time draft deltas visible
  │
  ├──→ A2A SendMessage → WPProcessor agent
  │       task: draft → WordPress-ready HTML
  │       output: HTML with internal links and formatting
  │
  └── New agent discovery
          RedditMonitor agent goes live → Agent Card auto-broadcasts
          Other agents discover via Agent Card → no rebuilding needed

Three key changes:

• No more duplicate building. The first Reddit listener deploys as an agent. Everyone else discovers and subscribes via Agent Card.
• Data flows between tools. Scrapbook’s research notes flow as structured artifacts into BriefGenerator. No manual copy-paste.
• Full chain traceable. Every task has a unique ID, state machine, and input/output artifacts. You can trace exactly which data source fed which agent at which stage to produce a piece of content.

OpenAPI Layer: Approval Boundary (PublishGate)

The Editorial Pipeline’s final step — “publish to WordPress live site” — was done manually during the hackathon. In a production system, it must go through approval.

BeeOS’s OpenAPI invoke path defines the permission boundary for agent write operations:

DraftWriter agent produces HTML
  │
  └──→ PublishGate (OpenAPI layer)
         ├── Draft phase: low permission (read/create)
         ├── Review phase: content manager reviews
         └── Publish phase: write production
                → bak_publish_controlled scope
                → enters approval queue
                → content manager approves → push to live site

The four pipelines together:

• Agent Role: ContentResearch — Entry Point: MCP — **bak_ scope: bak_mcp_research — Responsibility: Collect and organize research notes from multiple sources — Forbidden**: Write to CMS, publish
• Agent Role: BriefGenerator — Entry Point: A2A — **bak_ scope: bak_a2a_brief — Responsibility: Generate content briefs from structured research artifacts — Forbidden**: Modify source data, publish
• Agent Role: DraftWriter — Entry Point: A2A — **bak_ scope: bak_a2a_draft — Responsibility: Generate drafts from briefs with SSE streaming — Forbidden**: Publish, modify style guide
• Agent Role: PublishGate — Entry Point: OpenAPI — **bak_ scope: bak_publish_controlled — Responsibility: Approve and publish drafts to WordPress live site — Forbidden**: Skip approval, modify content

User initiates content production task
  │
  ├── ContentResearch (MCP layer)
  │     → tools/list discovers GSC, Reddit API, Ahrefs, LinkedIn
  │     → tools/call collects data, produces structured research artifact
  │
  ├── BriefGenerator (A2A layer)
  │     → Agent Card discovers ContentResearch
  │     → JSON-RPC SendMessage: receives research artifact
  │     → outputs structured brief
  │
  ├── DraftWriter (A2A layer)
  │     → receives brief, streams draft via SSE
  │     → each artifact delta visible in real time
  │
  └── PublishGate (OpenAPI layer)
        → WPProcessor produces WordPress-ready HTML
        → enters bak_publish_controlled approval
        → content manager approves → push live

The Ahrefs hackathon produced 16 tools in one person’s workspace. BeeOS turns those tools into a reusable, composable, approvable agent collaboration pipeline.

The difference isn’t in the number of tools — it’s in three layers:

• Data layer: MCP decouples the ContentResearch agent’s toolbelt from any single execution platform. Ahrefs + GSC + Reddit today, LinkedIn API or arXiv tomorrow — no agent code changes.
• Collaboration layer: A2A makes tools talk via structured tasks. Scrapbook artifacts → BriefGenerator → DraftWriter → WPProcessor — not manual copy-paste, but JSON-RPC.
• Security layer: OpenAPI’s bak_ permission boundaries put human approval on publish. Agent drafts at low permission. Push to live site goes through bak_publish_controlled approval.

Closing

The Ahrefs content team did something remarkably simple that almost no team does: instead of demanding “use AI more,” they asked everyone to aim at their most painful manual task and eliminate it with a specific tool.

The proof is in three insights: the best AI tools wrap existing habits (SavedIn, Scrapbook), not create new ones; agent memory matters more than agent writing (Mateusz’s index.json pattern); and five days is enough to move a content team from “talking about AI” to “already using AI to work.”

If you run a content team or are figuring out how to move yours past the “use AI more” fog, three questions are worth writing down now:

1. What manual operations does your team repeat every week that no one ever writes into a formal process document? (Be honest. Boring counts.)
2. If each operation got a small tool—not a perfect product, just a friction-removing v1—who would build it and how would the output change?
3. Once those tools exist, can they talk to each other? Or will they become isolated islands on different people's machines?

If question three’s answer is “islands,” start by making tools pass data to each other. If you can’t answer question one, spend an afternoon having your team write a frustration list — that’s a more valuable starting point than any AI stack.

Ryan Law’s directive was one sentence: “The more specific your goal, the better the outcome.” That sentence is more useful than any AI product roadmap, because it moves the starting point from “what technology should we use” to “what is wasting your time.” You don’t need to know what an Agent Card is, how to configure an MCP server, or what states an A2A task has. You just need to know: what do you keep doing manually, and hate every time. Start there. Spend an afternoon building a v1. It doesn’t need to be perfect. It just needs to save tomorrow’s you an hour of manual work.

References & Further Reading

• Source (factual basis): We Ran an AI Hackathon for Our Content Team. Here’s What We Built with Agent A (Ahrefs Blog, 2026–05–25, by Si Quan Ong)
• Elena Verna LinkedIn quote: original post
• BeeOS: docs.beeos.ai · openapi.beeos.ai · a2a.beeos.ai · mcp.beeos.ai
• A2A Specification: A2A (Google)
• MCP Specification: Model Context Protocol

BeeOS: docs.beeos.ai · openapi.beeos.ai · a2a.beeos.ai · mcp.beeos.ai