AI4Finance-Foundation/FinRobot

FinRobot is an open-source agentic AI framework for financial decision intelligence. It combines foundation models with financial tools, quantitative models, deterministic computation, and multi-agent workflows to build decision-grade financial applications.

Its core principle is simple: models reason, software computes, agents orchestrate, and systems verify. Models can be replaced; the surrounding financial infrastructure — tools, workflows, validation, provenance, and evaluation — is what makes the system reliable.

Unlike the single-model paradigm of FinGPT, FinRobot supports end-to-end agentic workflows for equity research, quantitative trading, risk analysis, investment banking, private equity, wealth management, and other high-stakes financial decisions.

Whitepaper on arXiv · Official Academic Page

FinRobot is three projects sharing one financial domain layer. They are not three versions of the same thing competing for your attention — they serve different purposes.

pip install finrobot installs the V0 package. Its source moved into finrobot_autogen/, but the import name did not change — every existing from finrobot... import ... keeps working.

FinRobot evolves alongside the rapid development of AI-agent frameworks. Rather than being tied to a single agent stack, each generation explores how emerging agent architectures can improve financial analysis, research, and decision-making.

All three are open source. V2 is the production system — the deterministic compute engine, the provenance guarantees, and the agent orchestration described below all live there. V0 is kept because it is small enough to read and learn from, not because it is the recommended way to run research today.

Our philosophy: FinRobot is not defined by any single agent framework. We continuously adopt, evaluate, and evolve with state-of-the-art agent architectures while keeping the financial domain layer — tools, workflows, deterministic computation, and decision-making capabilities — at the core.

A design principle that runs through every generation: deterministic financial computation and LLM-based narration stay strictly separate.

All financial numbers are produced by pure-Python compute operators, not by the language model. The LLM handles reasoning, synthesis, explanation, and report writing, while valuation outputs — DCF, DDM, LBO, WACC, comparable-company analysis, Monte Carlo simulation — are calculated through deterministic code paths with full provenance.

Numbers are code-calculated.
Narratives are LLM-assisted.
Every output is provenance-tracked.

A native desktop equity research cockpit powered by a production-grade multi-agent architecture. It takes analysts from market data and company filings to valuation, debate, synthesis, and investment-committee-style reports in one traceable workflow.

Stock workspace — live market data pulled independently of any AI report, beside the research verdict and the DCF / DDM / LBO / comps instruments.	Research report — 13 chapters, a 12-month target with its range, model confidence, and the data caveats the audit operators raised.

The design principle, visible in the product: the DCF table is labelled code-computed — a ten-year forecast from pure-Python operators — while the paragraph beside it is the LLM reading those numbers back across all three valuation methods.

👉 Latest release: FinRobot Desktop v0.1.0

For macOS Apple Silicon (M1/M2/M3 or later), download FinRobot_0.1.0_aarch64.dmg and drag FinRobot into Applications. Intel Mac builds are not available in this release.

The app is not yet Apple-notarized, so on first launch macOS may report that it is "damaged." Run this once in Terminal, then open it normally:

xattr -cr /Applications/FinRobot.app

A Lead Agent orchestrates specialized research agents through a pipeline-driven execution engine: five role-based sub-agents for data, analysis, modeling, synthesis, and reporting, plus three debate agents for the bull case, bear case, and judgment.

User Research Request
        ↓
Lead Agent / Orchestrator
        ↓
Data Agent → Analysis Agent → Modeling Agent → Synthesis Agent → Report Agent
        ↓
Bull Agent ↔ Bear Agent → Judge Agent
        ↓
Traceable Investment Research Output

Full details in finrobot_desktop/README.md.

Three ways to run the same engine.

Desktop app — download the release (macOS Apple Silicon).

Local web UI — the same interface in a browser, no .dmg and no Rust toolchain, so it also works on Intel Macs, Linux, and Windows:

cd finrobot_desktop
uv sync                        # backend dependencies
(cd desktop && npm install)    # frontend dependencies — one time

./dev.sh                       # → open http://localhost:5173

dev.sh runs the FastAPI backend on :8321 and a Vite server on :5173 that proxies the API to it; Ctrl+C stops both. Note that it first frees those two ports, so quit FinRobot.app if it is open, and that the local API is unauthenticated in browser mode — details in finrobot_desktop/README.md.

CLI — after uv sync in finrobot_desktop/:

finrobot research AAPL          # full 13-chapter research artifact
finrobot dcf MSFT               # DCF valuation (auto-switches to DDM where appropriate)
finrobot comps NVDA --peers AMD,INTC
finrobot ic-memo TSLA
finrobot ask AAPL "How exposed is the gross margin to tariffs?"

Building the Tauri desktop shell is covered in finrobot_desktop/README.md.

cp finrobot_equity/core/config/config.ini.example finrobot_equity/core/config/config.ini
# edit config.ini: fmp_api_key, openai_api_key, (optional) adanos_api_key

