Agent Reach Deployment Guide: Make Claude Code / OpenClaw Understand Twitter / Xiaohongshu / Bilibili

One-line overview: Your AI Agent is great at coding—but when you tell it to “search the web for something,” it freezes up? Agent Reach is the one-command cure—install 14+ platforms (Twitter, Reddit, YouTube, Bilibili, Xiaohongshu, Douyin, WeChat Official Accounts, and more) in one go, and the Agent automatically knows which tool to use.

Project Overview

Agent Reach is an “internet capability installer” for AI agents. GitHub: Panniantong/Agent-Reach, MIT License, a Python package.

Its core positioning is truly distinctive: not a framework—it's a scaffolding tool.

What does that mean? Once your AI Agent (Claude Code / OpenClaw / Cursor / Windsurf...) has Agent Reach installed, it doesn’t go through a wrapper layer from Agent Reach. Instead, it directly calls upstream tools—twitter-cli / rdt-cli / yt-dlp / xhs-cli / douyin-mcp-server / Jina Reader / gh CLI—all selected by the project maintainers, battle-tested, and shipped with sensible default parameters. Agent Reach only handles:

1. Installer — one-liners: pip install agent-reach + agent-reach install to install all those upstream tools
2. Diagnoser — agent-reach doctor tells you which platforms work, which don’t, and how to fix them
3. Configurator — manages Cookie authentication, API keys, MCP services, etc. in one place
4. SKILL injection — registers SKILL.md for the Agent, so when it encounters requests like “search Twitter” or “watch a video,” it automatically routes to the right tool

Supports 14+ platform channels:

One-line takeaway: No commands to memorize, no web-scraper setup—just tell the Agent, and it can browse.

Difficulty / Time / What You Get

• Difficulty: ⭐ (beginner-friendly; truly one command)
• Time: 5–15 minutes (local); 30 minutes (server, including Cookie setup)
• What you get:
  • Claude Code / OpenClaw can directly read Twitter, browse Xiaohongshu, and read YouTube subtitles
  • Understand the design difference in the AI agent tool ecosystem: “scaffolding vs framework”
  • Learn how to use Cookie-Editor to manage cookies across multiple platforms in one workflow, avoiding QR login traps
  • Know that agent-reach doctor is a great practice for an agent toolchain

Target Audience

• Developers using Claude Code / OpenClaw / Cursor
• Want an Agent that can actually search the web for information, not just stare blankly
• Don’t want to deal with separate scrapers—or pay for separate APIs—for Twitter / Reddit / Xiaohongshu
• Already have an AI agent toolchain and want to add a layer of “internet capability”
• When running long tasks, want a way to get decent compute results without the bill going crazy (more on this later)

Core Dependencies & Environment

Minimum requirements:

Recommended / Optional:

Complete Project Directory Tree

Agent-Reach/
├── pyproject.toml                # Python package definition
├── agent_reach/
│   ├── __init__.py               # Version
│   ├── cli.py                    # CLI entry (argparse)
│   ├── core.py                   # Core read/search routing
│   ├── config.py                 # YAML configuration management
│   ├── doctor.py                 # Diagnoser engine
│   ├── cookie_extract.py         # Cookie extraction tool
│   ├── channels/                 # One file per platform
│   │   ├── base.py               # BaseChannel abstract class
│   │   ├── web.py                # Jina Reader
│   │   ├── twitter.py            # twitter-cli
│   │   ├── youtube.py            # yt-dlp
│   │   ├── github.py             # gh CLI
│   │   ├── bilibili.py           # yt-dlp + bili-cli
│   │   ├── reddit.py             # rdt-cli
│   │   ├── xiaohongshu.py        # xhs-cli
│   │   ├── douyin.py             # douyin-mcp-server
│   │   ├── linkedin.py           # linkedin-mcp
│   │   ├── wechat.py             # Exa + Camoufox
│   │   ├── rss.py                # feedparser
│   │   ├── exa_search.py         # Exa via mcporter
│   │   ├── weibo.py
│   │   ├── v2ex.py
│   │   └── xueqiu.py
│   ├── integrations/
│   │   └── mcp_server.py         # MCP server integration
│   ├── skill/                    # SKILL.md for the Agent
│   ├── guides/                   # Usage docs (ZH/EN/JA/KO)
│   ├── scripts/                  # Install scripts
│   └── utils/
├── config/
│   └── mcporter.json             # MCP tool configuration
├── tests/                        # pytest tests
└── docs/                         # README multilingual versions

As a user, you only need to touch three commands: pip install / agent-reach install / agent-reach doctor. channels/ is for developer extensions.

Step-by-Step Guide

Step 1: Basic Installation (main path)

# Recommended: isolate with pipx
pipx install agent-reach

# Or use pip (don’t install into system Python)
python3 -m venv ~/.agent-reach-venv
source ~/.agent-reach-venv/bin/activate
pip install agent-reach

After installing, you should have this command:

agent-reach --version
# agent-reach 1.4.0

Step 2: One-click install all upstream tools

# Default mode: auto-detect environment, install all dependencies
agent-reach install --env=auto

