MLP - BTC Breakout Probability [Deep Learning] [Open Source]I trained a single Multilayer Perceptron on 13 years of Bitcoin price history and open-sourced the result. Not because it's perfect, but because the idea is worth sharing.
The concept is simple.
Most breakout strategies are rule-based. Fixed levels, static conditions. This one is different, instead of predicting direction, the model learned the distribution of Bitcoin's daily price moves. You pick a threshold, it gives you the probability. Same model, any level.
How to use it
Pick a percentage threshold , by doing that you're asking the model to evaluate. When price breaks that level and the model is showing meaningful confidence, a label is shown on the chart.. Daily only. BTC only.
Under the hood
A lightweight Multilayer Perceptron (MLP) trained on ~4,700 daily candles of raw OHLC data from May 2009 to May 2022 . The architecture is two hidden layers (16→8), ReLU activations throughout, and a sigmoid output that squashes the result into a clean 0–1 probability score. ReLU keeps the internal representations sparse and non-linear, sigmoid makes the output as a probability.
What makes this interesting is that the model didn't just learn a raw number, it learned the underlying distribution of Bitcoin's daily price moves. That's what allows a single model to answer probability questions across different thresholds rather than being hardcoded to one fixed level.
The output isn't a prediction, it's a calibrated belief about where price is likely to go, derived from 13 years of market structure.
Honest limitations
Fat tails eat this model alive. The features are correlated and the model has no concept of liquidity. It underestimates the extremes.
Daily timeframe only. Bitcoin only. Long only.
This was built as a personal project, mostly for fun and to serve as a working example of how ML concepts can be applied to market data.
Disclaimer
This indicator is provided for educational and informational purposes only. It does not constitute financial advice, trading recommendations, or a guarantee of future results. Past performance does not predict future returns. You alone are responsible for your trading decisions. Always test thoroughly in a simulated environment before trading with real capital. Indicator
Trade checklist!Here is a clean, professional, and compelling description tailored specifically for the PulseWire community. It is designed to be pasted directly into your script’s publishing page to clearly explain what the indicator does, why traders need it, and how to use it.
📋 Trading Setup Checklist (Pre-Trade Gatekeeper)
📌 Overview
The Trading Setup Checklist is an interactive, on-screen heads-up display (HUD) designed to eliminate emotional trading, FOMO, and impulsive entries. Instead of relying on mental notes or external scratchpads, this indicator embeds a clean, high-contrast digital checklist directly onto your PulseWire chart. It acts as your personal pre-flight gatekeeper before risking any market capital.
By forcing you to visually confirm your edge rule-by-rule, this tool bridges the gap between a written trading plan and disciplined execution.
🚀 Key Features
10 Fully Customizable Rules: Type your exact strategy conditions (e.g., HTF Trend Alignment, Key S/R Levels, Risk-to-Reward Ratio, Macro News Check) directly into the script settings.
Dynamic Visual Feedback: Uses a strict, high-contrast color system. Unchecked rules stay Maroon (Stop/Wait), while confirmed rules instantly flip to Green (Go).
Adjustable Display Length: Don't need all 10 rules? Use the "Visible Items Count" slider to scale the display down to match your exact setup.
Zero Chart Clutter: Built using Pine Script’s native table engine. The dashboard stays anchored smoothly to the top-right corner of your screen and won't get buried or distorted when you zoom or scroll through candlesticks.
Performance Optimized: The engine executes strictly on the live close (barstate.islast), ensuring zero chart lag, lightning-fast rendering, and maximum processing efficiency.
🛠️ How to Use It
Define Your Edge: Open the indicator settings (gear icon) and type your specific trading rules into the text boxes.
Set Your Layout: Adjust the visible item count and choose between Small, Normal, or Large text sizes to fit your display resolution.
Scan the Setup: When a potential setup forms, open the settings menu.
Check the Boxes: Tick the boxes for the conditions the market has successfully met.
Execute with Discipline: If the dashboard on your screen isn't completely green, no trade is taken.
🧠 Trading Psychology Value
The hardest part of trading isn't finding a strategy; it's executing it consistently. This indicator addresses cognitive bias by transforming your passive trading plan into an active, visual checkpoint. It forces an objective pause before hitting "Buy" or "Sell," ensuring you only execute trades that completely align with your proven edge.
> Disclaimer: This indicator is a visual checklist utility designed solely to assist tracking user-defined rule compliance. It does not generate automatic trade signals, commercial bias, or financial advice. Indicator
Indicator
AetherEdge - Quantum-Inspired Entanglement Detector🖊️ Overview
A detector built on a "quantum entanglement" analogy. In entanglement, the states of several particles are so correlated that measuring one instantly informs the others. This engine transposes that onto markets: it measures the synchrony (entanglement strength) among several market variables — price, volume, and one or two correlated assets / global indices — and watches for decoherence, the moment that synchrony breaks down (a decoupling). A NeuraLib map weighs the pairwise couplings into a single Entanglement score, while a self-learning baseline distinguishes "normal" coupling from genuine breaks. Decoupling events — when the system falls out of its entangled state — are flagged as opportunity (divergence, regime shift). Visualization: a circular radar of Entanglement strength radiating from a center node to each variable, with alerts when synchrony collapses.
🔶 Key Features
Quantum-entanglement analogy — quantifies multi-variable synchrony as "entanglement strength"
Pairwise coupling detection — measures four links: price×volume, price×alt, price×index, alt×index
NeuraLib entanglement map — nonlinearly weights the couplings into a unified Entanglement score
Self-learning baseline — learns the "normal" synchrony level to judge genuine collapses by deviation
Decoherence detection — flags decoupling (opportunity) when entanglement drops sharply below baseline
Coherence/decoherence state — distinguishes synchronized (coherent) from collapsed (decoherent)
Circular entanglement radar — radial spokes from a center node to each coupling (length/color by strength) plus concentric rings
Intelligence panel — entanglement, baseline, decoupling magnitude, and each coupling strength at a glance
🧠 Technical Architecture
The engine pulls in a correlated asset and a global index via request.security and forms the "states" of four variables (price return, volume anomaly, alt return, index return).
As pairwise couplings, it computes the absolute rolling correlation |corr|∈ over four pairs (PX·VOL, PX·ALT, PX·IDX, ALT·IDX) — the strength of each "entanglement link." When all links are strong, the system is synchronized (high entanglement).
The NeuraLib entanglement map (couplings(4) → hidden(tanh) → entanglement strength(1, squashed to )) nonlinearly weights the couplings into a unified score. The target is the system-wide mean coupling (a self-supervised synchrony measure), and the network learns a smoothed, weighted estimate generalizing the raw mean.
For decoherence, it measures the drop from entanglement's self-learning baseline (a slow EMA tracking the "normal" level): baseline − current. When this clears the threshold, it flags decoupling. The key is catching deviation from the synchrony the system usually holds — not just low correlation.
The circular radar computes coordinates via math.cos/math.sin, drawing spokes from the center node to each coupling link with length proportional to coupling strength. Spoke color shifts with strength (red = collapse → cyan = sync), and concentric rings (25/50/75/100%) mark the scale.
⚙️ Recommended Settings & Tuning Guide
BTC (main) + ETH + TOTAL (1H–4H): Entanglement Window 40, Coherence 0.65, Decoherence 0.35 — a crypto setup
ETH (main) + BTC + TOTAL (1H–4H): BTC as the alt, the broad crypto market as the index
Stock (main) + peer + SPX/index: for single-stock coupling and decoupling detection
SOL (15m–1H): High volatility favors Entanglement Smoothing 5–6 to smooth, Decoherence Threshold 0.4 to be strict
Entanglement Window: longer is a steadier synchrony estimate; shorter is nimbler — ~40 is practical
Coherence Level: above this is "strong sync" — set to the group's typical correlation
Decoherence Threshold: a drop below baseline beyond this is decoupling; smaller is more sensitive (earlier warning)
Choice of alt/index: pick economically coupled assets/indices for detection accuracy
💡 How to Use in Practice
Reacting to decoupling alerts: a ⚡DECOUPLING marker is the moment usually-synced variables break apart — an opportunity for divergence trades or regime shifts; the broken variable may be "leading"
Reading the circular radar: a long, bright (cyan) spoke = strong coupling (synced); short, red = weak (collapsed). All spokes long = system-wide high entanglement; some short = partial decoupling
Using the coherence state: in COHERENT conditions the market moves as one (risk-on/off) and trends propagate; in DECOHERENT conditions idiosyncratic factors dominate, favoring selection and pair trades
Comparing to baseline: when panel entanglement is far below baseline, that's an abnormal break — judge deviation against the usual synchrony
Which coupling broke: the per-coupling rows (PX·VOL, etc.) identify which pair's sync broke (e.g. a broken PX·IDX means the symbol decoupled from the broad market)
Multi-timeframe usage: read the big-picture coherence state on the higher timeframe (4H), then catch opportunities on decoupling alerts on the lower one (15m–1H)
⚠️ Important Notes
Alt/index must be set: this requires proper correlated-asset/index symbols; unrelated variables break synchrony detection
On the quantum analogy: "entanglement" and "coherence" are metaphors from quantum mechanics, not actual quantum effects; the essence is detecting statistical synchrony among variables
Initial learning period: right after launch the network buffer and baseline are immature; treat entanglement estimates as low-confidence until it learns (several hundred bars)
Decoupling ≠ direction: a break signals an opportunity exists, not a direction (buy/sell); which variable leads needs separate analysis
request.security constraints: alt/index are fetched on the same timeframe; liquidity or timeframe mismatch can make synchrony estimates inaccurate
Adaptive-system nature: historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation within Pine's compute budget
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The entanglement detection, coupling analysis, decoherence judgment, and circular radar are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Synchrony-break detection can produce false positives. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - Evolutionary Strategy Genome🖊️ Overview
A meta-AI that evolves the strategy itself. Where most tools learn weights inside a fixed model, this engine runs a genetic algorithm over a population of genomes — each a vector encoding how strongly, and in which direction, to read several indicator "genes" (trend, momentum, mean-reversion, volatility, volume). Every genome is a candidate trading strategy. Each generation, genomes are scored by fitness (how well their signal predicted recent forward moves), then evolved by selection (tournament), crossover, and mutation. Over generations the population converges toward strategies that fit the live regime, and the engine proposes the current best genome in real time. Visualization: a text label describing the current best genome (which genes it favors) plus a single forecast line from that evolved strategy.
🔶 Key Features
Strategy evolution — evolves the strategy's composition itself via a genetic algorithm, not just weights (meta-AI)
Genome (strategy DNA) — a vector of five indicator-gene weights and directions
Fitness scoring — tracks how accurately each genome's signal predicted forward moves
Evolution operators — tournament selection, crossover, mutation, and elitism
Real-time best proposal — extracts the current best genome and proposes its strategy
Best-genome label — visualizes which genes the strategy favors and in which direction
Forecast line — a single line projecting the best genome's signal forward
Intelligence panel — best signal, best genome ID and fitness, each gene's weight, generation count, and average fitness
🧠 Technical Architecture
The engine builds five indicator genes: trend (deviation from an MA), momentum (normalized), mean-reversion (negative of stretch from the mean, fading extension), volatility (expansion/contraction regime with a directional sign), and volume (volume-weighted direction). Each gene is a directional reading.
The genome population has popSize individuals, each a five-gene weight vector (the strategy DNA). A genome's signal is tanh(Σ weightₘ · geneₘ), a directional conviction.
Evolution cycle: (1) fitness scoring — the signal each genome emitted fitLook bars ago is scored against the realized forward move as signal × outcome, updating a running fitness via EMA; (2) generation turnover (every evolveEvery bars) — elitism carries the top individuals over unchanged, while the rest are bred via tournament selection (the fitter of two random individuals), crossover (each gene inherited from one parent), and mutation (genes mutate with probability mutRate at scale mutScale). After turnover, fitness is softened and the new individuals are re-evaluated.
For the best-genome proposal, every bar the highest-fitness individual is extracted, and its strategy's signal drives the forecast line and label. The population is sized at MAXPOP(24) and run at popSize(4–24).
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Population 12, Evolve Every 5, Mutation Rate 0.15, Elite 2, Fitness Lookahead 5. Standard settings fit well
ETH (1H–4H): As BTC, with Fitness Memory 50–80
SOL (15m–1H): High volatility favors Mutation Rate 0.2 / Evolve Every 3 to evolve fast and track change nimbly
XRP (1H–4H): Spike-prone; Fitness Decay 0.88 to forget old performance quickly and accelerate adaptation
Population Size: more explores more strategies but adds compute; 10–16 is a practical balance
Evolve Every: smaller evolves often (nimble but less stable); larger is steadier but slower to adapt
Mutation Rate/Scale: higher is exploratory (tries new strategies); lower is stable (refines existing) — tune to market change
Elite Survivors: more preserves good strategies but reduces diversity; 2–3 is practical
💡 How to Use in Practice
Reading the best-genome label: it shows the gene composition of the currently best-performing strategy (e.g. a strong TREND +▮▮▮ means trend-following dominates; MEAN-REV +▮▮▮ means reversion works)
Using the forecast line: a signal-based projection from the evolved best strategy; a steeper slope means stronger directional conviction
Watching gene composition shift: changing gene weights over time signal a regime change and the evolution migrating to a new strategy
Checking generation and fitness: a rising generation count (G#) with rising best fitness means evolution is working and refining; a large gap to average fitness means one strategy stands out
Handling EVOLVING states: when the signal doesn't clear the gate, the strategy lacks conviction — stand aside
Multi-timeframe usage: read the dominant strategy type (gene composition) on the higher timeframe (4H), then time on the forecast on the lower one (15m–1H)
⚠️ Important Notes
Initial evolution period: right after launch the population is randomly initialized and strategies are unevolved; treat signals as low-confidence until enough generations pass (tens of generations = hundreds of bars)
Stochastic evolution: a genetic algorithm is a stochastic search; even the same market can converge to different strategies with a different seed (settings)
Overfitting risk: evolution fits recent conditions, with no guarantee they persist (overfitting to the past); too-short Fitness Memory overfits to recent noise
Learning resets: changing parameters, symbol/timeframe, or recompiling reinitializes the population and fitness, restarting evolution from zero
On look-ahead: fitness uses closed-bar realized moves (a standard training construct); as with any adaptive system, historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation within Pine's compute budget; more population increases compute proportionally
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The genetic algorithm, genome evolution, fitness scoring, best-strategy proposal, and forecast line are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Even an evolved strategy can be wrong. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - Causal Inference Filter🖊️ Overview
A causality-driven filter that asks not "what pattern is on the chart" but "what is actually driving price right now." Where SMC / Order-Block tools read price structure, this engine applies a scientific, causal lens. First, Granger-style causality — for each candidate driver (momentum, volatility, volume, range expansion), it measures whether the driver's past values help predict future returns beyond what past returns alone explain. That is predictive precedence, not mere correlation. Second, NeuraLib feature importance — a small network learns to forecast forward returns, and an ablation-style importance score reveals which driver the model actually relies on. The two combine into a causal confidence: signals fire only when a true driver is clearly identified; in noisy, causally-ambiguous regimes the filter stays silent. Visualization: soft rectangular boxes only over high-causal-confidence zones, plus simple arrows.
🔶 Key Features
Granger-style predictive power — measures whether a driver's past precedes future returns (not mere correlation), correlation-based
NeuraLib feature importance — an ablation-style score identifies the driver the model truly relies on
True-driver identification — extracts the dominant driver from four candidates (momentum/volatility/volume/range-exp)
Causal confidence — a causal-clarity score blending Granger lift and importance concentration
Noise rejection — signals only when causality is clear; suppressed when ambiguous
Causal zones — soft rectangular boxes only in high-confidence conditions (opacity by confidence)
Simple arrows — causally-confirmed directional signals shown with minimal arrows
Intelligence panel — causal confidence, the true driver, each driver's importance and Granger lift, and the forecast at a glance
🧠 Technical Architecture
The engine tests the causal influence of four candidate drivers (momentum, volatility, volume anomaly, range expansion — all normalized).
Granger causality: for each driver d, it computes the rolling correlation between the driver lagged by grangerLag and the current return. If the driver's past predicts today's move, that is predictive precedence (Granger-like). The return's own autocorrelation (how past returns explain the future) is subtracted as a baseline, isolating the causal lift the driver adds — distinguishing "merely correlated" from "predictively precedent."
Feature importance: the NeuraLib network (drivers(4) → hidden(tanh) → forward-return forecast(1)) learns to forecast forward returns by supervision. Each driver's importance is the change in forecast when that driver is "ablated" (set to 0): |full forecast − ablated forecast| — a method inspired by permutation importance.
Causal confidence is a blend of the dominant driver's Granger lift and the importance concentration (the top driver's share of total importance = causal clarity). Only when it clears the gate do arrows and causal zones fire. Zones are drawn with width and opacity scaled by confidence, extend right via extend.right, and retire past their lifespan.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Causal Lag 5, Causality Window 60, Min Causal Lift 0.15, Min Causal Confidence 0.50. Standard settings fit well
ETH (1H–4H): As BTC, with Forward Outcome 5–8
SOL (15m–1H): High volatility favors Confidence Smoothing 4–5 to smooth confidence, Min Confidence 0.55 to reject noise more strictly
XRP (1H–4H): Spike-prone; Causal Lag 3 for shorter precedence, Causality Window 50 to weight recent causality
Causal Lag: the assumed bars by which a driver precedes price — tune to the market's reaction speed
Causality Window: longer is a steadier causal estimate; shorter is nimbler — ~60 is practical
Min Causal Lift: the minimum predictive power for a driver to count as causal — higher is stricter
Min Causal Confidence: the firing threshold for signals/zones — higher narrows to only the clearest causality
💡 How to Use in Practice
Reacting to causal arrows: an arrow marks where a clear causal driver is identified and a direction predicted — a low-false-signal entry basis grounded in statistical causality, not structure patterns
Reading causal zones: a soft box is a price band of high causal confidence; within it causality is clear and price tends to respect the zone — a causal take on support/resistance
Confirming the true driver: the panel's "True Driver" shows whether momentum, volatility, volume, or range is moving price now (e.g. a dominant VOLUME means a volume-led market)
Avoiding ambiguous regimes: low-confidence (AMBIGUOUS) conditions mean the driver is unclear — a noisy market; the absence of a signal is itself a "wait" signal
Checking driver lift: the panel's per-driver Granger lift shows which drivers predictively precede; those above the lift threshold lead
Multi-timeframe usage: confirm the dominant driver and causal direction on the higher timeframe (4H), then time on causal zones and arrows on the lower one (15m–1H)
⚠️ Important Notes
Approximate causal inference: the Granger causality here is a lightweight correlation-based approximation fit to Pine's compute budget — not a rigorous Granger test (VAR regression / F-test), but a heuristic indicator of predictive precedence
Correlation ≠ causation limit: statistical causal inference is powerful but cannot fully exclude hidden common factors (confounders); "causal" means statistical predictive power, not proof of true economic causation
Initial learning period: right after launch the network's buffer is nearly empty and importance estimates are unstable; treat causal confidence as low-confidence until it learns (several hundred bars)
Learning resets: changing parameters, symbol/timeframe, or recompiling reinitializes the network weights and buffer
On look-ahead: the importance target uses closed-bar realized returns (a standard training construct); as with any adaptive system, historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation within Pine's compute budget
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The Granger causality, feature importance, causal confidence, causal zones, and signals are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Even statistical causal inference can misidentify. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - Hierarchical Temporal Memory Inspired🖊️ Overview
A sequence-memory engine inspired by HTM (Hierarchical Temporal Memory), a model of how the neocortex learns sequences. Fundamentally different from KNN similarity-search or LSTM weighted regression, HTM stores knowledge as a sparse columnar memory and learns which column tends to follow which. Each bar's market state is encoded into a Sparse Distributed Representation (SDR) where only a few of many columns activate. A transition memory (permanence weights between columns) learns the sequence "column A → column B," and every new bar the engine predicts which columns should activate next. When an unpredicted column fires instead, that is an anomalous transition — a break in the learned temporal pattern. The mismatch is the anomaly score, and its inverse is sequence stability. Visualization: a faint vertical line only on high-anomaly bars, plus a single Sequence Stability indicator.
🔶 Key Features
HTM-style sequence memory — brain-inspired columnar memory learns temporal patterns (fundamentally unlike KNN/LSTM)
SDR (sparse distributed representation) — encodes each bar into a few active columns
Transition learning — Hebbian strengthening/decay of inter-column permanence stores sequences
Predictive cells — predicts next-bar columns from learned transitions (higher-order capable)
Anomalous-transition detection — scores the firing of unpredicted columns as anomaly
Anomaly-bar emphasis — a faint vertical line only on bars whose anomaly clears the gate (noise excluded)
Sequence Stability — a single lower-pane stability readout (green stable → red anomalous gradient)
Intelligence panel — anomaly score, stability, an active-SDR visualization, predicted/hit counts, and learned-link count
🧠 Technical Architecture
The engine encodes the market state into four features (momentum, RSI deviation, volatility, position-within-range, all normalized) and turns them into an SDR. Each column has a fixed random receptive field (a spatial-pooler proxy); the top activeCols columns by overlap with the current state win and fire (k-winners-take-all). Similar states thus activate similar column sets, different states different ones.
The transition memory is a permanence matrix perm . Learning follows the Hebbian rule: if column A fired and B fired on the next bar, the link A→B is strengthened (permanence +permInc); links whose predictions failed decay (−permDec). Only links above the connection threshold can predict.
For prediction, from the recently-fired columns (both t-1 and t-2 for higher order) the engine follows connected links to build the set of columns expected to fire next. Of the columns that actually fire next bar, the predicted fraction is hits/active, and the anomaly score = 1 − hits/active (the share of unpredicted firings). As learning matures and patterns stay stable, predictions land and anomaly is low; when patterns break, predictions miss and anomaly spikes.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Columns 16, Active Columns 3, Permanence Inc 0.10 / Dec 0.04, Prediction Order 2, Anomaly Threshold 0.55. Standard settings fit well
ETH (1H–4H): As BTC (HTM learns sequences self-supervised, no outcome window needed)
SOL (15m–1H): High volatility favors Anomaly Smoothing 5–6 to smooth the score, Anomaly Threshold 0.6 to suppress false anomalies
XRP (1H–4H): Spike-prone; Columns 20 for more capacity, Prediction Order 1 to weight recent transitions
Columns / Active Columns: more columns add capacity but slow learning; sparsity (Active/Columns) is the heart of HTM — lower is more HTM-like
Permanence Inc/Dec: higher Inc learns faster, higher Dec forgets old memory faster — tune to how fast the market changes
Prediction Order: higher considers longer context (higher-order sequences); lower uses only recent transitions
Anomaly Threshold: higher makes vertical lines rare (only large anomalies); lower more frequent
💡 How to Use in Practice
Reacting to anomaly lines: a vertical line marks a bar where the learned temporal pattern broke — often the onset of a trend change, breakout, or regime shift; a basis for caution or reversal
Reading Sequence Stability: high (green) = the market follows learned patterns (predictable); low (red) = patterns broke, unpredictable. A sudden drop signals an environment change
Interpreting anomalies: sustained anomalies = a regime change in progress; a one-off = a transient shock — stability recovery means adaptation to a new pattern is done
Watching the active SDR: the panel's SDR view (▰▱) shows which columns fire now; recurring SDRs = known patterns, novel SDRs = unfamiliar conditions
Using predicted/hit counts: hits near predicted = stable sequence; a gap = anomaly — also a gauge of learning maturity
Multi-timeframe usage: confirm the big-picture sequence stability on the higher timeframe (4H), then time turns on anomaly lines on the lower one (15m–1H)
⚠️ Important Notes
Initial learning period: right after launch the transition memory is empty and everything looks "anomalous"; treat anomaly as elevated until enough transitions are learned (several hundred bars)
Learning resets: changing parameters, switching symbol/timeframe, or recompiling reinitializes the column receptive fields, transition memory, and SDR history, restarting learning from zero
Anomaly ≠ trade signal: an anomalous transition marks a "pattern break," not a direction (buy/sell); use it as a caution signal of possible change and pair direction calls with other analysis
Sparsity constraint: to fit Pine's compute budget, this is a lightweight build with fewer columns than a true HTM — not as sparse as HTM's ~2%
Adaptive-system nature: historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation within Pine's compute budget; it scans a columns × columns transition matrix, so very large column counts affect performance
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The HTM-style sequence memory, SDR encoding, transition learning, anomaly score, and sequence stability are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Anomaly detection can produce false positives. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - Sentiment-Proxy Correlation Mapper🖊️ Overview
A psychology-focused engine that infers crowd emotion without any social or news feed — purely from price action. It builds sentiment proxies — volume anomaly (panic/euphoria), volatility (fear), price velocity (momentum drive), wick asymmetry (greed vs. fear at extremes), and run-length (FOMO / capitulation) — then uses a NeuraLib correlation map to learn how these proxies move together and weighs them into a single Fear ⇄ Greed sentiment score. A self-adapting mapping continuously re-correlates the proxies against realized outcomes, and the engine flags sentiment turning points — the moments crowd emotion flips. Visualization: a chart-background gradient shading the tape from Fear (red) to Greed (green), plus emphasis dots only at the reversals.
🔶 Key Features
Sentiment proxies — five emotion proxies built from price action alone (no external data)
NeuraLib correlation mapping — learns the proxies' joint behavior and fuses them into a Fear⇄Greed score
Self-adapting correlation — continuously re-correlates proxies against realized outcomes (learns which matter)
Turning-point detection — flags fear⇄greed reversals on a zero-line cross with sufficient swing
Sentiment background gradient — shades the chart from fear (red) through neutral to greed (green), intensity by magnitude
Turning-point dots — only the reversal moments are emphasized with dots and labels (noise excluded)
Emotional extreme markers — faint diamonds when sentiment enters a greed/fear extreme zone
Intelligence panel — Fear⇄Greed gauge, each proxy's value and learned correlation strength, and the latest turn
🧠 Technical Architecture
The engine builds five sentiment proxies from price: (1) volume anomaly (volume z-score × candle direction = euphoric buying / panic selling), (2) volatility (ATR ratio = higher is fear/stress), (3) price velocity (ATR-normalized speed of change = momentum), (4) wick asymmetry (lower − upper wick = which side defended the extreme), and (5) run-length (consecutive up/down within the window = FOMO / capitulation).
These feed the NeuraLib correlation map: proxies(5) → hidden(tanh) → sentiment(1, tanh-bounded ), trained by supervision so sentiment correlates with realized forward direction — greed (positive) preceding up-moves, fear (negative) preceding down-moves. After each step, each proxy's contribution to the hidden layer (mean absolute weight) is recomputed as its correlation strength, shown in the panel so you can see which proxy currently dominates emotion.
Sentiment is smoothed into a Fear⇄Greed score. Turning-point detection flags a fear→greed (or reverse) reversal when a zero-line cross's magnitude clears the Turn Sensitivity. The background is colored continuously by color.from_gradient, with intensity proportional to emotional magnitude.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Volume 20, Volatility 14, Velocity 10, Smoothing 4, Turn Sensitivity 0.20. Standard settings fit well
ETH (1H–4H): As BTC, with Outcome Lookahead 5–8
SOL (15m–1H): High volatility favors Smoothing 5–6 to smooth sentiment, Turn Sensitivity 0.25 to suppress false turns
XRP (1H–4H): Spike-prone; Volume window 15 for sensitive anomaly detection, Extreme Threshold 0.5 for early extremes
Turn Sensitivity: higher makes turns selective (only large emotional reversals); lower detects more frequently
Extreme Threshold: beyond ±this is "extreme greed/fear" — a contrarian guide at 0.5–0.6
Sentiment Smoothing: higher smooths the background and score; lower is more reactive
Background Intensity: lower makes the background more vivid — adjust to taste
💡 How to Use in Practice
Reading the gradient: deep green = greed dominates (possible overheating); deep red = fear dominates (possible capitulation); neutral = balanced — saturation is emotional strength
Using turning-point dots: a "FEAR→GREED" dot marks a flip from fear to greed (possible bottom); "GREED→FEAR" a possible top — a basis for contrarian/trend entries
Contrarian at extremes: at extreme greed (green diamond) beware a pullback from overheating; at extreme fear (red diamond) watch for an oversold bounce — quantifying "be fearful when others are greedy"
Watching proxy correlations: the panel's per-proxy value and correlation strength reveal what drives emotion now (e.g. high volume-anomaly correlation = volume-led sentiment)
Background vs. price divergence: price rising while the background reads fear (bearish sentiment) is an early reversal warning
Multi-timeframe usage: read the big-picture emotional regime on the higher timeframe (4H), then time entries on turning points on the lower one (15m–1H)
⚠️ Important Notes
Nature of proxies: this is not real social/news sentiment but an estimated proxy inferred from price action — an approximation of crowd psychology that differs from external sentiment data
Initial learning period: right after launch the map's buffer is nearly empty and emotion estimates are unstable; treat as low-confidence until it fills (100+ bars)
Learning resets: changing parameters, switching symbol/timeframe, or recompiling reinitializes the map weights and buffer, restarting learning from zero
Danger of contrarianism: extreme emotion can persist (greed runs long in strong trends) — an extreme is not an instant reversal; pair with risk management
On look-ahead: the map's target uses closed-bar realized direction (a standard training construct); current-bar emotion is on confirmed values, but as with any adaptive system, historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation operating within Pine's compute budget
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The sentiment proxies, correlation mapping, Fear⇄Greed score, turning-point detection, and sentiment background are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Estimates of crowd psychology can be wrong. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - Fractal Geometry + Diffusion Predictor🖊️ Overview
A geometric forecaster unlike any channel or trendline tool. Two ideas combine. First, fractal geometry — a Higuchi-style fractal-dimension estimate and a Hurst-like persistence exponent quantify the market's self-similarity (roughness vs. smoothness). A rough, mean-reverting tape and a smooth, trending one have distinct fractal signatures, and the engine reads which regime is live. Second, diffusion-style generation — echoing how a diffusion model denoises noise into data, the engine seeds many noise vectors and runs a guided reverse process to GENERATE multiple future price paths. Their drift and volatility structure are conditioned on the fractal signature, so trending regimes generate persistent paths and rough regimes generate mean-reverting ones. Visualization: a central forecast line (the mean of generated paths) plus a faint fan of prediction bands whose opacity encodes probability.
🔶 Key Features
Fractal dimension — Higuchi method quantifies market roughness (self-similarity) as D∈
Hurst persistence exponent — distinguishes trend-persistence (H>0.5) from mean-reversion (H<0.5)
Diffusion-style path generation — generates multiple future paths by guided reverse diffusion from noise
Fractal guidance — the self-similarity signature steers path drift (classifier-style guidance)
Multi-scenario forecasting — samples many paths to build a per-step distribution
Geometric prediction fan — a central line plus nested probability bands fanning out with horizon
Probability via opacity — band opacity follows Gaussian mass (inner = higher probability = denser)
Intelligence panel — fractal dimension, Hurst exponent, persistence, and the forecast target price at a glance
🧠 Technical Architecture
Fractal geometry: the Higuchi estimator computes the curve length L(k) at each interval k and derives the dimension D from the least-squares slope of log L(k) vs log(1/k). Higher D means a rougher (noisier) series; lower means smoother (more trending). In parallel, a rescaled-range (R/S)-style Hurst exponent is estimated as H = log(R/S) / log(n). The two combine into a persistence score ∈ (+1 strongly trending, −1 strongly mean-reverting).
Diffusion generation: for each path, starting from the current price, each future step runs a reverse-diffusion process over Denoising Steps iterations. Each denoise step shrinks the noise amplitude along a cosine schedule (noisy early, clean late) while progressively strengthening a fractal-guided drift (guidance bites as the noise clears — classifier-style guidance). When persistence is negative (a mean-reverting regime), a pull-back force toward the starting price is added. Repeated across Generated Paths paths, the per-step mean and variance are accumulated via Welford's online algorithm.
Visualization: the per-step mean price forms the central line, and nested bands at multiples of the standard deviation (±k·σ) form the fan. Band opacity is proportional to Gaussian mass exp(−0.5k²), denser inside (higher probability). The fan naturally widens with horizon as variance grows.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Fractal Window 40, kMax 5, Persistence Window 50, Generated Paths 24, Denoising Steps 8, Horizon 16. Standard settings fit well
ETH (1H–4H): As BTC, with Fan Width 1.0 for standard spread
SOL (15m–1H): High volatility favors Noise Scale 1.2 / Fan Width 1.2 to widen path dispersion, Fractal Guidance 0.5 to soften guidance
XRP (1H–4H): Spike-prone; Persistence Window 40 to weight recent self-similarity, Paths 30 to smooth the distribution
Fractal Window / kMax: a wider window and higher kMax refine the dimension estimate but add compute; 40/5 is practical
Generated Paths: more smooths the distribution but is heavier; 20–40 is a practical balance
Denoising Steps: more smooths paths; ~8 is sufficient
Fractal Guidance: higher lets the fractal signature steer drift more; lower is noise-driven
Render load: the fan draws Fan Bands × Horizon × 2 boxes, so maxing both can hit the 500-object render cap
💡 How to Use in Practice
Reacting to the central line: the mean of generated paths is the most probable future path — its slope and target price are the forecast's core
Reading the fan: a narrow fan = high forecast confidence (paths converge); wide = high uncertainty (paths diverge); the dense inner bands are the high-probability zone
Using the fractal regime: in high-persistence (trending) conditions, follow the central line's direction; in low (mean-reverting), expect the forecast to pull back
Reading fractal dimension: low D (toward 1.0) = smooth trending tape; high (toward 2.0) = rough range/noise — an aid to regime classification
Checking Hurst: H>0.5 trend-persistent, H<0.5 reversion-prone — corroborates the central forecast's direction
Fan width and risk: tighten stops when the fan is narrow, give room when wide
Multi-timeframe usage: confirm the fractal regime and forecast direction on the higher timeframe (4H), then time entries on the lower one (15m–1H)
⚠️ Important Notes
Initial computation period: until the fractal and Hurst windows fill (tens to a hundred-plus bars), the dimension and persistence estimates are unstable; treat forecasts as low-confidence until then
Stochastic generation: diffusion paths are generated from noise seeds, so changing the seed (settings) changes the distribution — forecasts are probabilistic scenario sets, not deterministic
Interpreting the fan: the fan shows where generated paths landed, not a guarantee that price stays within it — it is a probability-density visualization
On look-ahead: fractal dimension, Hurst, and drift are all computed from confirmed past data; the forecast projects from now into the future and can of course be wrong — always forward-test
Render load: box count is Fan Bands × Horizon; lower either if it feels heavy
Constraints: this is a lightweight implementation within Pine's compute budget; the Higuchi dimension, Hurst, and path generation are all approximations
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The fractal dimension, Hurst exponent, diffusion-style path generation, prediction fan, and central line are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Even a probabilistically generated forecast can be wrong. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - Multi-Agent RL Consensus Engine🖊️ Overview
A council of independent reinforcement-learning agents that debate, then vote. Three to five lightweight Actor-Critic agents run in parallel, each trained under a DIFFERENT reward function — trend-following, mean-reversion, risk-averse, breakout, and volatility-scaled — so each develops its own "personality" and reads the same market through a different lens. Every bar, each agent casts a directional vote, and a CONSENSUS score measures how strongly the council agrees. The engine speaks only when the agents do: a large arrow appears only on high agreement, and a single Consensus Meter (0–100%) shows the strength of the collective conviction. The evolution of a single RL optimizer into a "debate among multiple AIs."
🔶 Key Features
Multi-agent council — 3–5 independent RL agents learn in parallel and form consensus by voting
Different reward functions (personalities) — trend, mean-reversion, risk-averse, breakout, volatility-scaled
Consensus scoring — combines how many agents agree with their confidence into an agreement score
Meritocratic voting (optional) — better-performing agents get a larger say in the consensus
Fires only on high agreement — the large arrow appears only when council agreement clears the gate
Consensus Meter — a single 0–100% gauge of agreement, lit in the direction color on consensus
Per-agent vote dots — tiny dots show each agent's individual vote at the signal bar
Intelligence panel — consensus score, vote tally, and each agent's name / vote / performance at a glance
🧠 Technical Architecture
The agents perceive the market as a four-dimensional state vector (momentum spread, RSI deviation, Bollinger position, position-within-range — all z-normalized). The core is N independent Actor-Critic agents, each producing Actor logits (3 actions → softmax policy) and a Critic value from a compact shared trunk (tanh).
Agents differentiate via personality-specific reward shaping. From a common risk-adjusted (volatility-normalized) return, the trend agent amplifies reward in strong trends, mean-reversion when stretched, risk-averse shrinks reward in high vol and penalizes drawdown, breakout near range edges, and vol-scaled by volatility magnitude. The agents thus learn distinct behaviors from the same price data. Learning is Advantage Actor-Critic (A = r + γV(s′) − V(s) driving the Actor's policy gradient) from a shared replay buffer.
In the consensus process, every bar each agent produces a policy and votes its max-probability action. Each vote is weighted by "performance × confidence" (when meritocratic), and the weighted long vs. short sums determine the consensus direction. The consensus score is a blend of the dominant side's weighted share (its fraction of the council's total voice) and the raw vote agreement (fraction of agents on the dominant side). Only when this clears the gate do the large arrow and meter light up.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Number of Agents 5, γ 0.93, Min Consensus 0.60, Weight by Performance ON. The full 5-personality roster fits well
ETH (1H–4H): As BTC, with Reward Lookahead 5–8
SOL (15m–1H): High volatility favors Min Consensus 0.65–0.7 to be stricter, where the risk-averse agent earns its keep
XRP (1H–4H): Spike-prone; Agents 5 to include breakout and vol-scaled, Consensus Smoothing 3 to stabilize agreement
Number of Agents: more gives diverse views but makes consensus harder; 5 for all personalities, 3 for the core (trend / mean-rev / risk-averse)
Min Consensus to Signal: higher (0.7+) makes arrows rare and high-quality; lower (0.5) more frequent — raise it if you want near-unanimity only
Weight by Performance: ON for meritocracy (favoring better agents), OFF for equal say; ON is recommended in stable markets
Consensus Smoothing: higher smooths the agreement; lower is more reactive
💡 How to Use in Practice
Reacting to the large arrow: the arrow is a "collective verdict" where the council reached high agreement — multiple distinct strategy-AIs concurring, a core basis for trend-following entries
Reading the Consensus Meter: a full gauge lit in the direction color = strong agreement; under half = a split council, so standing aside is wise
Using vote dots & panel: check each agent's (TREND / MEAN-REV / RISK-AVERSE / BREAKOUT / VOL-SCALED) vote and performance to see which strategy backs the current market
Using disagreement as caution: low consensus marks an uncertain market where strategies diverge — a reason to skip entries
Watching performance scores: the per-agent performance reveals which strategy is working now (e.g. a high-performing trend agent suggests a trend regime)
Multi-timeframe usage: confirm the council's big-picture agreement on the higher timeframe (4H), then refine timing on consensus signals on the lower one (15m–1H)
⚠️ Important Notes
Initial learning period: right after launch the buffer is nearly empty and all agents are immature; treat signals as low-confidence until agreement stabilizes (several hundred bars)
Learning resets: changing parameters, switching symbol/timeframe, or recompiling reinitializes all agent weights, performance scores, and the buffer, restarting learning from zero
Nature of consensus: high agreement means "multiple strategies concurred," but markets exist where all agents are wrong at once (shock events) — consensus is not a guarantee of certainty
On forward-looking reward: rewards use closed-bar forward returns (a standard RL training construct); current-bar votes are on confirmed values, but as with any adaptive system, historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation operating within Pine's compute budget; more agents increase compute proportionally
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The multi-agent reinforcement learning, per-agent reward shaping, consensus score, and Consensus Meter are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Even a consensus of multiple agents can be wrong. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - Transformer-Inspired Attention Bias🖊️ Overview
A Transformer-style attention mechanism rendered in Pine — an engine for the selective focus of memory. Just as a Transformer attends selectively to the most relevant elements of a sequence, this engine treats the current bar as a query and every recent bar as a key/value. It scores each past bar's relevance via scaled dot-product (Q·Kᵀ/√d), normalizes the scores with softmax, and forms a weighted blend of those bars' directional signals — automatically focusing on the past patterns that matter most right now to compute the current bias (bullish/bearish). Several heads run in parallel, each learning a different notion of relevance, then merge into one directional bias. Visualization: an Attention Heatbar across the top of the chart (a horizontal strip whose brightness shows how much attention each point in recent time receives) plus one main bias arrow — a Transformer-style "selective focus of memory" in Pine.
🔶 Key Features
Multi-head attention — scaled dot-product attention (Q·Kᵀ/√d → softmax → ·V) reproduced in Pine
Selective focus of memory — automatically focuses on important past bars while suppressing noisy ones
Multiple heads — heads learn different relevance notions in parallel, merging into one bias
Positional encoding — an optional recency signal so the model knows how far back each bar is
Attention Heatbar — visualizes time-axis importance as a horizontal strip above price (brighter = more attention, tinted by bias)
Main bias arrow — the post-attention directional bias shown as one arrow (with glow)
Temperature parameter — softmax temperature tunes between sharp focus on a single bar and diffuse attention
Intelligence panel — attention bias, focus sharpness and distance (how far back focus sits), head count, context length, and more
🧠 Technical Architecture
Each bar is encoded into a small feature "token": momentum, RSI deviation, one-bar return, and range width (all normalized). Each bar is also assigned a directional "value" value = tanh(...) capturing its bullish/bearish lean.
The core is multi-head attention. The current bar's token is projected by Wq into a d-dim query q; each of the past ctxLen bars' tokens is projected by Wk into kᵢ. Attention scores are the scaled dot-product score_i = (q·kᵢ)/√d / temperature, where √d scaling ensures gradient stability. With positional encoding enabled, a recency signal is added to the keys. The scores are normalized by softmax into weights wᵢ, and the past bars' values are blended as Σ wᵢ·valueᵢ — that head's bias. Since each head has distinct projection weights, each captures a different relevance, merged via head output weights Wo.
A key implementation detail: Pine's history operator cannot take a loop variable, so past tokens are accumulated into rolling arrays and accessed dynamically via array.get(idx). Attention weights are aggregated into time-axis buckets and shown, normalized, as the Attention Heatbar (a brighter cell = stronger attention to that bar). The final bias is EMA-smoothed, and the main arrow fires when it clears the gate.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Context Window 40, Heads 3, Key Dim 4, Temperature 1.0. Standard settings fit well
ETH (1H–4H): As BTC, with Context Window 50 for slightly longer memory
SOL (15m–1H): High volatility favors Temperature ≈ 0.7 for sharp focus, Heads 4 to capture diverse relevance
XRP (1H–4H): Spike-prone; Context Window ≈ 30 to emphasize recency, Position Encoding ON
Context Window: longer references further back but is heavier; 30–60 is practical
Heads: more captures more relevance notions but adds compute; 2–4 is readable
Temperature: low (0.5–0.8) sharply focuses on the single most relevant bar; high (1.5–3) gives diffuse, smooth attention
Min |Bias| to Signal: higher makes arrows more selective — tune to your trade frequency
💡 How to Use in Practice
Reading the Heatbar: a bright cell means that bar strongly drives the current bias. Bright on the right (recent) = short-term pattern leads; bright on the left (older) = a past important moment is recurring
Reacting to the main arrow: the arrow is the verdict where multi-head attention's merged bias clears the gate — a core basis for trend-following entries
Using focus distance: small panel "Focus Distance" = recency-driven; large = attending to far-back patterns, suggesting recurrence of a past analog
Focus sharpness: high = attention concentrated on one point (clear pattern recognition); low = diffuse (ambiguous)
Pairing with temperature: if the heatbar is wide and faint, lower the temperature to sharpen focus and clarify what the engine attends to
Multi-timeframe usage: confirm the big-picture bias on the higher timeframe (4H), then refine timing on arrows on the lower one (15m–1H)
⚠️ Important Notes
Initial context period: attention is incomplete until the context window (ctxLen) fills; treat the bias as low-confidence until enough past bars accumulate
Effect of setting changes: changing parameters, switching symbol/timeframe, or recompiling reinitializes the projection weights and token history
On learning: the projection weights are seed-initialized fixed weights used to compute attention patterns; this tool does not update weights from reward — it focuses on visualizing the attention mechanism itself
Heatbar placement: the heatbar draws above price, so adjust Heatbar Height to avoid overlapping the candles
Adaptive-system nature: historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation operating within Pine's compute budget; Context × Heads × Key Dim drives compute load, so extreme settings affect performance
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The attention mechanism, multi-head attention, positional encoding, bias computation, and Attention Heatbar are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - Bayesian Neural Market Microstructure🖊️ Overview
A NeuraLib Bayesian Neural Network that does what a point-estimate model (e.g. a plain LSTM) cannot: it predicts WITH a confidence. Instead of one number, it runs many stochastic forward passes (MC-Dropout / weight-perturbation style) to produce a DISTRIBUTION of next-move predictions, reporting both a mean forecast and an uncertainty (the spread of the samples). Inputs are market-microstructure proxies — volume delta (buy/sell pressure), an estimated spread, and a liquidity proxy — alongside price features. Visualization: a probability-density "cloud" of predicted price bands (opacity ∝ probability) and a single forward zone that reddens as uncertainty rises. The edge over LSTM-style tools is clear — you see not just where, but how sure.
🔶 Key Features
Bayesian NN (uncertainty estimation) — multi-sample weight perturbation yields a predictive distribution: mean + uncertainty
Confidence-aware prediction — "mean ± σ", not a point estimate — the decisive difference from LSTM-style tools
Microstructure inputs — volume delta (order-flow proxy), estimated spread, and a liquidity proxy as features
Probability-density cloud — predicted bands drawn as nested probability tiers, opacity encoding probability mass (denser inside)
Uncertainty zone — a single forward zone that reddens and gains opacity as uncertainty rises
Mean forecast line — one line from current price to predicted price (with glow)
Online learning — the network continuously regresses toward realized forward moves
Intelligence panel — predicted move, predicted price, confidence, uncertainty, and each microstructure component at a glance
🧠 Technical Architecture
The agent perceives the market as a four-dimensional microstructure state: price momentum, order-flow pressure (a normalized volume delta from candle-direction × volume EMA), spread regime (an estimated effective spread from the high-low range), and liquidity (volume per unit range) — all z-normalized.
The network is in(4) → hidden(tanh) → out(1) = predicted normalized move, but its Bayesian behavior is reproduced via stochastic forward passes. Each sample (1) injects Gaussian-style noise into the weights (variational weight perturbation) and (2) applies an MC-Dropout mask to hidden units. Repeating this MC Samples times, the mean of the predictions is the forecast and their standard deviation is the uncertainty (epistemic uncertainty) — the heart of the Bayesian approximation.
Learning is supervised regression: for each state, the realized normalized move (close − close ) / ATR over the prediction horizon is the target, and the mean network regresses toward it via squared error (sampled from a replay buffer). For visualization, around the predicted price close + mean·ATR, nested probability bands of half-width k·σ·ATR form the density cloud, with opacity proportional to Gaussian mass exp(−0.5k²). The uncertainty zone gradients from the forecast color to red, with a bold red border once normalized uncertainty crosses the threshold.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): MC Samples 12, Dropout 0.25, Weight Noise 0.05, Prediction Horizon 8, Cloud Bands 5. Standard settings fit well
ETH (1H–4H): As BTC, with Uncertainty Scale 1.0 for standard cloud width
SOL (15m–1H): High volatility favors Dropout 0.3 / Weight Noise 0.08 for more sensitive uncertainty, Red Zone Threshold 0.5 to warn risk early
XRP (1H–4H): Spike-prone; MC Samples ≈ 16 to smooth the distribution, Uncertainty Scale 1.2 for slightly wider clouds
MC Samples: more smooths the uncertainty estimate but is heavier; 10–16 is a practical balance
Dropout / Weight Noise: higher widens the predictive distribution and raises uncertainty — tune to market noise
Cloud Density Bands: more makes a smoother, prettier cloud but adds render load; 4–6 is readable
Red Zone Threshold: lower warns red earlier (conservative); higher keeps the cool color only when very confident
💡 How to Use in Practice
Reading the density cloud: a narrow, dense cloud = low uncertainty, high-confidence forecast; a wide, faint cloud = high uncertainty, unstable forecast. The cloud center (mean line) is the predicted price
Uncertainty zone color: a forecast-colored (teal/coral) zone means confidence; a red, bold-bordered zone means high uncertainty — enter cautiously
Using confidence-aware prediction: consider entries only when panel Confidence is high — unlike point predictors (LSTM etc.), you can judge whether to trust the forecast
Checking microstructure: when order-flow Δ, spread, and liquidity align with the forecast direction, the prediction is better supported
Cloud width and sizing: size larger when the cloud is narrow (low uncertainty), smaller when wide (high uncertainty)
Multi-timeframe usage: confirm the big-picture forecast direction and uncertainty on the higher timeframe (4H), then time entries in low-uncertainty windows on the lower one (15m–1H)
⚠️ Important Notes
Initial learning period: right after launch the buffer is nearly empty and the network is untrained, so forecasts are unstable; treat them as low-confidence until it fills (several hundred bars)
Learning resets: changing parameters, switching symbol/timeframe, or recompiling reinitializes the network weights and buffer, restarting learning from zero
On microstructure proxies: this uses microstructure proxies estimated from OHLCV, not a real order book — an approximation that differs from true book data
Interpreting uncertainty: the reported uncertainty is the model's epistemic uncertainty (its lack of confidence), not a complete measure of actual market risk
On look-ahead: the target uses closed-bar realized moves (a standard training construct); current-bar prediction is on confirmed values, but as with any adaptive system, historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation operating within Pine's compute budget; raising MC Samples increases compute proportionally
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The Bayesian neural network, uncertainty estimation, microstructure proxies, predictive distribution, and density cloud are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Even a probabilistic forecast can be wrong. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - Self-Evolving RL Dashboard Lite🖊️ Overview
A streamlined self-evolving agent built on a lightweight Actor-Critic core with prioritized experience, learning by pitting multiple specialist RL heads against each other. Internally, three heads — TREND-FOLLOWING, MEAN-REVERSION, and BREAKOUT — each propose a directional view from their own lens, while a meta-selector tracks each head's recent reward performance and re-allocates trust toward whichever is working now. As the market's character shifts, the agent automatically moves its weight toward the style that's paying off. Visualization is intentionally minimal: one main signal arrow, one prediction line, a small composite score, and a "Learning Progress" label that makes the evolution visible.
🔶 Key Features
Competing RL heads — trend / mean-reversion / breakout specialists run in parallel; the best drives the unified call
Dynamic trust re-allocation — softmax trust weights adapt to each head's reward-performance score
Lightweight Actor-Critic — each head has an Actor (policy) and Critic (state value), learning via advantage
Prioritized experience replay — high-reward transitions re-learned preferentially
Style-specific reward shaping — each head is rewarded more in its specialty regime, differentiating behavior
Ultra-minimal visuals — just one main arrow + one prediction line + a small composite score
Learning Progress label — visualizes agent maturity (bars trained, buffer fill, trust concentration) as a bar
Exploration vs. exploitation — ε-greedy exploration
🧠 Technical Architecture
The agent perceives the market as a four-dimensional state vector (momentum spread, RSI deviation, Bollinger position, position-within-range — all z-normalized). The core is three independent Actor-Critic heads, each producing Actor logits (3 actions → softmax policy) and a Critic value from a compact shared trunk (tanh).
Heads differentiate via style-specific reward shaping. From a common directional return (ATR-normalized), the trend head amplifies reward in strong trends (large |momentum|), the mean-reversion head when stretched from the mean (large |BB position|), and the breakout head near range edges. The three thus learn distinct behaviors from the same price data.
Learning is standard Actor-Critic. Each head's Critic computes the TD target r + γV(s′), the advantage A = TD target − V(s) drives the Actor's advantage-weighted policy gradient, and the Critic regresses via squared error — all from a prioritized replay buffer (|reward|^exponent). In meta-selection, each head's performance score is EMA-smoothed and turned into trust weights via softmax. The final policy blends the three heads' policies by trust and picks the max-value action. The composite score is the decisiveness of the blended policy; learning progress combines training maturity, buffer fill, and trust concentration.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Training Horizon 800–1500, γ 0.93, Head Trust Adapt 0.05, Min Score 0.35. Standard settings fit well
ETH (1H–4H): As BTC, with Reward Lookahead 5–8
SOL (15m–1H): High volatility favors Head Trust Adapt ≈ 0.08 to switch styles quickly, Min Score 0.4 to be selective
XRP (1H–4H): Spike-prone; Priority Exponent ≈ 2.0 to learn hard from big experiences, shorter Prediction Length
Head Trust Adapt Rate: higher switches to the winning style faster but less stably; lower is stable but slower
Head Score Smoothing: higher (0.9–0.95) smooths performance assessment; lower is sensitive to recent results
Min Score to Signal: higher makes arrows more selective — tune to your trade frequency
Prediction Length: the projection distance of the line; a higher score steepens its slope
💡 How to Use in Practice
Reacting to the main arrow: an arrow is the "final verdict" where the trust-weighted consensus of all three heads clears the score gate — a core basis for trend-following entries
Using the prediction line: one line whose slope scales with score; steeper means a more confident directional view
Reading the composite score: a higher score % in the small label means clearer cross-head consensus; low means a balanced call (stand aside)
Using the Learning Progress label: as the "LEARNING" bar fills and the best head stabilizes, the policy is maturing; treat signals as indicative while progress is low
Watching the best head: the current leading head (TREND / MEAN-REV / BREAKOUT) in the progress label reveals how the agent reads the present market
Multi-timeframe usage: confirm the best head and direction on the higher timeframe (4H), then refine timing on arrows on the lower one (15m–1H)
⚠️ Important Notes
Initial learning period: right after launch the buffer is nearly empty and the heads are immature; treat signals as low-confidence until the Learning Progress bar fills (several hundred bars)
Learning resets: changing parameters, switching symbol/timeframe, or recompiling reinitializes all head weights, trust weights, and the buffer, restarting learning from zero
Nature of the Lite build: this distills the multi-head internals into ultra-simple output, omitting detailed internal-state visualization
On forward-looking reward: rewards use closed-bar forward returns (a standard RL training construct); current-bar decisions are on confirmed values, but as with any adaptive system, historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation operating within Pine's compute budget
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The Actor-Critic, competing RL heads, prioritized experience replay, reward shaping, composite score, and prediction are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Reinforcement-learning agents can and do make wrong calls. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - KNN-Augmented RL Hybrid🖊️ Overview
A self-evolving hybrid that fuses episodic memory with a learned value network. Each bar's state and its realized outcome are stored in an experience memory bank; to value the present, the agent runs a k-Nearest-Neighbors search over that bank — retrieving the most similar historical states and distance-weighting their outcomes — then blends that memory estimate with a NeuraLib NN/Q estimate. The fusion combines the generalization of gradient learning with the instant recall of episodic memory. A reward-driven update adapts the per-feature similarity weights, so the agent learns which dimensions of "similarity" actually matter for prediction. Visualization: auto breakout-zone boxes where high-similarity memory predicts a decisive move, plus directional arrows on the fused signal.
🔶 Key Features
kNN×RL hybrid — episodic-memory kNN retrieval fused with a NeuraLib value network
Episodic memory augmentation — instant distance-weighted recall of similar past outcomes
Memory ↔ network blend — continuously adjustable from pure memory (kNN) to pure network (NN/Q)
Reward-driven similarity-weight learning — learns which feature dimensions define "similar"
High-similarity breakout zones — zones spawn only when memory retrieval is confident; opacity tracks similarity
Fused signal arrows — the integrated kNN+NN verdict shown as directional arrows (with glow)
Exploration vs. exploitation — ε-greedy exploration
Premium panel — NN-vs-kNN breakdown, fused value, memory similarity, conviction, similarity weights, memory/zone counts
🧠 Technical Architecture
The agent perceives the market as a four-dimensional state vector (momentum spread, RSI deviation, a volatility-regime ratio, position-within-range — all z-normalized). The architecture fuses two value-estimation paths.
Episodic memory (kNN) path: each bar stores state, action taken, and realized value (reward) in a memory bank. To value the present, a weighted Euclidean distance — using adaptive per-feature weights — is computed against all memories, and the k nearest are retrieved. Each neighbor's distance is turned into similarity via a Gaussian-style kernel sim = exp(−sharpness × distance), and a per-action similarity-weighted average yields the kNN memory value.
Value network (NeuraLib) path: a single hidden-layer (tanh) network maps state to per-action Q-values, trained by a DQN-style update.
Fusion: per direction, fused = (1−blend)·Q_network + blend·Q_knn, and the action with the largest fused value is selected. The signature element is similarity-weight adaptation: on each reward, weights of feature dimensions consistent with the profitable outcome are raised and irrelevant ones lowered (w ← clip(w + lr·(|feature|·|reward| − baseline))). The very definition of "similar" thus evolves from reward. Zone spawning fires only when both memory similarity and conviction clear their gates, with box opacity tracking similarity.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Training Horizon 800–1500, Neighbors k 6, Memory Depth 300, Blend 0.5, γ 0.93. A 50/50 memory-network fusion as standard
ETH (1H–4H): As BTC, with Reward Lookahead 5–8
SOL (15m–1H): High volatility favors Similarity Sharpness 2.5–3.0 to weight only close neighbors, Min Similarity 0.7 to be selective on zones
XRP (1H–4H): Spike-prone; Blend ≈ 0.6 to lean on memory (recalling past sharp moves), k ≈ 8
Memory ↔ Network Blend: toward 0 favors generalization (robust to novel states); toward 1 favors memory (replays known patterns) — tune to market repetitiveness
Neighbors (k): small (3–5) is sharp but noisy; large (8–15) is smooth but less responsive
Similarity Weight LR: higher adapts feature weights faster but less stably; 0.01–0.03 is the stable zone
Memory Bank Depth: deeper retains more diverse memory but mixes in older regimes — balance against Training Horizon
💡 How to Use in Practice
Reacting to fused arrows: an arrow means both kNN memory and NN value back the direction and conviction cleared the gate — the integrated verdict, a core basis for trend-following entries
Using high-similarity zones: zones mark areas where memory shows a decisive move occurred in similar past conditions; watch breaks/bounces at zone edges
Reading memory similarity: higher panel similarity means the present closely matches a clear past pattern — higher prediction confidence; be cautious when low (novel conditions)
NN vs. kNN agreement: when both (e.g. the "NN / kNN" in the LONG row) are high together, confidence is highest; stand aside when they disagree
Watching similarity weights: the panel's Sim Weights (M·R·V·P = momentum, RSI, volatility, position) reveal which features the agent currently weights for similarity
Multi-timeframe usage: map high-similarity zones on the higher timeframe (4H), then refine timing on fused arrows on the lower one (15m–1H)
Combinations: filter for high-similarity, high-conviction arrows to focus on memory-backed, high-quality entries
⚠️ Important Notes
Initial learning period: right after launch the memory bank is nearly empty and kNN retrieval is non-functional; treat signals and zones as low-confidence until memory accumulates (several hundred bars)
Learning resets: changing parameters, switching symbol/timeframe, or recompiling reinitializes the memory bank, network weights, similarity weights, and zones, restarting learning from zero
Memory bias: the bank is built from recent states, so when the regime shifts substantially, past memory fits the present less well — low Memory Similarity is the tell
On forward-looking reward: rewards and memory values use closed-bar forward returns (a standard RL training construct); current-bar evaluation is on confirmed values, but as with any adaptive system, historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation operating within Pine's compute budget; kNN search scales with memory depth × neighbors, so extreme settings affect performance
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The kNN search, value network, reward shaping, similarity-weight adaptation, breakout zones, and fused signal are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Reinforcement-learning agents can and do make wrong calls. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - Q-Learning Trendline Drawer🖊️ Overview
A self-evolving auto-drawing engine that learns how to draw trendlines via tabular Q-Learning. It quantizes the market into a discrete state (trend posture, volatility regime, proximity to swing structure) and maps it through a state×action Q-table (a NeuraLib Q-head) to an optimal drawing action — anchor a support line, anchor a resistance line, steepen, flatten, or hold. When price breaks a line, the realized outcome feeds back as reward via Q(s,a) ← Q(s,a) + α , so the agent itself learns which drawing behavior pays off in each market state. Every rendered line carries an expiry, with its learned strength (Q-value) reflected in color, width, and opacity.
🔶 Key Features
Tabular Q-Learning — a state×action Q-table held as a NeuraLib Q-head, updated by the Bellman rule
State quantization — trend, volatility, and proximity compressed into discrete bins for an interpretable finite state space
Self-evolving drawing policy — no prior knowledge; the optimal way to draw is learned from the live chart
Reward on break — realized post-break return becomes reward, with an extra reward when a line is respected (bounces)
AI-optimal trendlines — multiple optimal lines auto-generated and adjusted from learned strength
Expiry + strength encoding — each line has a lifespan; Q-derived strength drives color, width, and opacity; old lines fade
Exploration vs. exploitation — ε-greedy over drawing actions
Premium panel — the current state's Q-row (all action values), optimal action, policy decisiveness, and active/broken counts at a glance
🧠 Technical Architecture
The agent first quantizes the market into a discrete state. Three axes — trend posture (ATR-normalized fast/slow EMA gap), volatility regime (ATR ratio), and proximity to the nearest swing structure — are each split into a configurable number of bins and composed into a single state index. The state space is thus a finite trendBins × volBins × distBins, and the Q-table holds the value of every action for every state.
Each bar, the agent picks a drawing action via ε-greedy: with probability ε it explores (a random action); otherwise it exploits (the max-Q action for the current state). Once chosen, a trendline is constructed anchored on two swing pivots, with STEEPEN/FLATTEN actions biasing the slope. New lines too close to an existing one are suppressed to avoid clutter.
Learning is driven by break / respect events. When a line breaks, the lookahead return in the break direction accrues as reward; when price tests a line and respects it (bounces), a separate reward is added. On the next confirmed bar, the update Q(s,a) ← Q(s,a) + α is applied to the prior state-action. Each line's strength is the spawning Q-value squashed logistically to , driving color saturation, line width (strong lines are thicker), and opacity. As lifecycle management, expired and long-broken lines retire, and when over the cap the weakest (lowest-strength) line is pruned.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Training Horizon 800–1500, α 0.2–0.3, γ 0.9, ε 0.08, Swing Sensitivity 8. State bins of 3 each give a standard granularity
ETH (1H–4H): As BTC, with Reward Lookahead 5–8 to value post-break follow-through
SOL (15m–1H): High volatility favors Volatility Bins 4 for finer regime classification, Break Buffer 0.1–0.15 to absorb fakeouts, Min Separation ≈ 0.8
XRP (1H–4H): Spike-prone; α ≈ 0.3 to learn fast, Respect Reward 0.4 to favor strong lines that bounce
Learning Rate α: higher (0.3–0.5) learns faster but values are noisier; lower (0.1–0.2) is stable but slower
State bins: more bins raise granularity but enlarge the state space and slow learning — balance against Training Horizon
ε (exploration): ~0.1 when studying drawing behavior; ~0.05 in live use to stabilize the policy
💡 How to Use in Practice
Reacting to AI-optimal lines: thick, saturated lines = high Q (high strength) = levels the agent learned matter. A reliable basis for S/R judgments
Reading strength (color/width): the thicker and more opaque a line, the higher its learned strength; treat faint, thin lines as tentative
Using breaks: on a break the line recolors (cyan up / gold down) and thickens; breaks of higher-strength lines matter more
Using respects (bounces): when price approaches a strong line and bounces, it marks a pullback/throwback entry in that line's direction
Multi-timeframe usage: map the major high-strength lines on the higher timeframe (4H), then time breaks/bounces on the lower one (15m–1H)
Combinations: pair with volume or horizontal S/R, filtering for high-strength lines to lift precision
⚠️ Important Notes
Initial learning period: right after launch the Q-table is near-zero and the drawing policy is immature; treat line strength as low-confidence until enough state visits accumulate (several hundred bars)
Learning resets: changing parameters, switching symbol/timeframe, or recompiling reinitializes the Q-table and the line set, restarting learning from zero
State-space constraint: more bins mean more unvisited states, whose lines rely on near-zero initial Q and thus show lower strength
On forward-looking reward: rewards use confirmed post-break lookahead returns (a standard RL training construct); current-bar drawing is on confirmed values, but as with any adaptive system, historical and live behavior can differ — always forward-test
Constraints: this is a lightweight tabular implementation operating within Pine's compute budget
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The Q-Learning, Q-table, reward shaping, trendline generation, and strength are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Reinforcement-learning agents can and do make wrong calls. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - RainbowDQN Multi-Component🖊️ Overview
A self-evolving multi-component agent that fuses the core pillars of Rainbow DQN into one policy: Double (overestimation control), Dueling (separating state value from action advantage), and Prioritized Replay (re-learning in proportion to surprise / TD error). It learns from a composite reward — risk-adjusted return, drawdown avoidance, and volatility scaling — so it generalizes across trending, ranging, and high-volatility regimes alike. The internals are multi-headed, but their complex valuation is distilled into a single refined unified-signal arrow, rendered with layered glow and a premium intelligence panel.
🔶 Key Features
Three Rainbow components fused — Double + Dueling + Prioritized Replay in one policy
Composite-reward learning — risk-adjusted return + drawdown avoidance + volatility scaling, weighted
Multi-regime adaptability — volatility scaling and drawdown penalty generalize across trend / range / high-vol
Overestimation control (Double) — online net selects, target net evaluates
V/A separation (Dueling) — state value V(s) and advantage A(s,a) on separate streams
Prioritized replay + importance sampling — high-TD-error transitions learned first, with IS bias correction
Unified signal arrow only — multi-head internals distilled into one clean arrow (Layered Glow / Minimal / Labeled styles)
Refined visuals — multi-layer glow arrows, conviction ribbon, signal pulse, and a sectioned premium panel
🧠 Technical Architecture
The agent perceives the market as a five-dimensional state vector: momentum spread, RSI deviation, ADX trend strength, a volatility-regime ratio, and position-within-range — all z-normalized. Two networks exist (online + target), each with a Dueling structure — a shared trunk (tanh) forks into a Value stream V(s) and an Advantage stream A(s,a), recombined as Q = V + (A − mean A).
As Double-DQN, next-state action selection uses the online net's argmax while its valuation uses the target net, curbing overestimation; weights hard-sync every Target Net Sync bars. The composite reward fuses three heads: (1) risk-adjusted return (forward return normalized by ATR), (2) drawdown avoidance (penalizing adverse excursion within the lookahead window), and (3) volatility scaling (shrinking rewards earned under abnormally high volatility).
For prioritized replay, each transition's TD error δ = pred − target is turned into a priority |δ|^α, skewing sampling toward surprising experiences, while an importance-sampling (β) weight corrects the resulting bias. Gradients flow through the dueling aggregation (dQ/dV = 1, dQ/dA = 𝟙 − 1/3) into each stream and the shared trunk via manual backpropagation. Finally, a unified conviction blending Q-spread and advantage-spread is computed, and a single arrow is drawn only when it clears the gate.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Training Horizon 800–1500, γ 0.94, Target Net Sync 25, reward weights Ret 1.0 / DD 0.6 / Vol 0.4. The balanced defaults fit well
ETH (1H–4H): As BTC, with Reward Lookahead 5–8 to value trend persistence
SOL (15m–1H): High volatility favors Vol weight 0.6–0.8 to strengthen scaling, Conviction Gate 0.45–0.55 to be selective
XRP (1H–4H): Spike-prone; DD weight ≈ 0.8 to penalize adverse excursion harder, Priority Exponent ≈ 2.0
Composite weights: raise Ret for trend-seeking, DD for steadier operation, Vol for choppy markets — allocate by market character and style
Conviction Gate: higher (0.5–0.6) gives fewer, higher-quality arrows; lower (0.3–0.4) gives more — tune to your trade frequency
Target Net Sync (τ): short (10–15) adapts fast but less stable; long (40–60) is stable — match to market stability
💡 How to Use in Practice
Reacting to the unified arrow: every arrow shown is the "final verdict" — past the multi-head valuation, composite reward, and conviction gate — a high-confidence core basis for trend-following entries
Using the conviction ribbon: the more saturated the under-price ribbon, the stronger the directional conviction; arrow plus matching ribbon color (teal bullish, coral bearish) is the most coherent setup
Across regimes: follow arrows directly in trends; in ranges the drawdown-avoidance head reduces forced signals; in high-vol the volatility head tempers overreaction
Signal pulse: the pulse dot on the firing bar improves entry-timing visibility
Multi-timeframe usage: confirm the big-picture unified direction on the higher timeframe (4H), then refine timing on aligned arrows on the lower one (15m–1H)
Combinations: pair with volume or key S/R, filtering for high-conviction arrows to lift precision further
⚠️ Important Notes
Initial learning period: right after launch the replay buffer is nearly empty and both networks are unstable; treat signals as low-confidence until it fills (several hundred bars)
Learning resets: changing parameters, switching symbol/timeframe, or recompiling reinitializes all network weights and the buffer, restarting learning from zero
Target-sync effect: calls may briefly shift right after a sync — this is normal Double-DQN behavior
On forward-looking reward: rewards and drawdown use closed-bar forward data (a standard RL training construct); current-bar evaluation is on confirmed values, but as with any adaptive system, historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation operating within Pine's compute budget
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The Rainbow DQN (Double/Dueling/Prioritized Replay), composite reward, networks, and signal outputs are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Reinforcement-learning agents can and do make wrong calls. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - A2C Advantage Critic🖊️ Overview
A self-evolving Advantage Actor-Critic (A2C) agent that trains two neural networks in tandem: an Actor that selects actions and a Critic that estimates state value. Their interplay produces the advantage A = R + γV(s′) − V(s) — the signed "surprise" of an outcome relative to what the Critic expected — which both trains the Actor and filters the signals: arrows fire only when the advantage is decisively in favor of a direction, naturally rejecting noisy conditions. Learning from experience on your chart, it visualizes its decisions with clean arrows and a single Critic-value histogram whose intensity encodes the strength of its valuation.
🔶 Key Features
Joint Actor-Critic learning — a shared trunk forks into an Actor head (softmax policy) and a Critic head (state value V(s)), trained together
Advantage filtering — signals fire only when |advantage| clears a gate, excluding low-conviction conditions (the heart of the A2C filter)
TD-error advantage — A = R + γV(s′) − V(s) as the action-evaluation signal
Entropy bonus — prevents premature Actor collapse onto one action, encouraging exploration
Prioritized Sampling (PER) — high-advantage transitions learned preferentially
Clean directional arrows — only filtered, decisive Long/Short signals are shown
Critic value histogram — normalized state value drawn as a single column, with intensity (opacity/height) encoding valuation strength
Intelligence panel — Actor per-action probabilities, selected action with filter status, Critic value, advantage, and buffer state at a glance
🧠 Technical Architecture
The agent perceives the market as a four-dimensional state vector: momentum spread (ATR-normalized fast/slow EMA gap), RSI deviation, a volatility-regime ratio, and position-within-range — all z-normalized. This state passes through a NeuraLib-style Actor-Critic network: a shared trunk (tanh hidden) forks into two heads. The Actor head produces three logits → softmax policy π(a|s); the Critic head produces a scalar state value V(s).
The core is the advantage. For a transition (s, a, r, s′), the Critic computes the TD target R + γV(s′) and the advantage A = R + γV(s′) − V(s) — a signed measure of how much better action a was than expected. The Actor updates via the advantage-weighted policy gradient ∇ = A·(𝟙 − p) (raising the chosen action's probability when advantage is positive, lowering it when negative), plus an entropy bonus. The Critic regresses toward the TD target via squared error. Both gradients backpropagate manually into the shared trunk, with separate Actor and Critic learning rates (a slightly faster Critic keeps the baseline tracking the Actor).
For signal filtering, the live advantage is EMA-smoothed and arrows fire only when its magnitude clears the gate. The Critic value histogram z-normalizes the state value over a rolling window, drawing a single column colored by sign (positive greenish, negative reddish) with opacity scaled by magnitude.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Training Horizon 800–1500, γ 0.94, Actor LR 0.03 / Critic LR 0.05, Advantage Gate 0.35, Hidden 8. Standard settings fit well
ETH (1H–4H): As BTC, with Reward Lookahead 5–8 to value slightly longer advantage
SOL (15m–1H): High volatility favors Advantage Gate 0.4–0.5 (stricter filter), Advantage Smoothing 4–5 to curb noise, ATR-normalization always ON
XRP (1H–4H): Spike-prone; a higher Advantage Gate, Critic LR 0.05–0.07 for baseline accuracy
Advantage Gate (filter): higher (0.4–0.6) gives fewer, higher-quality signals; lower (0.2–0.3) gives more but noisier — tune to your trade frequency
Actor LR / Critic LR: keep the Critic faster than the Actor (≈1.3–1.7×) for stability; lower both if diverging
Entropy Bonus: raise to 0.02–0.05 if the Actor biases too early to one side
💡 How to Use in Practice
Reacting to filtered arrows: every arrow shown has already cleared the advantage gate — an edge confirmed beyond the Critic's expectation, a high-confidence basis for trend-following entries
Reading the Critic histogram: a large green column = the Critic strongly values the current state (upside expectation); a large red column = strong negative valuation (downside). Taller, more opaque columns mean stronger Critic conviction
Arrow + histogram alignment: a Long arrow with a strong green column, or a Short arrow with a strong red column, is the most coherent setup; stand aside when they disagree
Advantage convergence: when the panel's advantage hovers near the gate, the call is balanced; a decisive break of the gate marks the entry opportunity
Multi-timeframe usage: read the big-picture Critic valuation on the higher timeframe (4H), then refine timing on filtered arrows on the lower one (15m–1H)
Combinations: use divergence between price and the Critic histogram (price at highs but Critic valuation falling) as an early reversal warning
⚠️ Important Notes
Initial learning period: right after launch the buffer is nearly empty and both Actor and Critic are unstable; treat signals as low-confidence until it fills (several hundred bars)
Learning resets: changing parameters, switching symbol/timeframe, or recompiling reinitializes the network weights and buffer, restarting learning from zero
Critic normalization: the histogram is a rolling-window z-score, showing relative strength rather than an absolute level; values are unstable until the window fills
On forward-looking reward: rewards and advantage use closed-bar forward returns (a standard RL training construct); current-bar evaluation is on confirmed values, but as with any adaptive system, historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation operating within Pine's compute budget
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The Advantage Actor-Critic, Actor/Critic networks, advantage computation, reward shaping, and outputs are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Reinforcement-learning agents can and do make wrong calls. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - PPO Policy Optimizer🖊️ Overview
A self-evolving policy-gradient agent built on Proximal Policy Optimization (PPO) that optimizes its trading policy itself. A NeuraLib policy network outputs a softmax probability distribution over LONG / SHORT / FLAT, improved through a PPO-style clipped objective — the probability ratio between the new and old policy is clipped to , so a single update can never shove the policy too far, the key to PPO's stability. Updates are driven by a virtual advantage estimate (GAE-style) computed against a learned value baseline. Learning from experience on your chart, it visualizes its evolving conviction with a policy-probability line (LONG %) and a trend line that recolors with the policy's tilt.
🔶 Key Features
PPO clipping — the probability ratio is clipped to , structurally preventing oversized policy updates (the heart of PPO stability)
Actor-Critic architecture — a shared trunk forks into an Actor head (softmax policy) and a Critic head (value baseline)
Virtual advantage (GAE-style) — forward-return-minus-baseline smoothed over time for a low-bias, low-variance advantage signal
Entropy bonus — prevents premature collapse to a single action, encouraging exploration
Multi-epoch optimization — each collected minibatch is reused several times per bar (PPO's data efficiency)
Policy LONG % line — the policy's LONG probability plotted 0–100 (best on its own scale)
Color-shifting trend line — nudged up/down by policy tilt, recolored by dominant action and confidence
Intelligence panel — per-action probabilities, dominant action, value baseline, policy entropy, and rollout state at a glance
🧠 Technical Architecture
The agent perceives the market as a four-dimensional state vector: momentum spread (ATR-normalized fast/slow EMA gap), RSI deviation, a volatility-regime ratio, and position-within-range — all z-normalized. This state passes through a NeuraLib-style Actor-Critic network: a shared trunk (tanh hidden) forks into an Actor head producing three logits → softmax policy π(a|s), and a Critic head producing a scalar value V(s).
The virtual advantage follows GAE (Generalized Advantage Estimation). Iterating backward through the rollout, the TD residual δ = r + γV(s′) − V(s) is smoothed by γλ into  = δ + γλ·Â_next, then normalized to zero mean and unit variance (standard PPO practice).
The heart of the PPO update is the clipped objective. With the ratio r(θ) = π_new(a|s)/π_old(a|s), the objective is min(r·Â, clip(r, 1−ε, 1+ε)·Â). Outside the trust region — advantage positive with r above 1+ε, or negative with r below 1−ε — the gradient is zeroed, structurally bounding each update step. This combines with the policy gradient ∂logπ(a)/∂logit = 𝟙 − p, an entropy bonus, and the Critic's squared-error value regression (weighted by vfCoef), all backpropagated manually into the shared trunk. The collected rollout is re-optimized over several epochs and minibatches.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Training Horizon 800–1500, Clip ε 0.2, GAE λ 0.95, γ 0.94, Epochs 3, Hidden 8. Standard PPO settings fit well
ETH (1H–4H): As BTC, with Reward Lookahead 5–8 to capture slightly longer advantage
SOL (15m–1H): High volatility favors Clip ε 0.15–0.2 (more conservative updates), Entropy ≈ 0.02 to strengthen exploration, ATR-normalization always ON
XRP (1H–4H): Spike-prone; GAE λ ≈ 0.9 to curb variance, Value Loss Weight 0.5–0.7 for baseline accuracy
Clip ε: smaller (0.1–0.15) is more conservative and stable; larger (0.25–0.3) learns faster but less stably — match to market stability
Learning Rate α: 0.02–0.04 is the stable zone; lower it if diverging, raise Epochs if convergence is slow
Entropy Bonus: raise to 0.02–0.05 if the policy biases too early to one side
💡 How to Use in Practice
Reacting to the LONG % line: 50% is neutral. A cross above 60% is a clearly bullish policy; below 40% is bearish. Drag it to its own scale to watch threshold breaks
Using the color-shifting trend line: when the line turns the LONG color and sits above price, it acts as a bullish-bias support line; the SHORT color makes it a bearish-bias resistance line
Policy tilt (flips): the moment the dominant action flips LONG↔SHORT, the trend line's color change is your directional-shift signal
Reading entropy: low panel entropy = the policy is confident; high = undecided. Low entropy plus a strong probability line marks the highest-confidence conditions
Multi-timeframe usage: confirm the big-picture policy bias on the higher timeframe (4H), then refine timing on aligned lower-timeframe (15m–1H) LONG %
Combinations: use divergence between price and the LONG % line as an early reversal warning
⚠️ Important Notes
Initial learning period: right after launch the rollout is nearly empty and both policy and value are unstable; treat signals as low-confidence until it fills (several hundred bars)
Learning resets: changing parameters, switching symbol/timeframe, or recompiling reinitializes the network weights and rollout, restarting learning from zero
On-policy nature: PPO is on-policy, so actions are sampled stochastically from the policy; selection can vary even in similar conditions — this is normal exploration
On forward-looking reward: rewards and advantages use closed-bar forward returns (a standard RL training construct); current-bar policy evaluation is on confirmed values, but as with any adaptive system, historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation operating within Pine's compute budget
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The Proximal Policy Optimization, policy network, virtual advantage computation, reward shaping, and probability outputs are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Reinforcement-learning agents can and do make wrong calls. Always combine any tool with your own analysis and disciplined risk management. Indicator
AetherEdge - DuelingDQN Breakout Hunter🖊️ Overview
A self-evolving breakout agent built on a Dueling Deep-Q-Network that learns to hunt breakouts on its own. Its defining trait is a forked network: a Value stream V(s) that learns "how promising is this state at all", and an Advantage stream A(s,a) that learns "which action is relatively better here", recombined as Q(s,a) = V(s) + (A(s,a) − mean A). This separation lets the agent value the breakout context independently of the directional decision, sharpening action selection exactly where it counts — inside detected breakout zones. Learning from experience on your chart, it visualizes its hunt with auto support/resistance boxes and faint probability arrows.
🔶 Key Features
Dueling DQN architecture — shared trunk → Value and Advantage streams → recombined via the dueling aggregation; state quality and action advantage learned separately
Self-evolving breakout learning — no pre-training; breakout context learned continuously from the live chart
Breakout reward bonus — extra reward for correct actions in breakout context, focusing learning on breakouts
Auto S/R zones — boxes spawn on rolling S/R breaks, with full lifecycle management
Faint probability arrows — drawn with subtle opacity scaled to softmax action probabilities derived from advantages
Prioritized Experience Replay (PER) — high-reward transitions re-learned preferentially
Exploration vs. exploitation — ε-greedy exploration avoids ossifying in local optima
Intelligence panel — V(s), per-action A(s,a), selected action, advantage spread, breakout context, and zone count at a glance
🧠 Technical Architecture
The agent perceives the market as a four-dimensional state vector: momentum spread (ATR-normalized fast/slow EMA gap), relative position within Bollinger Bands, ATR distance to the nearest S/R, and a volatility-regime ratio — all z-normalized.
The core is the Dueling structure. Input passes through a shared trunk (tanh hidden), then forks. The Value stream runs through its hidden layer to a scalar V(s); the Advantage stream runs through its hidden layer to three per-action values A(s,a). They aggregate as Q(s,a) = V(s) + (A(s,a) − mean_a A(s,a)), the mean-subtraction ensuring identifiability between Value and Advantage. Learning is done by manual backpropagation through this aggregation: gradients are correctly distributed to the advantage outputs (dQ/dA = 𝟙 − 1/3) and the value output (dQ/dV = 1), then propagated back through each stream's hidden layer and into the shared trunk.
The reward function is a directional, ATR-normalized forward return, plus a bonus for success in breakout context. Transitions (s, a, r, s′) enter the experience replay buffer, sampled by |reward|^exponent. As the zone lifecycle, boxes spawn on rolling S/R breaks and are pruned oldest-first on lifespan or cap overflow. Probability arrows vary in opacity by softmax advantage probability and are drawn only when the advantage spread clears the gate. The statistics panel makes the internal Value and Advantage readable.
⚙️ Recommended Settings & Tuning Guide
BTC (1H–4H): Training Horizon 800–1500, γ 0.92–0.95, Shared Hidden 8 / Stream Hidden 4, S/R Lookback 20, Breakout Bonus 0.5. Standard settings fit well
ETH (1H–4H): As BTC, with Reward Lookahead 5–8 to value post-break follow-through
SOL (15m–1H): High volatility favors Zone Width 0.3–0.5 (wider boxes absorb fakeouts), ε 0.05–0.08, Breakout Bonus 0.6–0.8 to strengthen breakout learning
XRP (1H–4H): Spike-prone; Priority Exponent ≈ 2.0, longer S/R Lookback (25–30) to focus on major levels
Learning Rate α: 0.02–0.04 in trending markets; 0.04–0.08 in choppy ones
Stream Hidden Units: widen to 6–8 for richer advantage representation on instruments with diverse breakout types
maxBoxes / Zone Lifespan: maxBoxes 4–6 to see only key levels; extend Lifespan to retain zones longer
💡 How to Use in Practice
Reacting to high-advantage actions: when one action's advantage dominates with a high spread, the agent sees a clear edge in the break direction — a basis for trend-following entries
Using S/R boxes: auto-spawned zones mark post-break retest (return-move) levels; watch reactions at zone edges
S/R flips: capture the classic pattern where a broken resistance zone flips to support, via the box plus the advantage shift
Arrow opacity: darker arrows mean higher action probability and stronger conviction; treat faint arrows as wait-and-see
Multi-timeframe usage: read the big-picture break and zones on the higher timeframe (4H), then refine timing on aligned high-advantage actions on the lower one (15m–1H)
Combinations: filter for breaks accompanied by volume surges to reject fakeouts and elevate signal quality
⚠️ Important Notes
Initial learning period: right after launch the replay buffer is nearly empty and both Value and Advantage are unstable; treat signals as low-confidence until it fills (several hundred bars)
Learning resets: changing parameters, switching symbol/timeframe, or recompiling reinitializes all network weights, the buffer, and zones, restarting learning from zero
Nature of zones: boxes are structural markers from rolling S/R breaks, not signals in themselves; judge alongside the agent's advantage
On forward-looking reward: rewards use closed-bar forward return (a standard RL training construct); current-bar action selection is made on confirmed values, but as with any adaptive system, historical and live behavior can differ — always forward-test
Constraints: this is a lightweight implementation operating within Pine's compute budget
🚨 Disclaimer
This indicator is an analytical and educational visualization tool. The Dueling Deep-Q-Network, experience replay, reward shaping, breakout-zone detection, and action probabilities are quantitative heuristics computed on-chart from price data — they are not financial advice, buy/sell signals, or any guarantee of future performance. Reinforcement-learning agents can and do make wrong calls. Always combine any tool with your own analysis and disciplined risk management.
Indicator
Statistical Mean-Reversion Engine [SMRE]## Statistical Mean-Reversion Engine (SMRE)
SMRE is an open-source mean-reversion indicator that combines a rigorous statistical core with up to eight optional confirmation layers, designed primarily for index-futures trading on intraday timeframes (1-minute through 1-hour).
### What it does
For every bar, SMRE fits an Ornstein-Uhlenbeck (OU) process to the recent price series via linear regression on lag-1 prices, yielding four outputs:
- **μ (the mean)** — the equilibrium price the series is reverting to
- **θ (mean-reversion speed)** — how strongly the series pulls back to μ
- **HL (half-life)** — how many bars it takes to revert halfway
- **σ_eq (stationary residual variance)** — used to z-score the current price
The current price's z-score against μ (the "OU Z") is the primary signal. When |OU Z| exceeds a configurable threshold, a mean-reversion entry is considered — but only after the script also confirms that the recent price series is genuinely stationary using three orthogonal statistical tests:
- **Hurst exponent** must be below 0.55 (i.e., the series is not persistently trending)
- **Augmented Dickey-Fuller** t-statistic must be below -2.86 (rejects unit root)
- **Variance Ratio** test at q=4 must be below 1.0 (variance grows sub-linearly with horizon)
If all four conditions pass, the L1 (statistical core) signal fires.
### Why the multi-layer structure (mashup justification)
A single OU-based mean-reversion signal works well in stationary regimes but degrades in trending or volatile conditions. SMRE addresses this by validating each potential entry through up to eight orthogonal confirmation channels, each measuring something the others do not:
- **L2 — Volatility Regime (6-state):** Classifies market state via VIX, ADX, and realized volatility. Suppresses signals during high-trend conditions (regime 6, "Spike") where mean-reversion historically fails.
- **L3 — Spot-Futures Basis (Kalman filter):** Tracks the deviation between actual and theoretical futures pricing. Statistically significant basis dislocations often resolve via mean-reversion.
- **L4 — Options Surface:** Computes ATM implied volatility from straddle pricing and a skew z-score from OTM put/call ratio. Optional; requires user to provide option symbols.
- **L5 — Microstructure:** Blends rolling VWAP and session-anchored VWAP z-scores with VPIN (a volume-clock toxicity proxy) and order-flow imbalance. Captures flow-based exhaustion.
- **L6 — Gamma Walls (GEX) OR Put-Call Ratio:** Two mutually exclusive options. GEX requires OI symbols at five strikes; PCR requires a single broker-published PCR feed. Both detect option-driven price magnets.
- **L7 — Dispersion:** Rolling correlation of index returns with its top 5 constituent stocks' returns. High dispersion (low correlation) penalizes signals; high cohesion boosts them.
- **L7b — Residual Dispersion:** Idiosyncratic residual z-scores (β-adjusted) per constituent. If 3 of 5 stocks show same-sign extreme residuals, the index is detached from constituents — strong mean-reversion candidate.
- **L9 — Cross-Asset Stress:** Sigma-normalized stress across USD/INR, DXY, and crude oil. Penalizes signals during cross-asset hedging cascades.
Each layer outputs a {direction, strength} pair. The Layer 8 fusion engine combines these via a weighted composite score (default weights: L1=0.28, L5=0.22, L3=0.18, L4=0.12, L6/L7b=0.10), then applies a regime multiplier (L2 × L7 × VRP × cross-asset × expiry), clamped to to prevent extreme compounding.
If the absolute composite score crosses one of three thresholds (0.25 / 0.40 / 0.45 by default), a signal is fired at Scalp / Swing / Session horizon respectively. A TCA cost filter then validates that the expected move (distance to μ) exceeds estimated round-trip transaction cost; otherwise the signal is suppressed.
### Originality
The author is not aware of any other public Pine script that implements the full OU-fit chain (mean, mean-reversion speed, half-life, stationary variance) together with all three stationarity tests (Hurst, ADF, Variance Ratio) directly in Pine v6 — every step is computed natively, no external library calls. Additionally, the session-anchored VWAP with running volume-weighted sigma bands, the rolling-beta residual dispersion across multiple constituents, and the Kalman-filtered futures-basis residual are original Pine implementations. The signal telemetry module (a 200-signal FIFO ring buffer with horizon × composite-magnitude bucket attribution) is also an original diagnostic tool.
### How to use
1. **Apply to an index futures chart.** Defaults are pre-configured for NSE NIFTY1! futures, but inputs allow any index — change the VIX symbol, spot/futures symbols, constituent symbols, and currency pairs.
2. **Read the compact dashboard.** It's a single 9-row table (default position: middle-right) showing only what you need to evaluate a setup:
| Row | What it shows | What it means |
|---|---|---|
| Title | Profile + OU window in use | Confirms which calibration is active |
| OU Z-Score | Z-score with half-life (HL) | How extended price is + how long mean-reversion typically takes |
| Stat Validity | H / ADF / VR pass-fail | Whether the recent series is actually stationary (all 3 must pass) |
| Regime | Volatility state + VIX value | Whether market conditions favor mean-reversion |
| Composite | Fused score × regime multiplier | The unified signal strength |
| Confluence | Layers agreeing (out of 6) | How many orthogonal signals support the direction |
| TCA Edge | Expected move in bps + PASS/FAIL | Whether the trade clears transaction costs |
| E / SL / TP | Entry, Stop, Target + Risk:Reward | The trade levels if a signal fires |
| **DECISION** | Direction · Horizon · Side | The actionable output (green=long, red=short, gray=neutral) |
3. **Trade levels and markers.** When a signal fires, entry/stop/target lines auto-plot on the chart. Stop is ATR-based (default 1.2× ATR); target is min(OU mean μ, entry + 2× ATR). Triangle markers plot below (long) or above (short) the bar — small for Scalp, medium for Swing, large for Session.
4. **Optional diagnostic.** A separate Signal Telemetry table (disabled by default; enable via the "Show Telemetry Dashboard" input) tracks the last 200 signals' outcomes (win = price touched μ, loss = stop hit, expired = timeout) and reports hit rate by horizon × composite-magnitude bucket. This is a backward-looking diagnostic, not a backtest.
### Recommended chart and timeframe
This indicator was developed and parameter-tested primarily on NIFTY1! futures. The OU window auto-mapping (1m→32, 2m→20, 5m→12, 15m→32, 30m→20, 1h→24) was selected empirically through parameter sweeps. Users on other instruments should expect to tune the OU window manually or accept the auto-mapped default as a starting point.
The indicator works on any timeframe between 1 minute and daily, though intraday timeframes (1m through 1h) are where the multi-layer confluence adds the most value.
### Important notes
- This is an **indicator**, not a strategy — no backtest equity curve is produced. The telemetry table is a descriptive measure of recent signal outcomes only.
- Many layers are **optional**. If you don't have symbols for options OI, just leave those inputs blank; the script will redistribute composite weight naturally across the active layers.
- Signals can fluctuate intra-bar before bar close, especially in real-time mode. For consistent behavior, evaluate signals on closed bars only.
- The default constituents (top-5 NIFTY weights) need to be changed in the L7 inputs to use this on a different index.
### Disclaimer
This indicator is published for educational and research purposes only. It is not financial advice, not an investment recommendation, and not a solicitation to trade. Past behavior of signals does not guarantee future results. Trading futures, options, and equities carries substantial risk of loss. You are solely responsible for your trading decisions. The author makes no representations about the accuracy, completeness, or suitability of this indicator for any particular purpose. Use at your own risk, and always consult a qualified financial professional before trading.
Indicator
Indicator
Elaris Session Liquidity Grabs Pro# Elaris Session Liquidity Grabs Pro
Elaris Session Liquidity Grabs Pro is a professional session-based liquidity sweep and reversal detection tool designed for traders who focus on smart money concepts, stop hunts, failed breakouts, and institutional liquidity behavior.
The indicator automatically builds key liquidity ranges from major global trading sessions including London, New York, and Asia, then detects high-probability liquidity grabs when price sweeps session highs or lows and rejects back into range.
Unlike basic sweep indicators, this tool includes advanced filtering systems designed to reduce noise and focus on stronger reversal conditions using ATR displacement, candle strength analysis, EMA trend filtering, and optional volume confirmation.
Built for active intraday traders, scalpers, and smart money traders, the indicator provides a clean visual framework for identifying areas where liquidity may have been engineered before a market reversal or continuation move.
━━━━━━━━━━━━━━━━━━
FEATURES
━━━━━━━━━━━━━━━━━━
• Automatic London, New York, and Asia session ranges
• Session high/low liquidity tracking
• Bullish and bearish liquidity grab detection
• Wick sweep and close-break detection modes
• ATR-based sweep validation filters
• Strong displacement candle confirmation
• EMA trend filter for directional bias
• Volume confirmation filter
• Optional cooldown system to reduce signal clustering
• Session equilibrium (midline) plotting
• Clean session range visualization
• Professional dashboard panel
• Dark mode and light mode support
• Alert conditions for automation and notifications
• Non-repainting confirmed signals
━━━━━━━━━━━━━━━━━━
HOW IT WORKS
━━━━━━━━━━━━━━━━━━
The indicator builds liquidity ranges from selected market sessions and monitors price action after those sessions complete.
When price aggressively sweeps a session high or low and then rejects back into the range, the indicator identifies it as a potential liquidity grab event.
Examples:
• Price sweeps above London High and closes back below → potential bearish liquidity grab
• Price sweeps below New York Low and closes back above → potential bullish liquidity grab
Additional confirmation filters help reduce weak or low-quality signals by requiring stronger candle displacement, trend alignment, and optional volume expansion.
━━━━━━━━━━━━━━━━━━
BEST USE CASES
━━━━━━━━━━━━━━━━━━
• Smart money trading concepts
• Session liquidity trading
• Stop hunt reversals
• Scalping and intraday trading
• ICT-style trading approaches
• Breakout failure detection
• Market manipulation detection
━━━━━━━━━━━━━━━━━━
RECOMMENDED MARKETS
━━━━━━━━━━━━━━━━━━
• Crypto Futures
• Forex
• Indices
• Gold and Commodities
━━━━━━━━━━━━━━━━━━
RECOMMENDED TIMEFRAMES
━━━━━━━━━━━━━━━━━━
• 1 Minute
• 3 Minute
• 5 Minute
• 15 Minute
━━━━━━━━━━━━━━━━━━
NON-REPAINTING
━━━━━━━━━━━━━━━━━━
This indicator is designed to be non-repainting.
Signals are confirmed only after candle close and session levels are finalized after the session completes. No future data is used.
━━━━━━━━━━━━━━━━━━
NOTES
━━━━━━━━━━━━━━━━━━
This tool is designed to assist with identifying liquidity behavior and market structure reactions. It should be used alongside proper risk management, higher timeframe analysis, and additional trade confirmation techniques.
No indicator guarantees profitability or win rate consistency across all market conditions.
Indicator
Indicator