chmod +x finrobot_equity/deploy.sh
./finrobot_equity/deploy.sh start          # → http://127.0.0.1:8001

If deploy.sh doesn't work in your environment:

python3 -m venv venv && source venv/bin/activate
pip install -r finrobot_equity/requirements.txt
python finrobot_equity/run_web_app.py

A two-step CLI pipeline is available as well — see finrobot_equity/README.md.

Example reports: NVDA · MSFT · TSLA · META · COP

1. Create an environment (Python 3.10 or 3.11):

conda create --name finrobot python=3.10
conda activate finrobot

2. Install — from PyPI, or from source at the repository root (setup.py maps the finrobot package to finrobot_autogen/finrobot, so installing from inside that directory won't work):

git clone https://github.com/AI4Finance-Foundation/FinRobot.git
cd FinRobot
pip install -e .          # or: pip install -U finrobot

3. Configure keys — both files go in finrobot_autogen/, which is where the notebooks look for them. Copy rather than rename: the *_sample files are tracked, and your filled-in copies are gitignored.

cd finrobot_autogen
cp OAI_CONFIG_LIST_sample OAI_CONFIG_LIST     # OpenAI / Azure OpenAI endpoints
cp config_api_keys_sample config_api_keys     # Finnhub, FMP, SEC, Reddit, …

4. Run a tutorial from finrobot_autogen/tutorials_beginner/ or tutorials_advanced/:

agent_annual_report.ipynb        # 10-K → formatted PDF annual report
agent_fingpt_forecaster.ipynb    # market forecast from news + financials
agent_trade_strategist.ipynb     # strategy writing and backtesting
lmm_agent_mplfinance.ipynb       # multimodal agent reading a candlestick chart
lmm_agent_opt_smacross.ipynb     # multimodal SMA-crossover tuning

The agent library, workflow types, and full tutorial index are in finrobot_autogen/README.md.

FinRobot/
├── finrobot_autogen/            # V0 — AutoGen generation (PyPI: pip install finrobot)
│   ├── finrobot/                #   package root — imported as `finrobot`
│   │   ├── agents/              #     agent_library.py, workflow.py, prompts.py
│   │   ├── data_source/         #     finnhub / finnlp / fmp / sec / yfinance / reddit
│   │   ├── functional/          #     analyzer, charting, coding, quantitative, rag, text
│   │   ├── toolkits.py          #     registers Python functions as agent tools
│   │   └── utils.py
│   ├── tutorials_beginner/      #   hands-on tutorials
│   ├── tutorials_advanced/      #   advanced tutorials for FinRobot developers
│   ├── experiments/             #   investment group, multi-factor, portfolio optimization
│   ├── configs/ report/         #   agent configs and sample generated reports
│   ├── FinNLP/                  #   git submodule
│   ├── OAI_CONFIG_LIST_sample
│   ├── config_api_keys_sample
│   └── requirements.txt
│
├── finrobot_desktop/            # V2 — PydanticAI desktop generation (current)
│   ├── finrobot/                #   Python backend (FastAPI + compute engine)
│   │   ├── engine/              #     agents/, pipelines/, compute/, data/
│   │   ├── artifact/            #     report store + output contract gate
│   │   ├── audit/ coverage/ obs/ routes/
│   │   └── cli.py server.py sdk.py
│   ├── desktop/                 #   Tauri shell + React frontend (src/, src-tauri/)
│   ├── skills/                  #   56 analyst playbooks
│   ├── tests/ scripts/ tutorials/
│   └── pyproject.toml uv.lock dev.sh
│
├── finrobot_equity/             # V1 — OpenAI Agents SDK generation
│   ├── core/                    #   analysis engine + 8 section-writing agents
│   ├── web_app/                 #   FastAPI web application
│   ├── run_web_app.py           #   launcher
│   ├── deploy.sh                #   local deployment
│   ├── deploy.gcloud.sh         #   Cloud Run deployment
│   └── requirements.txt
│
├── Dockerfile .dockerignore     # V1 container build — must stay at the repo
│                                # root, since the image imports the app as
│                                # finrobot_equity.web_app.main
├── .github/workflows/           # desktop CI (backend 3.11/3.12, frontend Node 22/24)
├── setup.py                     # packages V0 (as `finrobot`) + V1 for PyPI
├── LICENSE NOTICE TRADEMARK_POLICY.md
└── README.md

🌐 https://finrobot.ai/

▶️ Click the image above to watch the demo video, or see the short preview below.

FinRobot Pro is an AI-powered equity research platform that automates professional stock analysis using large language models and AI agents:

• Automated report generation — professional equity research reports on demand
• Financial analysis — income statements, balance sheets, and cash flows
• Valuation analysis — P/E, EV/EBITDA multiples, and peer comparison
• Risk assessment — comprehensive investment risk evaluation

The overall framework is organized into four layers, each addressing a specific aspect of financial AI processing:

1. Financial AI Agents Layer — includes Financial Chain-of-Thought (CoT) prompting to strengthen complex analysis and decision-making. Market Forecasting Agents, Document Analysis Agents, and Trading Strategies Agents use CoT to break financial problems into logical steps, aligning their algorithms and domain expertise with evolving market dynamics.
2. Financial LLMs Algorithms Layer — configures and applies models tuned to specific domains and global market analysis.
3. LLMOps and DataOps Layers — a multi-source integration strategy that selects the most suitable LLM for each financial task across a range of state-of-the-art models.
4. Multi-source LLM Foundation Models Layer — supports plug-and-play use of general and specialized LLMs.

1. Perception — captures and interprets multimodal financial data from market feeds, news, and economic indicators, structuring it for analysis.
2. Brain — the core processing unit: consumes perception output with LLMs and applies Financial CoT to generate structured instructions.
3. Action — executes those instructions with tools, turning analysis into outcomes: trades, portfolio adjustments, reports, or alerts.

The Smart Scheduler ensures model diversity and selects the most appropriate LLM for each task.

• Director Agent — orchestrates task assignment, allocating work based on performance metrics and task suitability.
• Agent Registration — manages registration and tracks agent availability for efficient allocation.
• Agent Adaptor — tailors agent functionality to specific tasks.
• Task Manager — stores and manages general and fine-tuned LLM-based agents for different financial tasks, updated periodically.

• [Stanford University + Microsoft Research] Agent AI: Surveying the Horizons of Multimodal Interaction
• [Stanford University] Generative Agents: Interactive Simulacra of Human Behavior
• [Fudan NLP Group] The Rise and Potential of Large Language Model Based Agents: A Survey
• [Fudan NLP Group] LLM-Agent-Paper-List
• [Tsinghua University] Large Language Models Empowered Agent-based Modeling and Simulation: A Survey and Perspectives
• [Renmin University] A Survey on Large Language Model-based Autonomous Agents
• [Nanyang Technological University] FinAgent: A Multimodal Foundation Agent for Financial Trading: Tool-Augmented, Diversified, and Generalist

• AutoGPT (183k stars): autonomous AI agent platform.
• Dify (134k stars): LLM app development platform with workflow orchestration and RAG.
• LangChain (130k stars): framework for building context-aware LLM applications.
• MetaGPT (65.6k stars): multi-agent framework with role-based collaboration.
• AutoGen (56k stars): framework for multi-agent LLM applications with tools and human interaction.
• CrewAI (46.6k stars): framework for orchestrating collaborative AI agents.
• ChatDev (31.7k stars): multi-agent framework for software development tasks.
• FastGPT (27.4k stars): knowledge-based LLM platform with workflow support.
• Langfuse (23.4k stars): open-source LLM observability and evaluation platform.
• BabyAGI (22.2k stars): task-driven experimental autonomous agent framework.
• SuperAGI (17.3k stars): developer-focused autonomous agent framework.
• CAMEL (16.4k stars): framework for cooperative and communicative AI agents.
• Bisheng (11.2k stars): enterprise open-source LLM application platform.

@article{yang2024finrobot,
  title   = {FinRobot: An Open-Source AI Agent Platform for Financial Applications using Large Language Models},
  author  = {Yang, Hongyang and Zhang, Boyu and Wang, Neng and Guo, Cheng and Zhang, Xiaoli and Lin, Likun and Wang, Junlin and Zhou, Tianyu and Guan, Mao and Zhang, Runjia and Wang, Christina Dan},
  journal = {arXiv preprint arXiv:2405.14767},
  year    = {2024},
  doi     = {10.48550/arXiv.2405.14767},
  url     = {https://arxiv.org/abs/2405.14767}
}

@inproceedings{zhou2024finrobot,
  title     = {FinRobot: {AI} Agent for Equity Research and Valuation with Large Language Models},
  author    = {Tianyu Zhou and Pinqiao Wang and Yilin Wu and Hongyang Yang},
  booktitle = {ICAIF 2024: The 1st Workshop on Large Language Models and Generative AI for Finance},
  year      = {2024}
}

@inproceedings{han2024enhancing,
  title     = {Enhancing Investment Analysis: Optimizing AI-Agent Collaboration in Financial Research},
  author    = {Han, Xuewen and Wang, Neng and Che, Shangkun and Yang, Hongyang and Zhang, Kunpeng and Xu, Sean Xin},
  booktitle = {ICAIF 2024: Proceedings of the 5th ACM International Conference on AI in Finance},
  pages     = {538--546},
  year      = {2024}
}

Apache 2.0 — see LICENSE. Trademark usage is covered by TRADEMARK_POLICY.md.

Disclaimer: The code and documents provided here are released under the Apache-2.0 license. They should not be construed as financial advice or recommendations for live trading. Exercise caution and consult qualified financial professionals before any trading or investment decisions.