An AI-assisted research platform governed by the research community.

01 The challenge

AI agents can now write most of the code for computational science. They can investigate papers, help with ideas and suggest new experiments, and doing all of this in a loop can be immensely powerful. It also raises real questions of AI safety. An agent that works on its own spends computing, handles sensitive data and runs code on real machines. Somebody has to set its limits, and somebody has to be able to check what it did.

Adopting such a platform therefore requires a great deal of trust, because whoever runs it becomes the steward of valuable data and of what the agents are allowed to do. They see research before it is published, and they hold everything that passes through the loop: the ideas, the failed attempts and the reasons for changing course. That is the best material there is for training ever more powerful research AI, and it would sit with whoever runs the platform.

So before researchers and institutions hand over their work, they need clear answers. Who can see my unpublished work? Can it be used to train a model? Who decides what the agents may do on their own? Who sets the rules, and how can they change? Can I leave and take my work with me?

02 The solution

Terminus is a proposal for a platform that must be trusted. It has two parts. The first is the software and infrastructure that automate the steps between an idea and a result. A researcher formulates an idea, a question or a problem and attaches the relevant data and papers. An AI agent processes the data, investigates the problem and writes the code for the experiments. The code and data are sent to a compute node, perhaps a university’s HPC cluster, where a job is submitted and runs in a container. The results return to the agent, which analyses them and reports back to the researcher with suggestions for the next round. The researcher can approve each run or let the agent work on its own, within limits set by the people responsible for the data and the computing. Every step goes on one record, so anyone with the right access can check what the agent did and why.

A first prototype does this today for small machine-learning experiments. It runs on an institution’s own GPU node, with each run in an Apptainer container and its results tracked in MLflow. For now the researcher approves every run, and submitting jobs to a shared HPC cluster through SLURM is the next step.

The second part is the organisation and governance needed to trust such a platform. Its job is to make sure the answers to those questions don’t depend on whoever happens to run it, including how far the agents may go on their own and who may train AI on the research. It would start with one nonprofit that partners with local institutions. Then a second, independent organisation would start in another country. The governance would grow out of the collaboration between institutions and countries.

03 The prototype

Research loop · an illustrative study

New experimentProject · sequence memory

RUNTemplate

Can a sequence model learn which earlier tokens to retain?Can a sequence model learn which earlier tokens to retain?Replace the fixed window with a learned memory gate of 128 tokens, and compare it with the template.Replace the fixed window with a learned memory gate of 128 tokens, and compare it with the template.

model/memory.pyReading the modelWriting the changeAwaiting approval+3 −1 · drafted by the agent

def forward(self, x, mem):

− ctx = mem[:, -self.window:]

+ g = self.gate(mem).sigmoid() g = self.gate(mem).sigmoid()

+ idx = g.topk(self.k, dim=1).indices idx = g.topk(self.k, dim=1).indices

+ ctx = take(mem * g, idx) ctx = take(mem * g, idx)

return self.attn(x, ctx)

config.yaml

−window: 256

+memory: learned_gatememory: learned_gate

+k: 128 # half the windowk: 128 # half the window

Institute HPC clusterSLURM · Apptainer · submitted by the agent

login01$sbatch -p gpu --gres=gpu:1 train.shsbatch -p gpu --gres=gpu:1 train.sh

Submitted batch job 4817203

4817203#3 Memory gatekeeps the 128 scored highestpending · queuerunning · gpu-a07✓completed · gpu-a07step 4000 / 4000val_loss 2.43

Research noteReading 4 runs from MLflowDraftingWritten by the agent

Template#1#2#3

Observation: Validation loss 2.43 with the gate keeping 128 of the 256 tokens, against 2.41 for the template and 2.55 with regularisation increased.Validation loss 2.43 with the gate keeping 128 of the 256 tokens, against 2.41 for the template and 2.55 with regularisation increased.
Interpretation: The gate keeps up with the template on half the memory, and the earlier try at more regularisation did worse. One task and one seed cannot settle that.The gate keeps up with the template on half the memory, and the earlier try at more regularisation did worse. One task and one seed cannot settle that.
Suggested next experiment: Evaluate the memory gate on longer sequences, from 1k to 8k tokens.Evaluate the memory gate on longer sequences, from 1k to 8k tokens.

New experimentProject · sequence memory

PDFConsistency training · example paperRUNTemplate

Try the method from the attached paper on the template.Try the method from the attached paper on the template.

train.pyReading the paperWriting the changeAwaiting approval+3 · drafted by the agent

def training_step(model, x, y):

loss = ce(model(x), y)

+ a, b = two_views(x) # 1k, 4k a, b = two_views(x) # 1k, 4k

+ c = consistency(model(a), model(b)) c = consistency(model(a), model(b))

+ loss = loss + cfg.lam * c loss = loss + cfg.lam * c

return loss

Institute HPC clusterSLURM · Apptainer · submitted by the agent

login01$sbatch -p gpu --gres=gpu:1 train.shsbatch -p gpu --gres=gpu:1 train.sh

Submitted batch job 4817391

