Operate on real models. Prove every cut.

A visual operating theatre for neural networks in your browser: load a real model file, see its anatomy in 3-D, operate with reversible tools, measure every consequence, and export with a cryptographic record anyone can verify.

No. Every operation is point-and-click. Code only appears in what you *export* — scripts and a notebook you can run elsewhere.

Yes — that's a core design promise. Models are parsed like documents, never executed, so a booby-trapped checkpoint has nothing to run.

No. Your original weights are byte-preserved for the whole session. Edits (excisions, grafts, renames, merges) are a *surgical plan* layered on top; nothing is applied to the actual bytes until you export, and the export writes a new file. Undo/redo can walk the entire plan back at any time.

Everything is purged — model, edits, generated assets. Sessions are ephemeral by design (AI sovereignty). Use Save Theatre first if you want to resume later.

No. The only internet-touching features are the ones you explicitly invoke: pulling from Hugging Face and pushing to Hugging Face. Both are labeled as such.

Free accounts open models up to 1 GB — plenty for most vision models, distilled LMs, and every teaching template. Practitioner raises the ceiling to 20 GB for .safetensors files, which stream to disk and are read piece-by-piece. Other formats (.pt, .bin, .ckpt, .onnx, .h5) cap at 1 GB in every tier because they must be fully unpacked in memory — the refusal message says so honestly.

Yes — generate a blank teaching model from eight architecture templates (transformer, CNN, SNN, GNN, and more) and operate on it.

Load anything → delete a mid-chain node → ↩ undo it → Δ Diff. Sixty seconds, and you've done measured, reversible surgery.

Two tiers. Free (signup required): 1 GB models, every template, full 3-D anatomy and search, all surgical operations with unlimited undo/redo, recipe (ops.yaml) download, and in-app measuring. Practitioner: $39/month or $390/year (two months free) adds the 20 GB ceiling, signed exports with GGUF and the retraining kit, live execution on the validator (Test, Generate), Δ behavioral Diff, Hugging Face push, Provenance Compare, read-only share links, Save/Restore Theatre, and the Chimera Ward. Verification of exported packages is free for everyone, forever — no account.

PyTorch (.pt/.pth/.bin/.ckpt, including full pickled checkpoints like YOLO), safetensors, ONNX, Keras/H5, and sharded zip checkpoints.

Yes — paste any public repo id into the Hub field, or one of your own private repos with a read token (used for that pull only, never stored). Two million models, one field. Big pulls show live progress (megabytes, total, percent) right in the drop area, and every loading control locks until the model lands, so you can't collide two loads.

Excise (), graft from the component library (118 research-backed parts), transplant weights (Ctrl+C/Ctrl+V), ⇄ replace, rename/reparent, ◧ F16 quantize, and Chimera merges.

Everything, until export. ↩/↪ walk the full history.

Advise → apply the top compute-share candidates → Δ Diff to confirm output cosine ≥ 0.90 with argmax unchanged → export.

A real sample (synthetic, your image, or your text) run through the live table by the validation service — layers glow by activation heat, hot cores swell, dead channels flag red.

Original vs edited on the *same* sample: output cosine, L2 shift, argmax stability, and an activation-profile cosine over shared stages that survives shape-changing surgery.

The edited model (safetensors, plus optional GGUF), a signed operation lineage, a fingerprint manifest, an auto-written model card, a stdlib verifier script, and a retraining kit (loader, fine-tune script, notebook, dataset onboarding).

An HMAC attestation over every operation and every file fingerprint — change one byte anywhere and verification flips to TAMPERED.

Two ways, both free forever: the public verify page (drop the zip), or the bundled verify_package.py — pure standard library, works fully offline and air-gapped, no account.

Verify the fresh package → ✔ VERIFIED. Copy it, flip one byte, verify again → ✖ TAMPERED. That's the whole story.

Your finalized surgery exported as ops.yaml, replayable headlessly with the CLI against a fresh checkpoint — or a whole directory of nightly builds — each output independently attested. The CLI ships as the thin client on PyPI: pip install falconsai-surgeon; an air-gapped install takes the wheel and its sha256 from /download/ on your server; compare, quantize and fold still run from a copy of the repository until the server runs them as jobs, failures exiting loudly.

No — it travels in a header (never a loggable body), is used once server-side and discarded, is wiped from the page the instant the request sends, and is redacted even from diagnostic logs.

Yes — finalize once visually, export ops.yaml, replay across a directory with the CLI: summary table, per-model attestation, nonzero exit on any failure. Built for CI gates. The CLI ships as the thin client on PyPI: pip install falconsai-surgeon; an air-gapped install takes the wheel and its sha256 from /download/ on your server; compare, quantize and fold still run from a copy of the repository until the server runs them as jobs.

The advisor is a heuristic; costing is roofline; imaging covers common conventions (fused GPT-2-style attention shows honestly as unexecuted); provenance yields findings, not verdicts. Certified users state the limits *first* — so does the model card.

Yes — the bundled verify_package.py is standard-library only and runs air-gapped.

Trust compounds when *recipients* can check claims — the free verifier is the product's growth loop and its ethics in one feature.