It will:

1. Install system dependencies (Node.js / gh CLI / mcporter / twitter-cli / rdt-cli, etc.)
2. Configure the search engine (connect Exa via MCP, no key required)
3. Detect whether you’re on local or a server, and give different recommendations
4. Register SKILL.md in the Agent’s skills/ directory

openclaw config set tools.profile "coding"
openclaw gateway restart

Step 3: Check channel status

agent-reach doctor

You should see something like:

✅ web              Jina Reader OK
✅ youtube          yt-dlp 2025.10.x installed
✅ rss              feedparser 6.0.x
✅ exa_search       Exa MCP connected
✅ github           gh CLI 2.x authenticated
⚠️  twitter         twitter-cli not logged in  → run: twitter login
⚠️  reddit          rdt-cli not logged in       → run: rdt login
✅ bilibili         yt-dlp OK
⚠️  xiaohongshu     xhs-cli not logged in      → see step 4
✅ douyin           douyin-mcp-server OK
✅ wechat           Exa search OK
✅ v2ex             API OK

✅ means it’s ready to use out of the box; ⚠️ means you need extra setup (usually Cookie authentication).

Step 4: Configure authentication for Cookie-required platforms (key section)

Twitter / Xiaohongshu / Reddit require a logged-in session—use Cookie authentication instead of QR code scanning.

Install Cookie-Editor first: Search “Cookie-Editor” in your Chrome / Edge extension store and install it.

Unified workflow:

1. Log in to x.com / xiaohongshu.com / reddit.com manually in your browser
2. Click the Cookie-Editor extension icon → "Export" → choose the "Netscape" format
3. Send the exported cookie string to the Agent, and tell it: “Help me configure Twitter”
4. The Agent uses cookie_extract.py to store it in ~/.agent-reach/config.yaml
5. Set file permissions to 600 so only your account can read it

# You can also configure via command line, not through the Agent
agent-reach config set twitter.cookie "$(pbpaste)"  # macOS
agent-reach config set xhs.cookie "$(xclip -o)"     # Linux

Step 5: Verify Cookie-enabled platforms

agent-reach doctor

Run diagnostics again. The platforms that were previously marked ⚠️ should now be ✅.

Step 6: Let the Agent try it once

Tell your Agent (Claude Code / OpenClaw / Cursor):

Help me see what this tweet says: https://x.com/vercel/status/1234567890

After reading SKILL.md, the Agent will automatically call the twitter tweet URL command and return the tweet content within seconds.

Try a few combinations:

Check what r/LocalLLaMA on Reddit has been discussing lately
Watch this YouTube video: https://youtube.com/watch?v=xxx
See what “camping gear” top posts exist on Xiaohongshu
What is this GitHub repository for: https://github.com/xxx/yyy

You’ll notice a detail: You don’t need to tell the Agent which command to run. SKILL.md already maps “read Twitter = twitter CLI” and “watch a video = yt-dlp,” etc. This is the biggest difference between Agent Reach and a normal tool collection—once installed, the Agent consciously chooses tools, not random trials.

Step 7 (optional): Semantic web-wide search

Exa is connected by default, so no API key is needed. Just ask the Agent:

Search for the latest LLM agent framework comparison in 2026, and give me 5 most relevant articles

It will call Exa’s MCP tool, then fetch full text using Jina Reader, and finally organize everything into a report.

Step 8 (optional): Access GitHub private repositories

# Login once
gh auth login

After completing OAuth, the Agent can read private repos under your account, file issues, PRs, and reviews.

Step 9 (optional): Bilibili / Douyin enhancements

Bilibili (local) is plug-and-play; Bilibili on overseas servers needs a proxy (~$1/month, residential proxies like FluxNode are recommended):

# Assume your proxy is http://127.0.0.1:7890
agent-reach config set bilibili.proxy "http://127.0.0.1:7890"
agent-reach doctor  # Re-run diagnostics

Douyin needs no login at all—just send the share link to the Agent:

Parse this Douyin video: https://v.douyin.com/xxxxx

The Agent calls mcporter call 'douyin.parse_douyin_video_info(...)', giving you the video information plus a no-watermark download link.

Step 10 (optional): Safety mode / Uninstall

Safety mode (for production servers or multi-user machines):

# Doesn’t install system packages automatically; only lists what it would do
agent-reach install --env=auto --safe

# Or preview what it would do without actually executing
agent-reach install --env=auto --dry-run

Full uninstall:

agent-reach uninstall             # Remove config + skill files
agent-reach uninstall --keep-config  # Keep tokens for re-install
pip uninstall agent-reach         # Uninstall the Python package

Troubleshooting

Q1: OpenClaw installation reports “permission denied” / Agent won’t move

Root cause: OpenClaw defaults to tools.profile = messaging, which prevents the Agent from executing shell commands. Fix:

openclaw config set tools.profile "coding"
openclaw gateway restart
# Open a new session and send “Help me install Agent Reach” again

Or modify ~/.openclaw/openclaw.json:

{
  "tools": { "profile": "coding" }
}

Q2: Xiaohongshu QR login keeps spinning

