How it works
Four pictures of SIDERIUS
Agents propose, write and check models; deterministic code trains, scores and checks validity. The four pictures below show how those parts fit together. The second half of the page shows how to build your own workflow from capabilities, connectors, adaptors, routes and loops.
One lap is one research iteration
Swipe sideways to see the whole diagram.
Any caller, the same typed capabilities
Swipe sideways to see the whole diagram.
A human, a fixed workflow or an LLM orchestrator chooses the calls; each capability keeps its own reasoning and tools.
Source: SIDERIUS paper (opens in a new tab) Orchestration setup (opens in a new tab)
No single number plays every role
Swipe sideways to see the whole diagram.
Only scientific selection ranks results, and validity is checked separately from quality.
Source: SIDERIUS paper (opens in a new tab) Objectives and metrics (opens in a new tab)
One typed contract for every seat
Swipe sideways to see the whole diagram.
Humans and agents are interchangeable: advise any capability, take its seat, or use one capability alone.
In more detail
How a workflow fits together
From single capabilities to the connections between them, then adaptors, aggregators, distributors, and finally routes and loops.
Capabilities: one job each
A capability is one agent with one job. It receives one kind of input and sends one kind of result.
SIDERIUS has seven. The six below can be placed in a workflow. A seventh capability, data analysis, is used by orchestration and by the command-line native chain; it cannot yet be placed in workflow.py.
Each capability sees only the input it is given and hands over only the result it promised, so you can replace any one of them: a different model, a person doing that job, or that capability used on its own.
Train & tune's agent chooses the training settings; the training run itself, scoring and Health checks are done by SIDERIUS's deterministic code, not by an agent.
| Capability | Receives | Sends |
|---|---|---|
| Interpret results | Run summaries | Results analysis |
| Literature review | Search evidence | Paper findings |
| Propose model | Results analysis, Paper findings or Design brief | Model plan |
| Implement | Model plan | Model code |
| Validate | Model plan + Model code | Code verdict |
| Train & tune | Code verdict + Model plan + Training settings | Training report |
Settings are per capability too: each capability's language model is chosen separately in your LLM profile, time and VRAM budgets sit on Train & tune, and advice goes in each capability's own field. 1.1.0 has no time or GPU budget shared across capabilities.
Connectors: typed inputs and outputs
Every input and output of a capability is a connector with a type, such as Model plan or Code verdict. A connection joins only an output and an input of the same type.
Before: steps pass loose files to each other, and a wrong hand-off often shows up only halfway through a run. Change: every connector says what it carries; in the experimental 1.1.0 console, when you drag a connection, only the inputs of the matching type light up. After: a wrong connection is refused before anything runs, and the message names both types, for example “Propose model sends Model plan; this input receives Design brief.”
An input's value comes from one of three places:
- Another capability: for example Model plan or Code verdict.
- A resource you provide: for example Storage folder (where outputs go) or Data folder (where the data is). With a template, the run prepares these for you.
- A setting you give: for example Expert advice, Training settings or Parameter rules.
Some inputs are optional; the experimental console draws them hollow and folds them away when unused.
Adaptors: gather, choose, hand out
An adaptor is a small step between capabilities that gathers, chooses and hands out results. Most adaptors follow fixed rules; some aggregators use a language model as a judge when they gather.
Every adaptor works in the same three parts:
- Gather: take in the results that can be used. Code that failed Validate, or a training result that failed its Health checks, is kept out here.
- Choose: keep all, keep the first one that qualifies, or rank them and keep the top few.
- Hand out: pass the choice downstream, as one value or split into several (see distributors below).
Order is always the order you declared, never the order things happened to finish, so the same inputs always give the same choice. Every adaptor records what it received, what it chose and why.
Example: First passing selection gathers the Code verdicts of two implementations, chooses the first that passed, and hands only that one to Train & tune. In SIDERIUS 1.1.0, your coding agent writes adaptors into a concrete (v1) workflow document, not the reusable workflow.py that preparation and the console use, and runs it from the command line. Such a workflow runs once: it cannot yet be combined with a research loop, and the console cannot build it.
Aggregators: many into one
An aggregator is an adaptor whose job is to turn several results into one input for the next capability.
Before: several literature reviews each stand alone, and one Propose model can take only one. Change: Collect reviews gathers them in the order you declared and labels each with the capability that produced it. After: one proposal reads every review and knows where each finding came from.
Collect reviews only gathers; it does not score or rewrite. Other aggregators ask a language model to rank, debate or merge the results. They go into a separate workflow document (not workflow.py) that runs once; the reference explains each one.
Distributors: one into many
The hand-out part of an adaptor decides how many outputs it sends. A distributor fans one input out into several branches.
| Hand-out | What it does | Runs in 1.1.0? |
|---|---|---|
| single | Sends one value | Yes |
| split-items | Splits the list inside one result: each branch gets one entry, everything else unchanged | Yes, in Split findings |
| per-item | The 1st chosen item goes to branch 1, the 2nd to branch 2, and so on | Yes, after an LLM aggregator (Rubric rank, Debate judge, Judge merge, Primary and advisors) |
| replicate | Copies the same value to several branches | Can be declared; no workflow shape runs it yet |
You set how many branches there are. If a result has more entries than branches, the step fails rather than silently dropping some; the reference lists the exact limits.
Routes and loops
A route runs part of a workflow only when a condition holds. A loop runs the whole workflow again, iteration after iteration, until a limit or a stop condition ends it, or pauses to ask you.
Routes
A route reads one earlier result and checks its cases in order; the first that matches wins. Without a default, nothing runs when no case matches. A branch that is not chosen costs nothing, and Monitor shows it as skipped. In 1.1.0, routes work around Implement and Validate, on whether a Code verdict passed, together with First passing selection. Your coding agent writes them into a concrete (v1) workflow document, not the reusable workflow.py, and runs it from the command line; it runs once and cannot yet be combined with a research loop.
Loops
One pass through the workflow is one iteration. After each iteration, the Training report goes back to Interpret results, so the next iteration starts from what the last one learned instead of from nothing.
A loop needs a limit, or it would never end. You always set the most iterations it may run, and you can add stop conditions that end it earlier:
| Ends the loop | When |
|---|---|
| Final iteration | After this many iterations. This limit always applies. |
| Metric threshold | The best valid score reaches the value you set. |
| No improvement | Several iterations in a row do not beat the best score. |
| Judge | A language model reads your rule, written in plain words, and decides that the loop has done enough. |
Your coding agent writes these into workflow.py. The experimental browser console can also set them.
Pause and ask me. Sometimes you would rather look at the results than let the loop end on its own. Each stop condition can therefore either Stop the loop or Pause and ask me. For example, take a limit of 6 iterations and a no-improvement condition of 2, set to pause. The best score comes from iteration 2; iterations 3 and 4 do not beat it, so the loop pauses after iteration 4 and shows a summary of what was met and where the best score came from. You write advice, such as "try a recurrent model", and resume. Iteration 5 starts, and Propose model reads your advice. You can also end the loop at the pause instead.
You can stop or pause a running loop yourself at any time. The current iteration finishes first, so no half-finished result is kept. A loop that ended or paused on a condition says which one.
Want to try it? The tutorials start with your coding agent, then show the same steps in the experimental browser console.
Tutorials