Design, lint, and cost-check a model before you train it. 41 structural checks run as you build, so the shape bug and the blown budget surface in the editor, not three hours into a GPU run. The graph is yours to read, edit, and export as the PyTorch you would have written.
Watch an agent design a model and a verifier grade every edit. No LLM judge, no GPU.
Your sketch has no tensor shapes, no validation, no link to running code. By Monday you can't read it either.
print(model) isn't an architectureA 200-line tree dump won't show data flow, won't catch the wiring bug, won't fit in a Slack message.
Figure 2 is pretty. The actual layer order, init, and shape contracts are buried in 40 pages of methods.
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, stage a free real-GPU Colab run with one pasted cell, 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.
+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. A one-click notebook trains on a free Colab / Kaggle GPU and streams curves and the checkpoint back. 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 |
|---|---|---|---|---|
| Natural language → architecture | ✓ | ✕ | ✕ | ✕ |
| 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) | ✓ | ✕ | ✕ | ✕ |
| 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 | ✓ |
.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.
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 →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 on managed A10G / A100 with live streaming, no notebook round-trip. The trainer and runner UI are built; the hosted GPU pool comes online with billing.
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 (Llama, Mistral, Phi), pick a HuggingFace instruction dataset, and Modal handles the LoRA loop. Tabular and image fine-tuning already works today.
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.