Script Radiens: automation you can read, run, and vouch for.
RadiensPy and the Radiens CLI are the free programmatic tools of Radiens. They carry the hard, large-data computation behind a clean API — so your automation stays small, readable, and reproducible: scripts a lab can own, maintain, and vouch for, long after the person who wrote them has moved on.
Automation you can own.
Today the lab's automation is amateur code that grows messy, breaks when its author graduates, and — increasingly — an agent that answers confidently but can't be checked. With Radiens, the hard computation lives in a verified engine, so what you keep is a small, readable script you can read, run, and stand behind.
Low-code and readable
The API carries the complexity; your script stays small enough to read, understand, and trust.
Outlives the author
A thin script over a stable engine — the lab can maintain and re-run it after its writer is gone.
Absorbs the scale
The compiled engine handles the large-data design, so simple logic runs across thousands of sessions.
Agents on a leash
An AI operates the same auditable, provenance-stamped interface — readable calls, not a black box.
You'll be accountable for code you didn't write.
In most labs the automation is written by trainees who are not paid to be software engineers — scripts grow large and messy, and the person who understood them leaves within a few years. Now add agents: someone will feed a data matrix to an AI and get back a fluent, confident answer. Your name is on the result — so how do you know it is right? The answer is not to automate to zero, and not to trust the black box. It is to keep the automation low-code and readable: let RadiensPy carry the sophisticated, large-data work behind a clean API, so what remains is a small, straightforward script you can read, run, and vouch for — and let an agent operate that same interface instead of guessing.
RadiensPy: convey accurate data in a few lines.
Discover a workflow in the app; script the same operations in a short, readable file.RadiensPy is free at every tier — a professional-grade Python client over the same compiled engine that powers Allego and Videre, with full parity. Discover a workflow interactively, then script the identical operations; the results match because the app and the code share one core, and the heavy computation stays in the engine, so your code is thin logic, not a re-implementation.
Full app parity — in Python
Every operation in Allego and Videre is a Python call, against the same engine.
Prototype in the GUI, then scale
Work a workflow out by hand, then apply it across thousands of sessions unattended.
The hard part stays in the engine
The compiled back end carries the heavy work — so there is little user code to get wrong.
It outlives the author — and re-runs when Reviewer 2 asks.
Small scripts over a stable, verified engine: reproducible today, re-runnable months later.A workflow has to survive the person who built it. Because the logic is thin and the computation is a maintained engine, the script the lab keeps is readable and durable — and every result carries the record needed to re-derive it, long after its author has moved on.
Reproducible by default
Every sort and transform carries a unique ID with settable RNG, so any result re-derives itself.
Runs headless, at scale
Batch and headless pipelines run across large archives unattended — local-first, on your own storage.
Pinned open-source runtimes
Run the field’s tools at fixed versions, so the same analysis re-runs identically, years later.
The Radiens CLI: from no-code interactive to full power tool.
Structured commands in, structured data and files out — typed by hand, scripted, or driven by an agent.The CLI is the free command-line interface, and it spans the range: type a command to run an accurate operation with no program to write, or compose those same commands into pipelines and CI as a power tool. Because every command takes structured input and returns structured output, an agent drives the exact same interface a person does — so its work is readable and re-runnable, not a black box.
No-code and interactive
Drive recordings, check status, open a file in Videre — from the shell, no program to write.
Structured in and out
Structured input, structured output (JSON, markdown, stdout) — and the data files to match.
Agent-operable — the power tool
Compose it into pipelines and CI, or let an agent drive the same readable, re-runnable calls.
The durable thing you control is the interface — not the model.
Models and agents will keep improving, and they will stay black boxes: you cannot own one or freeze it. What you can own is the interface around it — your scripts, your prompts, the pinned pipelines and the tooling that direct it. Radiens keeps that interface current: safe, structured update paths keep every install up to date without breaking your workflow, and version-pinned runtimes and neuroscience-tuned agents keep pace with the field. So your automation stays accurate as the frontier moves, instead of aging into a liability.
What each tier unlocks.
RadiensPy and the core CLI are free at every tier. What you buy is compute and the paid capabilities, not the client.
Where this is going.
Everything above ships today. The frontier extends the toolset — more compute, more openness, safer agents.
On-demand cluster and GPU compute
Scale beyond a single workstation for large, parallel jobs — running against your own storage, no data custody.
Extensible-algorithm platform
Bring your own methods on version-pinned open-source runtimes — reproducibly, through the same tools.
Neuroscience-tuned AI agents
Agents tuned for systems-neuroscience analysis — guided, structured, readable operation of Radiens.
The apps and the code are one system.
Everything you script runs the same verified engine as Allego and Videre — explore a workflow in the app, automate it in code, and the result is identical. The GUI and the API are two ways into one core.
Frequently asked questions
How can a PI trust an AI agent’s analysis in Radiens?
The agent does not compute in a black box — it operates the same structured interface a person does: small RadiensPy scripts and structured CLI calls against the verified engine. Every operation carries a unique ID and provenance and re-derives itself, so an agent’s work is readable and re-runnable, and the person accountable for the result can read and check exactly what was done.
What happens to a lab’s analysis scripts when the author leaves?
Because RadiensPy carries the hard computation behind a clean API, the script the lab keeps is small, low-code, and readable — a thin layer of straightforward logic over a maintained engine, not a large bespoke codebase. With version pinning and provenance, that script re-runs and re-derives its results long after its author has moved on.
What is RadiensPy?
RadiensPy is the free Python client for Radiens — a professional-grade client over the same compiled engine behind Allego and Videre, with full app parity, so every operation in the apps is a Python call and the results are identical. It is free at every tier.
Does Radiens have a command-line interface?
Yes — the Radiens CLI is a free command-line interface that spans no-code interactive use to a scriptable power tool. Every command takes structured input and returns structured output (JSON, markdown, stdout) and the data files to match; account, session, and recording control are free, and headless pipelines and the agent-operable interface are Pro.
Is scripting Radiens free?
Yes — RadiensPy and the core Radiens CLI (structured command I/O and account, session, and recording control) are free at every tier; Pro adds headless and batch pipelines, the agent-operable interface, and advanced analysis through the API, with on-demand cluster and GPU compute, the extensible-algorithm platform, and version-pinned open-source runtimes in development.
Can I run Kilosort, SpikeInterface, and MNE from Radiens?
Radiens is adding a catalog of version-pinned open-source runtimes (Kilosort, SpikeInterface, MNE, FieldTrip, EEGLAB), reachable from RadiensPy, so you keep the open-source tools you know at reproducible, pinned versions.
Automation you can vouch for — free to start.
RadiensPy and the Radiens CLI are free at every tier. Install with pip, point them at data you already have, and keep the correctness in scripts you can read, run, and vouch for.