Don’t use QR. Do instead:

1. Install Cookie-Editor from the Chrome extension store
2. Log in to the Xiaohongshu web page in your browser
3. Cookie-Editor → Export → Netscape
4. Send the string to the Agent and say “Help me configure Xiaohongshu”
5. Done in 30 seconds

Q3: Reddit returns 403 as soon as you call it

Since 2024, Reddit enforces authentication. Fix:

# Install rdt-cli (Agent Reach install should already do it)
pipx install rdt-cli

# Login once (it will automatically grab cookies from your Chrome)
rdt login

# Verify
rdt search "LocalLLaMA" --limit 5

Like Twitter / Xiaohongshu, rdt login uses browser cookie auto-extraction—not QR.

Q4: Can’t connect to Bilibili from an overseas server

Bilibili blocks overseas IPs, so you need a residential proxy. Two options:

# Option 1: Configure via CLI (recommended for cheap proxies like FluxNode)
agent-reach config set bilibili.proxy "http://user:pass@proxy:port"

# Option 2: Environment variables
export HTTP_PROXY="http://user:pass@proxy:port"
export HTTPS_PROXY="http://user:pass@proxy:port"

Cheap residential proxies are about ~$1/month—no need to set up your own.

Q5: agent-reach doctor reports “channel not found” / channel file conflicts

Usually caused by some upstream tools failing to install, or you installed into system Python instead of pipx. The cleanest fix is to start fresh:

agent-reach uninstall
pipx uninstall agent-reach
# Clean up possible leftovers in ~/.agent-reach/
rm -rf ~/.agent-reach/

pipx install agent-reach
agent-reach install --env=auto
agent-reach doctor

Q6: You changed browsers / cookies expired

Cookies can expire after a few months. Just redo the same flow: “browser login → Cookie-Editor export → send to the Agent.” The Agent will automatically overwrite the old cookies in ~/.agent-reach/config.yaml.

Q7 (Bonus): When the Agent runs long tasks and the bill explodes—how do you calculate it?

Let me share one pitfall I personally hit while running Agents.

Agent Reach solves the problem of “how the Agent connects to the internet,” but when the Agent actually runs tool calls, it fundamentally still consumes LLM tokens. A typical “research competitors + summarize” task may involve 5–10 tool-call rounds (searching, grabbing webpages, reading tweets, searching again, reading again). That quickly turns into hundreds of thousands of tokens. Run 20+ tasks in a day, and your bill will explode fast.

Three connection approaches (from my own deployment experience):

1. Use Anthropic’s official API — the best experience, but when Claude Opus runs agent tasks, four-digit RMB bills per day are still normal
2. Use aggregation APIs like OpenRouter — slightly cheaper than official, but still expensive
3. Use Defapi — my current solution. Half the official price, and the protocol layer is fully compatible. Agent Reach configuration stays the same: no need to change any SKILL / prompt / tool-calling code

Concrete configuration (assuming your Agent uses the Claude / Anthropic protocol):

# ~/.openclaw/openclaw.json or env config for Claude Code
ANTHROPIC_BASE_URL=https://api.defapi.org
ANTHROPIC_API_KEY=sk-xxxxxx    # get it from defapi.org backend

Defapi’s models mostly support all three mainstream protocols—v1/chat/completions (OpenAI) / v1/messages (Anthropic) / v1beta/models (Gemini). Switching models is just changing a name. For “tool-call heavy” tasks like Twitter scraping, Xiaohongshu analysis, and video subtitle summarization, going from a four-digit to a three-digit monthly bill is absolutely real.

Further Reading / Advanced Directions

• Custom channel: Add a file under agent_reach/channels/, inherit BaseChannel, and implement four methods: can_handle(url) / read(url) / search(query) / check(). Then run pip install -e . again. Low barrier—one platform, one file.
• Replace upstream tools: channels/web.py uses Jina Reader by default. If you find it insufficient, switch to Firecrawl / Crawl4AI / your own crawler—change the import and you’re done.
• SKILL.md mechanism: After installing Agent Reach, SKILL.md automatically registers to ~/.claude/skills/ / ~/.openclaw/skills/. You can write your own SKILL.md to teach the Agent which channel to prioritize in specific scenarios.
• Any MCP via mcporter: Not just Exa—any MCP-compatible server can be connected via config/mcporter.json. Just change the alias’s startup command.
• Shared config across multiple Agents: Agent Reach config ~/.agent-reach/config.yaml is file-based. If you run multiple Agents (Claude Code + OpenClaw + Cursor) on the same machine, they can share the same config.
• Works with Defapi: Agent Reach fetches data, Defapi runs inference. One is an “information retrieval layer,” the other is a “compute cost layer.” Both are protocol-driven. Together, they form a “low-cost Agent long-task workflow.”

GitHub repo: Panniantong/Agent-Reach. Multi-language docs are in docs/README_en.md / docs/README_ja.md / docs/README_ko.md. The design philosophy is in the “Design Philosophy” section at the end of the README. If you want to contribute a new channel, feel free to open a PR—maintainer Neo Reid is very active.