TL;DR

This publication presents Agentic Forex AI, a fully containerized multi-agent system that automates daily forex market analysis using news streams, technical indicators, and rule-based validation. It integrates FastAPI, Streamlit, and Prometheus-based observability for a real-time, interactive decision-support dashboard. The solution demonstrates how open-source orchestration of AI agents can produce trustworthy recommendations (BUY / SELL / AVOID) with traceable logic, logs, and performance metrics—deployable via Docker and Railway.

Abstract

Agentic Forex AI represents the culmination of the Agentic AI Developer Capstone Project, transforming a modular multi-agent prototype into a production-grade, observable, and reliable forex decision-support system. It integrates five coordinated agents — Market, News, Strategy, Validation, and Email — to generate daily recommendations across 20 major and minor currency pairs.

Each recommendation is derived from real-time market data (via yFinance) and sentiment cues (via RSS news parsing), validated through safety guards, and automatically delivered to users through an email notification pipeline. The system is fully containerized, combining FastAPI for orchestration, Streamlit for visualization, and Prometheus for monitoring and metrics collection.

Beyond its technical implementation, the project demonstrates key principles of responsible AI deployment: input validation, operational resilience, performance logging, and transparent observability. Deployed via Docker and Railway, it showcases how open, reproducible architectures can bridge the gap between intelligent automation and production reliability in real-world financial applications.

1. Introduction

Purpose and Motivation

Forex traders and analysts often rely on fragmented tools—such as economic calendars, RSS feeds, and chart patterns—to make time-sensitive decisions. Agentic Forex AI unifies these signals into a reproducible, explainable multi-agent system that delivers consistent, transparent recommendations daily.

Why This Matters

By automating routine analysis and embedding observability, the system:

• Reduces manual monitoring time for traders.
• Encourages explainable automation in financial analytics.
• Demonstrates best practices for real-world agentic AI deployment.

2. System Architecture

2.1 Overview

The architecture unifies five operational layers inside a Docker container:

---

2.2 Multi-Agent Workflow

The system executes end-to-end pipelines via safe_run_pipeline_once() to ensure isolation, reliability, and safety.

---

2.3 Tools Layer Overview

---

2.4 Supported Pairs

Major Pairs:
EURUSD, USDJPY, GBPUSD, USDCHF, AUDUSD, USDCAD, NZDUSD

Minor Pairs:
EURGBP, EURJPY, GBPJPY, EURCHF, EURAUD, AUDJPY,
GBPCHF, NZDJPY, CADJPY, AUDNZD, EURCAD, CHFJPY, GBPAUD

All validated by input_validation.py with dynamic whitelist logic.

3. Implementation Details

3.1 Core Stack

---

3.2 Repository Structure

├── api.py                         # FastAPI backend (main API routes)
├── dashboard.py                   # Streamlit dashboard UI
├── Dockerfile                     # Docker image configuration
├── requirements.txt               # Python dependencies
├── supervisord.conf               # Supervisor config for API + Dashboard
├── README.md                      # Project documentation
│
├── src/
│   ├── agents/
│   │   ├── market_agent.py        # Fetches forex candles via yfinance
│   │   ├── news_agent.py          # Parses news from FXStreet, Investing.com, DailyFX
│   │   ├── strategy_agent.py      # Combines data → issues BUY/SELL/AVOID
│   │   └── email_agent.py         # Sends daily strategy report to Gmail
│   │
│   ├── tools/
│   │   ├── yfinance_tool.py       # Handles price data retrieval
│   │   ├── rss_tool.py            # RSS parsing and cleaning
│   │   ├── strategy_tools.py      # Core logic for combining market + news data
│   │   └── email_tool.py          # Email sending utility (smtplib-based)
│   │
│   ├── guards/
│   │   ├── input_validation.py    # Validates currency pairs and API input
│   │   ├── pipeline_safety.py     # Safe execution wrapper for resilience
│   │   └── validation_guard.py    # Ensures runtime safety & fallback logic
│   │
│   ├── utils/
│   │   └── logger.py              # Logging utilities with Loguru
│   │
│   ├── graph.py                   # Defines multi-agent pipeline graph
│   ├── schemas.py                 # Pydantic models (Candle, NewsItem, Recommendation)
│   └── main.py                    # Entry point for multi-agent orchestration
│
├── data/
│   ├── traces/                    # JSON logs of each pipeline execution
│   └── samples/                   # Example test data or responses
│
├── tests/
│   ├── test_agents.py             # Unit tests for each agent
│   ├── test_pipeline.py           # Integration tests across agents
│   └── test_end_to_end.py         # End-to-end system tests 

4. Implementation & Testing

4.1 Testing Strategy

Example run:

pytest --maxfail=1 --disable-warnings -q --cov=src

---

4.2 Evaluation & Logging

Each pipeline run logs structured JSON traces in /data/traces/ including:

• Timestamp
• Agent execution times
• Pair symbol and recommendation
• News source count
• Email delivery confirmation

5. Monitoring and Observability

5.1 Prometheus Metrics Integration

Metrics exposed at /api/metrics include:
-# HELP api_request_total Total API requests
-# HELP api_request_latency_seconds API request latency in seconds
-# HELP api_health_status 1 if healthy, 0 otherwise

All accessible via:
curl http://localhost:8000/api/metrics

6. Reproducibility and Deployment

6.1 Local Run

To build and run the project locally:

docker build -t forex-ai .
docker run -p 8501:8501 -p 8000:8000 forex-ai

Then open in your browser:

• Dashboard: http://localhost:8501
• API Health: http://localhost:8000/api/health

---

6.2 Cloud Deployment (Railway)

1. Connect your GitHub repository to Railway.

2. Select Dockerfile as the deployment method.

3. Set the environment variable:

   API_URL=https://<your-railway-app>.up.railway.app/api

4. Deploy your project.

5. Verify the logs — you should see messages like:

   success: api entered RUNNING state
   success: dashboard entered RUNNING state

7. Limitations and Future Work

8. Conclusion

Agentic Forex AI embodies the principles of safety, stability, and explainability, delivering practical value in real-world decision-making contexts. It is a fully monitored, tested, and documented system that illustrates the hallmark of professional AI engineering.

9. License Rationale (CC BY-SA)

The Creative Commons Attribution-ShareAlike (CC BY-SA) license was chosen to encourage open collaboration while protecting authorship. It permits others to use, modify, and redistribute this work —including its code and documentation—provided they give appropriate credit to the original author and share derivative works under the same terms. This ensures the project remains freely accessible and improves collectively, which aligns with Ready Tensor’s ethos of transparent and reproducible AI innovation.

10. Resources

• GitHub Repository: https://github.com/Sarah-Mashhood/forex-agentic-ai
• Live Demo (Railway): https://forex-agentic-ai.up.railway.app
• Prometheus Endpoint: /api/metrics
• Health Endpoint: /api/health

11. Demo