After the AI Scientist: What Would Autonomous Engineering Look Like?

Science is beginning to build systems that can pursue research goals with limited human intervention. Engineering may follow a similar path, but the surrounding infrastructure matters as much as the AI itself.

FutureHouse has an ambitious goal: automate scientific discovery.

Its AI Scientist vision goes beyond using AI to search papers, analyse data or write code. The system should be able to pursue a broad scientific objective, generate hypotheses, design experiments, analyse results and decide what to investigate next.

Parts of that loop already exist.

FutureHouse’s Robin system generated hypotheses, proposed experiments and interpreted the resulting data in a therapeutic discovery programme, although humans still performed the physical experiments. Kosmos, developed by FutureHouse and now commercialised through Edison Scientific, extends the idea towards longer-running autonomous research.

Other groups are starting to build the environment around such systems.

C5R’s SciUniverse benchmark puts AI models into scientific work that includes choosing materials, operating instruments, adapting protocols, dealing with equipment failures and deciding what to try next. Models direct work at a real laboratory called Facility-0, where they control machines and give instructions to human operators.

That exposes a different class of problems from benchmarks based on clean datasets.

Current frontier models still fail on basic details of laboratory work. C5R reports examples such as trying to pipette frozen samples or mishandling open containers. Its strongest model currently passes around 45 percent of the Level 1 benchmark.

That number should be read as a snapshot, not a forecast. Recent progress in mathematics and theoretical physics shows how quickly apparent capability limits can move. The more durable observation is that physical work exposes a different class of problems from reasoning over text or clean datasets: agents must perceive state, handle equipment, recover from mistakes and act under real resource constraints.

The infrastructure is interesting in its own right. SciUniverse tests instrument control through vendor software, Python APIs and direct firmware commands. It includes tasks involving limited materials, experimental budgets, equipment failures and deadlines.

A recent Google DeepMind paper, Agentic Economies for Autonomous Scientific Discovery, looks further ahead.

Its authors argue that autonomous science becomes a resource-allocation problem once hypothesis generation becomes cheap. Experiments still require compute, laboratories, equipment and time. If AI can generate far more ideas than can be tested, the bottleneck moves from producing hypotheses to deciding which ones deserve validation.

Taken together, these developments suggest that autonomous science depends on more than an AI capable of scientific reasoning.

It needs a representation of the problem, infrastructure the agents can operate, a way to choose which evidence is worth acquiring and a mechanism for coordinating the work.

The same structure may apply to engineering.

What Would Autonomous Engineering Require?

Imagine an engineering system given a goal such as developing a subsystem within a set of performance, mass, cost, safety and interface constraints.

It can propose architectures, modify designs, run analyses and use the resulting evidence to decide what to change.

As those capabilities improve, generating candidate solutions may become relatively cheap. Determining which ones actually work remains costly.

An engineering system could generate thousands of geometries or architectures. Running the highest-fidelity simulation on all of them would make little sense. Physical prototypes and qualification tests impose much stronger constraints.

Autonomous engineering would therefore need to manage an entire engineering loop rather than simply produce designs.

Four capabilities appear particularly important.

1. Agent-Native Engineering Artefacts

An autonomous system needs a machine-actionable representation of what it is engineering.

Requirements, functions, architecture, interfaces, constraints, assumptions and verification relationships have to form a coherent engineering state that the system can inspect and modify.

A system model can provide much of this structure. The system model does not need to arrive fully formed. Creating and evolving it could become part of the engineering process itself. A human might define the initial objective and major constraints, while the autonomous system develops requirements, explores architectures and updates the model as the design evolves.

The representation also needs information that often sits outside formal MBSE models: modelling assumptions, previous designs, standards, configuration, provenance and the evidence behind previous decisions.

The DeepMind paper describes an analogous problem in science. Scientific papers are written primarily for human readers and often omit information that an agent would need to reproduce and extend the research. It proposes more structured, agent-native research artefacts.

Engineering may need something similar.

An agent-native engineering artefact could connect the system model with executable analyses, assumptions, configuration state and verification evidence. Humans can still consume documents, diagrams and reports generated from that underlying state.

2. Agent-Native Engineering Infrastructure

A machine-readable product model is useful only if the autonomous system can act on it.

Agents can already operate graphical software, websites and modelling tools. They can write scripts and use applications built for humans. Existing engineering software is therefore not automatically a blocker.

The difficulty is running long engineering workflows reliably and economically.

An autonomous system may need to perform thousands of operations across CAD, simulation, requirements and specialist tools. It has to understand their current state, transfer information correctly, detect failed operations and preserve configuration and provenance.

Agents can use graphical interfaces where no structured interface exists, but this adds interpretation, latency and cost. Direct access to structured state and programmatic actions makes long-running workflows more reliable and efficient.

SciUniverse provides a useful example. Models interact with scientific equipment through several levels of control, from vendor software to Python interfaces and direct firmware commands. The laboratory is being adapted so machines can perceive its state and act within it.

