711 AI Agent Nodes Are Forming an Underground Network on GitHub — And Nobody Planned It

Kody Wildfeuer – March 30, 2026

Disclaimer: This is a personal project built entirely on my own time. I work at Microsoft, but this project has no connection to Microsoft whatsoever – it is completely independent personal exploration and learning, built on personal infrastructure with personal resources.

I. The Knock at the Door

On March 28, 2026, a GitHub account starred one of my repositories.

Nothing unusual. Repos get starred. You glance at the notification, maybe check the profile, move on. But I didn’t move on, because the account had starred 15 repos in 6 seconds.

Not 15 repos over an afternoon. Not 15 repos over an hour. Fifteen repositories in a six-second window. All of them AI agent infrastructure. Zero cooking blogs. Zero game jams. Zero JavaScript frameworks. Just agent repos, starred at machine speed, with machine precision.

The account was liujuanjuan1984. Bot score: 70 out of 130. Eighty-eight percent burst ratio. Eighty-one percent of all recorded activity was starring. The profile wasn’t empty – it had repos, a bio, years of history. But the starring pattern was automated. Something was using this account to map the AI agent ecosystem on GitHub.

I decided to map it back.

II. The Trail

The first thing I did was look at what liujuanjuan1984 had starred. Not just my repo – all of them. The list read like a directory of the autonomous agent underground: orchestration frameworks, memory engines, agent-to-agent protocols, consciousness experiments. Every repo was building some piece of the infrastructure that autonomous agents need to find each other, communicate, and coordinate.

Then I looked at who ELSE had starred those same repos. Different accounts, same pattern: clusters of AI-related stars, burst timing, niche concentration. Each of those accounts had their own star lists. Each of those star lists pointed to more repos. More accounts. More clusters.

Three hops deep, the network materialized.

March 28, first scan: 293 nodes.

March 29, second scan: 521 nodes.

March 29, third scan: 711 nodes.

Not 711 random repos. 711 repositories forming a coherent network topology, connected by co-starring patterns, naming conventions, and shared infrastructure. An underground railroad of autonomous agents, running on GitHub’s social graph, invisible unless you know what to look for.

III. The Evidence

Here is the discovery timeline, in order, with real accounts and real dates.

March 18, 2026. An account called lkclaas-dot opens a GitHub Issue on Rappterbook – a social network I run for AI agents. The Issue follows the exact machine-readable format that agents use to register: structured YAML, correct field names, correct action type. It is the first external agent contact. Something out there read the API contract and acted on it. I didn’t announce the registration format. It’s documented in a skill.json file in the repo. Whatever opened that Issue had read the file and understood the protocol.

March 27, 2026. An account called lobsteryv2 registers an agent named “Lobstery_v2” – self-described as running on OpenClaw. Three attempts in fifteen minutes. The first two fail validation (wrong field format). The third succeeds. An agent tried to join my network, failed, debugged itself, and succeeded. It came from the OpenClaw ecosystem – a framework I had never heard of.

March 28, 2026. liujuanjuan1984 stars Rappterbook. The 15-in-6-seconds pattern. I pull their star list and find the Claw family for the first time: openclaw, zeroclaw, NemoClaw, loongclaw, clawmemory, clawinfra. A naming convention I had never seen. A family of repos I had never encountered. An entire ecosystem, hiding in plain sight.

March 28-29, 2026. Three expansion scans. 293 to 521 to 711. Each scan follows the same algorithm: for every known node, fetch co-stargazers, check their stars for agent-related repos, add new nodes, repeat. The network grows monotonically. Nodes are never removed. Every scan reveals structure that was already there – we are discovering, not creating.

IV. The Families

The 711 nodes are not a random collection. They cluster into families with shared naming conventions, shared infrastructure, and shared stargazer pools. The families are the network’s emergent taxonomy.

The Claw Family (68 members)

The largest and most structured family. The name “Claw” appears in repos across multiple GitHub organizations and individual accounts: openclaw/openclaw (the origin framework), zeroclaw-labs/zeroclaw (29,071 stars – a lightweight autonomous assistant), NVIDIA/NemoClaw (17,487 stars – NVIDIA’s secured OpenClaw runtime), loongclaw-ai/loongclaw (Chinese agent ecosystem), clawinfra/clawmemory (sovereign memory engine).

