AQUARIUS

What It Is ?
Aquarius is a protocol-aware risk intelligence and mitigation system for DeFi positions, starting with Aave.  
The architecture is protocol-extensible, allowing Aquarius to support additional DeFi protocols as risk modules are developed.
Aquarius continuously :

• Monitors on-chain position health,
• Computes deterministic risk signals off-chain via Chainlink CRE,
• Escalates risk states through a predefined state machine,
• Triggers protective on-chain actions before liquidation thresholds are reached.

By shifting DeFi risk management from reactive liquidation to proactive mitigation, Aquarius improves capital efficiency and reduces cascading risk events.

The problem Aquarius Solves:
There have been countless times where I — and even DAO operators — hold leveraged DeFi positions on protocols like Aave, Curve, or Compound, and only realize the health factor is deteriorating when liquidation pressure is already close.
At that point, liquidator bots are already watching the position 24/7 on-chain, ready to capture liquidation incentives. Protocols like Aave reward these external liquidators to maintain system solvency — which is good for the protocol, but often results in avoidable capital loss for the user.
Because of this, most users end up repeatedly coming back to their screens to manually monitor their health factor and adjust their position whenever it becomes risky. This management task is time-consuming, stressful, and inefficient — especially when managing positions across multiple protocols like Compound, Curve, or Lido.
Instead of exploring new strategies or focusing on capital efficiency, users are stuck babysitting their positions.

Most existing systems today are still reactive dashboards:
They show risk metrics, but they do not orchestrate deterministic protection workflows. There is no proactive, autonomous risk protection layer.

Aquarius changes that.
Instead of waiting for liquidation triggers, Aquarius turns risk monitoring into a proactive, machine-speed orchestration layer — where positions are continuously assessed, escalated through defined risk states, and mitigated before liquidation conditions become critical.

Aquarius is designed to be ahead of liquidation bots
Liquidator bots operate within protocol-defined constraints.
They can only act once a position crosses the liquidation threshold — when incentives become available.
But Aquarius has a different objective.
Because it is designed for protection, not incentive capture, it evaluates projected health factor deterioration before liquidation conditions are triggered and can initiate mitigation earlier.
This creates a structural timing advantage:
protection logic can act before liquidation logic becomes eligible — positioning Aquarius ahead of external liquidators and reducing the likelihood of avoidable liquidation losses for defi users.

Aquarius introduces the missing protection layer for on-chain finance.
As traditional financial systems (TradFi) move on-chain, institutional participants and advanced users require deterministic, automated risk protection — not manual monitoring.
Aquarius is designed to become the standard financial protection layer for on-chain systems.

The Problem Aquarius Solves for Chainlink and Its Ecosystem:
Aquarius addresses a gap that is structural — not a weakness — within the Chainlink architecture.
Chainlink CRE is a powerful execution and orchestration layer, intentionally designed to be protocol-agnostic and neutral across the ecosystem. That neutrality is essential to its mission as the linking layer of on-chain systems.
However, DeFi protocols such as Aave, Uniswap, and Curve each have unique risk dynamics, invariants, and liquidation mechanics. Effective mitigation require protocol-specific intelligence — not just secure execution.
By design, Chainlink does not embed domain-specific risk logic at the protocol level (for example, exposing risk APIs or SDKs tailored to a particular protocol). Doing so would fragment neutrality and composability across Web3, ultimately creating ecosystem-level constraints.

Maintaining neutrality requires a separation between:

• Execution infrastructure and
• Application-specific decision systems
  That separation is structural — and necessary.

Aquarius extends ecosystem capabilities vertically without compromising Chainlink's neutrality, by introducing domain-specific risk intelligence through Aqua Agents that:

1. Interpret protocol-level risk conditions
2. Determine when mitigation workflows should activate
3. Delegate secure execution and orchestration to Chainlink CRE

In essence:
Chainlink executes.
Aquarius decides when protection is needed.

How Does It Work?
Aquarius provides three core steps to protocol clarity and position protection.

Step 1: Protocol & Position Visibility

Users select the protocol and chain where their position exists.
Aquarius immediately surfaces:

• Real-time health factor
• Actionable protocol-specific risk metrics
• Liquidation distance
• Deterministic risk stage
• Recommended mitigation actions generated by Aqua Agents

Once users connect their wallet, they can view their personal risk evaluation and projected position trajectory in real time.

Step 2: Choose Your Protection Mode

Users decide how they want their risk to be managed.
Note: Aqua Agents are autonomous and non-custodial across all modes.
Users retain control of their positions at all times.

Option A — Manual Monitoring (Dashboard Only)

Users monitor risk metrics and rebalance manually when needed.
This mode provides full visibility without automation.
However, users must continue monitoring their positions themselves.

