Add 4-part Medium article series on ArbIntel quantitative strategies

docs/articles/part1_architecture.md

@@ -0,0 +1,30 @@
+# ArbIntel Part 1: Architecture of a Production-Grade Prediction Market Engine
+
+Prediction markets like Polymarket and Kalshi have emerged as highly efficient forecasting mechanisms. However, the microstructure of these markets presents unique challenges: high latency, sparse order books, and fragmented liquidity. To exploit these inefficiencies, we built **ArbIntel**, a production-grade algorithmic trading system.
+
+In this first part of a four-part series, we'll dive into the architecture of ArbIntel.
+
+## The Tri-Layer Architecture
+
+A robust trading system requires strict separation of concerns. ArbIntel employs a tri-layer design:
+
+1. **Data Ingestion Layer**: 
+    The foundation of any quantitative model is clean data. ArbIntel establishes persistent async WebSocket connections to both the Polymarket Gamma API and the Kalshi v2 trade API. Real-time tick updates (Bids, Asks, Sizes) are normalized into implied probabilities (0.0 to 1.0) and persisted to a local TimescaleDB instance for tick-level backtesting.
+
+2. **Strategy execution Layer**: 
+    This is where the Alpha is generated. Raw ticks are fed through multiple independent engines:
+    *   *Cross-Platform Arbitrage Scanner*: Continuously monitors the spread between Polymarket and Kalshi.
+    *   *Bayesian Fair Value Model*: Estimates the "true" probability of an event using continuous Beta distribution updates.
+    *   *NLP Momentum Tracker*: Analyzes breaking news and social sentiment to front-run retail flows.
+
+3. **Execution & Risk Layer**: 
+    Alpha is useless without execution. ArbIntel utilizes a Paper Trading framework enforcing rigorous risk constraints, including maximum position sizing and daily drawdown limits. 
+
+## Technical Stack Overview
+
+*   **Language**: Python 3.13 (Asyncio heavy)
+*   **Database**: PostgreSQL + TimescaleDB extension
+*   **Machine Learning**: `hmmlearn` (Regime Detection), Hugging Face `transformers` (Sentiment)
+*   **Dashboard**: Streamlit + Plotly
+
+In **Part 2**, we will explore the mathematics behind our Bayesian Fair-Value Model and how we use 1D Kalman Filters to smooth out the noise of illiquid order books.

docs/articles/part2_bayesian_fv.md

@@ -0,0 +1,27 @@
+# ArbIntel Part 2: Smoothing the Noise with Bayesian Statistics and Kalman Filters
+
+In Part 1, we established ArbIntel's unified data pipeline. However, prediction markets are notoriously noisy. A single retail trader's market order on Polymarket can dramatically swipe an illiquid order book, creating a temporary price spike that doesn't reflect a true change in the underlying event's probability. 
+
+How do we differentiate between random bid-ask bounce and genuine new information? The answer lies in state-space smoothing and Bayesian updating.
+
+## The 1D Kalman Filter
+
+A Kalman Filter is recursive. It estimates the true state of a system (the "Fair Value" of an asset) from a series of incomplete and noisy measurements (the traded prices). 
+
+In ArbIntel, we use a 1D implementation:
+*   **State Estimate ($x_t$)**: Our current belief of the true probability.
+*   **Process Variance ($Q$)**: How fast we think the true probability fundamentally changes over time (low for stable markets, high for volatile ones).
+*   **Measurement Variance ($R$)**: The estimated noise in the exchange's order book.
+
+When a new trade occurs, the Kalman Filter calculates the Kalman Gain ($K$)—essentially deciding whether to trust the new market print or our existing belief. This allows ArbIntel to completely ignore short-term liquidity sweeps.
+
+## Bayesian Fair Value
+
+While the Kalman filter is great for smoothing, it doesn't establish an intrinsic "Fair Value." For this, we treat the probability of an event resolving "YES" as a Beta distribution, $Beta(\alpha, \beta)$.
+
+1.  **The Prior**: We establish base rates (e.g., incumbents win elections 65% of the time $\rightarrow Beta(65, 35)$).
+2.  **The Update**: When trades occur on Polymarket, we adjust our $\alpha$ and $\beta$ parameters scaled by the trade volume. High volume trades shift our belief significantly; low volume trades are treated as noise.
+
+By combining the structural rigidity of a Kalman Filter with the probabilistic updates of a Bayesian model, ArbIntel refuses to be faked out by market microstructure dynamics.
+
+In **Part 3**, we'll discuss the easiest money in prediction markets: Cross-Platform Arbitrage.

docs/articles/part3_arbitrage.md

