Neurarch is the agent in your repo that plans every model change, blocks the ones that will not run, and remembers what trained. One command gives you a plan you can share.
The one line in that plan no frontier model can write, because the data is not in it:
history Last time this structure trained here: valAcc 0.9865, 3 epochs, <$0.01, 34s, 2026-09-04
That row is real, off a pull request, out of your own organisation's ledger and nobody else's.
Same verifier behind all five. One is a recording of the whole loop; the other four are places to run it where you already work.
www.neurarch.com/watch
Try it
Paste a model, get the card. Nothing to install, no account.
www.neurarch.com/try
The bot
Two files in your repo, and every pull request gets a plan.
uses: neurarch-ai/neurarch-bot@v0
MCP server
Your coding agent gets the graph, and the checks, as tools.
claude mcp add neurarch -- npx -y neurarch-mcp /abs/path/to/model.py
The API
plan, check, rank, fix, train, history. Over HTTP, no model call.
curl -sS https://www.neurarch.com/api/v1/check
One command traces a forward pass and prints a plan: params, will it run, GPU fit, cost. Real output, real link.
$ neurarch-trace torchvision.models:resnet18 --input 1,3,224,224 --plan --share Plan: resnet18 68 layers · 11.7M params · fingerprint 9ea7d4ae shape [3,224,224] -> [1000] will run yes (0 blockers, 0 warnings) fits T4 16GB yes · A100 40GB yes · H100 80GB yes train ~$0.11 / 6m on A10G (24GB) (10 epochs, batch 32, 50k samples assumed) Share: https://www.neurarch.com/p/r7rq5c4jt2
pip install neurarch-trace
It compiles, forward-passes, and trains to the last epoch. No stack trace, no failing check, nothing to grep for. You learn it was the wrong one after you paid for it.
To tell two legal designs apart, you train both. That is the price of one answer to one question, and you ask it again every time you change something.
Across 24 designs we trained on a real GPU, outcomes ran from 6.8% to 97.2% while static scores barely moved: Spearman 0.17, essentially uninformative. We publish our own number because closing that gap is the product. See the 24 rows →
Head divisibility is one of 41 structural checks that run as you build. See real bugs caught before the GPU bill →
Real session, no cuts: a model on the canvas, then which GPU it fits, in 17 seconds.
One continuous take on the live app, captioned: sketch layers by hand while Tab autocompletes and wires the next one, let the AI complete the design without touching your layers, or describe the task and the wizard loads BERT. Read the design-time serving physics, KV cache, hardware fit and cost per million tokens before a single training step. Run the Model Audit with its GPU-fit table and GQA / MLA what-ifs, flip on the roofline overlay, let the agent deepen the encoder, then training, evaluation, deploy, and the same graph as PyTorch and TensorFlow side by side. Browse the Studio's derived artifacts and the community gallery, audit any HuggingFace model (Qwen-2.5 7B), open it on the canvas folded to blocks, and export a publication-ready figure. Design, lint and cost it before you train.
Recorded against production on a free-to-start account: the task wizard assembles a CNN, the pre-launch card quotes the run ($0.04 on a T4, auto-stop at your budget), real loss/accuracy curves stream back from the GPU, and the pipeline carries the run through Evaluate (which flags the model's own overfit) into the Deploy advisor's pricing ($0.16 per million requests). Only edit: the mid-run wait is fast-forwarded 16x. No card required for the free path: the same project exports as a Colab notebook that trains on a free T4 and reports back, and simulation mode stays free for design iteration.
+RandAugment. Generated vit_cifar.py + training script.
Every step above is a real action in the app, not a script. Try it yourself →
Names anonymized while we collect attribution permission · roles representative of actual users
Catch defects straight off the camera feed. Small enough to run on the line's edge hardware.
Read every ticket. Route it by urgency and department. Walk away with the fine-tuning code.
Watch the sensor stream. Flag the failure before it happens. Variable-length sequences handled.
Paste the arXiv link. Get the actual wiring, not Figure 2. Diff it against your baseline and train.
Two towers, user and item embeddings. Trained on your interactions. Shipped as code you own.
Fits in 10 MB. Runs on a phone CPU. Quantization preview and hardware-fit analysis built in.
Sketch it yourself, or let the agent draft one from a spec like "10-class image classifier on 224×224 RGB". Either way the graph is typed and yours to edit.
41 structural rules and shape propagation run as you build: head divisibility, shape mismatches, dead paths, blown param and KV budgets. The wiring bug shows up in the editor, not three hours into a GPU run.
Run training. AI reads the loss curves, diagnoses overfitting or underfitting, and applies targeted fixes.
PyTorch, Keras, ONNX, Jupyter notebooks. Clean readable code that runs without any Neurarch import.
Everything on the left lands in the same typed graph. Everything on the right is generated from it: runnable, readable, yours. No third-party tool to host, no plugin to babysit.
shapes · lint
params · serving cost
182 layer types + 75 macro blocks. Tensor shapes propagate automatically. Dimension mismatches caught before you train.
The agent has access to your selected layers, the shape trace, and the lint output. So when you ask "why's this exploding?", it answers from your model, not a textbook one.
Catches vanishing gradients, missing normalization, GQA head mismatches, MoE aux-loss, overfitting risk, ordering errors before you waste compute. See the full rule book →
Paste a paper URL. The agent parses the architecture and builds it on the canvas. Diff against your version.
Paste an HF model ID, get a clickable architecture. Useful when you want to read what BERT or LLaMA actually does instead of skimming the config.
PyTorch, Keras, ONNX, Jupyter notebooks, PDF reports. Full training script with optimizer and scheduler.
Drop a CSV, pick a HuggingFace dataset, or upload an image-zip. Train free on a Colab / Kaggle GPU via a one-click notebook, or run in-app on managed GPUs (T4 to H200) with live curves. AI diagnoses the results and proposes the patch.
Save architecture checkpoints. Diff any two versions. Compare training runs side-by-side, mark a best run, re-use a config in one click.
Live cursors, shared canvas, team model library. Built on our own WebSocket layer, no Pusher / Liveblocks dependency. Launching with Pro Plus.
Every layer carries provenance. One canvas state generates a TikZ figure, a "Methods" paragraph, and a BibTeX file with the right entries cited. Authoring path for ML papers, not toy demos.
Drop a screenshot of any architecture diagram. Vision LLM rebuilds nodes + edges (residuals included). Skip-edges get bowed routing so the result reads like the original figure.
Point at a paper and your nn.Module source. Per-layer drift report: dimensions, activations, ordering, missing residuals. Catches re-implementation bugs before review.
Edit code in Monaco, parse back, the canvas only updates what changed (matched by name first, type-ordinal second). BERT's two norm layers don't collide; residuals survive when you parse the edited code back.
Latency / FLOPs / size / energy on 7 platforms (mobile, browser-WebGPU, Coral edge-TPU, A100, …). Quantization variants table, perf-budget gauge, smell detector with clickable layers, comparison vs LeNet → Llama-3.
Export a real .onnx straight from the canvas, drop it back in the browser to run inference live (WASM + WebGPU). Top-5 softmax bar, no server round-trip. CSV upload auto-infers the task before you even build.
| Capability | Neurarch | HF AutoTrain | Google AutoML | Write code |
|---|---|---|---|---|
| Typed graph you can edit (not a read-only view) | ✓ | ✕ | ✕ | ✕ |
| Semantic checks (head divisibility, norm placement, aux loss) | ✓ | ✕ | ✕ | ✕ |
| Serving physics before you train (KV cache, GPU fit) | ✓ | ✕ | ✕ | ✕ |
| Architecture lint (gradient / overfit / order) | ✓ | ✕ | ✕ | ✕ |
| Natural language → architecture | ✓ | ✕ | ✕ | ✕ |
| Import arXiv paper → canvas | ✓ | ✕ | ✕ | ✕ |
| Import any HuggingFace model | ✓ | ✓ | ✕ | manual |
| Import .onnx / .safetensors → editable canvas | ✓ | ✕ | ✕ | ✕ |
| PyTorch + ONNX code export (you own it) | ✓ | ✕ | ✕ | ✓ |
| AI reads training curves + targeted fixes | ✓ | ✕ | limited | ✕ |
| Real-time team collaboration | Pro+ soon | ✕ | ✕ | ✕ |
| Free to start | ✓ | ✓ | trial | ✓ |
AutoML hands you a black box and a number. Great if the number is good enough. If it isn't, you have nowhere to start debugging. Neurarch shows you the layers, the shapes, and the code, so when it goes wrong, you know which line to change.
print(model)
| Capability | Whiteboard / Excalidraw | print(model) |
Netron | Neurarch |
|---|---|---|---|---|
| See full layer graph | manual | tree only | ✓ | ✓ |
| Tensor shapes verified end-to-end | ✕ | if forward runs | ✓ | ✓ |
| Edit graph + re-export code | ✕ | ✕ | read-only | ✓ |
| Architecture lint (gradient/overfit/order) | ✕ | ✕ | ✕ | ✓ |
| Build from prompt or arXiv paper | ✕ | ✕ | ✕ | ✓ |
| AI reads training curves + applies fixes | ✕ | ✕ | ✕ | ✓ |
| Shareable URL of your architecture | screenshot | ✕ | file only | ✓ |
| Dimension | LLM writes PyTorch | Neurarch |
|---|---|---|
| What the model lives as | free-form code | typed graph + the same code |
| Edits checked before they apply | ✕ | 41 structural checks |
| Head-dim / GQA / merge bugs surface | at GPU time | in the editor |
| Cost to verify one edit | a forward pass | 0.27 ms, one laptop core |
| Does the verdict track reality? | untested | 96/96 blocked graphs crash PyTorch |
| Do passing designs actually train? | find out on the GPU | 24/24 trained end-to-end on a managed T4 |
| Blast radius of a change | grep and hope | impact analysis per edit |
| You own the code | ✓ | ✓ |
An LLM writing PyTorch is fast and often right. The problem is the edit nobody checks: the head count that stops dividing the embedding dim, the Linear that no longer matches its upstream width. Those compile, pass review, and fail on the GPU you already paid for. Because Neurarch keeps the model as a typed graph, every edit (yours or the agent's) is verified in under a millisecond before it lands. In a 264-graph study, all 96 designs the verifier blocked crashed in PyTorch, and all 80 it passed ran clean. The loop now closes upward too: in the grounded benchmark split, all 24 verifier-passed designs (18 by frontier models, 6 human references) trained end-to-end on a managed T4 through the production trainer. On 4 of 5 classification tasks, the best verifier-passed model-generated design finished at or above the human reference's accuracy after identical real training; on the other task, every generated design trained to noise. The designs that trained to noise are the failure class no static check can see, which is exactly why training outcomes feed back into the checks. The 41 checks are public, rule by rule.
.onnx or .safetensors file onto Neurarch, we reconstruct the full graph as editable canvas nodes.
Modify layers, fix architecture issues, run training, and export clean PyTorch code.
Netron shows you what a model is. Neurarch lets you change it.
Beta pricing, rates lock in for life when you subscribe during early access.
Need invoicing, a custom seat count, or on-prem? contact us →
No accounts required for the canvas, agent, or export. When you BYOK, the request goes browser → provider, we're not in the path.
Architecture, prompts, and pasted code live in browser memory only. Refresh the tab to wipe them.
Your Anthropic / Gemini key is stored in your browser's localStorage, sent directly to the provider, never to our servers, and wiped when you sign out or switch accounts.
Browser → Anthropic / Google. We're not a man-in-the-middle. Open the network tab and verify it yourself.
Local snapshots stay in browser memory. Cloud save (Pro) and team workspaces (Pro Plus) are explicit actions, one-click delete from the dashboard at any time.
24 designs that all passed the verifier and all trained end to end on one T4 finished between 6.8% and 97.2%. Spearman between static score and trained outcome: 0.17. Every row is on the page, both ways of pooling it, and the part we have not closed yet.
Read the calibration →The Arch-Bench arena shows a model a design spec and a starting graph, takes structured edits, and grades the result with a deterministic verifier. No human judge, no LLM judge, no GPU. Every leaderboard row reproduces with one command.
Enter the Arch-Bench arena →A gym for architecture design: reset to a design spec and a starting graph, take typed structured edits, get back a deterministic, verifiable reward. No LLM judge, no GPU. GRPO-ready, one command to run.
Open the environment →POST a graph to /api/v1/check and get back what the app shows a human: can it train,
what would the run cost, where should it serve, and what is still a person's decision. Same code
path, no browser, no LLM. Built for an agent that generates a design and needs to know if it holds.
Structural bugs don't fail in code review. They fail at forward time, on hardware you already paid for. A running list of real bugs the structural checks intercepted at design time.
Read the case list →KV cache per token, GPU fit, cost per million tokens. The same estimators the in-app Model Audit runs, validated against published serving numbers.
Open the calculator →Authoring surface with automatic tensor shape propagation, 41 structural checks, and drag-and-drop editing.
Tell the agent what you're building. It picks the layers, wires them up, and patches its own mistakes when the advisor flags something.
Paste any arXiv URL or HF model ID and the architecture appears on your canvas instantly.
Production-ready code, full training scripts, Jupyter notebooks, you own the output.
One-click notebook that trains on a free Colab or Kaggle GPU and streams loss curves, eval metrics, and the best checkpoint back to your account. Drop a CSV, pick a HuggingFace dataset, or upload an image-zip. AI diagnosis of the results.
The same runs in-app on managed GPUs, T4 up to H200, with live loss curves and no notebook round-trip. Per-plan runtime and budget caps enforced server-side.
Export the canvas to a real .onnx file, right in the browser. Drop any .onnx back in to run inference live (WASM + WebGPU). Plus Docker / FastAPI / training-script bundles for deploy anywhere.
Every layer carries provenance (paper / HF / manual). Generate a TikZ figure, a "Methods" paragraph, and a BibTeX file with the right entries cited, straight from canvas state.
Live cursors, shared canvas, team model library. Pro Plus feature launching with Stripe billing.
Pick a base model, pick a HuggingFace instruction dataset, and the managed GPU runs the LoRA, QLoRA or DoRA loop with the loss curve streaming back live. The trained adapter is kept, so you can serve it behind an OpenAI-compatible endpoint in one click. Open-weight bases (Qwen, Phi, Mistral) work as they are; gated ones need your own HuggingFace token.
Trained model + auto-generated card → pushed to your HF account in one button. Local Docker / FastAPI deploy bundles already work today.
Full canvas + AI agent + code export on the free plan.
Drop your email to get Pro updates and early access pricing.
No spam. Or just open the app now →
Add this badge to your README, notebook, or paper to show the architecture was built with Neurarch.
Click to copy Markdown
Bug reports, feature requests, partnerships, design partners, investor intros, fastest way to reach us is email or GitHub.