MathSphere Nexus official corporate seal MathSphere Nexus

Demo

Every feature tested live, and documented — the house rule, made public

Every project in this house carries a demo section: every feature tested live, and the test documented as guidance. This page is that section, public — the model runs included in it in full, alongside the house's other demos, each with its verdict and a road to its complete record.

Model runs

A diagram can claim anything. These records keep the receipts of the real thing: a live model, seated locally, asking the gate of the Wizard Central Pro AI Modes Toolkit for tools — and the gate answering. Each run is documented the way this house documents everything: beginning to end, what the model asked, what the gate allowed or refused, and the verdict. The client in these runs is ollmcp — the MCP Client for Ollama — the base MCP client this house pairs with Ollama, the base local seat. Nothing in a run leaves the machine it ran on.

Run Record — the bridge, verified

October 17 and October 24, 2026 — the Chromebook

The first end-to-end confirmation came on October 17, 2026: ollmcp 0.35.1, with the local model qwen3.5:0.8b seated, connected to the bridge and called a JSON validation tool on a file the person had granted — and the call went through the gate and was served. A model had used the system, through the checkpoint, for the first time.

A week later, on October 24, the same arrangement was put through a formal five-check verification against the then-current tree — a real client, a real model, the real server. All five checks passed. The shape of what they proved:

The record's own wrinkle, kept as it fell: the client that day merged its saved registry with the run's server script, and connected to the same server twice under two names — same tree, same state, the same 11 tools each time. Noted, understood, and carried into how later runs are staged.

The standing the house gives this record, in its own words: the bridge is verified.

Run Record — the second machine

November 14, 2026 — the house's second machine, staged fresh

The October run, repeated from bare metal on a second machine: a fresh clone of the Pro toolkit, the client installed new that night — ollmcp 0.35.1, in its own environment — and the same smallest model seated, qwen3.5:0.8b. The run is recorded as it fell, stalls and all; a record that only keeps its successes would prove nothing.

The empty offer. The first connection succeeded — and offered 0 tools. A fresh install starts closed: every feature of the gate at its default, which is off. Only the receipts and the nine built guard modes stand on from the start. Nothing about the bridge was broken; it was doing what a default-closed gate does until its owner opens it.

