Stop Building AI Agents Blind: This Repo Gives Them Wall Street Brains

Your AI agent can write code, debug errors, and summarize PDFs. But can it tell you whether gold's overnight crash will obliterate your A-share portfolio by lunch? Most developers are building AI agents with a massive blind spot. They're packing them with coding skills, creative writing prompts, and image generation tools—while ignoring the one capability that actually moves money: financial intelligence.

Here's the brutal truth. Markets don't wait for you to finish your morning coffee. By the time you've manually scraped Cailian, checked Polymarket odds, and cross-referenced Weibo sentiment, that arbitrage window has slammed shut. Your competitors? They're already deploying AI agents that ingest 10+ news sources simultaneously, auto-generate logic chain diagrams explaining market transmission, and spit out Kronos-powered predictions with news-aware adjustments.

What separates hobbyist agents from production-grade financial analysts? It's not bigger models. It's not fancier prompts. It's skills—modular, plug-and-play capabilities that transform generic LLMs into domain-specific powerhouses. And right now, there's one open-source collection that's making Wall Street-grade financial analysis accessible to any developer with a terminal.

Welcome to Awesome-finance-skills—the secret weapon that top quant developers are quietly deploying to give their AI agents genuine market intuition.

What is Awesome-finance-skills?

Awesome-finance-skills is a plug-and-play skill collection created by RKiding that empowers large language models with comprehensive financial analysis capabilities. Born from the intersection of autonomous AI agents and quantitative finance, this repository represents a fundamental shift in how developers think about agent capabilities.

The project emerged during a critical inflection point in AI development. As frameworks like AutoGPT, Claude Code, and OpenCode matured, developers realized that raw LLM intelligence wasn't enough—agents needed specialized tools to operate in complex domains. Finance, with its real-time data demands, multi-source information fusion, and high-stakes decision making, became the ultimate proving ground.

What makes this repository genuinely trend-worthy isn't just its feature set. It's the philosophy of modularity. Each skill is self-contained, framework-agnostic, and installable independently. Want news aggregation without prediction? Install alphaear-news alone. Need sentiment scoring for your existing pipeline? Grab alphaear-sentiment. This isn't a monolithic black box—it's a financial analysis LEGO set for AI builders.

The repository has gained significant traction among quantitative developers, fintech startups, and academic researchers. Its bilingual documentation (English and Chinese) reflects its global user base, particularly strong in Asian markets where A-share and HK stock analysis is critical. The companion project DeepEar demonstrates production deployment at scale, with a live demo available for immediate testing.

Why now? Three converging forces make this repository essential: (1) the proliferation of agent frameworks requiring standardized skill interfaces, (2) LLM context windows finally large enough to process multi-source financial data, and (3) retail and institutional demand for AI-powered market analysis that actually works in real-time.

Key Features That Separate Amateurs from Pros

Let's dissect what makes each skill in this collection genuinely powerful—not just marketing fluff, but technical capabilities that solve real quantitative problems.

alphaear-news: Multi-Source Intelligence Fusion

This isn't basic RSS aggregation. The news skill performs cross-lingual, cross-platform information fusion from 10+ sources including Cailian (China's premier financial wire), WSJ, Weibo (social sentiment early signals), and critically—Polymarket prediction market data. Polymarket integration is genius: it provides crowd-sourced probability estimates that often lead traditional media by hours. The skill structures outputs for LLM consumption, with relevance scoring and entity extraction built-in.

alphaear-stock: Comprehensive Market Data

Covers A-shares, Hong Kong, and US equities with OHLCV data, fundamental metrics, and ticker resolution. The technical architecture handles exchange-specific quirks—China's T+1 settlement, HK's half-day trading, US pre-market sessions—without requiring developer intervention. This means your agent can reason about "how did overnight US tech earnings affect HK semiconductor names before A-share opening?"

alphaear-sentiment: FinBERT + LLM Hybrid Scoring

Produces normalized sentiment scores from -1.0 (extreme bearish) to +1.0 (extreme bullish). The dual-model approach is crucial: FinBERT captures financial domain nuances (understanding that "dividend cut" is negative regardless of surrounding positive language), while the LLM component handles emerging terminology and contextual inference. This isn't toy sentiment analysis—it's production-grade financial NLP.

alphaear-predictor: Kronos Time-Series with News Adjustment

