AryaStrata Control Center

An optional AryaCode plugin for the AryaStrata engine. The sidebar entry is AryaStrata. Start, stop and restart the engine from the header. Strata's own web UI fills the rest of the page for hardware health, inference monitoring and model management, and the Benchmark tab runs the built-in benchmark lab. Open AryaStrata web UI opens the Strata interface in a separate tab.

Harness compatibility

Verified on AryaCode 0.2.2-alpha.2 (build 0.2.2-alpha.2.AryaCode.0.1.0) on 2026-10-28: [email protected] installed from npm into a clean packaged profile, the plugin loaded live with no import error, and its row renders in Plugins → Installed with the switch on. An earlier attempt that installed the same version from a temporary tarball failed to load (duplicate client factory); the published package does not.

The package declares no dsh.engines.dsh range, so the market cannot state a requirement for it: the card reads "Host requirement undeclared" when the manifest is readable and "Host requirement unknown" when that lookup fails.

Setup

Keep the dsh-local-llm package identity for existing installations and updates. The engine controller is included in this package; no separate controller or agent preset is required. Its routes use /api/aryastrata, so an older standalone controller can coexist during an update without duplicate route registrations. Configure the strata fields on the llamacpp plugin row for the controller’s pythonPath, serverDirectory, configPath, baseUrl and port for the installed AryaStrata engine. This machine uses C:/AryaStrata and port 8080. The selected startup configuration is strata-qwen36s-ud-q4_k_xl.json; changes saved to it by AryaStrata are used on restart.

Stop and Restart require a process owned or adopted by the controller. Adoption matches the server entry point and configured configuration path; a process is never stopped merely because it occupies the engine port. Both strata.exe and strata-poly.exe are recognized. Changing model architecture is handled by AryaStrata, without a Qwen-only model list in this page.

The page offers the Strata engine and the benchmark lab. Ollama, llama.cpp and FreeToken have no page controls; their existing backend APIs remain available to preserve saved model-provider integrations. Changing this page does not install, delete or move engines, model files or chats.

Benchmark lab

The Benchmark tab runs the built-in benchmark lab (suite 3.0) against the models AryaStrata publishes. Add one to AryaStrata and it appears here. Chat model discovery, Benchmarks and model sharing with a paired computer are unchanged.

Five tabs: Board ranks models by a weighted Overall score with medals, per-suite bars and a suite-profile radar. Live shows a completion ring, per-model progress, ETA and GPU sparklines while a run executes; Cancel stops it. Results is a model × suite matrix; click any cell for a drawer with the check list, metrics, the model's answer, generated code downloads and website screenshots. Compare stacks up to three saved runs against a baseline with per-suite deltas and radars. Sites renders every generated website card with desktop/mobile captures, interaction play and 1–5-star visual ratings.

Batteries: Speed (◷ ×30) throughput probes; Readiness (✳ ×15) tool-call and vision probes; Context (⌖ ×15) long-needle tests up to 256K; Reason (∴ ×15) twelve deterministic short-answer tasks (arithmetic, logic, JSON extraction, formatting contracts) checked offline at temperature 0; Build (▤ ×20) eight website tasks scored by DOM contracts, design metrics and screenshots; Industrial (⚙ ×20) twelve engineering tasks — JavaScript with real Worker assertions, OpenNode PLCopen XML, Rockwell L5X generation and reading, ladder diagnosis, tag cross-reference, HMI screen specs, safety verdicts and EtherNet/IP protocol Q&A. PLC, HMI and network answers are offline deterministic fixtures, not vendor-validated content; PLC outputs need engineering review.

Readiness measures the live tool catalog: every chat turn with a local model records the tool definitions the host sends with it, and the readiness suite runs against the newest capture, so it always measures the real catalog of the running tool set. An arya-request-header.json snapshot in the engine directory is still accepted as a fallback. Start one local chat before running the readiness suite; the benchmark panel reports which catalog will be used.

Overall is the weighted mean of present suites, renormalized when a run skips batteries; Speed is scored against the fastest model in the run, so the ranking stays comparable across hardware. Pick a preset (Quick check, Standard, Full gauntlet) or tune suites, context, speed, thinking, repeats, vision and task lists by hand. Older 2.0 runs stay readable and comparable.

Scoring never asks a model to judge a model: every check is a fixed script run offline against the captured answer, so scores are reproducible across runs and machines.

Browser access

The web UI loads directly from the configured engine URL. A phone or another computer cannot access the host's 127.0.0.1; the page explains this instead of embedding the wrong computer. Configure a reachable, authenticated AryaStrata address before using it remotely. An HTTPS AryaCode page cannot embed an HTTP engine; use the separate-tab link or an HTTPS engine address. The engine's own authentication remains in effect, and credentials are never added to its URL.

