Norsk English

Agents as collaborators in computational science

We develop technology that turns AI agents into genuine collaborators in demanding technical work, starting from simulation and computational science.

Contact persons

Our aim is technology that makes AI agents genuine collaborators in demanding technical work: something you discuss a problem with, delegate a task to, and get informed pushback from. An agent is then not simply an interface that translates commands, but a colleague that can reason about results, propose the next step, and work independently for a stretch in a given direction.

When we first wrote this page, in late summer 2025, even the simplest step was still an aspiration. Asking a simulator for something in plain language is now part of our daily work, but it remains only the first step.

What remains

Internationally this is often called agentic scientific discovery: agents that do not merely perform calculations, but take part in the scientific cycle of forming hypotheses, designing experiments, interpreting results, revising the model and trying again. The gap between that and today's tools has less to do with language understanding than with three things:

  • Judging its own results. Running a simulation is easy. Deciding whether the answer is physically plausible, whether the resolution was sufficient, or whether a discrepancy against data stems from the model or from the data, calls for expert judgement.
  • Holding a direction over time. Scientific work is rarely one task. It is a hundred tasks that build on one another, and the agent has to remember what has been tried, why it failed, and what is still outstanding.
  • Knowing when to ask. A good colleague knows the difference between a decision they can take themselves and one that has to be escalated.

We are working towards this step by step, with simulation as our starting point. That is where our domain expertise lies, and it is one of the few areas where an agent can actually find out that it was wrong.

Why the simulator is the key

An agent that is to work independently needs something to be corrected by. Without feedback, independence is just unsupervised guesswork.

This is where our advantage lies. Mature simulators such as Jutul have typed interfaces, extensive built-in consistency checks and informative error messages. That makes the simulator a reliable judge of the agent's work. The simulator determines what is physically and numerically valid, while the agent handles setup, execution and interpretation in a loop: first interpreting the user's intent, then retrieving documentation and writing code, and finally running that code and reading the solver diagnostics.

The better this feedback is, the further the agent can go on its own. Documentation, error messages and API design are therefore no longer only something users encounter. They are the material the agent corrects itself against, and thus a direct limit on how independent it can become.

JutulAgent

JutulAgent is currently our most important R&D tool in this area. It is a system in which user and agent work together to set up, run and progressively refine simulations towards a desired goal. Either party can propose, object and revise along the way, and the agent has the simulator as an external authority on what is actually valid. It is also how we investigate the limits of what an agent can be trusted to take responsibility for.

The system is built around Jutul, which is itself a research platform, written in Julia. Jutul is our exploration of how modern simulation software ought to be built: modular, fully differentiable, composable across physics domains and hardware-accelerated. The whole family shares data structures, discretisation and automatic differentiation, so the same agent works across fields: reservoir simulation with JutulDarcy, geothermal energy with Fimbul, batteries with BattMo, carbon capture with Mocca and emissions from hydrocarbon transport with VOCSim.jl.

Agentic coding around validated software

Agents can also be used the other way round, to build tools around software we have already developed and validated over many years. In the SUrbArea project, a researcher and an AI agent together built an interactive 3D interface for exploring how surface water moves during heavy rainfall. The agent produced the interface layer and connected data sources, visualisation and user interaction, while the calculations are still performed by SWIM, our open tool for rapid stormwater modelling.

The agent builds the tool; a validated simulator does the computing. In our view, that division of labour is one of the most responsible ways to put agentic AI to work in scientific software.

SINTEF AgentLab

Our work on agents began in this research group. In 2024 we started building a broader initiative, which became SINTEF AgentLab, bringing together relevant activity across the whole of SINTEF Digital: agentic coding, simulator agents, navigation of the research literature, and infrastructure for safe experimentation. For us it means that methods and experience are shared with groups working in entirely different fields, and that questions of trust and verifiability are asked across all of them.

National AI centres

SINTEF is a partner in several of Norway's national research centres for artificial intelligence, and we are working to give agentic technology a clear place in them. In aiD (Norwegian Centre on AI for Decision) we lead the work package on disruptive technologies and co-lead the work package on human–AI interaction. In TRUST (The Norwegian Centre for Trustworthy AI) the work connects to the question of what it takes for a result produced by an agent to be verifiable and trusted.

This is a deliberate position. Agentic AI is developing faster than most research programmes are set up for, and we believe the centres need to engage with the technology while it is still moving, rather than afterwards.

Collaboration

We welcome collaboration. That might mean connecting an agent to your own models and tools, exploring what agentic coding can do within a specific workflow, or using our sandboxes to try the technology out in a controlled setting.

One example is our collaboration with Geoteric, where we have connected their AI-based interpretation of seismic data directly to JutulDarcy through JutulAgent. Steps that traditionally require export and manual reformatting between specialist applications here run as a single workflow, with every step logged for review.

What we have learned

The hard part is not getting the agent to do something, but knowing whether what it did was right. The agent inevitably fills in choices the user never mentioned, and settles on one reading where the description was ambiguous. The simulator can confirm that a result is consistent, but not that it is what the user meant. The more independently the agent is to work, the more that distinction matters.

Traceability is a precondition for independence, not an add-on. For anyone to trust a result, it must be possible to go back and see what the agent actually did: which assumptions it relied on, which alternatives it discarded, where it changed course. We therefore log every step, both so that people can review the work and so that other agents can build on it. This also gives reproducibility. Two runs from the same description can produce two valid but different models, and that is only manageable if the trail is legible afterwards.

Domain expertise does not become less important; it moves. It shifts from writing each individual step to defining the task, setting the constraints and judging whether the result holds up. That is also why we believe the ambition set out above is within reach here in particular. If an agent is to assess its own work, the criteria for that assessment have to be encoded somewhere, and in our case they live in simulators we built ourselves.

Distinguish what lasts from what does not. This field is moving faster than anything we have worked with before, and much of what looks like technological progress is scaffolding that will end up being discarded. We therefore treat the agent layer as short-lived and are willing to tear it down, while our investment goes into what endures: the simulators, the domain expertise, the quality of documentation and error messages, and the ability to verify a result. We develop in open source and build on open standards such as MCP for the same reason. The move from our first prototype, JutulGPT, to today's JutulAgent in under a year makes the point. The agent architecture was replaced almost in its entirety, while the value that survived lay in the simulators underneath.

Read more