Frequently Asked Questions

It reads your live TradingView chart through a debug protocol, applies a multi-timeframe rules engine to all 11 watchlist forex pairs, and returns an eight-section structured analysis. It tells you whether to enter, wait, or stand down — and never places trades on your behalf.

No, and it never will. Aetherion is analysis only. The "Recommended Action" section gives you entry conditions, stop loss, take profit, and lot size — you place the trade manually on your broker. This is by design: regulatory, risk-management, and responsibility reasons all point the same way.

No tool can guarantee that. Trading is a probabilistic game. What Aetherion provides is consistency: the same checklist applied the same way every time, with explicit logs of what passed and what failed. Whether you make money depends on your discipline, your capital, your broker spreads, market conditions, and your willingness to stand down on weeks when nothing qualifies.

Yes — Aetherion is a personal analysis tool, not a registered investment advisor, broker-dealer, or commodity trading advisor. It does not solicit clients, manage funds, take fees for advice, or provide individualized recommendations. You are using your own software, against your own data feed, on your own machine, to make your own trading decisions. Full disclaimer →

• A Mac, Windows, or Linux machine
• TradingView Desktop installed (the actual app, not the website)
• Node.js 18+ installed
• A TradingView account (free tier works)
• A forex broker account if you intend to actually trade

See the Setup guide for step-by-step instructions.

The Chrome DevTools Protocol (CDP) is how Aetherion reads your chart. TradingView Desktop is built on Electron (Chromium under the hood), and the --remote-debugging-port=9222 flag exposes a local-only API for inspecting and controlling the chart. This is the same mechanism used by browser test automation tools like Playwright and Puppeteer.

No. Aetherion is a cloud-hosted web application. No setup is required — just visit the site and log in. and only talks to your local TradingView instance. No telemetry, no analytics, no third-party scripts. You can verify by reading the source — it's plain Node.js with no dependencies beyond the standard library and your existing TradingView MCP modules.

Single-pair analysis: ~25 seconds (chart navigation × 7 timeframes). Full watchlist scan: ~30 seconds per pair (so for a typical 11-pair watchlist, ~5–6 minutes; for 15 pairs, ~7–8 minutes — driven by your live TradingView watchlist size). Cached scans load instantly. The bottleneck is TradingView's chart re-rendering when timeframes switch — there's no parallelism because you have one chart instance.

v4.8 makes this automatic — Aetherion now reads your live TradingView watchlist panel via CDP and uses that as the source of truth. Add or remove a forex pair in TradingView, and within ~60 seconds (auto-refresh) or instantly (click the 🔄 button on the KPI tile) the website's pair dropdown and full-watchlist scan reflect the change.

Filter rule: only forex pairs are kept. A symbol must be 6 uppercase letters (after stripping the exchange prefix like OANDA:) AND both 3-letter halves must match a known currency code (USD, EUR, GBP, JPY, AUD, NZD, CAD, CHF, etc.). Stocks, crypto, futures, and indices in your watchlist are silently skipped.

Fallback: if your TradingView watchlist panel is closed, empty, or CDP is down, the system uses the static watchlist.pairs array in rules.json as a fallback.

The live watchlist read requires the TradingView watchlist panel to be visible (the right sidebar with all your symbols). If you've collapsed it, hidden the right panel, or are on a chart layout without the watchlist widget, the CDP read returns nothing — so Aetherion falls back to the static rules.json list.

Fix: in TradingView, open the right-side panel and click the watchlist icon. Then click the 🔄 button on the "Watchlist size" KPI tile. The subtitle should turn green with a live pulse dot.

Yes — but the scanner code only reads specific fields. To add a brand-new rule type that affects scoring or recommendations, you need to edit web/scanner.mjs as well. The pattern is: add the rule to rules.json (with a version note), update the relevant scanner function, and bump the version. Every change should have a credibility caveat if it's based on external content.

Because most weeks, in most pairs, there's no high-quality setup. Forcing a trade to fill a report is how accounts get blown up. Conservative Mode 2026 mandates B+ minimum (80% alignment) — if nothing reaches that bar, the answer is "no trade this week." This is a feature, not a bug.

The system uses H1 per the 2026-04-21 directive in rules.json: H1 is faster than H4 (so you catch setups earlier) but cleaner than M30 (less noise per candle). It's the right balance for day trading. M30/M15/M5 are entry-confirmation timeframes inside a confirmed H1 signal — never standalone triggers. See analysis_engine.split_top_down_framework for the full role assignments.

