Quantum — the DAAVILEFX agentic ecosystem

YOUR DESK BUILDS IT, TESTS IT, AND TRADES IT WHILE YOU SLEEP.

Quantum is the working side of DAAVILE FX: nine apps, an MT5 testing machine, a backtest engine, and AI agents that drive all of it. An idea goes in as words, comes out as a tested configuration, and the version that survives keeps working the account day and night.

What you actually get: a desk that never sleeps. Strategies get built, measured on real market history, checked against the next version, and then left running while you are not looking — with every number written down where you can read it.

THE ECOSYSTEM — NINE APPS, ONE ENGINE IDEA → ACCOUNT MT5 DECK QUANTUM TESTER MAIN APP STUDIO · CHARTING CALENDAR · JOURNAL DATA FORGE the testing machine the backtest engine agent · IDE · vault plan it, then see it context and memory history in, bars out BUILT · BACKTESTED · RUN 24/7
Fig. 0.1 — the apps we offer, the two engines underneath them, and one agentic loop

DAAVILEFX · PLATE 00 · REV 2026-11-14 · SCHEMATIC

9Apps in one ecosystem
2Engines: deck + tester
3Conditions per candidate
24/7Automatic, no human needed
00The apps we offer

Nine apps, one desk.

None of these are mockups on a roadmap. Every one is built, running and carrying its own test suite, and they share a single Rust engine and a single tool layer — so the chart, the tester and the deck can never disagree about the same bar file.

Engine 01

MT5 Deck

The testing machine. It runs campaigns of candidates, measures each one across ranges of time, and banks every result with its receipt attached.

  • Runs hold candidates — one named campaign carries many configurations under test
  • Three conditions each — clean, delayed and robustness, and a candidate has to survive all three
  • Receipts on disk — every number on screen can be traced back to the run that produced it
CampaignsSetfile candidatesBanked cells
Engine 02

Quantum Tester

The backtest engine. The shared Rust core behind the run, optimise and batch surface — and the same door the agents use when they work on their own.

  • One shared engine — the deck and the tester run the same code, so a fix lands once and both get it
  • Fourteen data tools — an agent can pull history, rebuild bars and verify the result without touching the screen
  • Agent-callable — the same tools the interface uses, available over one local protocol
Rust engineRun · optimise · batch14 forge tools
App 01

Quantum Dashboard

The main app and the cockpit: Agent, IDE, Quantum, MT5 Deck and Vault in one window, with one settings surface for the models, the terminal bridge and the playground.

  • Five realms, one bar — switch between the agent, the IDE, the lab, the deck and the vault
  • Deep links still land — a link from one realm opens the right content in the app that owns it
  • Settings in one place — models, terminal bridge and playground under a single gear
AgentIDEDeck & Vault
App 02

DAAVFX Dashboard

The daily control room. Vibe, Logics, Control, Vault and Tools: the surface you open when you want to see what the system decided and change how it behaves.

  • Behaviour and connections — one place for how the system trades and what it talks to
  • Data and storage — where the runs, the vault and the exported receipts live
  • Tools, not toys — every tool is a real job the desk can be asked to do
ControlVaultTools
App 03

Strategy Studio

Where the idea starts. A freeform Excalidraw board for drawing the strategy, with the icon repository beside it and the board attachable to the run that tests it.

  • Draw it before you code it — the plan lives on the board, not in someone's head
  • Autosaves as a file — boards are self-contained files, portable and versionable
  • Attach to the run — the board and the campaign stay linked
ExcalidrawIcon libraryPortable boards
App 04

Charting

The chart. A WebGL2 renderer over real tick data, with a full drawing layer on top and windowed loading so a long history stays smooth.

  • 32 drawing tools — the whole toolkit, measured in the code and pinned by tests
  • Three-tier data loader — tick store, native timeframe files, then in-memory resampling
  • Gap fill and LOD — missing bars and long ranges handled instead of hidden
Vela WebGL232 toolsReal ticks
App 05

Economic Calendar

The macro sheet. Week, month and year of economic events, filtered by country and impact, with the news folders that belong to each one attached.

  • Three views — the week, the month and the year, so context is one click away
  • Country and impact filters — only the events you actually trade around
  • Copy straight to the desk — an event goes to the agent without retyping
Week · month · yearImpact filtersShared cache
App 06

Journal

The memory. Daily markdown pages, a vault explorer with wikilinks between notes, and a proper editor — so every finding outlives the session that produced it.

  • Plain markdown files — yours to read, yours to move, yours to keep
  • Linked notes — findings connect to the run and the strategy that caused them
  • Editor with preview — write and read in the same window
Daily notesWikilinksMarkdown editor
App 07

Data Forge

