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

The SIDERIUS research loopFive capabilities in a cycle: Propose a model, Implement its code, Validate the implementation, Train and tune it, Interpret the results, then Propose again. In the centre, a deterministic core owns data selection, execution, scoring, Health validity and provenance.Deterministic coreData selectionExecutionScoringHealth validityProvenanceProposeImplementValidateTrain & tuneInterpret
Research loop, planned and judged by LLM agentsDeterministic code: no LLM decides data, scoring or validity

Swipe sideways to see the whole diagram.

Source: SIDERIUS docs (opens in a new tab)

Any caller, the same typed capabilities

Any caller, same capabilitiesThree kinds of caller, a human expert, a fixed workflow and LLM orchestration, call the same typed capability contracts. The caller owns composition and history; seven capabilities, Interpret, Analyze, Literature, Propose, Implement, Validate and Train and tune, own their reasoning and tools.CALLERSHuman expertFixed workflowLLM orchestrationTyped capability contractsCAPABILITIESInterpretAnalyzeLiteratureProposeImplementValidateTrain & tuneCallers own composition and history; capabilities own their reasoning and tools.

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

No single number plays every roleThe task package declares separate quantities: a training objective that drives optimization, validation monitoring that tracks learning, scientific selection that orders eligible results by a declared direction, and secondary evidence that informs reasoning but never sets the ranking. Validity is a separate question: scoreability asks whether the declared metric can be computed, and deterministic Health checks record task-applicable model and output checks.TASK DECLARESWHAT EACH NUMBER DOESIS IT VALID?Task packageone manifestTraining objectivedrives optimizationValidation monitoringtracks learningScientific selectionranks eligible resultsSecondary evidenceinforms, never ranksScoreabilitymetric computable?Health checksrecorded per modelvalidity is a separatequestion from quality

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

One typed contract for every seatBecause every capability has a typed contract, a human can advise any agent through the same advice field automated callers use, take any agent's seat, for example writing the proposal and handing it to the implementer, or use a single capability alone, for example handing in their own model to be trained, tuned and scored.Advise any agentProposeValidateImplementTrain & tuneYouTake any seatInterpretYouin the proposer's seatImplementUse one aloneYour modelTrain & tuneTuned + scored

Swipe sideways to see the whole diagram.

Humans and agents are interchangeable: advise any capability, take its seat, or use one capability alone.

Source: SIDERIUS docs (opens in a new tab)

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.

CapabilityReceivesSends
Interpret resultsRun summariesResults analysis
Literature reviewSearch evidencePaper findings
Propose modelResults analysis, Paper findings or Design briefModel plan
ImplementModel planModel code
ValidateModel plan + Model codeCode verdict
Train & tuneCode verdict + Model plan + Training settingsTraining 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-outWhat it doesRuns in 1.1.0?
singleSends one valueYes
split-itemsSplits the list inside one result: each branch gets one entry, everything else unchangedYes, in Split findings
per-itemThe 1st chosen item goes to branch 1, the 2nd to branch 2, and so onYes, after an LLM aggregator (Rubric rank, Debate judge, Judge merge, Primary and advisors)
replicateCopies the same value to several branchesCan 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 loopWhen
Final iterationAfter this many iterations. This limit always applies.
Metric thresholdThe best valid score reaches the value you set.
No improvementSeveral iterations in a row do not beat the best score.
JudgeA 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