A paired computer is more capable than a bare address: its own Host asks the paired address whether the engine's port answers there, and offers the interface only when it does. Publishing the engine port on the tailnet is enough — this machine uses tailscale serve for port 8080 — and the panel then embeds the engine UI instead of asking the user to walk to the other computer. When the port does not answer, the panel says so rather than showing a broken frame.

Another computer

Install this plugin on both computers; 0.7.4 or newer is needed on both for the fixed pairing address and every engine model (model sharing needs 0.7.2, control alone 0.7.1). Control is set up with a short pairing code, the same way a phone is connected:

1. On the engine computer open AryaStrata → Let another computer control this engine and choose Create pairing code.
2. On the other computer open AryaStrata → Control another computer. Choose the engine computer from the list of machines on its tailnet, or type its Tailscale address, then type the eight-character code — the one it displays beside the addresses a second computer can reach it at. Letters and digits only; the dash is ignored.
3. Pair and control exchanges the code once for a private token and starts controlling that engine. The code expires five minutes after it is created.

The address the code offers is served by this plugin on a fixed port (45900) bound to the engine computer's tailnet address, and it forwards only the routes a paired computer uses: /api/aryastrata/* and /api/local-llm/*. Everything else on that address is a 404. The port matters because AryaCode chooses its own web port afresh at every launch — an address saved against that port stops working on the next restart, which looks like a network failure. With the fixed port the pairing survives restarts. Set strata.pairPort to use a different port, or 0 to turn the relay off (the offer then names the page's own port again). Set strata.pairHost when the tailnet address is not the one to bind. The first time it listens, Windows may ask whether to allow the app to accept connections — allow it for the tailnet, not for public networks.

The paired computer appears under Paired computers on the engine computer, where it can be unpaired; unpairing revokes its token immediately. Pairing does not need a secret pasted by hand, and no token is shown on screen. Use this computer points the page back at the engine it runs itself.

A panel that has a strata.controlToken on its llamacpp row still accepts that token, which is what an older installation uses:

- id: llamacpp
  config:
    strata:
      controlToken: a long random value

Restart AryaCode after editing it — the row is read at startup, and a page reload does not reload host code. A computer with no token and no paired computer keeps answering only itself, which is the safe default; the page says so rather than letting a connection fail as a 401. Under Control another computer → Use a control token instead, the same address and token can be entered directly.

Start, stop, restart, the engine snapshot and logs are then answered by the engine computer, and the page names the computer it is controlling. The same code also shares the engine's models: every installed model is offered, and the paired computer lists them all in AryaCode's model picker (provider Remote Local LLM) with their real context windows. One code, one token, control and models together; revoking the paired computer ends both.

An engine serves one model at a time but can switch: choosing a model the engine has not loaded asks it to switch (POST /api/models/load) before the request is sent, so chat moves between models without visiting the Control Center. The engine finishes the request it is running first, and refuses with the reason when that takes longer than its switch window. Models the engine reports as unusable are left out rather than offered and then failing.

The models are also listed in the engine computer's own Local model library, so the host can chat with its engine without a separate provider row.

The engine's own web interface still listens on the engine computer, so it is opened there rather than embedded when its port is not reachable.

The hop is server to server: the page stays on its own machine's origin and the token never reaches the browser. Choosing a computer to pair with is local to that computer, and redeeming a code needs the code itself; nothing else changes which computer a page controls. Plain http is accepted only for loopback and Tailscale addresses, where the transport is already encrypted; any other address must be https. The status and control routes demand the token from every caller that is not on the engine computer, and an origin the engine computer never named is refused outright.

Validation

npm run typecheck
npm run build
npm test
node tests/aryastrata-ui.mjs

The browser test covers lifecycle controls, desktop/mobile layouts, an embedded web UI and errors retaining the current UI. To exercise a real local engine, set ARYA_STRATA_LIVE=1 before running that test. This explicitly stops, starts and restarts the configured engine; run it only when no inference request is active. The live test loads the built Control Center package itself.

Legacy backend reference describes retained compatibility APIs, not the current page.

Chat output limits

Open AryaStrata → Chat output limits, choose a configured local model, adjust Output tokens per response, and save. The number includes thinking, tool arguments and the final answer. Changes apply to subsequent requests. The editor supports values from 1,024 tokens to below the configured context window; input and output still share that context. Saving preserves other model settings. The desktop application can embed loopback engines through its dsh-app origin as well as a localhost browser.

Updating from the two-package release

Install or update only dsh-local-llm 0.7.1 or newer on both computers in a remote-control setup. The old dsh-strata package may be uninstalled; its source and previous archives are retained for older installations. If you customized its controller row, move those configuration values into the strata object on the Control Center’s llamacpp row before removing it. The retired dsh-strata-agent preset is unrelated to engine control and is not included. Model files, chat history and saved model-provider settings are preserved.