Aria

AI model and agents

Comment

Inspiration

Most AI assistants can explain what to do, but complex professional work requires more than generating an answer. It requires understanding an objective, gathering real data, selecting the right tools, executing multi-step workflows, validating results, and adapting when something goes wrong.

That is what inspired us to build Aria.

Aria is an agentic AI system designed to turn natural-language intent into executable workflows. For this project, we focused on quantitative finance as a demanding real-world environment where an agent must reason across market data, quantitative models, code, risk constraints, and backtesting rather than simply produce text.

Our goal was simple:

Move AI from answering questions to actually doing the work.

What it does

A user can give Aria a high-level objective such as:

"Build a momentum strategy for AAPL, NVDA, and TSLA, keep maximum drawdown below 15%, and backtest it."

Aria then breaks the objective into a multi-step workflow. Depending on the task, it can:

  • retrieve and analyse market data
  • calculate quantitative factors
  • generate a structured strategy specification
  • write executable strategy code
  • call quantitative analysis tools
  • validate syntax, structure, risk controls, and strategy requirements
  • automatically correct detected problems
  • run historical backtests
  • calculate risk and performance metrics
  • optimise portfolio construction and position sizing
  • return the results to the user through a conversational interface

Instead of exposing dozens of disconnected financial tools, Aria acts as the orchestration layer between the user and those capabilities.

How we built it

Aria uses an agent-oriented architecture composed of three major layers:

1. AI Orchestration Layer

The model interprets user intent and determines which tools and workflows are required. Aria supports multi-round tool execution, allowing the model to call a tool, inspect its result, and continue reasoning before producing a final response.

2. Tool and Execution Layer

The agent can access specialised tools for market data, factor analysis, portfolio optimisation, risk analysis, strategy validation, backtesting, news research, chart generation, and other operations.

Tool calls are treated as part of the agent's reasoning loop rather than isolated API requests.

3. Quantitative Engine

Behind the agent is our quantitative research infrastructure, supporting capabilities including factor analysis, momentum and mean-reversion strategies, statistical arbitrage, portfolio optimisation, VaR/CVaR risk analysis, stress testing, transaction-cost modelling, walk-forward validation, and historical backtesting.

For strategy creation, we designed a structured workflow:

DATA → SPEC → CODE → VALIDATE → BACKTEST → DEPLOY

This allows Aria to move progressively from understanding an investment objective to producing something that can actually be evaluated and executed.

The interface streams model output, reasoning states, tool calls, tool results, strategy-generation phases, validation results, and code generation in real time so users can understand what the agent is doing while it works.

Challenges we faced

One of the biggest challenges was making the system behave like an agent rather than a chatbot.

Generating a plausible answer is relatively easy. Building a system that can decide when external information is required, select the correct tool, interpret its output, recover from failures, and continue toward the original objective is significantly harder.

Another challenge was reliability.

Generated quantitative code cannot simply "look correct." We introduced multiple validation gates for syntax, strategy structure, risk controls, and compliance. When validation fails, Aria can use the detected errors as feedback and attempt to repair the strategy before continuing.

We also had to connect very different systems—LLM inference, streaming responses, market-data APIs, quantitative models, code generation, backtesting, persistent storage, and frontend visualisation—into one coherent workflow.

This changed how we think about AI applications: the intelligence of an agent does not come only from the underlying model. It also comes from the architecture surrounding the model—its tools, context, feedback loops, execution environment, and ability to verify its own work.

What we learned

The most important lesson was that useful agents need more than increasingly capable language models.

They need tools, memory, structured context, verification, and feedback loops.

For complex tasks, we found that decomposing work into observable stages produces a more reliable system than asking a model to generate an entire solution in a single response.

We also learned that domain-specific engines can dramatically extend what a general AI model can accomplish. The model does not need to internally reproduce every quantitative algorithm; it needs to understand the user's objective and know how and when to use specialised computational systems.

What's next

Quantitative finance is our first major proving ground, not the final boundary for Aria.

The architecture is being developed so that additional tools and execution environments can be connected to the same agentic layer. Our longer-term direction is to expand Aria into software engineering, research, business intelligence, operations, and other professional workflows.

We envision Aria as an intelligence layer where users describe an objective, and the system coordinates the models, tools, data, and execution required to accomplish it.

Built With

Share this project:

Updates

Submission history