GitHub Action · MIT · traces the model, never runs your training

The pre-check on every model change PR.

Today the bot gives two of the pre-check's four answers on the pull request: what changed in the model's structure, and what it needs. Every pull request that touches a model gets its peak memory at your batch, the smallest card it fits and what one run costs, before the job takes a reservation. A change that will not fit your card, or will not run at all, turns the check red. The memory number is fitted on 178 measured runs (held out, median error 7%; 14% on 25 runs measured after the fit). And the bot keeps the row, so the next plan can say what this structure did last time: history Last time this structure trained here: valAcc 0.9865, 3 epochs, <$0.01, 34s, 2026-09-04 That one is real, from model-ci-example#2, out of a ledger that holds your organisation's runs and nobody else's. It is event-driven (pull requests, comments, a weekly clock), it uses tools (the tracer, the verifier, the plan, git, the training runner), it acts on its own (opens fix pull requests, submits jobs when asked), it verifies its own work with a deterministic gate before pushing anything, and it remembers outcomes in a ledger the next change is checked against. Dependabot did this for dependencies.

Install in one click Or in two files, traced See a shared plan See it on a real PR Paste a model, get the plan

Plan and block are shipped. Fix pull requests and /neurarch train are in progress. Neither artifact below is a mock. Both are copied from a real run and link to it.

One command, one card
zsh
$ 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
Every pull request that touches a model
neurarch bot commented on model-ci-example#2

Neurarch plan

models/small_cnn.py:SmallCNN will run

SmallCNN: 21 layers, 1.1M params, will run, fits a T4, about $0.05 to train, vs SmallCNN: params +978.9K

Layers / params21 / 1.1M (+978.9K, +693%)
Shape[3,32,32] -> [10]
Will it runyes, 0 warnings
GPU fitT4 yes · A100 40GB yes · H100 80GB yes (memory +0.02 GB)
Est. training~$0.05 / 3m on A10G (24GB) (+<$0.01)
Blast radius7 downstream layers from 8 touched
~ features.3.0.outChannels 64 -> 256 ~ features.4.0.inChannels 64 -> 256 ~ features.6.0.outChannels 128 -> 192 ~ classifier.2.inFeatures 128 -> 192
✓ Neurarch plan passed · one comment, updated in place on every push
Install

Install in one click.

The GitHub App reads the model files a pull request changes and posts the same plan card, with no file to commit and no account to create.

Add the Neurarch App to a repository

It asks for three permissions: read your repository contents, read pull requests, write issue comments. Nothing else. It never pushes, never opens a pull request, and never runs your code.

The hosted App reads your source statically, and that is weaker. A serverless function has no torch, so it cannot trace a forward pass: it recognises the layers assigned in __init__ and nothing built at runtime. Every comment it posts says so and lists the layers it could not read. For the real graph, the two-file Action below installs torch and traces it, and it is the way to get a traced plan and (later) training from a comment.

Install

Or install in two files, and get a traced graph.

One workflow, one config that names the models and their input shapes. The bot traces a forward pass in CI, so it works on models built at runtime: from_pretrained, timm factories, architectures across a dozen files.

.github/workflows/neurarch-bot.yml
name: neurarch-bot
on: [pull_request]
permissions:
  contents: read
  pull-requests: write
jobs:
  plan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: neurarch-ai/neurarch-bot@v0
.neurarch.yml
models:
  - path: models/gpt.py:GPT
    input: 1,128:long
  - path: models/resnet.py:ResNet18
    input: 1,3,224,224
policy:                      # optional, coming with phase 3
  max_params: 200M
  must_fit: A100-40GB
  forbid_types: [softmax]

No account needed. An API key (Settings → Developer API) lifts the anonymous rate limit and, later, turns on the ledger. Try the same plan locally first: pip install neurarch-trace.

Who opens the pull request

Every model pull request now has an author who is not on your team.

Coding agents in the editor change model files as part of ordinary work. Research agents sold as products run experiments on your stack and open pull requests with a promise attached: better than your baseline, on your own evals. Approving that pull request is still your job, and so is being able to say afterwards what changed, what it was quoted, and whether it ran. The bot writes that record on the same pull request the promise arrived on, from the graph, the same way for every author.

The promise"Beats the baseline" is a claim about a run. The record is which graph, which base it was compared with, what it was quoted, and whether it ran at all. The plan comment carries the first three from the graph alone; the fourth lands in the ledger when a run goes through the API.
The changeLayers added and removed, parameter count before and after, GPU fit before and after, blast radius, and the exact lines that changed structurally. Nothing in it is a judgement of the author.
The gateA graph that cannot forward-pass goes red before any queue sees it. Deterministic, so an agent that retries the same change gets the same answer, and a reviewer reading the check knows it is not an opinion.
Install neurarch-bot Or run the check inside your network
On every pull request

What it does, and what it does not do yet.

shipped

plan

Traces base and head, posts one comment: layers, params and the delta, GPU fit, estimated cost and the delta, blast radius, the exact lines that changed structurally. Updated in place on every push, never duplicated.

shipped

block

A graph that will not forward-pass turns the check red. Deterministic: the same graph gets the same answer every run, which is what a gate in front of a GPU queue needs.

in progress

fix pull request

On a blocker the bot opens a branch with the patch, re-traces, re-plans, and pushes only if the new plan is legal. Exact fixes need no model call; proposed fixes are verified in your CI before anything is pushed.

in progress

/neurarch train

Comment on the PR and the bot submits the job, watches it, posts the curve and the metrics, and writes the outcome to your ledger so the next change is checked against what actually happened.

Privacy

What leaves your repository.

The graphLayer types, shapes, parameter counts and connections, as a JSON graph. That is what a plan is computed from and all the bot sends.
NeverWeights, data, training scripts, environment variables. The bot runs the forward pass in your CI runner; the server never runs your code.
Only on requestA public link exists only when you pass --share or set share: true. Shared plans are stored at an unguessable URL and say so on the page.

The full contract is in docs/DATA_POLICY.md; the site privacy page is here.

Why not just ask Claude

Three things a model call cannot be.

Remembers what trainedThe ledger pairs a structure with what it cost and how it scored, in your organisation, and the next change is checked against it. No model has that data, so no amount of reasoning recovers it. It is a different axis from intelligence, not a better score on the same one.
Deterministic at the gateA frontier model gives a different answer on a different day. The bot's gate is a graph check with a published error rate: across 264 graphs, every design it blocked crashed in PyTorch forward and every design it passed ran clean.
Lives in your CIIt runs where the code already goes, on every pull request, with no one opening a new tool. A model in a chat window is a suggestion; a red check is a control.
The honest part: at picking which of two legal designs will train better, a frontier model reading the code beats our static score. We measured it on our own held-out designs and publish the number in CALIBRATION.md. The bot does not rank two legal designs. It tells you what each one costs, whether it runs, and what happened last time.