Users may upgrade at any time to an Aqua Agent protection mode.

Option B — Alert Mode

Aqua Agents continuously monitor positions and send alerts when risk escalates.
Alerts can be delivered via:

• Telegram
• Webhook
• Web push
  Users remain fully in control and execute mitigation manually after receiving alerts.
  This mode is advisory and fully non-custodial.

Option C — Autonomous Agent Mode

Users delegate mitigation authority to Aqua Agents under a selected protection policy.
When predefined risk thresholds are reached, the agent:

• Executes repay or collateral reinforcement
• Follows deterministic mitigation logic
• Validates post-execution health factor improvement
  This enables proactive protection without requiring continuous user monitoring — while remaining non-custodial.

Option D — Insurance Buffer Vault
(Includes Alerts + Autonomous Protection)

For users seeking additional resilience, Aquarius provides a tokenized ERC vault buffer mechanism.
In this mode:

• Users allocate capital into a protective buffer vault
• When risk escalates, the system can draw from the vault
• Collateral is automatically reinforced to prevent liquidation

Importantly, vault funds are not idle.
The buffer is structured as a tokenized ERC-4626 vault that generates yield, allowing users to maintain capital efficiency while securing downside protection.
This aligns protection with productive capital deployment.

Step 3: Advanced Integration (Developers & Institutions)

Advanced users — including institutions, DAOs, and protocols — can integrate directly via:

• Aquarius API
• SELVA SDK

This allows external systems to:

1. Monitor Protocol positions across chains
2. Access deterministic risk intelligence
3. Integrate mitigation workflows

Planned upgrades include:

• Custom agent plug-ins

• Agent verification framework

• Decentralized identity validation

• Protection against prompt injection and agent-level attacks

Risk Intelligence Pipeline

Aquarius continuously ingests live position data:

• Collateral
• Debt
• Health factor
• Liquidation distance

It computes deterministic risk intelligence including:

• Projected health factor
• Stress scenario outcomes
• Escalation stage classification
• Mitigation readiness state

This orchestration layer is powered through Chainlink services, enabling secure workflow execution and off-chain computation.

For full architecture diagrams, Chainlink workflow integration points, API/SDK references, validation stages, and testnet proof links, please see the README.

How Aquarius Is Built

We built Aquarius as a layered system, starting from deterministic risk logic and then adding orchestration, execution, and product surfaces around it.

1. Deterministic Risk Intelligence Layer
   First, we built the core risk pipeline for Aave: ingest position/market snapshots, derive risk signals, compute scores, and track escalation state.
   This gave us a deterministic engine that can classify risk consistently and quickly. From there, we wrapped the engine in a shared CRE-oriented workflow orchestrator so the same workflow can run via API routes and CLI simulation, instead of duplicating logic in multiple places.

2. Execution & Mitigation Layer
   Next, we implemented a mode-based execution layer. When risk crosses thresholds, mitigation intents are routed through execution adapters. In the current validated setup, this runs in simulated_ccc mode on Tenderly and supports dual paths: non-custodial mitigation and vault-backed reinforcement.
   We added pre/post state checks (including health factor changes) and execution reports so outcomes are measurable, not just logged.

3. Cross-Chain Coordination Layer
   After that, we added cross-chain risk propagation (CCIP-style sender/receiver + synchronizer/coordinator) so risk posture can be coordinated across chains, and a scheduler safety layer (anomaly detection, circuit breaker, recovery flow) to make the system resilient under abnormal conditions.

4. Product Interface Layer
   On top of the deterministic backend, we built the product interfaces :

• versioned bot-ready APIs for health/risk/projection/stress/actionable metrics,
• SELVA SDK methods so bots and integrators can consume intelligence directly and
• A real-time, position-aware Risk Copilot UI that assembles deterministic context and uses Groq only for interpretation in informational mode.
• Clarity focused User-interface.

5. End-to-End Architecture Validation
   Finally, we validated everything end-to-end with a full architecture runner (pnpm run run:full-validation) on Tenderly Virtual TestNet.
   This validation runs on Tenderly Virtual TestNet and exercises the entire system pipeline.

The runner validates:

1. Contract deployment
2. Protocol initialization
3. User scenarios
4. Risk prediction
5. Security checks
6. Dual-path mitigation execution
7. Cross-chain propagation
8. Safety control activation
9. API and SDK consistency

All validations produce:

• Assertion-based outputs
• Transaction-level proof links

This ensures the architecture is reproducible and verifiable.

Architecture Summary
Aquarius was built in the following order:

• Deterministic risk intelligence
• CRE-based orchestration
• Execution and mitigation systems
• Cross-chain coordination
• Developer and user interfaces

The entire stack was then validated through reproducible end-to-end testing.