HKUDS vs LLMQuant: Two Project Universes for My Research OS

I recently organized two large project universes that are shaping my current research direction:

• HKUDS: an AI research ecosystem around agents, RAG, graph learning, recommender systems, spatio-temporal intelligence, and research automation.
• LLMQuant: an AI-native finance ecosystem around quant data, financial knowledge, agent skills, market intelligence, and strategy research workflows.

They are both useful, but they are useful in different ways.

My current view is:

HKUDS    = AI research infrastructure
LLMQuant = finance-domain research and workflow system

This distinction matters because I do not want to collect repositories passively. I want to convert every project I study into a reusable component in my own research operating system.

HKUDS as AI Research Infrastructure

HKUDS is broad and academically dense. Its public project map covers many research directions:

• agent systems;
• retrieval-augmented generation;
• graph learning;
• recommender systems;
• spatio-temporal and urban computing;
• video and multimodal agents;
• LLM efficiency and reasoning;
• automated research and paper delivery tools.

The projects I currently care about most are:

LightRAG
nanobot
Vibe-Trading
AI-Researcher
DeepResearch-Eval
Paper2Slides
RAG-Anything
OpenHarness
AutoAgent
GraphGPT / OpenGraph / GraphAgent

The reason HKUDS matters to me is not one single repository. It gives me a map of how modern AI research systems are built.

For example:

• LightRAG shows a practical direction for fast retrieval-augmented generation and project memory.
• nanobot is useful as a lightweight personal agent shell.
• AI-Researcher and DeepResearch-Eval are relevant for automated scientific discovery and evaluation.
• Vibe-Trading and AI-Trader connect agent systems with market research and trading workflows.
• The graph and recommender repos provide a deeper academic base for top-tier ML research.

So HKUDS is my infrastructure layer:

agent loop
  -> tools
  -> memory
  -> RAG
  -> graph/recommender models
  -> evaluation
  -> research automation

It is especially valuable for building systems such as:

• a personal AI operating loop;
• a paper-to-idea research assistant;
• a source-grounded RAG memory layer;
• a research evaluation workflow;
• an agent-native finance research system.

LLMQuant as Finance Domain System

LLMQuant has a different character. It is less like a pure academic repo collection and more like a finance-domain product ecosystem.

The major components include:

• LLMQuant Data / data-mcp: a data access layer for AI agents.
• LLMQuant Skills: reusable finance agent workflows.
• QuantMind: financial knowledge extraction and retrieval.
• Finance Context / docs: financial workflow education and domain context.
• Quant Wiki / LLMQuant Book: longer-form finance and quant knowledge.
• Awesome Trading Agents: an ecosystem map for agentic trading and MCP tools.
• Pengyi project and strategy folders: personal research scaffolds built around the LLMQuant ecosystem.

The strongest part of LLMQuant is that it thinks in finance workflows.

Its skills are already organized around real market tasks:

equities
options
rates / FX
macro
credit
commodities
crypto
events
portfolio
risk
strategies
market intelligence
investor lenses

This makes LLMQuant valuable as a domain layer:

market data
  -> financial knowledge
  -> domain workflow
  -> investment or research memo
  -> strategy idea
  -> risk review

For my own system, this matters because AI infrastructure alone is not enough. A generic agent can search, summarize, and write. But a useful finance research agent needs domain structure:

• What asset class is this?
• What data should be checked?
• What is the economic mechanism?
• What is the risk?
• What baseline or benchmark matters?
• What decision workflow does this support?

LLMQuant helps answer those questions.

The Core Difference

The simplest comparison:

HKUDS teaches me how to build AI research systems.
LLMQuant teaches me how to apply AI systems to finance and quant workflows.

More concretely:

Dimension	HKUDS	LLMQuant
Main identity	AI research ecosystem	AI + quantitative finance ecosystem
Core strength	Infrastructure, models, agents, RAG, graph/recsys research	Finance data, domain skills, market workflows, strategy research
Typical artifact	Paper repo, framework, model, agent infra, benchmark	Data MCP, skill workflow, knowledge card, research memo, strategy note
Best for	Building the technical engine	Giving the engine a finance domain
My use	PM2.0, Paper Auto OS, RAG memory, research automation	FI-C-C OS, Quant R&D Agent, strategy workflows, market intelligence

In short:

HKUDS = engine room
LLMQuant = domain cockpit

Why The Combination Matters

If I only study HKUDS, I may build strong AI infrastructure without enough domain grounding.

If I only study LLMQuant, I may understand finance workflows without enough depth in agent architecture, RAG, graph models, and evaluation.

The important move is to combine them:

HKUDS infrastructure
  + LLMQuant finance workflows
  -> personal research and quant production OS

Then X2Strategy can become the execution layer:

research input
  -> finance-domain framing
  -> strategy specification
  -> code / experiment
  -> backtest / diagnosis
  -> human review

That gives a full loop:

HKUDS      -> AI / agent / RAG / research infra
LLMQuant   -> finance domain / data / skills / workflows
X2Strategy -> strategy spec / code / backtest / diagnosis
PM2.0      -> memory / routing / review / execution

How This Connects To My Projects

This comparison directly informs my current personal projects:

PM2.0

PM2.0 is the coordination layer. It captures ideas, routes them to the right project, records memory, and keeps the daily execution loop alive.

HKUDS contributes agent and memory architecture.

LLMQuant contributes finance task structure.

Paper Auto OS

Paper Auto OS turns papers into:

structured notes -> ideas -> hypotheses -> experiments -> draftable artifacts

HKUDS contributes AI-Researcher, DeepResearch-Eval, RAG, graph, and research automation references.

LLMQuant contributes finance-paper interpretation, domain tagging, and market-relevant idea framing.

FI-C-C OS

FI-C-C OS is my trial for real financial domain engineering across:

Fixed Income
Currency
Commodity

HKUDS contributes retrieval, agent workflow, and system design.

LLMQuant contributes rates / FX / commodities / macro / credit / risk workflows.

A Practical Pilot

The first useful pilot should be small:

one FICC or macro idea
  -> source-grounded research note
  -> LLMQuant-style domain framing
  -> X2Strategy-style strategy specification
  -> minimum backtest or experiment plan
  -> diagnosis note
  -> human review

This avoids the common failure mode:

too many repos, no output

The right pattern is:

understand -> compare -> extract -> integrate -> verify

Every external project should eventually become one of:

• a reusable schema;
• a project note;
• a workflow template;
• a benchmark;
• a public-safe demo;
• a technical write-up;
• a validated experiment.

My Current Conclusion

HKUDS and LLMQuant are not competing maps. They are complementary.

HKUDS gives the research infrastructure.

LLMQuant gives the financial domain system.

X2Strategy gives the execution loop.

PM2.0 keeps the memory and daily operating discipline.

The long-term direction is clear:

AI research infrastructure
  + finance domain intelligence
  + executable strategy workflow
  + human review
  -> auditable research production OS

This is the kind of system I want to keep building: not a loose collection of interesting repositories, but a personal research engine that can produce structured, testable, and reusable research artifacts.