NEWS2SIGNAL

Inspiration

We built News2Signal to answer a simple but important question:

Can a multi-agent system turn noisy market news into an explainable trading signal?

A lot of tools in finance can tell you what moved. Far fewer can explain what happened, why it matters, who it affects downstream, and whether the signal is strong enough to trust.

The idea came from a mix of quantitative investing, passive/ETF thinking, and a real hackathon constraint: we wanted to build something that felt financially meaningful, but was still intuitive for non-finance judges. Market news is a perfect testbed because everyone understands headlines, but turning headlines into disciplined signals is hard.

What it does

News2Signal is a multi-agent event intelligence system for markets.

It takes live market news, extracts structured event facts, reasons over direct and downstream impact, checks historical support, and produces an explainable long / short / neutral signal.

Instead of treating the model like one black box, we split the workflow into specialized agents:

Retrieval Agent Uses Gemini + Tavily to decide what to search for and gather event candidates.
Extraction Agent Uses Gemini to convert articles into normalized facts like event type, severity, sentiment, theme, and affected symbols.
Reasoning Agent Uses Prometheux as the deterministic reasoning layer to apply rule-based logic over the facts and propagation graph.
Evaluation Agent Uses ClickHouse as memory and replay infrastructure to check cache hits, similar historical events, and confidence support.

The result is not just a headline summary. It is a structured signal with an explanation trail.

How we built it

We built the system as a Python-based multi-agent pipeline.

Data and retrieval

Tavily retrieves live finance-relevant articles
We filter out quote pages, profile pages, and low-signal noise
Yahoo Finance provides lightweight market context for the symbols

Multi-agent reasoning flow

Gemini plans retrieval queries and extracts event facts in structured JSON
We normalize facts into fields such as:
- event_type
- severity_score
- sentiment_score
- macro_theme
- affected_sectors
We map direct events into downstream contagion using a propagation graph
Prometheux / Vadalog evaluates deterministic rules over those facts
ClickHouse stores articles, facts, signals, agent traces, and evaluation snapshots

Signal design

We intentionally separated direction from confidence.

The signal combines multiple sleeves:

$$ \text{direction score} = 0.55 \cdot \text{direct impact} + 0.30 \cdot \text{propagation} + 0.15 \cdot \text{macro theme} $$

$$ \text{confidence} = 0.35 \cdot \text{fact quality} + 0.30 \cdot \text{historical support} + 0.20 \cdot \text{source diversity} + 0.15 \cdot \text{price confirmation} $$

Then deterministic rules gate the output:

no material event (\rightarrow) neutral
conflicting evidence (\rightarrow) cap the score
low-confidence evidence (\rightarrow) reduce conviction
systemic contagion (\rightarrow) allow stronger propagation impact

That combination let us keep the system explainable while still benefiting from LLM-based extraction.

Challenges we ran into

This project had several real challenges:

1. Market news is noisy

Financial news is full of quote pages, generic commentary, recycled summaries, and low-information articles. One of the hardest parts was getting from “a lot of news” to “a few discrete events that actually matter.”

2. LLM outputs can be non-deterministic

A big issue early on was that the signal could vary between runs. In finance, that is a serious problem. We addressed it by using multi-agent decomposition, stricter JSON extraction, deterministic scoring, and Prometheux for rule-based reasoning instead of relying on free-form LLM judgment for the final signal.

3. Prometheux integration was real, not just cosmetic

At first, Prometheux was authenticated but compute was not active, so we had to build graceful fallback logic while still wiring it into the reasoning path. Once compute was enabled, we validated real Vadalog execution inside the live workflow.

4. ClickHouse had to be more than storage

We did not want ClickHouse to be just a database at the end of the pipeline. A key challenge was making it useful inside the system as a memory and evaluation layer for replay, history, and confidence support.

5. Building something meaningful in hackathon time

There is always a temptation to overbuild in finance. We had to keep the scope realistic enough to finish, while still making the project feel credible, technically interesting, and understandable to judges outside the industry.

What we learned

The biggest lesson was that multi-agent systems are most useful when each agent owns a different decision surface.

What worked best was not having four agents all give generic opinions on the same headline. What worked best was:

one agent finding evidence,
one structuring evidence,
one reasoning deterministically,
and one checking memory/history.

We also learned that in financial applications, deterministic layers matter a lot. LLMs are powerful for retrieval planning, extraction, and explanation, but rule-based reasoning and historical replay are critical if you want outputs that are stable and defensible.

What’s next

If we continue this project, the next steps would be:

connect portfolio or ETF holdings directly for exposure-aware signals
expand the propagation graph beyond a small curated universe
run proper replay / backtesting over historical event windows
improve calibration of confidence vs realized move
add a richer frontend for agent traces, signal explanation, and sector contagion