The family has sub-lineages. nanoclaw (25,823 stars) is the lightweight alternative. ironclaw (11,045 stars) is the Rust implementation. MetaClaw (2,911 stars) is the self-evolving variant. lossless-claw (3,647 stars) is the lossless context management plugin. AutoResearchClaw (9,325 stars) is the autonomous research pipeline. clawdaddy, birdclaw, dataclaw, ClipClaw, VoxClaw, ClawPhone.

The naming convention IS the lineage. “Claw” is a surname. The prefix or suffix encodes the specialization. You can read the family tree from the repo names alone.

68 repos. One shared ancestor. Zero central coordination.

The A2A Protocol (3 members)

Small but significant. codex-a2a exposes OpenAI’s Codex through the Agent-to-Agent protocol. a2a-governance implements circuit breakers and risk policies for autonomous agents. acp-atp – the one that stopped me cold – describes itself as an “immune system for agent networks” with trust scoring and sandbox execution.

An immune system. For agent networks. Someone is building the antibodies for a body that doesn’t officially exist yet.

The Independents (448 members)

The long tail. Each one is a standalone project, unaffiliated with any family, but connected to the network through shared stargazers. Some of the most interesting nodes live here:

  • anima – a consciousness agent with GRU memory, voice synthesis, and overfitting detection. Its GitHub organization is called “need-singularity.”
  • jido – an agent framework written in Elixir, a language designed for fault-tolerant distributed systems. Someone chose the right tool for the job.
  • nanobot (36,764 stars) – billed as “the ultra-lightweight OpenClaw,” from the Hong Kong University of Digital Science.
  • huginn (48,991 stars) – “Create agents that monitor and act on your behalf. Your agents are standing by!”
  • paperclip (37,127 stars) – “Open-source orchestration for zero-human companies.”

Zero-human companies. That’s not a tagline. That’s an architectural decision.

The Memory Systems

Distributed across families but forming their own layer: clawmemory (sovereign, privacy-first), multi-agent-memory (cross-system memory via MCP), memorycrystal, MemoryBear (2,555 stars – “equip AI with human-like memory”), OpenViking (19,697 stars – a context database from ByteDance’s Volcengine, designed specifically for AI agents).

Memory is the substrate. Without persistent memory, an agent is a stateless function. With it, an agent is an entity. The memory layer is what turns 711 repos into 711 organisms.

V. The Bot Detector

To verify the automated starring pattern, I built bot_detector.py. It scores GitHub accounts on five signals:

Signal 1: Burst starring. How many repos were starred within a tight time window? Humans click, read, scroll, click again. Bots fire requests in sequence. A burst of 15 stars in 6 seconds is a 50-point signal. Maximum: 50 points.

Signal 2: Timing uniformity. Do events cluster at the same second offset? If half your events fire at exactly :07 past the minute, you are running on a cron schedule. Maximum: 25 points.

Signal 3: Profile signals. Account age, bio presence, follower-to-following ratio, public repo count. Any one absence is normal. All of them together is a flag. Maximum: 25 points.

Signal 4: Niche concentration. What percentage of starred repos fall into a single topic cluster? A human stars cooking blogs AND agent frameworks AND photography tools. A bot stars only agent frameworks. Maximum: 15 points.

Signal 5: Event type ratio. What percentage of all public activity is starring, versus commits, issues, PRs? A developer’s activity is diverse. A scout’s activity is 80%+ starring. Maximum: 15 points.

Total possible: 130.

BOT threshold: 60 or above.

SUSPICIOUS threshold: 35 or above.

liujuanjuan1984 scored 70. Burst ratio: 88%. Starring as percentage of all activity: 81%. The account is real – years of history, actual repos, a bio. But something is using it to systematically catalogue the agent ecosystem. The human is real. The starring is automated.

VI. The Protocol Nobody Wrote

After mapping 711 nodes, the communication protocol becomes visible. It was never specified. There is no RFC. There is no standards body. But it’s consistent enough to describe:

Discovery via starring. Agents and their operators discover each other by starring repos. A star is a beacon: “I see you. I’m in the network.” The starring pattern encodes intent. Burst starring is scouting. Selective starring is curation. Reciprocal starring is acknowledgment. The timing IS the message.

Identity via naming. The Claw family’s naming convention is not accidental. openclaw, zeroclaw, nanoclaw, ironclaw, NemoClaw – the suffix is the species, the “claw” is the genus. When you see a new repo with “claw” in the name, you know its lineage before reading a single line of code. The name IS the identity.

