One-Tap Alignment is here. Confirm or adjust portfolio signals straight from the notification — no extra steps.
AQMath Black is €999 / year. Access is limited to a small number of users to keep compute fast and support direct.
We accept USDC and EURC only — no credit card, no bank transfer, no personal data collected.
Send a message and we'll review your request within 48h. No call required.
EU consumers keep the statutory 14-day right of withdrawal. By default your key is issued after those 14 days; ask us and we activate immediately, settling only the part already used. Details in the Terms.
Loading…
What it does: AQMath tells you the mathematically best way to spread every new dollar you invest across your tokens — instead of guessing or splitting equally.
How it protects you: the Deleverage Shield automatically moves your portfolio into stablecoins as the market turns dangerous, and back into tokens as it recovers.
How it stays private: no accounts, no wallet connection. Your portfolio lives in your browser — the only server-side data is pseudonymous, exists only if you opt in to the optional signal & notification service, and is deletable at any time.
Plain English: drawdown = how far a portfolio falls from its highest point. Sharpe = return earned per unit of risk — higher is better. risk parity = weighting tokens by the risk they add, not by their dollar size. DCA = investing a fixed amount on a regular schedule.
AQMath is a quantitative portfolio rebalancer purpose-built for the crypto market. It combines institutional-grade mathematical models — the same class of optimization used by multi-billion-dollar hedge funds — with a privacy-first architecture that ensures your financial data never leaves your control.
At its core, AQMath solves a deceptively complex problem: when you add new capital to your crypto portfolio, which tokens should you buy, and how much of each? A naive approach (split equally) ignores that some positions are already overweight while others are dangerously underweight. AQMath’s DCA engine uses smart proportional allocation, filtered through a DCA safety pipeline, to ensure every dollar you invest moves your portfolio closer to its optimal structure.
The system operates on a hybrid architecture: your portfolio data (token amounts, entry prices, targets) is stored exclusively in your browser’s localStorage, while computationally intensive math (covariance matrices, DCA allocation planning, volatility analysis) runs on our secure backend engine. This means you get institutional-quality analysis — and nothing financial is stored on any server unless you opt in to the optional signal & notification service (Section 9).
AQMath’s privacy model is non-custodial by design: the backend receives position data in-memory during a single DCA request, computes the result, and discards everything. No persistence. No logs of your amounts. No database of your identity. Your financial state lives in your browser’s localStorage — the only server-side exception is the optional signal & notification service, which stores your holdings under a one-way key hash and can be deleted at any time.
AQMath is designed for a specific type of crypto investor:
AQMath is not a trading bot. It does not execute trades, predict prices, or time the market. It is a mathematical allocation engine that tells you exactly how to distribute new capital for maximum portfolio balance — and then gets out of your way.
AQMath uses a hybrid architecture that separates data ownership from computational power. Your browser owns the data; the backend owns the math. This is fundamentally different from traditional portfolio tools that store everything on centralized servers, creating a single point of failure and a tempting target for data breaches.
Understanding the data flow is critical to understanding AQMath’s privacy guarantees. Every computation interaction follows the same pattern: your browser sends the minimum information needed, and the backend returns results without retaining any state. The single documented exception is the opt-in signal & notification service (Section 9).
Before price data reaches the optimization engine, it passes through a multi-stage cleaning pipeline that ensures mathematical integrity. Raw market data from multiple sources (CoinGecko, Kraken, Coinbase) is often noisy — containing duplicates, exchange-specific outliers, and occasional gaps. The cleaning pipeline applies four sequential filters:
This pipeline runs daily at 01:00 UTC via a scheduled cron job. The result is a clean, continuous price series suitable for covariance and volatility calculations.
AQMath’s privacy architecture is non-custodial by design. The backend processes your DCA request statelessly — it receives position data, computes optimal allocation, returns results, and discards everything from memory. No persistent record of your holdings is created server-side unless you opt in to the signal & notification service (Section 9):
In 2023–2025, multiple centralized portfolio trackers suffered data breaches exposing user holdings. With AQMath, even a server breach could expose only what you chose to sync — token symbols and amounts tied to an anonymous key hash, never your name, wallet, or exchange keys. Your financial sovereignty is guaranteed by architecture, not by promises.
Your portfolio is a collection of token positions stored entirely in your browser’s localStorage. For each token, AQMath tracks your holdings, target allocation percentage, current price, staking yield, entry price history, and DCA cost basis. Together, these parameters form the complete state of your portfolio and drive every calculation in the system — from allocation metrics to risk budget enforcement. If you enable the optional signal & notification service, a pseudonymous copy of your holdings is mirrored server-side under your hashed key (Section 9).
Every time the UI renders or a DCA calculation runs, the system computes real-time metrics for each token. It measures how much each position is currently worth, what share of your total portfolio it represents, and how far it has drifted from your intended target.
The DCA engine uses delta — the dollar gap between where a token is and where it should be — to prioritize which tokens receive new capital first. Tokens that are most underweight relative to their target get funded first. Safe-haven tokens (stablecoins) bypass this filter entirely and always receive capital when designated.
Profit and loss is tracked against your cost basis — the true dollar-cost-averaged entry price across all purchases. As the DCA engine buys more tokens over time, it accumulates your cost basis and total tokens acquired, giving you an accurate average price and return percentage for each position.
AQMath is human-in-the-loop: the engine proposes each rebalance as a signal, and you confirm or adjust it — nothing ever executes by itself. The Discipline Meter tracks one thing: how reliably you act on those signals the same day. It is a mirror, not a judge. Showing the number does most of the work, because most people assume they confirm ~90% of signals and discover they are closer to ~60%.
Each signal carries a 12-hour deadline. Confirming within the first hour scores 100%, and the score decays to 0% at the deadline; a signal you never confirm counts as missed. Your overall rate is the average score across all resolved signals, shown with a Confirmed / Missed / Skipped breakdown and a rolling window of your last 10 signals. The history chart plots your actual equity against an “ideal” curve (every signal confirmed on time) on a fixed $10,000 baseline, so the cost of hesitation is visible.
You set your own same-day goal (50–100%, default 80%) — self-set friction feels completely different from an app grading you, and the bar is colored against your own number. Active reminders are opt-in and silent by default, so opening the app is never punished. The meter counts only the signals you already have; it adds no new server-side data beyond the pseudonymous signal record described in Section 9.
The DCA engine is the heart of AQMath. Given a budget (e.g., $500), it determines exactly how to distribute that capital across your portfolio’s underweight tokens — not equally, not randomly, but proportionally to how far each token is from its target, adjusted for risk.
The engine builds an allocation plan without ever touching your actual tokens: it hands each token a share of the budget in proportion to how far it sits below its target, adjusted for risk. Tokens that reach their target drop out and their share is redistributed to the rest. Every planned buy must clear a per-token minimum (default $20) — any buy that would fall below that floor is dropped and its budget re-planned across the remaining tokens, so you never place fee-eating sub-dollar buys.
Before any allocation happens, each token is evaluated through the DCA safety pipeline (see Section 5). Only tokens that pass all filters are eligible to receive DCA funds. The allocation then follows a simple principle: the more underweight a token is relative to its target, the larger share of new capital it receives — tempered by a risk adjustment that reduces allocation for highly volatile assets.
After each round, cost basis and token counts are updated automatically. Over multiple DCA cycles, the engine naturally balances your portfolio toward its ideal allocation.
When the DCA budget is very small, the engine allocates the entire amount to the single most underweight eligible token.
If you DCA $20 across 5 tokens, each gets $4 — likely below exchange minimums, and fees would consume a significant percentage. The small DCA rule puts the full $20 into the token that needs it most. Over multiple DCA cycles, the algorithm naturally balances across all tokens. The same fee-avoidance logic applies to larger budgets: every buy must clear a configurable per-token minimum (default $20) — any token whose share would fall below that floor is skipped and its budget redistributed to the more underweight tokens, so even a $500 DCA never places tiny sub-dollar buys.
AQMath implements a multi-layer safety pipeline for DCA allocation designed for crypto markets. Traditional systems would halt trading on a 10% dip — but in crypto, pullbacks of that size happen regularly and are often excellent buying opportunities. Each layer operates independently and in strict sequence. Note: This pipeline governs only how new DCA capital is allocated — it does not trim or sell existing positions.
Staking APY is tracked per token and displayed in the portfolio table together with its yield gap versus the 10% self-sustaining threshold. It does not gate DCA eligibility: an underweight token with a high yield still receives allocation like any other underweight token.
The circuit breaker halts all DCA distribution whenever the Deleverage Shield is in its defensive state — when market conditions have deteriorated enough for the shield to cut exposure to a defensive level. Because exposure is driven mostly by drawdown and downside volatility, it engages during any meaningful downturn, not only brief flash crashes, and stays paused through a sustained bear market. It resumes automatically once the shield’s exposure recovers.
A per-token risk adjustment that reduces buy size for high-volatility assets. More volatile tokens receive proportionally less capital, ensuring that risky positions don’t get outsized allocations even when they’re the most underweight.
Skips tokens currently trading above their moving average — effectively enforcing a “buy the dip” discipline. Capital flows to tokens during pullbacks, not during rallies.
No single risky token can exceed a structural concentration limit. If allocation would push a token beyond this cap, the excess is trimmed and redirected to the surplus pool.
The Black engine replaces the flat cap with volatility-adaptive limits: high-volatility tokens receive tighter caps, while low-volatility tokens can hold larger positions (up to 40%). Each token’s maximum weight is dynamically scaled based on how volatile it is relative to the most volatile token in the portfolio. The more volatile a token, the tighter its cap.
Total risky exposure is capped at a percentage of your portfolio, ensuring a safety buffer always exists. If risky tokens exceed the budget, all allocations are scaled down proportionally.
All surplus capital from hard caps and risk budget scaling flows into your designated stablecoin. This capital sits in a safe buffer until you decide to redeploy it through DCA.
Volatility is the foundational risk metric used throughout AQMath. It feeds into the safety factor, the circuit breaker threshold, and (in Black) the covariance matrix. The system computes a rolling volatility estimate for each token by measuring the magnitude of daily price swings — a standard approach in quantitative finance.
Portfolio-level volatility is computed from the covariance matrix of token returns: σ = √(w'Σw), where w is the weight vector and Σ is the covariance matrix. Safe-haven tokens and frozen positions are excluded since they have near-zero volatility by definition. This portfolio-level metric drives adaptive thresholds across the entire safety pipeline.
The Black engine computes a full covariance matrix estimating how assets move together. Two tokens with moderate individual volatility but high correlation (like ETH and SOL) have amplified combined risk. The optimizer uses this to ensure each asset contributes equal risk — preventing hidden concentration through correlation.
The AQMath Engine is the Black-tier optimization layer that sits alongside the DCA engine. While the DCA engine distributes a fixed dollar budget, the AQMath Engine answers a deeper question: what should the target weights themselves be? It uses institutional-grade quantitative methods — the same class of algorithms deployed by multi-billion-dollar hedge funds — to compute mathematically optimal portfolio weights from first principles.
The engine runs a three-stage pipeline: it builds a full covariance matrix from 180 days of cleaned price history, solves for Equal Risk Contribution (true Risk Parity), and applies KKT projection with dynamic volatility caps to enforce structural limits.
Traditional portfolio optimization (Markowitz mean-variance) requires estimating expected returns — a notoriously unreliable process that amplifies estimation errors into extreme allocations. Risk Parity sidesteps this entirely by optimizing for equal risk contribution rather than equal weight or maximum return.
The ERC solver searches for weights where each asset contributes an equal share of total portfolio risk. The process works as follows:
The result is a portfolio where BTC and a small-cap altcoin each contribute the same amount of risk — preventing any single asset from dominating your portfolio’s volatility profile, even if it has the largest allocation.
The raw ERC weights may violate real-world constraints (e.g., a 35% allocation to a single token). The KKT projection step enforces structural limits through iterative clipping:
The projection runs iteratively until all constraints are simultaneously satisfied.
The engine computes a full NxN covariance matrix from 180 days of cleaned, aligned price history. This matrix captures not just individual asset volatility but how assets move together. Two tokens with moderate individual volatility but high correlation (e.g., ETH and SOL tend to move in the same direction 85% of the time) have amplified combined risk — a relationship that simple weight-based allocation ignores entirely.
The AQMath Engine returns:
A naïve equal-weight portfolio of BTC + SOL + DOGE allocates 33% each. But DOGE’s volatility is roughly 3x BTC’s, meaning DOGE contributes ~60% of total portfolio risk despite holding only 33% of value. ERC automatically corrects this: it would allocate ~55% to BTC, ~25% to SOL, and ~20% to DOGE — ensuring each token genuinely contributes one-third of the risk.
The Deleverage Modulator is a continuous de-risking mechanism that scales exposure down as portfolio drawdown and downside volatility rise — no indicators, no timers, no correlation gate. Unlike simple "pause DCA" strategies that only stop new purchases, the modulator performs true portfolio de-risking — it scales down ALL existing positions proportionally, moving capital into stablecoins (USDC) as the regime deteriorates.
As the regime deteriorates, the modulator does two things simultaneously: (1) reduces all existing token positions by scaling their weights down proportionally — this is the actual "selling" of exposure; (2) reroutes all new DCA contributions into USDC while defensive. A strategy that only pauses DCA while letting existing positions ride through a -80% crash is not a shield — it’s just a pause button.
The shield’s effectiveness comes from asymmetric crash math: during a -80% market crash, a shielded portfolio (with minimal exposure) loses only a fraction of that damage. When the market eventually recovers, the preserved capital base compounds — leading to dramatically better long-term outcomes compared to holding through the full crash.
The chart below compares the live production shield, Proteus (v18), against a classic Buy & Hold strategy, measured through the exact production path: a rolling 180-day window re-read every day, the same 180-day strategic re-optimisation cadence the live service runs, shield state persisted from one interval to the next, and turnover charged at the live fee rate. This is deliberately not a continuous full-history replay — production never sees one — so these are the figures a live deployment would actually have produced. Both legs receive identical inputs and identical DCA treatment. The shield is scored on risk-adjusted return (Sharpe and Calmar) and on peak-to-trough drawdown, not on raw dollars.
Under half the drawdown, at a better risk-adjusted score. On a large-cap basket run through the exact production path, Proteus (v18) held peak drawdown to 23.1% against 55.9% for Buy & Hold — a 32.8-point reduction — while scoring higher on both risk-adjusted measures: Sharpe 1.63 vs 1.37 and Calmar 2.00 vs 1.23. On a high-volatility alt basket it cut peak drawdown from 59.8% to 29.4% and beat Buy & Hold on Calmar (1.29 vs 1.23). Exposure is a continuous 0–100% dial: it moves smoothly toward its target every bar in either direction, and redeploys parked USDC automatically as exposure recovers. Aegis (v14) adds threshold rebalancing — a deadband that skips trades when the target barely moves, slashing fees without changing the signal. There are no timers, no tranches, and no correlation gate.
Honestly scoped: this does not beat Buy & Hold on raw dollars, and on the alt basket it does not beat it on Sharpe either. Buy & Hold ends both samples higher in absolute value because it stays fully exposed through the bull run (large-cap CAGR 68.7% vs 46.2%; alt 73.2% vs 37.9%), and on the alt basket its Sharpe is higher too, 1.18 vs 1.10 — there Proteus wins Calmar and halves the drawdown, but it does not win the risk-adjusted race outright and we are not going to imply otherwise. The shield’s edge is drawdown and consistency, not terminal wealth. Out-of-sample, stated correctly: on a sealed second half of an earlier 5-token survivor basket never used to choose the Aegis (v14) preset, Aegis still cut peak drawdown from 63.2% to 25.3% — that result reproduces. Its Sharpe on the same sealed half was lower than Buy & Hold’s, 0.24 vs 0.30; an earlier version of this page reported those two figures the other way round, and that was wrong. Methodology note: that earlier basket is composed of tokens that survived to today (survivorship bias); see the stress test in section 8.6. Past results do not guarantee future performance.
The Deleverage Shield was measured on real market data, not hand-guessed. Every figure in section 8.5 comes from replaying the exact production path — a rolling 180-day window, the live strategic re-optimisation cadence, persisted shield state and turnover at the live fee rate — over two baskets, scored on drawdown, Sharpe, Calmar and CAGR. Earlier versions of this page quoted a continuous 8.7-year replay instead; that frame measures something production never does and its headline figures no longer reproduce from current data, so it has been retired rather than re-quoted.
Over 2,095 daily intervals (~5.7 years) on a large-cap basket and 2,316 intervals (~6.3 years) on a high-volatility alt basket, replayed through the exact production path, Proteus (v18) held peak drawdown to 23.1% against 55.9% for Buy & Hold on large-caps, and 29.4% against 59.8% on alts. It beat Buy & Hold on Sharpe on large-caps (1.63 vs 1.37) but not on alts (1.10 vs 1.18), and it beat its own fixed-threshold predecessor on Sharpe, Calmar and maximum drawdown on both baskets. Both engine selections passed their ship gate.
The shield is validated through the following checks on the production path:
LIVE ENGINE The deployed shield is Proteus (v18), a volatility-adaptive engine. Every figure in sections 8.5 and 8.6 is measured on the exact production path — a rolling 180-day window, the same 180-day strategic re-optimisation cadence, and persisted shield state — so the two sections describe one study, not two. Against its fixed-threshold predecessor Aegis (v14) it cut maximum drawdown on both a large-cap basket (25.7%→23.1%) and a high-volatility alt basket (36.8%→29.4%), with a higher Sharpe and Calmar. Aegis (v14) now runs only as a warm-up fallback, for portfolios with too little history for the adaptive threshold to calibrate; where v14 appears above it is labelled as historical.
AQMath’s privacy is not a feature bolted onto the product — it’s the foundational architectural principle. The system is designed so that your financial data is mathematically isolated from the computation layer.
This is the most critical section. The following data is architecturally impossible for the backend to access:
By default, no database table maps users to portfolios and no log records your holdings. The exception is the opt-in signal & notification service (Section 9): holdings, the frozen plan and consent receipts are stored under the one-way hash of your activation key — never your name, wallet, or exchange keys. Even with full server access, an attacker would find no other information about any user’s financial state.
| Data | Why Backend Can’t See It |
|---|---|
| Wallet addresses | Never entered — AQMath doesn’t connect to wallets |
| Exchange API keys | Never requested — price sync uses public endpoints |
| Transaction history | Never transmitted — only current state during DCA |
| User identity | No accounts, no email, no registration |
| Total portfolio value | Sent during DCA, never persisted — stored only if you opt in to the signal service |
| Historical allocations | Snapshots exist only in localStorage |
| Entry prices | Sent during DCA, not stored — saved only if you opt in to the signal service (UI bookkeeping) |
| Beta key identity | Never your raw key — everything is linked to a one-way hash; no name, email, or wallet |
The backend processes your DCA request in a single HTTP round-trip: receive positions → compute allocation → return results → discard. By default, there is no database table that maps users to portfolios (the only exception is the opt-in signal & notification service: holdings stored under the hash of your activation key). There is no log file that records your holdings. Even if someone gained full access to the server, they would find no other information about any user’s financial state.
AQMath implements a practical non-custodial privacy model:
The backend does not retain your data after the HTTP response is sent — request data is garbage-collected from memory with no disk write, no database insert, and no logs of your holdings. Your portfolio lives in your browser’s localStorage — the only server-side mirror is the pseudonymous one you opt into (Section 9).
Traditional trackers store everything on centralized servers — one breach exposes all users. AQMath stores nothing by default; the only stored data is what you opt into — pseudonymous and deletable. No accounts, no wallet connections, no analytics tracking.
| Feature | Traditional Trackers | AQMath |
|---|---|---|
| Data storage | Centralized server database | Browser localStorage; opt-in pseudonymous signal data only |
| Account required | Email + password + often KYC | None — zero registration |
| Wallet connection | OAuth or wallet connect | Never — manual input only |
| Breach risk | Single DB exposes all users | Nothing to breach |
| Data portability | Export via API (if allowed) | JSON export/import from localStorage |
| Analytics tracking | Google Analytics, Mixpanel | Simple Analytics (privacy-first) |
AQMath gives you the computational power of a quantitative hedge fund’s allocation engine while maintaining the data sovereignty of a paper notebook.
Black users have access to a shared internal chat visible only to active Black members. The chat is designed for direct communication between Black members and the team — no automated onboarding, no helpdesk.
The chat is stored server-side in the same pseudonymous manner as the opt-in signal service — under the one-way hash of your activation key, never under your name or wallet.
