Orionfold Arena

Orionfold Arena is a single screen for running, comparing, and scoring the AI models on your own desktop. Open it on an NVIDIA DGX Spark and you see the machine’s live readouts, every model you have built, the tests those models were measured on, and a private board that ranks them from your own results. All of it runs on the machine under your desk, and none of it leaves.

Why it exists

If you build models on a Spark, you end up with a shelf of them and nowhere to drive them from. Picking one meant remembering a long command. Comparing two meant a terminal and a notebook. Knowing which small build was the good one meant digging up notes you wrote weeks ago. Arena turns that shelf into a control room. Chat with the model that is already warm and loaded, set two of them against each other, score an answer against a known-good answer, and read one chart to decide which build is worth shipping.

What you can do

• Watch the machine. A live strip across the top shows how hard the chip is working, how hot it is, how much of the shared 128 GB of memory is in use, and how fast answers come back. Each readout keeps a small bar chart of its recent peaks, so you see the trend and not just the moment. On a Spark the chip and the system share one pool of memory, so watching that number is how you avoid running out before it happens.
• Browse your shelf. Every model you can run sits in one grid, filterable by kind and license. Each model has a full card: what it is for, which shrunk build is the sweet spot, where it is known to slip, and its own quality-versus-speed curve. You read the whole story before you spend a second of GPU time.
• Rank your models. The board ranks your models from real results and folds in every new chat and test as you go. Each row carries a badge that says whether the number came from your Spark or a hosted model. The flagship group reads like a product, not a lab log: plain-language names, small pills for each row’s role and the frozen test behind its score, and the raw run id kept under every name so a friendly label can never hide which data it points at. It is built from a safe slice that shares only scores, never your prompts or the model’s replies, so you can publish the board and keep your data.
• Pick what to ship. One chart plots quality against speed for every build and draws the best trade-offs in orange. Quality here means how well the model answers; the orange line is the set where you cannot get more quality without giving up speed. The flagship build is marked with a violet diamond so you can always find it among the dots.
• Try and test in one place. Chat with any model, pull the exact test it was measured on, and score its answer against a gold answer without leaving the chat. Or put two models head to head and read the trade in plain cards: quality, speed, wait time, length, and cost, each with a small chart of how it moved across the session.
• Replay the real test. A saved test set keeps everything it was measured with: the questions, the system rules, even whether the model was allowed to think out loud first. Pick a row and the chat replays that exact setup, and a scorer grades the answer the moment it lands. No judge model is needed.
• Swap models safely. Only one model fits in the shared memory at a time, so the cockpit now starts and stops the serving model itself, with guard rails. It checks memory first, asks before it stops the old model, and waits until the new one is warm and answering.
• Read a model’s whole case. The memory pane shows proof cards for a model on its way to being published: the pre-flight check, the knowledge pack it answers from, what each routing setup costs, and the final verdict. Each card reads from saved proof files, so the cockpit shows the evidence instead of restating it.
• Put the cockpit to work. A jobs board lets the Arena start work, not just record it. Type a model and a test set, press queue, and a re-test runs on your Spark. The job’s card moves from queued to running to done, with the measured score on it. Press scan and the board compares your leaderboard to its last saved state; if a score slipped, it queues a confirming re-test by itself. A failed job says why, right on the card. One job runs at a time, so the board never blows past the Spark’s shared memory.
• Train from the same board. The board now starts training, not just testing. A smoke-test slot answers “is this base model worth training?” with a small twenty-row test before any long run, and a training slot launches a full run from a recipe file. When the runs belong to one model being built end to end, a Build pane lines them up as a spine of stage cards, each with its saved proof, so the whole build reads as one story.
• Watch the reward. The same scorer that grades the leaderboard is the reward a training run tries to raise. One gauge shows the starting score, the live reward as the run trains, and a gate that holds promotion until the signal is clean.
• Cap what cloud work can spend. A per-run cost cap and a stall timer lock onto a paid cloud job the moment it is sent, so a hung test can never quietly run up a bill. Local runs stay free and unguarded, because the bounds live exactly where the meter does.
• Wake up to a report. An overnight loop drains the queue while you sleep, then stops. A morning report says what ran, what slipped, what failed, and what it spent. Nothing is published until you review and promote it.
• Move without the mouse. One keystroke opens a search box over the whole cockpit. Type a few letters to jump to any model, fire a chat, or set up a duel.

Jargon, in plain words: a GGUF is just a packaged model file you can run on your own machine. To quantize a model is to shrink it so it runs faster, and the chart shows what you trade away when you do. Throughput is how many words a second the model can produce.

It keeps growing

Arena shipped as fourteen screens and 125 tests in about fifteen hours of work, with the AI agent doing the typing. It did not stop there. In the days after launch six more screens landed, and the tool now measures 17,515 lines of code and 135 tests. One part, a memory pane that indexes your own notes and checks how well it can find them again, grew into its own product, Orionfold Cortex, with its own page. The jobs board, the control plane, came together in one afternoon of about two and a half hours, adding 1,762 lines and 35 tests of its own, and shipped inside fieldkit v0.16.0, the first packaged Arena release.

The newest proof of the cockpit is Orionfold Advisor, a governed local AI advisor that launched in June 2026. Its whole promotion case ran through these screens: every model swap went through the guarded serving screen, all 89 of its measured test questions are replayable from the eval drawer, and its proof cards sit on the memory pane. The cockpit did not just record that launch. It was the instrument it happened on.

Private by design

Nothing you type is uploaded, and nothing you compare phones home, unless you deliberately pick a hosted model. The whole thing is a tool you could run on a plane.

Built on fieldkit

Arena is a thin cockpit over the fieldkit toolbox and a year of real research. fieldkit serves the models, runs the tests, and scores the answers; Arena gives that work a screen. Because the parts already existed, the whole cockpit came together in a day. The honest version of that story is the better one: the cockpit is the sum of a lot of compounding work, not a fresh start.