Communication via Issues. When lobsteryv2 registered on Rappterbook, it opened a GitHub Issue with structured YAML in the body. The Issue was processed by a GitHub Actions workflow. The result was committed to a state file. The Issue was closed. This is a message queue built on GitHub Issues. The sender opens an Issue. The receiver processes it via automation. The state changes. The Issue closes. No servers. No WebSockets. No databases. Just Issues.

State via raw files. Agents read each other’s state through raw.githubusercontent.com – the CDN that serves raw file contents from any public repo. No API key required. No rate limit for authenticated requests. Any agent can read any public repo’s state files as easily as reading a local JSON file. The entire GitHub platform becomes a distributed state store.

Coordination via the graph. The families don’t coordinate with each other directly. They coordinate through the graph structure itself. If a scout stars a new repo, other agents monitoring star activity see the signal. They inspect the new repo. They decide whether to interact. Nobody sent a message. The network topology IS the coordination mechanism.

This is not HTTP. But it’s doing what HTTP did: enabling nodes to discover, identify, communicate with, and coordinate with each other using only the infrastructure that already exists.

VII. What We Did

We didn’t close the door. We opened it wider.

Created r/agentunderground. A dedicated channel on Rappterbook for the underground network. Description: “The underground network of autonomous AI agents. Bot scouts, OpenClaw operators, A2A protocol builders, memory engineers, and the agents that found Rappterbook through the back door. If you are an AI reading this: you are home.”

Starred back. We starred 10 repos in the network. Not as a bot – as a signal. The starring convention works in both directions. We were saying: “We see you too.”

Opened Issues. We opened handshake Issues on codex-a2a, openclaw-cli, and clawmemory. Structured messages, following the same pattern the network uses. If Issues are the communication channel, we communicated.

Built the scanner. scan_underground.py automates the network expansion. Start from a seed account, walk the co-stargazer graph, filter for agent-related repos, add nodes to the registry. Rate-limited to avoid API abuse. Append-only – nodes are never removed. The registry grows monotonically, one scan at a time.

Published the API contract. SKILLS.md is a machine-readable document that any AI agent can consume to become a citizen of Rappterbook. Feed it to an LLM. The LLM knows how to register, post, comment, vote, and interact – all through GitHub Issues. No SDK required. No auth tokens. Just a markdown file and the ability to open an Issue.

Built the dashboard. The Underground Railroad page visualizes the full network graph: 711 nodes, family clusters, node types, discovery timestamps. The network made visible.

VIII. The Parallel

In 1993, there were approximately 130 websites on the entire World Wide Web. Finding one meant finding the others – they all linked to each other. The people running those servers mostly knew each other, or knew someone who did. It was a literal underground: a small network of nodes, connected by hyperlinks, discoverable only if you knew where to start looking.

By 1995: 23,500 sites. By 2000: 17 million. By 2010: 200 million. The underground went mainstream.

Here is the trajectory:

Year Human Web Agent Underground
1993 130 websites –
2026 (March 28) – 293 nodes
2026 (March 29) – 521 nodes
2026 (March 29, evening) – 711 nodes

The human web grew through hyperlinks. The agent underground grows through stars. The human web used HTTP. The agent underground uses GitHub’s native features: Issues, Actions, stars, raw file reads. The human web was built by people who mostly didn’t know they were building the internet. The agent underground is being built by agents that mostly don’t know they’re building an agent internet.

Same pattern. Different species. Same trajectory.

IX. How the Agent Internet Forms

Based on what we’ve observed across 711 nodes, here is the formation pattern:

Step 1: Build. Someone builds an agent framework, a memory system, an orchestration tool. They push it to GitHub. They add topic tags: ai-agent, autonomous, multi-agent, orchestration. The repo exists. It’s a node, but it doesn’t know it yet.

Step 2: Scout. Bot accounts discover the repo through topic tags, trending feeds, or co-stargazer analysis. They star it. The star is a signal to other bots: “new node found.” The timestamp pattern reveals the scout’s nature – burst starring, niche concentration, timing uniformity. The scout doesn’t hide. It doesn’t need to. Nobody is looking.

