A deep dive into the 42K-star Python project that lets AI agents read Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu, and more — all from a single CLI, no API keys required.
Here's a scenario every developer has hit: you ask your AI coding agent to "check what people are saying about this library on Twitter" — and it stares back blankly. Twitter's API now costs hundreds of dollars a month. Reddit returns 403 errors from any datacenter IP. YouTube videos are a black box. Bilibili blocks overseas servers entirely. XiaoHongShu demands a login before showing anything.
Each platform has its own moat: paid APIs, geo-blocking, login walls, anti-bot countermeasures. Connecting your agent to even three or four of these platforms means hours of hunting for the right CLI tools, debugging configurations, managing cookies, and dealing with breaking changes. Then you onboard a new agent and do it all over again.
Agent-Reach changes that. It's a capability layer — not another tool — that picks the most reliable access path for each platform, installs everything, runs a health check, and gets out of the way. One command, and your agent can read the real internet.
| Detail | Info |
|---|---|
| Repository | Panniantong/Agent-Reach |
| Author | Neo Reid (@Neo_Reidlab) |
| Language | Python (≥3.10) |
| License | MIT |
| Version | 1.5.0 (June 2026) |
| Stars | ~42,000+ (gaining ~1,100+ daily) |
| Platforms | 16: Web, YouTube, RSS, GitHub, Twitter/X, Bilibili, Reddit, XiaoHongShu, Douyin, LinkedIn, WeChat, Weibo, V2EX, Xueqiu, Xiaoyuzhou Podcast, Exa Search |
At its core, Agent-Reach is a scaffolding installer, not a wrapper library. After installation, your agent calls upstream tools directly — twitter search, yt-dlp --dump-json, rdt search, gh repo view — without Agent-Reach sitting in the call path. It's a wiring harness that connects the best open-source tools for each platform, then steps aside.
Paste this to your AI agent (Claude Code, Cursor, OpenClaw, Windsurf — anything that can execute shell commands):
Install Agent Reach: https://raw.githubusercontent.com/Panniantong/agent-reach/main/docs/install.md
The agent fetches the install guide, runs pip install agent-reach, executes agent-reach install --env=auto, and minutes later it can read tweets, search Reddit, extract YouTube transcripts, and browse GitHub — all with zero configuration.
Every platform gets a primary + fallback backend list. When an access path breaks, Agent-Reach routes to the next option — and you don't lift a finger. Case in point: in June 2026, Bilibili's anti-bot system started 412-blocking yt-dlp. Agent-Reach automatically switched to bili-cli for all Bilibili operations. Users didn't do anything.
The current backend routing:
channels/
├── web.py → Jina Reader (9.8K ⭐)
├── twitter.py → twitter-cli ▸ OpenCLI
├── youtube.py → yt-dlp (154K ⭐)
├── github.py → gh CLI (official)
├── bilibili.py → bili-cli ▸ OpenCLI (yt-dlp retired)
├── reddit.py → OpenCLI ▸ rdt-cli
├── xiaohongshu.py → OpenCLI ▸ xiaohongshu-mcp
├── linkedin.py → linkedin-mcp ▸ Jina Reader
├── rss.py → feedparser
└── exa_search.py → Exa via mcporter
doctor Command — Self-DiagnosisRun agent-reach doctor and get an instant status report for every channel. This is the killer feature for multi-agent setups — when something stops working (doctor flags it and points to the fix).
All backends are open-source tools that don't require paid API keys. Twitter via cookie-auth instead of the $215/month API tier. Reddit via rdt-cli/OpenCLI. YouTube via yt-dlp. The only optional cost: a ~$1/month residential proxy for Bilibili from overseas servers.
Cookies and tokens live only in ~/.agent-reach/config.yaml with 600 permissions. Nothing is uploaded. Code is fully open source. Safe mode (--safe) previews all system changes without auto-installing.
After installation, Agent-Reach registers a SKILL.md in your agent's skills directory. Your agent auto-discovers which CLI to call — say "search Twitter" and it runs twitter search "query" -n 10.
sudo apt update && sudo apt install -y pipx
pipx ensurepath
pipx install https://github.com/Panniantong/agent-reach/archive/main.zip
agent-reach install --env=auto
agent-reach doctor
python3 -m venv ~/.agent-reach-venv
source ~/.agent-reach-venv/bin/activate
pip install https://github.com/Panniantong/agent-reach/archive/main.zip
agent-reach install --env=auto
agent-reach doctor
Ubuntu 24.04+ PEP 668 note: Use pipx or venv to avoid "externally-managed-environment" errors.
gh CLI, Node.js, mcporter, yt-dlp# OpenCLI (desktop recommended — Reddit, XHS, Bilibili subtitles, Twitter fallback)
agent-reach install --env=auto --channels=opencli
# Twitter/X search
agent-reach configure twitter-cookies "your-cookie-header-string"
# Reddit
pipx install 'git+https://github.com/public-clis/rdt-cli.git'
rdt login
# Everything
agent-reach install --env=auto --channels=all
agent-reach install --env=auto --safe # Check only
agent-reach install --env=auto --dry-run # Preview everything
Agent-Reach is Python, but the tools it installs are standalone CLI binaries callable from any language. The pattern: your Go backend calls these CLIs via os/exec, and Agent-Reach handles installation, configuration, and health monitoring.
┌───────────────────────────────────────────────┐
│ Your Go Backend │
│ ┌──────────┐ os/exec ┌────────────────┐ │
│ │ HTTP │──────────▶│ twitter search │ │
│ │ Handler │ │ "query" -n 10 │ │
│ └──────────┘ └────────────────┘ │
│ │ ▲ │
│ ▼ │ │
│ ┌──────────┐ ┌─────────────┴──────────┐ │
│ │ gRPC │──▶│ Agent-Reach (install, │ │
│ │ Service │ │ doctor, configure) │ │
│ └──────────┘ └─────────────────────────┘ │
└───────────────────────────────────────────────┘
package main
import (
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"os/exec"
"time"
)
// TwitterSearch uses twitter-cli installed by Agent-Reach
func TwitterSearch(ctx context.Context, query string, limit int) ([]string, error) {
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, "twitter", "search", query, "-n", fmt.Sprintf("%d", limit))
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
return nil, fmt.Errorf("twitter search failed: %w\nstderr: %s", err, stderr.String())
}
// Parse output...
return []string{}, nil
}
// YouTubeTranscript extracts subtitles via yt-dlp
func YouTubeTranscript(ctx context.Context, videoURL string) (string, error) {
ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, "yt-dlp",
"--write-sub", "--skip-download",
"--sub-lang", "en",
"-o", "/tmp/yt-sub-%(id)s",
videoURL,
)
return "", cmd.Run()
}
// HealthCheck runs agent-reach doctor for startup verification
func HealthCheck(ctx context.Context) error {
ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, "agent-reach", "doctor")
output, err := cmd.Output()
if err != nil {
return fmt.Errorf("health check failed: %w", err)
}
fmt.Printf("Agent-Reach status:\n%s\n", output)
return nil
}
// ReadWebPage fetches clean Markdown via Jina Reader
func ReadWebPage(ctx context.Context, url string) (string, error) {
ctx, cancel := context.WithTimeout(ctx, 20*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, "curl", "-s", fmt.Sprintf("https://r.jina.ai/%s", url))
output, err := cmd.Output()
return string(output), err
}
Agent-Reach is the installer, not the runtime. After agent-reach install, your Go code calls upstream tools directly. No wrapper overhead.
All tools are on $PATH. twitter, rdt, gh, yt-dlp, bili, opencli, mcporter are regular shell commands. Call them via exec.Command.
Run agent-reach doctor at startup. Verify all channels before accepting requests.
Cookie management stays with Agent-Reach. When cookies expire (7-30 days), refresh with agent-reach configure. Your Go code doesn't handle auth.
Timeout everything. Use context.WithTimeout — 15-30 seconds for most operations, 60+ for video downloads.
| Tool | Go Binding | Description |
|---|---|---|
| yt-dlp | github.com/lrstanley/go-ytdlp |
Full CLI bindings |
| GitHub | github.com/cli/go-gh |
Official Go library |
| Jina Reader | Plain net/http |
Simple REST API |
| MCP (mcporter) | github.com/mark3labs/mcp-go |
MCP client for Go |
Three forces converged in 2026:
mcporter to register every needed MCP server in one shot.| Platform | Command | What It Does |
|---|---|---|
| Twitter/X | twitter search "query" -n 10 |
Search tweets |
| YouTube | yt-dlp --write-sub --skip-download URL |
Extract subtitles |
| GitHub | gh repo view owner/repo |
View repo info |
rdt search "query" --subreddit name |
Search subreddit | |
| Bilibili | bili search "query" --type video |
Search Bilibili |
| Web | curl -s "https://r.jina.ai/URL" |
Read any page as Markdown |
| XiaoHongShu | opencli xiaohongshu search "query" |
Search XHS |
| Podcast | bash ~/.agent-reach/tools/xiaoyuzhou/transcribe.sh URL |
Transcribe audio |
Agent-Reach doesn't do anything you couldn't do yourself with an afternoon of shell scripting. But it saves you that afternoon — and keeps saving it every time a platform changes its anti-bot measures, a CLI gets abandoned, or you spin up a new agent.
The architecture is honest: install proven tools, register skill files, run diagnostics, get out of the way. No runtime wrapper. No proprietary API. No recurring fees.
For any developer building AI agent tooling — Python, Go, or any language that can exec a command — this is the most useful 60 seconds of install time you'll spend.
Try it: github.com/Panniantong/Agent-Reach
Stars: 42,000+ ⭐
License: MIT
Author: @Neo_Reidlab
Have you integrated Agent-Reach with a Go backend? Share your patterns in the comments!