vc-intern

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:

1. Literal sector phrase — e.g., "onchain FX"
2. Synonyms & jargon — e.g., "forex protocol", "stablecoin swap", "currency exchange"
3. Sub-vertical terms — e.g., "stablecoin AMM", "FX settlement", "FX derivatives"
4. Institutional/off-chain adjacent — e.g., "digital asset brokerage", "crypto OTC", "prime brokerage"
5. Regional/ecosystem terms — e.g., "local currency stablecoin", "non-USD stablecoin", "LatAm stablecoin"
6. 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):

1. 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.)

2. 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"}'

3. 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.)

4. 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:

1. 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)
2. Assign each project to a sub-category
3. 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