@@ -0,0 +1,30 @@
+# ArbIntel Part 3: Exploiting Cross-Platform Arbitrage
+
+The holy grail of quantitative trading is arbitrage—the simultaneous purchase and sale of an asset to profit from an imbalance in the price. 
+
+Because prediction markets are currently fragmented, with heavy US regulatory restrictions forcing Kalshi to operate differently than Polymarket, liquidity is isolated. Where liquidity is isolated, prices decouple.
+
+## The Anatomy of an Arb Trade
+
+Consider the market: *"Will the Federal Reserve cut rates by 25bps in September?"*
+
+Let's assume the current order books look like this:
+*   **Polymarket**: Bid \$0.50 | Ask \$0.52
+*   **Kalshi**: Bid \$0.55 | Ask \$0.57
+
+The inefficiency is screaming at us. ArbIntel detects this instantly via its WebSocket listeners.
+1.  **The Buy**: We buy the "YES" contract on Polymarket at the Ask price of \$0.52.
+2.  **The Sell**: We simultaneously sell the "YES" contract (or buy "NO") on Kalshi at the Bid price of \$0.55.
+
+Our gross margin is $0.55 - 0.52 = \$0.03$ per contract (a 3% risk-free return). 
+
+## Overcoming Edge Friction
+
+Gross margin is vanity; net margin is sanity. ArbIntel's `CrossPlatformArbitrage` module calculates true edge by accounting for two major frictions:
+
+1.  **Fees**: Polymarket historically has 0% taker fees, but interacting with the Polygon blockchain incurs gas costs. Kalshi utilizes a sliding fee schedule capped at a certain dollar amount. The scanner deducts the estimated fees from the gross margin dynamically before executing.
+2.  **Slippage & Depth**: We cannot arb 10,000 contracts if the Kalshi bid size is only 500 contracts. The module computes the maximum executable size as `min(Polymarket_Ask_Size, Kalshi_Bid_Size)`. 
+
+If the net margin after fees remains above our predefined risk-free threshold (e.g., 0.5%), ArbIntel fires off simultaneous Execution API requests. 
+
+In the final post, **Part 4**, we'll explore how ArbIntel uses Hugging Face NLP to trade breaking news momentum before human traders can react.

docs/articles/part4_nlp_momentum.md

@@ -0,0 +1,31 @@
+# ArbIntel Part 4: NLP and News Momentum Trading
+
+When breaking news hits, prediction markets move violently. For example, if a presidential candidate drops out of a race, their "YES" contracts crash to $0.00 instantly, while their opponents surge. The first machine to parse this information wins.
+
+In the final part of our series, we discuss how ArbIntel uses the Hugging Face ecosystem to build a low-latency sentiment momentum trader.
+
+## Transformers for Alpha
+
+Financial text is tricky. A phrase like "The FED lowered rates" is structurally neutral, but the market implication is strongly positive for equities and prediction markets tracking economic relief. Standard sentiment models (like NLTK's VADER) often fail here.
+
+ArbIntel leverages `ProsusAI/finbert`, a domain-specific BERT model fine-tuned entirely on financial communication, earnings transcripts, and analyst reports.
+
+1.  **Ingestion**: ArbIntel monitors social streams (like X/Twitter) filtered by mapped market keywords (e.g., "FOMC", "Powell").
+2.  **Processing**: The text goes through a regex preprocessor to strip URLs and mentions.
+3.  **Inference**: The clean string hits the FinBERT classifier. The output is a continuous score from -1.0 (Bearish) to +1.0 (Bullish).
+
+## The Volume Confirmation Trigger
+
+Trading blindly off sentiment is a recipe for disaster. We need confirmation that the market is actually reacting to the news.
+
+ArbIntel utilizes a dual-signal trigger inside `NewsReactionMomentum`:
+1.  **Sentiment Signal**: The aggregated FinBERT score surpasses our predefined confidence threshold (e.g., $|score| > 0.5$).
+2.  **Volume Confirmation**: The current contract volume spikes by at least $3x$ the moving average of the last 60 minutes.
+
+If and only if both conditions are met, an execution signal fires. The system automatically calculates dynamic Stop-Loss and Take-Profit limits and initiates a position in the direction of the news.
+
+## Conclusion
+
+ArbIntel proves that prediction market microstructure is ripe for exploitation. By combining high-speed WebSocket listeners with robust statistical models (Kalman Filters, HMM Regime Tracking) and deep learning (FinBERT), we created a system capable of operating in the most competitive quantitative environments.
+
+*Thank you for reading the ArbIntel series! Code is deployed locally and heavily guarded. For insights, questions, or recruiting, connect below.*