NeuroScan Start free

Your Python codebase, edge by edge.

NeuroScan scans a Python project, draws the call graph it really has, names what is broken, and returns patches its own checker has passed.

1,122 functions mapped from the parsed tree in seconds on httpx. Reading your code is never charged for.

demo/· the sample project, analysed live Open full screen ↗
Hover a module for its calls · click it for the findingsTap a module for its findings Parsed, not guessed
Free tier
5 projects
and one AI fix on the house. No card.
The analysis
0 tokens
the findings come from the parsed tree, and it is never billed
A fix, on average
160 tokens ≈ $1.60
160k model tokens, re-checked patch by patch
One model call
1–3 tokens
measured 1,050–3,000 model tokens per call

The graph, the findings, the fix

One run returns three things that refer to each other: a map you can walk, findings with their evidence, and patches that have already survived the analyzer.

  1. A call graph, resolved from the tree

    Packages open into modules, modules into classes and methods. A block carries its signature, its file and line, its length, its complexity and how many functions call it. Imports, constructors and self.x = Cls() assignments are read from the parsed tree. Nothing is matched from text.

  2. Findings with their evidence

    Twenty-two check codes across twelve areas. Every finding has a severity, the file and function it sits in, and a note on how solid the evidence is. A finding that depends on edges the parser cannot see is marked open, not confirmed.

  3. The coverage ledger

    The report says what it opened: modules, classes, functions, call edges, lines. It says how many check families ran. Every family carries a count, including zero, so a clean report and an unvisited file never look alike.

  4. Fixes judged by the checker

    A patch is built against a copy and must clear the gates before you see a diff: the file still parses, the finding is gone from a fresh analysis, no public name has disappeared, and no noqa was added. If nothing passes, you get a plan instead of a broken diff.

The call graph of the sample project: nine module blocks joined by arrows, with the two import cycles marked in red
demo/: the sample project, drawn by the same code that runs on your upload. The red arrows are import cycles: demo.app calls demo.service, and demo.service calls demo.app back.

The three screens you will actually use

Nothing here is a mock-up. These are captures of the product on the sample project, and the live version of each is one click away.

The upload screen: a drop zone for a .zip file and a field for a public GitHub repository URL
Upload. A .zip, or a public repository, on the sample project.
The report screen: the call graph on the left and, on the right, the package tree and the findings with their check codes
Read. The graph, then the package tree and every finding with its check code.
1 patch4/4 gates passed
--- a/demo/util.py
+++ b/demo/util.py
@@ -18,7 +18,8 @@
 def grow(rows, out=[]):
-    for r in rows: out.append(r)
+    out = list(out) if out is not None else []
+    for r in rows: out.append(r)
     return out
parses · finding gone · no name lost · no noqa
Fix. The diff that passed the checker, or a plan instead.

Every check, and where it draws the line

Twenty-two codes in twelve areas. The code is the contract. The wording of a finding may change, the code does not.

Three steps, one upload

No install, no configuration file, no build step. The server parses the tree with Python's own ast module and sends the report to your browser.

  1. Upload

    A .zip up to 200 MB (1 GB once unpacked, 4,000 files at most), or a public GitHub URL, with an optional branch and subfolder. Files that look like secrets are dropped before anything is read, and credentials inside .py are replaced with ***REDACTED*** before the model sees the file.

  2. Read

    The analyzer parses every .py, resolves imports and calls, and runs all 22 checks. The AI descriptions and the overview are written here too, and neither stage is metered: together they cost 0 tokens. Click a block for its panel, double-click a module to open it, and jump from a finding to the function it belongs to.

  3. Fix

    Tick the findings you want, or fix all of them. The fixer writes a patch, the server applies it to a copy and runs the gates; if the finding survives, the model is told what the analyzer still reports and tries again. You get the diff that passed, or a plan that says what to change. Then the patched tree as a .zip.

Upload
200 MB zip · 1 GB unpacked · 4,000 files
Read
22 checks in 12 areas · 0 tokens
Fix
1–3 tokens a call · up to 25 held during a run
Hand back
The patched tree as a .zip
a run of the analyzer
$ archscan analyze ./demo.zip