login01$sbatch -d afterok:4817391 eval.shsbatch -d afterok:4817391 eval.sh

Submitted batch job 4817392

4817391#4 Method from papertwo views, consistency losspending · queuerunning · gpu-b02✓completed · gpu-b02step 4000 / 4000val_loss 2.42
4817392Long-context evaluation1k to 8k tokenspending · dependencyrunning · gpu-b02✓completed · gpu-b02

Research noteReading 5 runs from MLflowDraftingWritten by the agent

Template#1#2#3#4

Observation: At 8k tokens, loss rises less with the paper's consistency objective: 2.52 against 2.66 for the template. Training took about 1.4× the GPU time.At 8k tokens, loss rises less with the paper's consistency objective: 2.52 against 2.66 for the template. Training took about 1.4× the GPU time.
Interpretation: The objective may steady the model as context grows. The second view alone could also explain it.The objective may steady the model as context grows. The second view alone could also explain it.
Suggested next experiment: Train with both views but without the consistency loss, to separate the two.Train with both views but without the consistency loss, to separate the two.

New experimentProject · sequence memory

RUN#4 Method from paper

Run the suggested ablation: both views, but no consistency loss.Run the suggested ablation: both views, but no consistency loss.Evaluate it from 1k to 8k tokens beside the paper's method.Evaluate it from 1k to 8k tokens beside the paper's method.

train.pyReading the last noteWriting the changeAwaiting approval+1 −2 · drafted by the agent

def training_step(model, x, y):

loss = ce(model(x), y)

a, b = two_views(x) # 1k, 4k

− c = consistency(model(a), model(b))

− loss = loss + cfg.lam * c

+ loss = loss + lm_loss(a) + lm_loss(b) loss = loss + lm_loss(a) + lm_loss(b)

return loss

Institute HPC clusterSLURM · Apptainer · submitted by the agent

login01$sbatch -p gpu --gres=gpu:1 train.shsbatch -p gpu --gres=gpu:1 train.sh

Submitted batch job 4817455

login01$sbatch -d afterok:4817455 eval.shsbatch -d afterok:4817455 eval.sh

Submitted batch job 4817456

4817455#5 Ablation of #4two views, no consistency losspending · queuerunning · gpu-a07✓completed · gpu-a07step 4000 / 4000val_loss 2.42
4817456Long-context evaluation1k to 8k tokenspending · dependencyrunning · gpu-a07✓completed · gpu-a07

Research noteReading 6 runs from MLflowDraftingWritten by the agent

Template#1#2#3#4#5

Observation: Without the consistency loss, loss at 8k is 2.57: most of the gain over the template (2.66) remains, but not all of it (2.52).Without the consistency loss, loss at 8k is 2.57: most of the gain over the template (2.66) remains, but not all of it (2.52).
Interpretation: The second view seems to do most of the work, and the loss adds a little. One seed, so the gap may not hold.The second view seems to do most of the work, and the loss adds a little. One seed, so the gap may not hold.
Suggested next experiment: Make the memory gate always keep the most recent tokens: on long sequences it may drop ones it still needs.Make the memory gate always keep the most recent tokens: on long sequences it may drop ones it still needs.

New experimentProject · sequence memory

RUN#3 Memory gate

Try the suggestion: keep the last 32 tokens and let the memory gate choose the other 96.Try the suggestion: keep the last 32 tokens and let the memory gate choose the other 96.Compare it at 8k with #3 and the paper's method, and at its cost.Compare it at 8k with #3 and the paper's method, and at its cost.

model/memory.pyReading the memory gateWriting the changeAwaiting approval+3 −2 · drafted by the agent

def forward(self, x, mem):

+ recent = mem[:, -self.recent:] recent = mem[:, -self.recent:]

− g = self.gate(mem).sigmoid()

+ g = self.gate(mem[:, :-self.recent]).sigmoid() g = self.gate(mem[:, :-self.recent]).sigmoid()

idx = g.topk(self.k, dim=1).indices

− ctx = take(mem * g, idx)

+ ctx = cat(take(mem * g, idx), recent) ctx = cat(take(mem * g, idx), recent)

return self.attn(x, ctx)

Institute HPC clusterSLURM · Apptainer · submitted by the agent

login01$sbatch -p gpu --gres=gpu:1 train.shsbatch -p gpu --gres=gpu:1 train.sh

Submitted batch job 4817512

login01$sbatch -d afterok:4817512 eval.shsbatch -d afterok:4817512 eval.sh

Submitted batch job 4817513

4817512#6 Recency-aware gatethe last 32 kept, 96 chosen by the gatepending · queuerunning · gpu-a11✓completed · gpu-a11step 4000 / 4000val_loss 2.41
4817513Long-context evaluation1k to 8k tokenspending · dependencyrunning · gpu-a11✓completed · gpu-a11

Research noteReading 7 runs from MLflowDraftingWritten by the agent

Template#1#2#3#4#5#6

