AI agents are not one category anymore. That is the most confident thing I can say after a week of radar pulls.

As of June 28, every agent-flavored project that consistently lands on the GitHub monthly leaderboard, the Product Hunt monthly leaderboard, or the HN weekly leaderboard has settled into one of five layers. Each layer has its own champion, its own growth curve, its own user base. The five: research, memory, orchestration, anti-slop, evaluation. This post lays the map flat, then explains why “separated cleanly” matters more than “built strong.”

Layer 1: research, give the agent eyes on the open web

The research layer does one concrete thing. It gives the agent eyes that can search, read, and summarize across multiple external sources. This is the input side of the stack.

Pulled from the radar this week (as of June 28):

  • Panniantong/Agent-Reach, GitHub monthly #4, +22,848 stars this month, ★43,587 total. The description says it straight: “Give your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu, one CLI, zero API fees.”
  • mvanhorn/last30days-skill, GitHub monthly #6, +20,777 stars this month, ★47,179 total. Description: “AI agent skill that researches any topic across Reddit, X, YouTube, HN.”
  • Fundraisly, Product Hunt monthly #1, ↑1,468 votes. Description: “AI fundraising agent that finds investors and books meetings.”

The common thread: all three do “reading,” but they read for completely different goals. Agent-Reach chases platform coverage. last30days-skill chases a 30-day time window. Fundraisly chases one vertical (fundraising). My read: the research layer is going to keep splitting along vertical lines. Generic research tools will get squeezed by vertical ones.

Layer 2: memory, let the agent remember you across sessions

The memory layer does something quieter. It keeps an agent’s understanding of one user or one project continuous across sessions, tasks, and tool calls. This is the context side.

Radar picks:

  • supermemoryai/supermemory, GitHub monthly #19, +5,121 stars this month, ★27,782 total. Description: “Memory and context engine + app that is extremely fast, scalable, and can be run fully locally. The Memory API for the AI era.”
  • minimi, Product Hunt monthly #16, ↑552 votes. Description: “Your ambient memory for Claude.”

The technical paths here are splitting. One camp, supermemory, is “general memory API + local deploy.” The other camp, minimi, is “ambient memory bound to one specific agent.” I think the general memory layer becomes infrastructure, the way databases did. Vertical memory layers (bound to Claude, Cursor, or Codex) stay at the application layer and collect the margin.

Layer 3: orchestration, coordinate sub-tasks inside one agent

The orchestration layer solves the “agent got too long” engineering problem. Once an agent passes twenty tool calls, it has effectively become a distributed system. This layer is the execution side.

Radar picks:

  • can1357/oh-my-pi, GitHub monthly #15, +7,339 stars this month, ★14,907 total. Description: “AI Coding agent for the terminal, hash-anchored edits, optimized tool harness, LSP, Python, browser, subagents.”
  • ogulcancelik/herdr, GitHub monthly #16, +5,076 stars this month, ★7,765 total. Description: “agent multiplexer that lives in your terminal.”

oh-my-pi is more “single-agent internal augmentation.” LSP, hash-anchored edits, subagents, all inside one agent. herdr is more “multiple agents in parallel.” Multiplexer is literally the engineering translation of that word. My prediction: the orchestration layer in H2 2026 replays the frontend framework wars of 2023. Single-agent augmentation vs multi-agent orchestration. That fight runs another year.

Layer 4: anti-slop, stop the agent from producing average output

The anti-slop layer is output-side quality control. Its existence alone tells you something: model capability has gotten strong enough that the default output is already “correct.” Strong enough that taste and judgment are now the bottleneck.

Radar picks:

  • Leonxlnx/taste-skill, GitHub monthly #11, +28,908 stars this month, ★52,110 total, this month’s leaderboard champion. Description: “Taste-Skill, gives your AI good taste. stops the AI from generating boring, generic slop.”
  • asgeirtj/system_prompts_leaks, GitHub monthly #17, +5,827 stars this month, ★46,628 total. Description: “Extracted system prompts from Anthropic, Claude Fable 5, Opus 4.8, Cl…”

taste-skill is this month’s GitHub monthly leaderboard champion, gaining almost thirty thousand stars in a month. That number, alone, tells you what you need to know. system_prompts_leaks tells you something else: people aren’t just shipping “anti-slop output,” they are reverse-engineering the system prompts of good agents. That is itself a meta-tool against slop.