Three reports you can open now

Real repositories, analysed by the same static pass that runs on an upload: the graph, the findings, the source. No account, and no AI summary in these three.

httpxHTTP client · encode/httpx · BSD-3-Clause
1,122functions
43findings
Open ↗
FlaskWeb framework · pallets/flask · BSD-3-Clause
1,431functions
114findings
Open ↗
RequestsHTTP for humans · psf/requests · Apache-2.0
691functions
109findings
Open ↗

Each file is the export the product writes: one HTML, no server, no network. The licence text travels inside it, with the source it covers.

Pay for fixes, not for analysis

The graph, the findings and the AI descriptions cost nothing on every account. You pay only for the fixes, and every model call reports its own token count, and that number is what gets deducted.

Free
$0
  • 5 projects
  • 1 AI fix for the account
  • The full call graph and every finding
  • The patched project as a .zip
  • No card, no subscription
Start free
Tokens
$5 minimum top-up
500 tokens · $0.01 a token · 500,000 model tokens
  • Tokens never expire
  • Unused tokens are refundable for 14 days
  • Paid in crypto: the invoice quotes the exact coin amount
Top up
Biggest pack
$20
2,500 tokens · $0.008 a token · 2,500,000 model tokens
  • Five times the tokens of the $5 pack
  • One fix of a 1,000-function project costs about 160 tokens
  • Analysis stays free, whatever you buy
Top up
$5
500 tokens
$0.01 a token, $10 per million model tokens
$10
1,250 tokens
$0.008 a token, $8 per million model tokens
$20
2,500 tokens
$0.008 a token, the best rate we offer

Top-ups are paid in crypto, and only in crypto: our provider NOWPayments hosts the invoice, shows the exact coin amount and forwards the payment straight to our wallet, so we never hold your funds and there is no card on file to charge. Prices are in dollars; the invoice quotes the coin at the rate of the moment. Before a paid run the app says how many tokens it will hold, and whatever the run does not spend is released.

Before you upload your code

Where does my code go?

Your source sits in the server's memory while a report can still be fixed, an hour at most, and it is never written to our logs. The report itself is kept in your browser, not in our database. Slices of source go to Ollama, Inc. in the United States, our only AI processor, and are never used to train a model. Files that look like secrets are dropped before upload, and credentials inside .py are replaced before the model reads the file. Deleting the account removes the account and its sessions immediately.

Which languages?

Python. Every .py is parsed with Python's own ast module, which is why the call graph comes from the code rather than from text matching. Other languages are counted and listed in the report but not parsed.

Is the graph real, or guessed?

Resolved, not matched from text. One heuristic remains: when a method name is unique in the project and the receiver's type cannot be proven, the edge is drawn and marked as inferred, so it renders dashed. Where the analyzer cannot see at all, a star-import or a computed lookup, the report names it as a proof gap and the findings that depend on it are marked open rather than confirmed.

What if the AI fix is wrong?

Nothing is applied to your files. A patch is built against a copy and must clear the gates before you see a diff: the file still parses, the finding is gone from a fresh analysis, no public name has disappeared, a call the code already made is still made, and no noqa or type: ignore was added. If nothing passes, you get a plan instead of a broken patch. If a free fix produces no patch at all, the allowance comes back.

Can I get an invoice?

Yes. The invoice page you pay from is the record of the payment: it carries the order number, the coin and the amount, and the transfer itself sits on a public blockchain anyone can check. Need a PDF with our company details on it — write from the email on the account to support@neuromomen.com and we send one the same day.

Can I get a refund?

Unused tokens are refundable within 14 days of the payment, in full or in part, at the pack rate. Tokens already spent on fixes are not, because the model calls behind them have already been paid for. A duplicate, failed or unauthorized payment is refunded in full. Write from the email on the account to support@neuromomen.com with the order number.

Who may use it?

Anyone 18 or older. You create an account with your own email, and the code to confirm it comes to you.

Do I need to keep the code somewhere?

No. The analyzer runs on the server and the report is kept in your browser, so you can close the tab and come back to the same report on the same machine. Nothing about your project has to live in a repository first.

Start with the graph