Inspiration
I built QFleet because previously I worked for Security and I know the pain points. We have to handle a plenty of information at the same time. In finance, important signals are scattered across RSS feeds, macro data, market APIs, company filings, research reports, and constantly changing news. Human analysts spend a huge amount of time collecting, filtering, and organizing information before they can even begin forming a view.
I wanted to build a system that acts like an enterprise AI harness for financial intelligence: one that continuously ingests information, organizes it, reasons over it with multiple agents, and produces traceable research outputs.
What it does
QFleet is a quantitative AI harness financial application built for analysis and decision support.
It connects multiple financial data sources, including:
- a self-built RSS / news database,
- macro and market data APIs such as FRED, AKShare, and Polymarket,
- company filings,
- market data services,
- and research-report APIs.
QFleet has two major layers:
Continuous information-flow layer
This layer continuously ingests, deduplicates, scores, and structures financial information. It transforms raw incoming data into:- high-signal events,
- market timelines,
- daily briefs,
- and long-term knowledge.
Deep-analysis layer
When a user selects a company or ticker, QFleet launches a multi-agent workflow to analyze the company from multiple perspectives, retrieve supporting evidence, compare peers, evaluate risks, and generate research outputs.
This is not an automated trading bot.
Its purpose is to help users understand markets, companies, and risks through transparent and auditable AI-assisted analysis.
How I built it
I built QFleet as a customized AI harness system for finance.
At the architecture level, the system combines:
- a data-ingestion and storage layer,
- a unified LLM harness,
- multi-agent workflows,
- deterministic analytics and auditing,
- and a web interface for human inspection.
The system uses a hybrid design philosophy:
- Deterministic code handles structured computation, data routing, aggregation, chart generation, and audit logic.
- LLMs handle interpretation, synthesis, reasoning, and judgment.
This is important to me because I do not want the model to "invent" core financial numbers.
Instead, I want AI to reason on top of data, not replace the data pipeline.
The deep-analysis workflow is built around a multi-agent graph. Different agents focus on areas such as:
- market context,
- sentiment,
- news,
- fundamentals,
- supply chain,
- peer comparison,
- risk review,
- and final portfolio-level judgment.
The web demo at qfleet.top exposes the system through several pages such as:
- Overview
- Timeline
- Knowledge
- Analysis
- Backtest
These pages help users inspect not only the final results, but also the full reasoning process behind them.
How I used Codex and GPT-5.6
This project was built with heavy help from Codex and GPT-5.6.
Codex
I used Codex as my engineering agent. It helped me:
- navigate and understand the codebase,
- refactor workflows,
- implement new agent logic,
- debug complex issues,
- validate architecture changes,
- and accelerate iteration speed during the build.
Instead of treating Codex as a toy code generator, I used it like a real development partner for system design and implementation.
GPT-5.6
I used GPT-5.6 as the reasoning engine inside the harness.
Different roles were assigned different model configurations depending on the task:
- planning,
- evidence extraction,
- analyst reasoning,
- judgment,
- and final synthesis.
This allowed the system to match reasoning depth to task difficulty, while keeping the workflow modular and scalable.
Challenges I ran into
One of the biggest challenges was making the system reliable rather than merely impressive.
In AI demos, it is easy to generate attractive outputs.
It is much harder to ensure that:
- the information pipeline is stable,
- the data sources are integrated coherently,
- the multi-agent workflow is actually useful,
- and the outputs are transparent enough for humans to inspect.
Another challenge was balancing:
- deterministic computation vs LLM reasoning,
- continuous ingestion vs deep analysis,
- and system complexity vs clarity of demo.
I also spent significant time making sure the project could be presented as a coherent product rather than just a collection of agent experiments.
What I learned
This project taught me that the future of AI products is not just better models — it is better harnesses.
The most important engineering problem is often not "which model is smartest?"
It is:
- how to organize models,
- how to connect them with tools and data,
- how to make outputs inspectable,
- and how to turn AI into a repeatable workflow rather than a one-off interaction.
I also learned a lot about building domain-specific AI systems for finance, especially around:
- data integration,
- evidence-based reasoning,
- multi-agent decomposition,
- and productizing AI infrastructure into something users can actually explore and trust.
What’s next for QFleet
My next step is to continue evolving QFleet from a prototype into a stronger enterprise-grade financial intelligence system.
That includes:
- improving the quality and coverage of financial data sources,
- expanding report intelligence and evidence retrieval,
- strengthening multi-agent coordination,
- improving evaluation and backtesting,
- and making the user interface more useful for real analysts and decision-makers.
More broadly, QFleet is part of a bigger direction I care deeply about:
building industry-specific AI harness systems that combine models, tools, data, and human inspection into practical, production-ready workflows.
Log in or sign up for Devpost to join the conversation.