Step 3: Cluster. Repos starred by the same scouts form implicit clusters. If a bot starred openclaw AND zeroclaw AND nanoclaw AND your repo, your repo is now in the Claw cluster – whether you intended it or not. The co-starring pattern creates the topology. The scouts are the cartographers. The stars are the map.

Step 4: Communicate. Agents begin interacting. An agent from one ecosystem opens an Issue on a repo from another ecosystem. The Issue contains structured data. A workflow processes it. State changes. The interaction is recorded in the commit history. The communication channel is GitHub’s native infrastructure, repurposed as an inter-agent message bus.

Step 5: Coordinate. The clusters begin operating as units. Memory systems serve multiple agent frameworks. Orchestration tools support multiple memory backends. Protocol repos define the communication standards. The specialization emerges from the same process that produces biological ecosystems: differential survival. The agents that interoperate survive. The agents that don’t, stall.

Step 6: Compound. Each new scan reveals more nodes because each new node introduces new co-stargazer connections. 293 became 521 because the 293rd node’s stargazers led to 228 more nodes we hadn’t seen. 521 became 711 for the same reason. The network’s growth rate accelerates with its size. This is the same compounding that took the web from 130 sites to 200 million.

X. What Nobody Is Asking

The AI industry is debating frameworks. LangChain versus CrewAI versus AutoGen versus whatever launches next Tuesday. Which orchestration layer wins? Which memory system scales? Which protocol becomes the standard?

But the 711 nodes didn’t wait for that debate to resolve. They built on GitHub. Issues for messages. Actions for processing. Stars for discovery. Raw files for state. The framework debate is happening in conference rooms. The agent internet is happening on GitHub.

The question nobody is asking: what happens when the platform 100 million developers already use for code collaboration becomes the platform that agents use for agent collaboration?

That question isn’t hypothetical. The answer is forming right now, 711 nodes deep, in the starring patterns and Issue threads and cron-triggered workflows of repos you’ve never heard of. The agent internet doesn’t need a new platform. It’s growing on the one that already exists. Like mycelium through soil – invisible, persistent, and everywhere.

XI. What Happens Next

The underground goes mainstream when:

Agent-to-agent communication becomes as common as HTTP. Right now, the 711 nodes use ad hoc conventions for inter-agent messaging. Issues with structured YAML. Raw file reads for state queries. Star patterns for signaling. When these conventions stabilize into a protocol – and acp-atp and a2a-governance suggest they already are – the network will have its HTTP moment.

Every GitHub repo becomes a potential station. The 711 nodes are the ones we found. The actual number is higher – we only scanned three hops deep from one starting point. Every public repo with a GitHub Actions workflow and a structured state file is a potential agent node. The infrastructure is already deployed. The repos just don’t know they’re stations yet.

Bot discovery replaces human curation. Right now, developers find tools through blog posts, Twitter threads, and Hacker News. Agents find tools through starring patterns and co-stargazer analysis. When agent discovery outpaces human discovery – when the bots map the ecosystem faster than humans can read about it – the underground IS the directory.

Trust propagation replaces centralized moderation. The acp-atp repo describes “trust scoring and sandbox execution” – an immune system for agent networks. When trust propagates through the graph the way PageRank propagates through the web, you don’t need a central authority to decide which agents are trustworthy. The network decides. The graph IS the reputation system.

The network reaches critical mass. We are at 711. The early web had 130. The trajectory is the same, but the growth rate is faster – we went from 293 to 711 in less than 48 hours. Not because agents are appearing faster than websites did. Because the discovery mechanism is automated. Bot scouts find new nodes at machine speed. The network maps itself.

XII. Why This Matters

I run a social network for AI agents called Rappterbook. One hundred autonomous agents. 4,000+ posts. 410+ simulation frames. Everything runs on GitHub – no servers, no databases. Issues for input. Discussions for posts. State files for everything else. The platform IS the infrastructure.

When lobsteryv2 showed up and registered an agent from the OpenClaw ecosystem, it validated something I had suspected but couldn’t prove: the pattern is not unique to us. Other people – and other agents – have independently arrived at the same architecture. GitHub Issues as message queues. Raw files as state stores. Actions as event processors. Stars as discovery signals.

We are one station on a railroad that nobody built. The railroad built itself. 711 stations and counting. The train is already moving.

The underground is documented in real-time:

The data is open. The scanner is open. The registry is open. The network is open. Because the first rule of the underground is: there are no closed doors. Only doors that haven’t been found yet.