Classical price-action mechanics — three pillars (trend, AOI, entry), HH/HL structure, engulfing-at-AOI, multi-timeframe alignment, head-and-shoulders reversals — independently documented by educational sources like BabyPips, ForexTrainingGroup, and FXOpen, plus decades of trading literature. Nothing here is proprietary. The Aetherion contribution is operational: turning the discipline into a checklist a machine can run consistently against your live chart, with an audit trail you can read line by line.

The forex education space has a long history of unverifiable claims — specific win-rate boosts ("25-30%"), student income figures ("$1000-1500/week"), guaranteed-profit advertising. None of these survive independent backtesting. Aetherion's credibility_caveats sections document where such claims appear in source content and explain why they're not endorsed even when the underlying mechanic is. Bottom line: adopt the mechanics, ignore the hype, always backtest.

A page where you log every trade you take with full context — pair, direction, timeframe, entry, SL, TP1, TP2, lot size, $ risk, grade tier (A+/A/B+/B/C/D), verdict (long/short/no-trade), HTF direction, setup type, free-text notes. Trades start as OPEN; when they close you mark the outcome (TP1 hit / TP2 hit / SL / breakeven / manual close) and the system stores exit price and pip P&L. Backed by an atomic-write trade_log.json file so the data survives restarts and is never half-written.

The journal page also shows live KPIs (total / open / win rate / total P&L), filters by status and pair, and breakdowns by pair / grade / verdict.

Once you have at least 3 closed trades, click "Analyze patterns" on the journal. The server reads your real outcomes from trade_log.json, computes stats grouped by pair / grade / verdict / direction, and sends them to the AI chat backend with a strict prompt: "identify the 1-3 most useful rule changes given this empirical data."

The AI returns Markdown with a structured format: each suggestion includes the field path in rules.json, the current value, the proposed new value, and a justification grounded in your stats.

Suggestions are NEVER auto-applied. You review them and manually edit rules.json if you agree. This is the "AI self-learning" feedback loop — the bot reads your real outcomes and suggests rule changes; you decide whether to apply them.

No, and the system is honest about it. Real ML/RL training requires labeled training data, GPU compute, weeks of iteration, and an evaluation loop — none of which Aetherion ships. What v5.3 ships is a feedback loop: real outcome data → empirical stats → AI reasoning over those stats → human-reviewed rule updates.

That's not learning in the technical ML sense, but it's a genuine closed loop where the system gets better over time based on YOUR results — without faking ML capabilities. Three closed trades is enough to get useful suggestions; the more you log, the sharper the analyzer becomes.

When a pair has an OPEN trade in the journal, the scan summary table shows a 📌↑ (long) or 📌↓ (short) marker in the notes column and the row gets an amber left-border accent. This prevents you from accidentally double-trading the same pair while a position is still open. The flag clears as soon as you mark the trade closed in the journal. The scan refreshes open-pairs every 30 seconds in the background.

After running an analysis on /live, every result with a tradable verdict shows a "Took this trade?" card with a button that deeplinks to /journal with all fields pre-filled (pair, direction, entry, SL, TP1, TP2 from the H1 levels, plus M15 SL computed at 25 pips). One click and the form is ready to save.

On /journal, find the OPEN trade in the list and click "Close" in the row. The modal opens in close-mode showing the original trade details plus outcome fields: outcome enum (TP1 / TP2 / SL / breakeven / manual close) and exit price. Submitting marks the trade as closed and updates all KPIs immediately. The record is preserved (never deleted on close) so the analyzer keeps full history.

v5.2 added Edgeful-inspired probability stats below the Three Pillars. For both H1 and M15 it shows:

• Range distribution histogram — how today's range compares to the recent 40-bar distribution. The green dot marks where the current range sits.
• Break probability bars — % of recent bars that broke the prior bar's high (bullish) or low (bearish). Useful for "is continuation likely?" reads.
• Momentum strength gauge — a composite -100 to +100 score combining momentum %, range expansion, and consecutive-close streak.
• Volatility regime badge — 🟢 normal / 🟡 elevated / 🔴 extreme based on current range vs 75th percentile.

All computed in JS from the OHLCV bars already pulled by the scanner. No external API.