The crown jewel. Kronos isn't just another Prophet clone; it's specifically architected for news-conditioned forecasting. Traditional time-series models fail because markets are driven by information shocks, not just historical patterns. Kronos ingests sentiment trajectories from alphaear-sentiment and adjusts probability distributions accordingly. A gold crash with -0.85 sentiment and high volume gets very different predictions than the same price move with neutral sentiment.

alphaear-signal-tracker: Investment Thesis Evolution

Tracks how specific investment signals strengthen, weaken, or get falsified over time. This enables meta-analysis of your agent's own reasoning. Did that bullish copper thesis hold after Chinese PMI data? The signal tracker maintains state, preventing the amnesia that plagues stateless LLM agents.

alphaear-logic-visualizer: Market Transmission Diagrams

Outputs Draw.io XML for auto-generated logic chain diagrams. This isn't vanity—it's explainability infrastructure. When your agent recommends a complex pairs trade, the visualizer produces the causal chain: Fed policy → USD strength → emerging market outflows → HKEX liquidity contraction → specific stock impacts. Regulators, risk managers, and your future debugging self will thank you.

alphaear-reporter: End-to-End Research Production

Implements a Plan → Write → Edit → Chart pipeline for professional report generation. This structured workflow prevents the rambling, unstructured output typical of raw LLM financial analysis. Each stage is validated against the previous, ensuring data citations match charts and conclusions follow from evidence.

alphaear-search: Web + Local RAG Hybrid

Supports Jina AI (neural search), DuckDuckGo (privacy-focused), and Baidu (China coverage). The local RAG capability means sensitive internal documents can augment external data without cloud exposure—critical for institutional deployments.

Real-World Use Cases Where This Actually Matters

Use Case 1: Pre-Market Briefing Automation

A Hong Kong quant fund deploys an agent at 6:00 AM HKT. It ingests overnight US earnings, European macro data, Weibo sentiment on China policy rumors, and Polymarket odds on tariff announcements. By 8:30 AM, the team receives a structured briefing with transmission diagrams showing exactly how these factors cascade into their HK-listed positions. Decision latency drops from 90 minutes to 4 minutes.

Use Case 2: Social-Media-Driven Alpha Generation

A retail trading collective uses alphaear-sentiment to monitor Weibo for early signals of retail sentiment shifts on specific A-share sectors. When sentiment on EV batteries spikes +0.4 standard deviations before mainstream financial media coverage, they get 24-48 hour information advantage. The signal tracker maintains running scores on whether these social signals historically predicted actual price movement.

Use Case 3: Regulatory Risk Monitoring

A compliance team at a US-China cross-listed company uses alphaear-news with custom keyword filters. When Cailian publishes draft regulations affecting their sector, the agent immediately generates: (a) sentiment-adjusted probability of implementation, (b) logic chain showing affected business lines, (c) Kronos prediction of ADR price impact. Regulatory response time shrinks from days to hours.

Use Case 4: Automated Research Production

A fintech content platform uses alphaear-reporter to generate 50+ daily market briefs. The Plan stage selects relevant themes; Write produces structured analysis; Edit validates data consistency; Chart generates publication-ready visuals. Human editors only handle edge cases and tone refinement. Output scales 10x without proportional headcount.

Use Case 5: Multi-Agent Debate Systems

An advanced deployment runs three agent instances with different skill combinations—one news-heavy, one fundamentals-focused, one sentiment-driven. The signal tracker aggregates their conflicting predictions, and the logic visualizer produces argument maps showing where agents agree and diverge. This ensemble approach significantly outperforms any single configuration.

Step-by-Step Installation & Setup Guide

Getting started is deliberately frictionless. The maintainers understand that financial analysis has time value—setup delays cost money.

Option 1: One-Step Install (Recommended)

The npx skills CLI provides the fastest path to production:

# Install a specific skill (e.g., alphaear-news)
npx skills add RKiding/Awesome-finance-skills@alphaear-news

# Or search for all the skills and then select one
npx skills find "alphaear"

This approach downloads only what you need, keeps skills isolated, and enables version-pinned reproducibility. The @alphaear-news syntax specifies exact skill versions—critical for production deployments where unexpected updates could break strategies.

Option 2: Manual Installation

For developers who prefer full control or need to modify skill internals:

# Clone the repository
git clone https://github.com/RKiding/Awesome-finance-skills.git