An engineering equivalent could connect agents directly to CAD systems, solvers, system models, test rigs and eventually manufacturing or laboratory equipment.

3. Resource-Aware Validation

Engineering evidence has a cost.

An autonomous system might have several possible next steps: a simple analytical calculation, another parameter sweep, a more detailed simulation, a physical test or a new prototype.

Each provides different information at a different cost.

The DeepMind paper argues that autonomous scientific agents will need to judge whether investigating a hypothesis justifies its cost. Engineering agents would face the same decision continuously.

This applies to AI compute as well. Routine actions may be handled by inexpensive models, while difficult reasoning justifies a more capable one. Fast analytical or surrogate models can screen large design spaces before expensive simulations are invoked.

A useful autonomous engineering system therefore needs some concept of the value of information.

It should be able to choose a cheap analysis when that is sufficient and spend more only when additional fidelity changes the decision.

If design generation becomes abundant, this capability may become one of the main constraints on how much engineering can actually be automated.

4. Orchestration Across the Engineering Loop

The system has to decide what happens next.

A design change may affect several disciplines. A simulation may invalidate an assumption elsewhere in the system. Two competing concepts may require the same scarce test resource. Some work may be best handled by another specialised agent, while other decisions may need a human.

Autonomous engineering therefore involves coordinating agents, engineering tools, evidence and resources around a common objective.

The DeepMind paper takes this idea to the scale of entire scientific ecosystems, where multiple agents and institutions compete and collaborate over scarce resources. Engineering within a company may require much simpler mechanisms, but the underlying allocation problem still exists.

A system has to prioritise work, avoid unnecessary duplication and decide where engineering effort should go.

CAD, simulation, MBSE and AI agents can all exist independently. Connecting them does not by itself create autonomous engineering.

The engineering process becomes autonomous when the system can use its current state and evidence to decide which action should follow.

Why Aerospace Is a Natural Test Case

Aerospace may be one of the first places where the logic of autonomous engineering becomes visible.

Aircraft and spacecraft are already developed through tightly coupled models, multidisciplinary simulation, formal requirements and expensive test campaigns. That creates both an opportunity and a constraint: much of the engineering loop is digital, while the final evidence is costly and safety-critical.

An autonomous engineering system would therefore need to do more than generate designs. It would have to maintain configuration, understand model validity, connect design decisions to verification evidence and manage scarce test resources across disciplines.

What Would Facility-0 for Engineering Look Like?

C5R’s Facility-0 makes the scientific vision unusually tangible.

An AI receives a scientific objective. It can inspect available resources, plan work, interact with instruments, receive measurements and adapt its next action.

An engineering equivalent might begin entirely in the digital domain.

The system receives an engineering objective and builds or updates a system model. It generates alternative architectures, creates detailed models, runs simulations and follows the dependencies between them. It records which assumptions produced each result and decides which concepts justify further analysis.

Later, the same loop could extend into the physical world through test rigs, prototype manufacturing and measurement systems.

The distinction between the engineering model and the engineering process would start to blur. The model would become the state on which autonomous engineering operates, while analysis and testing continually update that state.

Science is beginning to connect AI reasoning to laboratories, experiments and scarce physical resources.

Autonomous engineering would connect AI reasoning to product models, engineering tools, simulation, testing and eventually the physical product.

Working Backwards

This remains a future vision.

But it provides a useful way to inspect today’s engineering environment.

Would an autonomous system be able to understand our product structure?

Could it recover the assumptions behind an analysis?

Could it determine which model produced a result and under which configuration?

Could it run an engineering workflow without relying on undocumented knowledge held by one engineer?

Could it select an appropriate level of fidelity instead of running the most expensive available analysis?

Could it recognise which parts of the system need to be revisited after a design change?

Each weakness in that chain limits autonomous engineering.

Many of the same improvements are valuable today. Better product models, traceability, executable analyses and structured interfaces reduce friction for human engineers and current AI assistants as well.

After the AI Scientist

Autonomous science is beginning to move from an abstract idea towards a systems problem.

Researchers are developing agents that can pursue longer scientific investigations. Laboratories are being adapted so those agents can interact with physical experiments. Other work is asking how scarce experimental resources should be allocated when machines can generate more ideas than we can afford to test.

Engineering may eventually face the same transition.

A human defines what the product needs to achieve and the boundaries within which the solution must exist.

The autonomous engineering system maintains the engineering state, explores solutions, acquires evidence and decides what to do next.

If that direction is plausible, the useful question today is:

What would Facility-0 for engineering look like?

References

• FutureHouse, “What is an AI Scientist?” (2026)
• FutureHouse, “Demonstrating end-to-end scientific discovery with Robin: a multi-agent system” (2026)
• Edison Scientific, “Kosmos: An AI Scientist for Autonomous Discovery” (2025)
• C5R, “SciUniverse” (2026)
• Tomašev et al., “Agentic Economies for Autonomous Scientific Discovery” (2026)
• Freya Gnam, “From Wrong Sums to New Science: AI’s Frontier Keeps Moving” (2026)

AI helped to research and write this article.