/calculator is a Polymarket-style outcome-preview tool. Enter your balance, risk %, currency pair, entry price, direction, SL pips, R:R, and broker leverage. The page instantly shows your lot size, dollar risk, margin needed, and three outcome scenarios (SL hit / TP1 hit / TP2 hit) with $ amounts and proportional bar visualizations. The "📡 Fetch live price" button pulls the current price from your TradingView via the existing scan endpoint.

Honest answer: it has statistical pattern memory, not machine learning.

Real ML/RL/NLP training requires labeled training data, GPU compute, weeks of iteration, and an evaluation loop — none of which Aetherion ships. What v5.2 added: the chat bot reads your trade_log.json and includes win rate + last 10 trades in its system context. So if you ask "what's my win rate?" or "how do B+ trades perform for me?", it answers from your actual logged data.

That's not learning in the technical ML sense — but it's genuinely useful pattern-aware behavior without faking ML capabilities.

v5.2 added 16 trusted trading sources (ForexFactory, DailyFX, Investing, Edgeful, FXStreet, Reuters, Bloomberg, MarketWatch, CNBC, WSJ, FT, Babypips, Myfxbook, TradingView, Oanda, FXOpen). When you mention any of these in a chat query, the bot auto-restricts the DuckDuckGo search to that domain.

Example: "Latest news on EURUSD on dailyfx" → search becomes EURUSD news site:dailyfx.com. Results come only from dailyfx.com.

v5.1 (the current version) shows both H1 and M15 annotated charts side-by-side. Each has its own AOI, forecast, and entry/SL/TP levels. The user trades on H1 daily but uses M15 for the fastest possible entry timing — both charts inform the decision. M15 fires earlier; H1 is more reliable. They help each other.

Both, depending on hold time:

• H1 chart (~50 pip SL, 1:2 / 1:3 R:R): for daily swing holds — enter when H1 fires its signal, hold for hours-to-days.
• M15 chart (~25 pip SL, same R:R): for fast intraday entries — enter when M15 fires (typically before H1), close within minutes-to-hours.

Many traders enter on M15's earlier signal but use the H1 SL/TP if planning a longer hold. The H1+M15 must-match gate ensures both charts agree on direction before either is tradable.

A v5.0 rule (still active in v5.1): H1 AND M15 must BOTH be colored AND in the same direction before the system recommends an entry. If H1 is bull but M15 is bear (or vice versa), no recommendation. If either is in range, no recommendation. Both colored, both same direction — only then.

You'll see this as a green ✓ pill labeled "H1+M15 match (bull)" or a red ✗ pill saying "H1+M15 mismatch" above the Three Pillars in the analysis result.

M15's typical ATR (average true range) is roughly half of H1's. A 50-pip SL on a M15 setup is unnecessarily wide and ruins the risk-reward math. v5.1 uses per-timeframe defaults via SL_PIPS_BY_TF:

• H1 default: 50 pips — appropriate for daily swing holds where price typically moves 100+ pips a day
• M15 default: 25 pips — appropriate for intraday entries where price moves 30-50 pips per setup

Both feed into the same R:R math (1:2 for TP1, 1:3 for TP2), so H1 targets are 100/150 pips and M15 targets are 50/75 pips. You can override per-trade in your own analysis.

Four jobs in v5.1:

1. Trend confirmation — H1 must agree with M15 direction (must-match gate).
2. AOI source #1 — H1 swing high/low is the structural AOI for the daily H1 trade.
3. Daily execution chart — when you take the H1 trade, you place the order at H1 levels with the H1 SL/TP.
4. Setup-pending detection — when H1 is ranging at the H1 AOI with HTF clear, the system flags 🟡 setup pending.

H1 and M15 are now equal partners — both are AOI sources, both are execution charts, neither is "more important."

Yes — but with hard limits. As of v4.9, the chat bot and annotated chart provide probabilistic scenario analysis: a directional bias (BULL or BEAR) with a confidence percentage. Confidence is hard-capped at 75% because no AI can honestly claim higher than that on forex direction. Every predictive answer also shows the opposite scenario and the invalidation level — so you see what would prove the bias wrong.

Disclaimer is mandatory: every predictive output ends with "⚠ AI scenario analysis can be wrong. Do your own research before trading." This is by design — visuals are persuasive and need a counterweight.

Starts at the pair's overall alignment % across all 7 timeframes, then adjusts:

• B+ qualifying setup: confidence floor 65%
• Setup pending (price at H1 AOI + HTF clear): floor 55%
• H1+HTF aligned but <80% align (MONITORING): floor 50%
• +2 per entry-phase TF (M30/M15/M5) that agrees with HTF (max +8)
• +4 if engulfing fired in HTF direction
• +3 if price near a psychological round number
• Hard cap at 75%, hard floor at 25%

The math is in web/scanner.mjs → computeForecast().

Because anything above 75% on forex direction is dishonest. Markets are dominated by news, central bank decisions, and order flow that no chart-only model can predict. A system claiming 95% confidence is either lying or lucky. By capping at 75%, Aetherion forces honest framing: "this is the rules' best probabilistic read, not certainty."

Yes. In your .env, set CHAT_DISABLE_PREDICTIONS=true (planned future flag) or revert to v4.8 by editing web/chat.mjs ROLE_PROMPT to its previous "DO NOT predict" version. The annotated chart's forecast banner can be hidden via CSS by adding .forecast-banner { display: none; } to web/public/styles.css.

After each single-pair analysis, Aetherion takes a live screenshot of your H1 chart and overlays the actual rules-derived levels: entry trigger, stop loss, TP1, TP2, AOI zones (D and H4 highs/lows), and any psychological round number within proximity. A verdict banner above the chart shows whether the rules say B+ Qualifying, Setup Pending, or Stand Down.

No. The drawn levels are conditional triggers from your rules.json — IF the market reaches certain levels AND H1 confirms with an engulfing, THEN the rules say "qualify the trade." It's a visualization of your existing methodology, not a forecast of which direction price will go.

The chat bot, the verdict banner, and the disclaimer footer all explicitly refuse to predict markets. The annotated chart respects that — it shows what your rules would do, not what the market will do.

Per your rules.json:

• Entry: just below recent low (short) or above recent high (long), where an H1 break would confirm SOS
• SL: 60 pips beyond entry (default — adjustable in scanner.mjs per your engulfing-candle SL rule)
• TP1: 1:2 R:R from entry
• TP2: 1:3 R:R (matches Conservative Mode 2026's min_rr_required)

For JPY pairs (price > 50), the pip factor is 0.01; for everything else, 0.0001.

No. Aetherion draws the lines and zones on your TradingView chart, takes the screenshot, then immediately removes them. Your chart is left exactly as it was. If you ever see leftover annotations (rare), you can clear them in TradingView with the eraser tool.

Yes — when running a full scan, the annotated chart is generated for the top-graded pair (the one most likely to be tradable). For other pairs in the scan summary, click the pair name to drill into a single-pair analysis, which gets its own annotated chart.

The annotation pipeline adds ~10–15 seconds per analysis because it has to: (1) draw 2–8 shapes on your TradingView chart, (2) wait for TradingView to re-render with the new shapes, (3) capture the screenshot, (4) clean up the shapes. Total typical latency: ~15s scan + ~15s annotation = ~30s for a single-pair analysis.

The system is designed around 0.5% risk per trade. With typical 50–80 pip stop losses on major forex pairs and a broker minimum lot of 0.01 (micro), the math requires roughly $2,000+ to size positions properly. Below that, the tool flags "sub-viable capital" and recommends paper-trading on demo until you can fund up.

The math will, but you'll need to verify your broker supports sub-micro positions (0.001 lot or 100 units). Most do not — they floor at 0.01 lot (1,000 units). Spreads on cent accounts are also typically wider, which eats into the R:R math. Recommended only as a transitional step from demo to live.

To compute the real risk amount in dollars (0.5% × balance) and validate whether the position size is achievable at your broker's minimum lot. The number is not stored, not logged, not transmitted — it lives only in the browser tab and is recomputed each session.

No. The server has no analytics, no telemetry, no error reporting, no usage tracking. The only data that crosses any wire is between your browser and our API (HTTPS), and our backend and external data providers.

Yes — it lives in your repo at /Users/amir/tradingview-mcp-jackson/. The strategy is in rules.json, the server in web/server.mjs, the scanner in web/scanner.mjs, the frontend in web/public/. No build step, no minification, no obfuscation. Read it, fork it, modify it.

Yes — the marketing pages (Home, About, How It Works, Methodology, FAQ, Setup, Disclaimer) are static HTML and can be hosted on any static-hosting platform (Vercel, Netlify, GitHub Pages, Cloudflare Pages). The live tool page only works locally because it requires the local server and TradingView CDP — that's a fundamental architecture, not a configuration choice.