# Copy skills to your agent (example for OpenCode)
cp -r Awesome-finance-skills/skills/* ~/.config/opencode/skills/

Critical configuration detail: Each skill folder must contain a SKILL.md file. This metadata file defines:

• Skill name and version
• Required environment variables (API keys, endpoints)
• Input/output schemas for framework integration
• Dependency declarations

Framework-Specific Paths

Pro tip for multi-framework shops: Install skills at both project and global scopes. Project-scoped skills override global ones, enabling strategy-specific customization without breaking shared defaults.

Verification

After installation, test immediately:

"分析贵金属跳水对A股的影响"
"Analyze how the gold crash affects A-shares"

A properly configured agent should respond with structured analysis incorporating news context, affected sectors, and logical transmission chains—not generic LLM hallucination.

REAL Code Examples from the Repository

Let's examine actual implementation patterns from Awesome-finance-skills and understand why they're designed this way.

Example 1: One-Line Skill Installation

# Install a specific skill (e.g., alphaear-news)
npx skills add RKiding/Awesome-finance-skills@alphaear-news

# Or search for all the skills and then select one
npx skills find "alphaear"

Why this matters: The npx execution model means zero global installation pollution. No package.json bloat, no version conflicts, no node_modules nightmares. The @alphaear-news tag implements semantic versioning for skills—you can pin alphaear-news@1.2.3 in production while testing alphaear-news@1.3.0-beta in staging. The find command with fuzzy matching ("alphaear" matches all skills with that prefix) enables discoverability without memorizing exact names. This is infrastructure-as-code for agent capabilities.

Example 2: Manual Installation with Framework Integration

# Clone the repository
git clone https://github.com/RKiding/Awesome-finance-skills.git

# Copy skills to your agent (example for OpenCode)
cp -r Awesome-finance-skills/skills/* ~/.config/opencode/skills/

Deep dive on the architecture: The skills/* glob copies all skill directories, each self-contained with its own SKILL.md, source code, and dependencies. The ~/.config/opencode/skills/ path follows XDG Base Directory specification—portable across Linux, macOS, and WSL. For OpenCode specifically, this enables both global (all projects) and project-local (.opencode/skills/) scoping. The cp -r approach lets you selectively copy—maybe you only want alphaear-news and alphaear-sentiment, not the full suite. This granular control is essential for minimizing attack surface in production agents.

Example 3: Multi-Framework Path Configuration

| Framework | Scope | Installation Path |
|:----------|:------|:------------------|
| **Antigravity** | Workspace | `<workspace>/.agent/skills/<skill>/` |
| | Global | `~/.gemini/antigravity/global_skills/<skill>/` |
| **OpenCode** | Project | `.opencode/skills/<skill>/` or `.claude/skills/<skill>/` |
| | Global | `~/.config/opencode/skills/<skill>/` |
| **OpenClaw** | Workspace | `<workspace>/skills` (highest priority) |
| | Managed | `~/.openclaw/skills` |
| **Claude Code / Codex** | Personal | `~/.claude/skills/` or `~/.codex/skills/` |
| | Project | `.claude/skills/` |

Framework design intelligence: Notice the consistent <skill>/ suffix pattern across all paths. This enables framework-agnostic skill packaging—the same skill directory works everywhere. The dual-scope design (workspace/project vs. global/personal) solves a real operational problem: your "aggressive momentum" strategy needs custom alphaear-predictor parameters, but your "conservative dividend" strategy uses defaults. Project-scoped installations override without forking the skill. OpenClaw's "highest priority" workspace scope is particularly clever—it enables temporary experimentation without any persistent changes.

Example 4: SKILL.md Requirement

> 💡 Each skill folder must contain a `SKILL.md` file.

The contract that makes interoperability possible: SKILL.md is the OpenAPI spec for agent skills. It declares:

• Interface contract: What functions the skill exposes, their parameters, return types
• Runtime requirements: Environment variables, API rate limits, hardware prerequisites
• Version compatibility: Which framework versions this skill supports
• Security scope: What data the skill accesses, what it transmits externally

Without this standardized metadata, frameworks would need custom adapters for every skill—the nightmare that killed early plugin ecosystems. The SKILL.md convention enables automatic skill discovery, validation, and sandboxing. When you run npx skills add, the CLI reads SKILL.md to verify framework compatibility before installation, preventing runtime failures.

Advanced Usage & Best Practices

Skill Composition Patterns: The real power emerges when combining skills strategically. A "morning briefing" agent might chain: alphaear-news → alphaear-sentiment → alphaear-predictor → alphaear-reporter. But a "real-time alert" agent needs parallel execution: alphaear-news and alphaear-stock simultaneously, with alphaear-signal-tracker evaluating trigger conditions.

Caching Strategy: News APIs have rate limits. Implement tiered caching: Polymarket data (frequently updated, 5-minute TTL), Cailian headlines (15-minute TTL), fundamental data (daily TTL). The skills don't enforce caching—you architect this at the orchestration layer.

Sentiment Calibration: FinBERT scores require domain-specific calibration. A -0.3 score might be "slightly bearish" for stable utility stocks but "extremely bearish" for speculative biotech. Use alphaear-signal-tracker to backtest historical sentiment thresholds against actual price reactions in your target universe.

Visualization Automation: The Draw.io XML output from alphaear-logic-visualizer can be automatically rendered via Draw.io's CLI or embedded in Notion/Confluence via their API. Don't let diagrams die in files—integrate them into decision workflows.

Security Hardening: The alphaear-search skill's local RAG capability is essential for institutional use. Configure it with Jina for external queries and local embeddings for internal documents. Never route sensitive position data through cloud search APIs.

Comparison with Alternatives

The verdict: LangChain tools are fine for prototypes but lack financial domain depth. Bloomberg is institutional-grade but locked behind procurement walls and zero agent integration. Custom builds give control but burn months before first trade. Awesome-finance-skills occupies the sweet spot: production-ready, domain-specific, framework-native, and genuinely free.

FAQ: What Developers Actually Ask

Q: Do I need a Bloomberg terminal or paid data subscriptions?
A: No. The skills use free/public data sources (Cailian's public feed, Polymarket's API, Yahoo Finance for OHLCV). For institutional-grade tick data, you'd supplement with paid feeds, but the architecture supports this via environment variables in SKILL.md.

Q: Which LLM should I use with these skills?
A: GPT-4-class models handle the reasoning well, but Claude 3.5 Sonnet excels at the structured output formats. For cost-sensitive deployments, GPT-4o-mini works for simpler tasks like news summarization, while reserve GPT-4o for alphaear-predictor and alphaear-reporter.

Q: Can I use this for live trading or just research?
A: The skills are analysis and decision-support tools, not execution systems. They produce predictions, reports, and signals—you connect to broker APIs separately. This separation is intentional: analysis quality and execution reliability have different engineering requirements.

Q: How do I handle Chinese language sources if my team doesn't read Chinese?
A: The skills output structured data (sentiment scores, entity tags, logic chains) in English even when sources are Chinese. The alphaear-news skill abstracts language at the ingestion layer. For raw text, LLM translation is automatic.

Q: What's the relationship to DeepEar?
A: DeepEar is the complete autonomous framework that uses these skills as components. Awesome-finance-skills is the modular skill collection you can integrate anywhere. Think of DeepEar as the car, skills as the engine parts.

Q: Are there rate limits I should worry about?
A: Yes—Cailian and Polymarket have unauthenticated limits. The skills respect these, but for production scale, configure API keys in each skill's SKILL.md environment section. Implement exponential backoff at the orchestration layer.

Q: Can I contribute my own financial skills?
A: The repository structure is designed for community extension. Follow the SKILL.md specification, include bilingual documentation, and submit PRs. The most requested additions are options flow analysis and crypto-specific skills.

Conclusion: Your Agent's Financial Awakening Starts Now

The gap between AI agents that "can" analyze markets and those that actually do comes down to one thing: specialized skills. Awesome-finance-skills isn't another wrapper around GPT-4 with a finance prompt. It's a meticulously engineered collection of capabilities that transform generic language models into domain-competent financial analysts—handling real-time news fusion, sentiment quantification, news-conditioned prediction, and explainable logic visualization.

What impresses me most is the architectural maturity. The modular design, framework-agnostic packaging, and standardized SKILL.md contracts solve problems that have plagued agent ecosystems since their inception. This isn't a hackathon project—it's production infrastructure that happens to be open source.

The financial world rewards information velocity and analytical rigor. Every day your agent lacks these capabilities is a day you're operating with a self-imposed handicap. The installation takes seconds. The skills are free. The live demo proves it works.

Stop building AI agents that are blind to the forces that actually move markets. Give your agent the skills it needs, and watch it start thinking like the analyst you always wished you had on call.

👉 Star Awesome-finance-skills on GitHub and start your first installation today. The market doesn't wait—and neither should your agent.

P.S. — If you want to see these skills operating in a full autonomous framework, check out DeepEar and try the free lite demo. It's what happens when financial AI stops being theoretical and starts being useful.