Observation: Keeping the last 32 tokens, the memory gate reaches 2.50 at 8k, against 2.71 without them and 2.52 for the paper's method, at the template's GPU time instead of 1.4×.Keeping the last 32 tokens, the memory gate reaches 2.50 at 8k, against 2.71 without them and 2.52 for the paper's method, at the template's GPU time instead of 1.4×.
Interpretation: On long sequences the gate seems to drop recent tokens it still needs. It has been tried on one task and one seed only.On long sequences the gate seems to drop recent tokens it still needs. It has been tried on one task and one seed only.
Suggested next experiment: Run #6 on a second task, and at 16k tokens.Run #6 on a second task, and at 16k tokens.

Research Graph

An illustration of the research loop, played on repeat: the researcher has an idea, an AI agent implements it, the agent submits the approved run to an institute's HPC cluster through SLURM (in the prototype, SLURM submission is the next step), where it runs in an Apptainer container, and the agent reads the results from MLflow, writes a note and suggests the next experiment. The record starts from a template and two earlier variants of it, numbered 1 and 2; each new experiment builds on one already there and takes the next number. The experiments, the paper, the cluster and every number are invented; they are not results from Terminus.

Idea: the researcher writes “Can a sequence model learn which earlier tokens to retain? Replace the fixed window with a learned memory gate of 128 tokens, and compare it with the template.” Attached: Template. Implement: an agent drafts a change to model/memory.py, and the researcher approves that exact version. Train: SLURM job 4817203 trains #3 Memory gate in an Apptainer container on a GPU node. Analyse: the agent's note. Observation: Validation loss 2.43 with the gate keeping 128 of the 256 tokens, against 2.41 for the template and 2.55 with regularisation increased. Interpretation: The gate keeps up with the template on half the memory, and the earlier try at more regularisation did worse. One task and one seed cannot settle that. Suggested next experiment: Evaluate the memory gate on longer sequences, from 1k to 8k tokens.
Idea: the researcher writes “Try the method from the attached paper on the template.” Attached: Consistency training · example paper; Template. Implement: an agent drafts a change to train.py, and the researcher approves that exact version. Train: SLURM job 4817391 trains #4 Method from paper in an Apptainer container on a GPU node, and a second job evaluates it from 1k to 8k tokens. Analyse: the agent's note. Observation: At 8k tokens, loss rises less with the paper's consistency objective: 2.52 against 2.66 for the template. Training took about 1.4× the GPU time. Interpretation: The objective may steady the model as context grows. The second view alone could also explain it. Suggested next experiment: Train with both views but without the consistency loss, to separate the two.
Idea: the researcher writes “Run the suggested ablation: both views, but no consistency loss. Evaluate it from 1k to 8k tokens beside the paper's method.” Attached: #4 Method from paper. Implement: an agent drafts a change to train.py, and the researcher approves that exact version. Train: SLURM job 4817455 trains #5 Ablation of #4 in an Apptainer container on a GPU node, and a second job evaluates it from 1k to 8k tokens. Analyse: the agent's note. Observation: Without the consistency loss, loss at 8k is 2.57: most of the gain over the template (2.66) remains, but not all of it (2.52). Interpretation: The second view seems to do most of the work, and the loss adds a little. One seed, so the gap may not hold. Suggested next experiment: Make the memory gate always keep the most recent tokens: on long sequences it may drop ones it still needs.
Idea: the researcher writes “Try the suggestion: keep the last 32 tokens and let the memory gate choose the other 96. Compare it at 8k with #3 and the paper's method, and at its cost.” Attached: #3 Memory gate. Implement: an agent drafts a change to model/memory.py, and the researcher approves that exact version. Train: SLURM job 4817512 trains #6 Recency-aware gate in an Apptainer container on a GPU node, and a second job evaluates it from 1k to 8k tokens. Analyse: the agent's note. Observation: Keeping the last 32 tokens, the memory gate reaches 2.50 at 8k, against 2.71 without them and 2.52 for the paper's method, at the template's GPU time instead of 1.4×. Interpretation: On long sequences the gate seems to drop recent tokens it still needs. It has been tried on one task and one seed only. Suggested next experiment: Run #6 on a second task, and at 16k tokens.

Try the prototype

Email me at jesper@projectterminus.org for an access code.

04 The organisation

One possible shape: two national nodes and what they share

One possible shape is a nonprofit in each country, running Terminus on that country’s computing and shaped by the institutions and researchers that take part. A shared body would take on only what no single country can do alone, such as the code, common standards (among them the limits agents work within) and working across borders. The national organisations would govern it together.

Much is still open: how organisations join and leave, how decisions are made, and whether national nodes are the right shape at all. Those are for the first participants to settle, not for me to decide in advance.

05 Get involved

Today, Terminus is one prototype and one founder. There is no nonprofit, no national node and no charter yet, and nothing on this page binds anyone. Anyone is welcome to get in touch, whether you want to try the prototype, bring it to your institution, or talk about how a platform like this should be governed and kept safe.

Contact

Jesper Lauridsen, ML engineer and founder

jesper@projectterminus.org

A founding thesis, with the full argument, is coming soon.