| name | vc-intern |
| description | VC intern research skill — source projects from Twitter, RootData, and DefiLlama, research & categorize them, and produce a lean sector list. Does the grunt work a VC intern would do. |
| user-invocable | true |
| metadata | {"openclaw":{"requires":{"env":["TWITTER_TOKEN","ROOTDATA_KEY"],"bins":["curl","python3"]},"primaryEnv":"TWITTER_TOKEN","emoji":"📊","install":[{"id":"curl","kind":"brew","formula":"curl","label":"curl (HTTP client)"},{"id":"python3","kind":"brew","formula":"python@3","label":"Python 3"}],"os":["darwin","linux","win32"]},"author":"vc-intern","version":"2.0.0"} |
VC Sector Research Skill
End-to-end VC research workflow: source projects from Twitter/X, RootData, and DefiLlama, research and categorize them, and produce a lean sector list.
Invocation
/vc-intern <sector or topic> [optional: additional keywords, known project names, focus areas]
Examples:
/vc-intern AI agents infrastructure/vc-intern DePIN wireless networks/vc-intern LLM developer tools — focus on open source/vc-intern restaking protocols — include EigenLayer, Symbiotic, Karak
Workflow
Execute the following steps sequentially. Use parallel tool calls within each step where possible.
Step 1 — Project Sourcing (Twitter + RootData + DefiLlama + WebSearch)
Source projects from all four channels in parallel. Reusable scripts live in scripts/ — use them instead of writing temp scripts at runtime.
1-Pre — Keyword Expansion
Before querying any source, generate 8-12 keyword variants covering:
- Literal sector phrase — e.g., "onchain FX"
- Synonyms & jargon — e.g., "forex protocol", "stablecoin swap", "currency exchange"
- Sub-vertical terms — e.g., "stablecoin AMM", "FX settlement", "FX derivatives"
- Institutional/off-chain adjacent — e.g., "digital asset brokerage", "crypto OTC", "prime brokerage"
- Regional/ecosystem terms — e.g., "local currency stablecoin", "non-USD stablecoin", "LatAm stablecoin"
- Specific known names (if user-provided) — e.g., "Mento", "Nonco"
This keyword list feeds into Steps 1A–1C. Broader keywords catch projects that describe themselves differently.
1A — Twitter Sourcing
Use the reusable script to sweep multiple keyword queries:
python3 scripts/source_twitter.py \
--queries "onchain FX" "stablecoin foreign exchange" "local currency stablecoin" \
"FX protocol crypto" "non-USD stablecoin" "stablecoin swap" \
--min-likes 10 \
--max-results 50 \
--output output/sources/twitter.json
Then for each unique project handle found, enrich with profile and KOL data:
curl -s -X POST "https://ai.6551.io/open/twitter_user_info" \
-H "Authorization: Bearer $TWITTER_TOKEN" \
-H "Content-Type: application/json" \
-d '{"username": "<PROJECT_HANDLE>"}'
curl -s -X POST "https://ai.6551.io/open/twitter_kol_followers" \
-H "Authorization: Bearer $TWITTER_TOKEN" \
-H "Content-Type: application/json" \
-d '{"username": "<PROJECT_HANDLE>"}'
1B — RootData Sourcing
Use the reusable script with the expanded keyword list. Note: RootData auth uses apikey: header, NOT Authorization: Bearer.
ROOTDATA_KEY="$ROOTDATA_KEY" python3 scripts/source_rootdata.py \
--queries "onchain FX" "forex protocol" "stablecoin platform" "local currency stablecoin" \
"non-USD stablecoin" "FX settlement" "digital asset brokerage" "crypto OTC" \
--relevance-keywords "fx,forex,stablecoin,currency,cross-border,settlement,payment,swap,brokerage,otc" \
--output output/sources/rootdata.json
For promising projects, fetch full details via RootData's project endpoint:
curl -s -X POST "https://api.rootdata.com/open/get_item" \
-H "apikey: $ROOTDATA_KEY" \
-H "Content-Type: application/json" \
-d '{"project_id": <ID>, "include_investors": true}'
RootData API notes:
- Auth header:
apikey: <key> (NOT Authorization: Bearer)
- Endpoints:
https://api.rootdata.com/open/ser_inv, https://api.rootdata.com/open/get_item, etc. (NOT /open/skill/)
get_item may return 401 on free-tier keys — fall back to search results + web search
1C — DefiLlama Sourcing
Use the reusable script to filter 7000+ protocols by category and keyword:
python3 scripts/source_defillama.py \
--categories "Algo-Stables,Dexs,CDP,RWA,Stablecoin Issuer,Reserve Currency,Forex" \
--keywords "fx,forex,stablecoin,currency,cross-border,settlement,swap,money,fiat" \
--name-keywords "fx,forex,stablecoin,currency,money,settlement" \
--min-tvl 100000 \
--limit 60 \
--output output/sources/defillama.json
DefiLlama provides TVL, chains, and protocol categories that other sources lack. It's strongest for DeFi-native protocols and weakest for institutional/off-chain players.
1D — WebSearch Cross-Reference
Search for existing curated sector maps and lists to catch projects the structured sources miss (especially institutional/off-chain players):
WebSearch: "<sector> market map" OR "<sector> landscape" site:cbinsights.com OR site:defiprime.com OR site:messari.io
WebSearch: "<sector> startups funding 2026"
Fetch 1-2 hits with WebFetch and extract project names. This catches projects like institutional OTC desks, regulated fintechs, and stablecoin issuers that Twitter/RootData/DefiLlama may underweight.
1E — Merge & Deduplicate
Use the merge script to combine all sources:
python3 scripts/merge_sources.py \
--sources output/sources/twitter.json output/sources/rootdata.json output/sources/defillama.json \
--known "<user-provided known projects>" \
--output output/sources/merged.json
The merge script:
- Fuzzy-matches by name (strips " Protocol", " Finance", " Network", etc.)
- Combines fields: RootData for structured data (funding, investors, tags), Twitter for social signals (followers, KOL), DefiLlama for TVL/chains
- Ranks by multi-source signal strength (found in 3 sources > 2 > 1)
- Flags projects found only on one source
Goal: Identify 15-40 relevant projects with combined data from all sources.
Step 2 — Project Research
For each project identified, gather key information from RootData (structured data), Twitter (social signal), and web search (supplementary):
- RootData project detail (if project was found on RootData):
curl -s -X POST "https://api.rootdata.com/open/get_item" \
-H "apikey: $ROOTDATA_KEY" \
-H "Content-Type: application/json" \
-d '{"project_id": <ID>, "include_investors": true}'
This provides: description, tags, total funding, investors, founding date, social links, similar projects. (May return 401 on free tier — fall back to search results + web search.)
- Fetch recent tweets from each project to understand current focus:
curl -s -X POST "https://ai.6551.io/open/twitter_user_tweets" \
-H "Authorization: Bearer $TWITTER_TOKEN" \
-H "Content-Type: application/json" \
-d '{"username": "<PROJECT_HANDLE>", "maxResults": 10, "product": "Latest"}'
-
Web search each project to fill gaps not covered by RootData or Twitter:
- Key features / value proposition
- Team background (founders, notable team members)
- Launch date / current status (live, testnet, pre-launch)
- Key metrics if available (TVL, users, revenue, etc.)
-
Build a structured data record for each project:
Project: <name>
Website: <url>
Twitter: @<handle> (<follower_count> followers)
RootData: <rootdataurl> (if available)
One-liner: <what it does in one sentence>
Category: <sub-category within the sector>
Tags: <RootData tags>
Key Features: <2-3 bullet points>
Team: <key people and backgrounds>
Funding: <stage, amount, lead investors> (from RootData or web)
Investors: <investor names, lead flagged> (from RootData)
Status: <live/testnet/pre-launch>
Founded: <establishment_date from RootData>
Key Metrics: <if available>
KOL Followers: <notable followers>
Similar Projects: <from RootData similar_project field>
Source: <Twitter / RootData / DefiLlama / WebSearch — list all that found this project>
Step 3 — Categorization & Comparison
Analyze all researched projects and:
- Define 4-8 sub-categories within the sector (e.g., for "AI agents": Agent Frameworks, Agent Infrastructure, Agent Marketplaces, Agent-specific Chains, Agent Tooling, Agent Applications)
- Assign each project to a sub-category
- Categories should be MECE (mutually exclusive, collectively exhaustive)
Step 4 — Sector List
Generate a lean bullet-point list saved to <working_directory>/output/<sector-name>_sector_list.md (e.g., agentic_trading_sector_list.md). Derive the filename by lowercasing the sector name and replacing spaces with underscores. This is the scannable version — one line per project, grouped by category.
# [Sector Name] — Sector List
> [today's date] | [count] projects | [count] categories
### [Category 1]
- **[Project Name](https://website.com)** | Ecosystem | Last Round — One sentence: what it does + why it stands out.
- **[Project Name](https://website.com)** | Ecosystem | Last Round — One sentence: what it does + why it stands out.
### [Category 2]
- **[Project Name](https://website.com)** | Ecosystem | Last Round — One sentence: what it does + why it stands out.
- **[Project Name](https://website.com)** | Ecosystem | Last Round — One sentence: what it does + why it stands out.
[... repeat for each category ...]
---
*Data sourced from Twitter/X, RootData, and web research*
Format per bullet: - **[Name](website_url)** | <ecosystem> | <last round> — <one sentence highlight & differentiator>
Field rules:
- Ecosystem: Primary network — e.g.,
Ethereum, BNB Chain, Solana, Base, Multi-chain, Chain Agnostic. Use the chain the project is most associated with; use Multi-chain if deployed on 3+ chains with no clear primary.
- Last round: Most recent funding round — e.g.,
$13.8M (1kx, Feb 2025), $25M Series A (Archetype). Include amount, lead investor, and date if known. Use Bootstrapped if no VC funding, Not disclosed if unknown.
- One sentence: Lead with what the project does, end with what makes it different. Weave in KOL signal if it adds value (e.g., "followed by Vitalik"). No multi-line entries, no sub-bullets — strictly one line per project.
Output Files
All outputs are saved to <working_directory>/output/:
| File | Description |
|---|
<sector_name>_sector_list.md | Lean bullet-point sector list — one line per project, scannable |
sources/*.json | Raw sourced data from each channel (for debugging/re-runs) |
Reusable Scripts (in scripts/)
| Script | Purpose |
|---|
source_defillama.py | Fetch & filter DefiLlama protocols by category + keywords |
source_rootdata.py | Sweep RootData with multiple keyword queries, deduplicate |
source_twitter.py | Sweep Twitter with multiple keywords, extract project accounts |
merge_sources.py | Combine all sources, fuzzy-deduplicate, rank by signal strength |
Guidelines
- Breadth over depth: Aim for 15-40 projects. Better to have more projects with brief descriptions than fewer with exhaustive detail.
- Recency matters: Prioritize projects active in the last 3 months on Twitter.
- Funding signals: Note unfunded/stealth projects separately — they may be early opportunities.
- KOL signals: Projects followed by notable VCs/builders are worth highlighting.
- Be honest about gaps: If information is unavailable (funding, team), say "Not disclosed" rather than guessing.
- Categories should be MECE: Mutually exclusive, collectively exhaustive within the sector.
- If the user provides known project names, include them and search for additional ones around them.
- Ask the user before proceeding if the sector/topic is too broad (e.g., "AI" alone) — suggest narrowing.
Error Handling
- If
$TWITTER_TOKEN is not set, remind the user to get one at https://6551.io/mcp
- If
$ROOTDATA_KEY is not set, skip RootData sourcing and rely on Twitter + DefiLlama + web search
- If Twitter search returns few results, try alternative keyword combinations and broaden the search
- If RootData search returns few results, try broader keywords and check trending/funding endpoints for sector-adjacent projects
- If any source is unavailable, proceed with the others — the workflow should degrade gracefully (4 sources means no single point of failure)
- If web search cannot find info for a project, note it as "Limited public information" and move on
- If RootData rate limit is hit (429), respect the
Retry-After header before retrying