The data workshop. Tick history comes in raw and leaves as verified bars: download, a UTC master, the broker's timezone and decimals, rebuilt candles, checked.

  • Six panes, one pipeline — vault, download, convert, bars, verify, settings
  • Resumable downloads — committed months are skipped, so a long pull never starts over
  • Verified output — every rebuilt file is checked before anything backtests on it
Tick historyUTC masterVerified bars
One engine underneath, nine apps on top
The heavy Rust is included from one place, never copied. A fix in the engine reaches the tester, the deck and the apps at the same time.

The audited track record — what it produced

01How it works

Five steps, and nobody has to be awake for them.

An agent drives the whole chain. You set the objective, the desk does the work, and the receipts land on your disk where you can read them at any hour of the night.

1

Draw the objective

The board in the Studio holds the plan while the agent writes the implementation next to it.

2

Pull the history

The Forge downloads the ticks, normalizes them to UTC, rebuilds the bars and verifies the result.

3

Test the logic

The Quantum Tester runs the strategy over that data and hands back the numbers, not a story.

4

Run the campaign

The Deck repeats it across ranges and the three conditions until only the survivors are left.

5

Put it live

The winner is deployed to the account and keeps working it, day and night, with nobody clicking.

02What we offer

The desk keeps working when you are not there.

This is the part that matters. Not a tool you open, but a system that stays on the account and keeps the money working — with the versions, the receipts and the custody arranged exactly the way the audited track record was built.

The value

Capital that keeps working

  • The account stays live — the strategies keep trading while nobody is watching, so the capital is never parked
  • No human in the execution path — placing orders, sizing them and keeping the version on the account is the machine's job
  • One promise from both sides — the managed service runs your account, this ecosystem builds and tests what the service runs. Same idea: money that works around the clock
  • You decide, the system executes — you pick the version and the risk, the desk does the rest
The versions

Versions, not one-off settings

  • A line, not a snapshot — the live record runs on V1, then V2, then V3, each version built from what the previous one proved
  • A version replaces the last one only after it survives the harness — clean, delayed and robustness, across ranges of real time
  • Pauses are written down — when a version changes, the pause and the reason stay on record instead of hiding inside the curve
  • Months unattended — the first two versions ran live for months with no day-to-day management
Ready to start

Built, not promised

  • The apps carry their own gates — build, test suites and Rust checks run before anything gets called done
  • The results live on disk — runs, candidates and cells with receipts, readable by anyone holding the folder
  • The engine is shared — a fix in the Rust core reaches the tester, the deck and the apps at the same time
  • It starts populated — the tools, the engines and the loop are already there, ready for the first campaign
Your side

Your account stays yours

  • Trade-only access — the desk places orders. It has no way to move money out
  • Custody at your broker — the account stays in your name, at your broker, under your withdrawal password
  • The statements are the proof — audited broker statements, not screenshots and not backtests
  • You can pull the plug — change the password or revoke the access and the automation stops on the spot
03The agents

The work is done by agents, not by you.

The model layer is llama.cpp running on your own machine: the CPU and RAM carry the work, your graphics card joins in through Vulkan. Every agent inherits the same tools, runs in its own lane, and carries receipts with what it returns.

The model layer

llama.cpp, tuned for this desk

  • CPU and RAM first — the model loads on the processor, where the memory already is
  • Your GPU pulled in — the dedicated card works through Vulkan, so the answer comes back fast
  • No key, no bill — no cloud calls, no token invoices, no account to manage
  • The integrated chip stays out — I have not found a real use for it yet, so it does not pretend to help
The swap

Two slots, hot swap

  • Active plus shadow — one slot answers while the other warms up in the background
  • Atomic changeover — the two trade places without dropping a single call
  • Per-call budgets — chat and streaming with a ceiling you set
The pipes

One door for every agent

  • Same toolset — every agent inherits the full desk toolkit at session start
  • Parallel lanes — several jobs run at once and report back on their own schedule
  • The real engines — an agent reaches the deck and the tester through their own tools, never through a copy
  • Receipts attached — where a piece of work came from travels with the result
REQUEST AMN ROUTER SLOT A ACTIVE answers every call SLOT B SHADOW warming in parallel A → B B → A ATOMIC SWAP SOLID = LIVE PATH DASHED = WARM PATH NO CLOUD · NO API KEY
Fig. 3.1 — the agents' model layer: two slots on your own hardware, one answering, one warming, swapping without dropping a call

DAAVILEFX · PLATE 03 · REV 2026-11-14 · ROUTING

04Faster tools, built in Rust

The small tools get sharper every week.

A slow tool turns a ten-minute job into an hour, and an hour lost is an experiment never run. So the little helpers around the desk are being rebuilt in Rust — fast, small and native to your machine — and the engine they all sit on is included from one place instead of copied nine times.

In progress

Experimenting with Rune