A side thread: @zarazhangrui’s 212-like tweet on June 26 made the same case for video. “Btw I used Borumi to create this video, and it’s genuinely the most underrated video recording/editing tool out there. It’s like Screen Studio + Descript + CapCut all in one.” The anti-slop toolchain for video is being pushed by the same crowd pushing taste-skill. Same vine.

Layer 5: evaluation, make agent failures locatable

The evaluation layer is post-hoc observability. The agent finished a task. How do you know which step broke?

Radar pick:

  • AgentX, Product Hunt monthly #14, ↑580 votes. Description: “Evaluate AI agent, pinpoint issues, and fix with one click.”

The project count in this layer is still small. The signal is already loud. @rauchg’s June 27 tweet (270 likes) said it directly: “Agents are particularly hard-to-debug software. For one, and by design, AI models behave in non-deterministic ways. Even two identical prompts don’t always yield the same output. But agents are also complex distributed systems.” A core Next.js maintainer publicly calling agents hard to debug. That signal matters more to builders than any leaderboard number.

Three cross-source signals stacked together

Map laid flat, now three cross-source signals from the last three weeks of the radar. Three completely different sources. All pointing to the same thing.

Signal one: @rauchg, “agents are particularly hard to debug” (June 27, 270 likes). The source is one of the most serious frontline observers in the engineering circle. He is naming a specific thing: agent is non-deterministic plus distributed system. Both properties stacked. Traditional debuggers are not enough.

Signal two: @swyx, “scaling without slop” (June 26, 46 likes). Original: “we have been scaling without slop by working with aligned domain experts to add coverage.” The source is devrel. He is naming another specific thing: scaling content is not possible with pure AI automation. You need “aligned domain experts plus AI.”

Signal three: @nikunj in the taste comment thread (June 26, 40 likes). Original: “a lot of people who never have built anything, can’t achieve taste without being in the arena.” The source is builders. He is naming a third specific thing: taste is not learned from the screen. It is earned in the arena.

Three signals, three people, three completely different stands (engineering, growth, product). All of them are saying the same sentence: the bottleneck of the agent era is not model capability. It is the maturity of the surrounding stack.

Supporting signal: foxmoss’s “Running a software jam in a world of slop” hit 52 points on HN (id 48698188). The piece is exactly about “how do you run a software jam in the slop era without drowning in slop.” The困境 he describes, the困境 @swyx describes about scaling, the困境 @nikunj describes about taste, are the same困境 seen from different sides.

What normal people and builders should pick

Map and signals done. One last section for the people who have to pick tools this week.

Three steps, in my read:

Step one, pick one layer and go deep. Do not try to cover all five at once. I would personally start with the anti-slop layer. Single-skill files give you the fastest input-output ratio. taste-skill gaining thirty thousand stars in a month did not happen for no reason.

Step two, after picking a layer, pick vertical over generic. In the research layer, do not start with a platform-covering tool like Agent-Reach. Start with a vertical (Fundraisly for fundraising, last30days-skill for the last 30 days of a topic). Generic tools are for people who already know what they are doing. Newcomers using generic tools drown.

Step three, leave evaluation and orchestration for phase two. Both layers have a strong dependency on the maturity of the layers below them. Without research and anti-slop in place, building evaluation first is spinning in the air.

Where the leverage actually moved

Last section, and the judgment I most want to leave with you.

The “leverage” of the agent era is moving from “who writes the best prompt” to “who keeps the tool stack cleanly separated.” The evidence is more than the GitHub monthly distribution. It is the three cross-source signals I just stacked.

@rauchg is talking about debuggability. He is telling you: the single-agent ceiling has been hit. The next move is engineering the stack.

@swyx is talking about scaling. He is telling you: the model’s “generic average output” alone will not scale. The next move is adding an anti-slop layer to the stack.

@nikunj is talking about taste. He is telling you: people who build in the arena beat people who watch from the screen. The next move is putting people with judgment into the stack as nodes.

Three sentences, three directions, one conclusion: the winners of the agent era will not be the ones writing the most beautiful prompts. They will be the ones whose tool stack is the cleanest five-layer separation.

References