YOUR TRADING DESK, AS ONE MACHINE YOU OWN.

Ubuntu with MT5 already inside

The image boots into Ubuntu with MetaTrader 5 installed, licensed-ready and configured for both live and backtesting work. NinjaTrader and the other terminals are the next ones in line.

Herdr — the desk you look at

One window for the whole machine. Every agent, every terminal, every running job and every log, side by side. You stop hunting through six windows and start supervising a desk.

OpenCode — DAAVILE and RYIUK builds

Two tuned forks of OpenCode. The DAAVILE build knows the trading laws of this desk; the RYIUK build knows the local models. Both drive the backtesting and inference pipelines from the same session.

The brain runs at home

llama.cpp on your own CPU and RAM, with your graphics card taking the heavy work through Vulkan. No API key, no per-token bill, and it keeps answering with the internet unplugged.

The sandbox

Agents work inside a locked box. They can try things, break them and rerun them without ever reaching your live account or your real files. A failed experiment costs compute, not money.

Virtual machines

Spin up a clean room per experiment, snapshot it, throw it away. One bad candidate never poisons the desk, and you can always go back to the last known-good state.

Locked box for the experiments

• Your live account is out of reach — agents work on copies, never on the account that holds your money
• Your files are out of reach — the box only sees the folders it was given
• Failure is cheap — a broken run costs electricity and minutes, not capital
• Full visibility — every command the agent ran is written down and readable

A clean room per experiment

• Start from clean — every run gets a fresh machine instead of yesterday's leftovers
• Snapshot the good state — when something works, keep it. When it breaks, roll back
• Throw the rest away — a bad experiment never poisons the desk
• Run them in parallel — several clean rooms at once, all still on your own machine

Local means local

• No API key anywhere — there is no cloud account to create and no bill to receive
• Unplug and it still works — the models run on your own CPU, RAM and graphics card
• Your prompts stay home — nothing about your strategy is sent to a stranger's server

You own the whole image

• Copy it — clone the disk, move it to another machine, back it up however you like
• Open it — nothing is sealed. Every file, every log and every receipt is yours to read
• Wipe it — sell the hardware tomorrow and the desk goes with you, not the other way around

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

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

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
• Receipts attached — where a piece of work came from travels with the result

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

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
• Same for the brain — the model layer is tuned for the same reason: less waiting, more work

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.

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.

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.