I am testing Rune, a small scripting language written entirely in Rust, as the way to build quick native helpers that agents can call directly. The idea is simple: instead of shipping a heavy program for every tiny job, ship a tiny native tool that starts instantly and uses your processor directly.

  • Why it matters — a helper that starts in milliseconds instead of seconds, over and over, adds up to hours a week
  • Why Rust — one language, no runtime to install, no garbage collector pausing your work
  • Honest status — this is an experiment, not a shipped feature. It earns its place only if it is measurably faster
Pure RustNative, no runtimeExperimental
The rule

Nothing stays slow on purpose

  • Measure first — a tool gets rebuilt because a number moved, not because it sounded better
  • One job per tool — small, sharp and replaceable beats one big program nobody dares touch
  • Native where it counts — the heavy lifting runs directly on your own CPU and GPU
  • One fix, everywhere — the engine is included from a single place, so a repair reaches the tester, the deck and every app at once
05Always getting better

I am not finished, and I never intend to be.

The ecosystem is alive and it keeps moving. Every week an app gets sharper, the tools get faster, and the agents learn from what actually happened instead of from what I assumed would happen.

Learning

I read what the machine tells me

Every run leaves evidence. I read it, I compare it against what I expected, and I let the difference correct me. That is how the desk gets sharper instead of louder.

Adapting

It changes when the evidence says so

Nothing in the box is sacred. A tool that stops paying for itself gets replaced, a lane that keeps failing gets rebuilt, a hunch that never survives contact gets dropped.

Finding the best sauce

Good enough is not the target

The goal is not a working setup. It is the best version of it that I can build this week — and then a better one next week, with the receipts to prove the difference.

Why you should care
You are getting a desk that is still being improved by the person who built it — not a frozen product waiting for a support ticket.
06The pack — what you get

Nine apps, two engines, one loop. No per-seat billing, no cloud calls, no data leaving your machine. Everything runs on your own hardware.

Think of it as a small fund with one researcher, one laboratory and a rule that nothing goes live without proof. You are the investor. The machine is the analyst. Nothing is promised — it is measured.

Under development — beta testing This is still under development and is being beta tested.

MANIFEST — 9 apps · 2 engines · 1 loop · 0 manual steps at 3am

In the box
  • MT5 Deck — the testing machine: campaigns of candidates, three conditions, every cell banked with its receipt
  • Quantum Tester — the backtest engine on one shared Rust core, callable by the apps and by agents
  • The Quantum main app — agent, IDE, Quantum, deck and vault in one window
  • Studio, Charting, Calendar and Journal — plan it, see it, know the context, keep the memory
  • Data Forge — raw tick history in, UTC master, rebuilt bars, verified output
  • The agent layer — one model layer on your own hardware, one door for every tool, parallel lanes
Not in the box
  • Your broker account and your capital — you open it, the desk only places trades
  • A promise of profit — this is a machine that proves or disproves an idea, nothing more
  • The managed mandate itself — running an account for you is a separate service; it shares the same idea, not the same product
Keep reading

The audited track record is the proof: what the versions did on live money, and the broker statements behind every number.

The audited track record

07Straight answers

Before you ask.

Is this the same as the managed account service?

No, and they are separate products. The managed service runs your account with our team. Quantum is the desk behind that kind of work: the apps, the testing machine and the tester that build and prove what gets run. The idea behind both is the same one — the capital keeps working around the clock — but the service and the ecosystem are two different things.

What exactly do I get?

Nine apps and the two engines under them: the MT5 Deck, the Quantum Tester, the Quantum main app, the DAAVFX dashboard, the Strategy Studio, Charting, the Economic Calendar, the Journal and the Data Forge — plus the agent layer that drives all of it.

Do I have to install anything?

Not one app at a time. The desk arrives as one environment with the apps and the engines already inside it and the tools already wired together. You boot it and the whole set is running.

What hardware do I need?

A 64-bit machine with hardware virtualisation turned on, a reasonable amount of RAM, and a graphics card. A dedicated card helps the model layer most; the integrated chip in your CPU is still fine for everything else. If your machine only has the integrated one, it still runs — just slower.

Does it need the internet?

No. The agents and the local models work offline. The internet only helps when an agent wants to look something up.

Can my own agent use it?

Yes, and that is the point. The desk exposes its backend over one local protocol, so any agent you run can open jobs, read the reports and drive the deck, the tester and the terminals through the same doors the window uses.

Can I buy it yet?

Not yet. Quantum is still in beta testing, so there is no price and no purchase link while it is being tested.

Quantum — the DAAVILEFX agentic ecosystem · built, tested and run locally · DAAVILE FX
// Software lab RYIUK — local LLM inference, backtesting pipelines, agentic workflows. No signals. No courses.
RYIUK.pro →