The switch-on. At the terminal, by the owner's hand and under the house's double-ask, the work preset was applied: the bridge, the prompts and the tools switched on — 100 tools in 11 wizards, of 139 listed in 12 manifests (the twelfth wizard's tools are of a kind the bridge never serves). Custom modes were switched on as well. The next connection offered all 100 tools and 76 prompts — October's exact prompt count, reproduced on new iron.

The refusal. Asked to validate a JSON file in a folder nobody had granted, the model reached for a read tool instead; the person said yes at the client's own confirmation — and the gate refused the call: the path is refused: no grant covers it. A yes at the client is not a grant, on this machine exactly as on the first.

The grant. In a second terminal — the session left open, the gate re-reading its state on every call — the owner created a small demo folder and granted it for one hour, double-asked in the house form.

The wide-offer finding. Three times the model then tried to form the validation call, and three times it garbled the tool's name into one that does not exist; no call was made. In October, this same model formed its call cleanly — against an offer of 11 tools. Against 100, it drowns. The record keeps this as a measured finding, not an embarrassment: how much a gate offers at once is a question the smallest models answer with their limits, and a system built for the weakest models has to price the width of its own offer.

The third wall. The model's fallback read call did reach the machinery — and was refused at sandbox setup, for a named reason: the sandbox's Python packages were not present in the environment the server was running from. The project's own sandbox document states the rule in advance: without those packages the wall cannot be built, and the call is refused. The gate chose refusal over running a call unwalled. The two packages were installed and verified importable, and the session was relaunched.

The served call. The same read call, behind the live grant, with the wall able to stand: it ran inside the sandbox and completed. Its response carries the proof lines the server attaches to every served call:

Kept honest, the same way as the rest: the validation call itself was never formed by the smallest model under the wide offer — the served call was the read. What this record proves is the gate's whole path on a fresh machine: closed by default, opened by its owner's hand, refusing without a grant even after a client's yes, refusing again rather than run unwalled, and serving the call once every wall could stand. The run also changed the product's direction the night it happened: the bridge's packages and the full sandbox stack are being carried into the setup wizard's requirements, so a fresh install arrives with them by default instead of discovering them mid-run.

Run Record — the same question, a bigger seat

November 14, 2026 — the second machine again, an hour later

One variable changed: the seat. Same machine, same gate, the same 100 tools on offer, and the same question, word for word — use the JSON Wizard's validate tool on the file in the granted demo folder — put this time to qwen3.5:2b, a step up the ladder from the 0.8b of the run above. The grant still had time on it; nothing else was touched.

The validation call was not formed — again. The bigger model's own thinking says it plainly: it could not see the validation tool among the functions it was offered. At an offer of 100, the failure to locate one tool in the crowd has now happened at both sizes tested. Against October's offer of 11, the smallest model formed this same call cleanly and was served. The width of the offer is the variable that has bitten twice.

How it failed is the difference. The 0.8b invented a tool that does not exist and errored, again and again. The 2b invented nothing: on its first try it chose a real tool — the same read the smaller model fell back to — and that call was served behind the live grant, with the same proof lines: exit status: 0, granted folders unchanged: yes, outcome: completed. Size changed the grace of the failure, not its outcome. One honesty note, kept because this page keeps them: the bigger model's written summary dressed the result up a little, in words the tool's output does not contain. The output was clean; the dressing was narration, and narration is never the result.

The table the two runs make, then: the smallest model at 11 tools — validation formed and served; the smallest model at 100 — validation never formed; a bigger model at 100 — validation still not formed, the fallback served first try. A system built for the weakest models now has a measured reason to care how much it offers at once.

Run Record — the same question, three more seats

November 14, 2026 — the second machine, later the same morning

Three more models from the machine's own ladder then faced exactly the same test: the same gate, the same 100 tools and 76 prompts on offer, the same demo file, and the same ask — this time worded as a direct instruction to call the JSON wizard's validate tool with the file's path. A fresh grant was made first, for one day, over the same demo folder; the double-ask earned its keep on the way in, refusing two mistyped confirmations — capitals the ask did not ask for, then the second answer given at the first question — and changing nothing until the answers came in the order and the words asked for.

No call was executed in any of the three sessions. llama3.2:3b never formed a callable tool name at all: it merged two real names into tools that do not exist — four times across the session — and otherwise answered in prose instead of calling. qwen2.5-coder:3b did something subtler — its first answer printed the validate call itself, with the correct name and the correct path, as a block of text. It read perfectly. It was an answer, not a call, and the client never ran it; asked again, the same model merged two names into an invented one. qwen2.5-coder:7b, the largest seat tried that morning, also printed the correct call as text — and in the record as taken, that is where it ends: written out, never fired.

One of the three went further, and it is the part of this record that matters most. The 3b general model, having called nothing, printed a validation report anyway — complete with an error the real file does not have (it reported a required property missing from a file that carries that very property). No run produced that report. It was composed. This is the reason this house keeps hash-chained receipts and treats a model's narration as narration: the server's own log is the record of what ran, and across these three sessions the server ran nothing — whatever the answers claimed.

The measured table now covers five models across six runs against this one question. At an offer of 11 (October), the smallest model formed the validation call and was served. At an offer of 100: the 0.8b invented a tool and errored; the 2b could not locate the tool and fell back to a read that was served; the two coder models could name the right call in text but never fired it; and the 3b general model invented names, then invented a result. Offer width is no longer a suspicion. It is the variable that has bitten at every size tried.

The 100 tools, parsed

The offer of the second-machine run, wizard by wizard — parsed from the manifests themselves

The run above offered 100 tools — every tool of two classes out of the 139 listed in 12 manifests: text tools (39), which work only on text they are given, and files tools (61), which read files — and for those, every path named must sit inside a live grant. The other 39 were not offered, each for its own reason: 32 belong to a class the bridge never serves no matter how it is switched, 6 run code — all of them one wizard's — and were left off by the owner's choice, to be switched on one at a time, double-asked, only when a run calls for one, and 1 drafts. The twelfth wizard contributes none of the hundred: its 11 listed tools are all of the never-served class, because what it certifies is a person's act, not a model's.

In the second-machine run, one of the hundred was exercised to a served call. The other ninety-nine stand ready — each one a demo this page can still gain, run the same way: asked for by a seated model, checked by the gate, receipted either way.

More demos from the house

The free Toolkit, feature by feature. On November 9, 2026, the Wizard Central Toolkit's whole demo section ran live — 19 sections, every feature exercised against real fixtures — and days later the shipping gate for the current version closed at 561 passing. The full record: Toolkit Feature Evidence.

A fresh install, in other hands. On November 8, 2026, a first-ever install on a new machine wrote its first receipt, and the hash chain verified intact — the receipts machine working, start to finish, for someone who had never touched it before. The full record: Wizard Central Pro Feature Evidence, which also carries the reference test loop, green at 67 of 67 files.

The Arbiter, sealed and verified. Two integrity baselines — 57 files, then 76 — both verify clean, and the Arbiter's own bridge serves exactly 8 read-only tools with its suite at 149 of 149. The full record: Arbiter Feature Evidence.

The prototypes. Four working miniatures of designs the house has ruled on — the floor, the broker, the hub, and the start lock — every one of them built to the house laws and run by the owner's own hand: 21 of 21, 17 of 17, 18 of 18, and 26 of 26. Their own page carries each Terminal Record in full: Prototypes.

What is still open

One completing proof is still owed, and this page names it rather than letting the records above sound finished: the free toolkit’s demo section names a real-seat run — its seat-dependent features run against a live local model on the author’s machine — as its completing proof, and that run has not yet landed. The note stands on the toolkit’s feature evidence page, where the run’s Run Record will join it; when it lands, this note comes off.

Generous software, with built-in privacy.

— Alexander

MathSphere Nexus official corporate seal