🔢 mathematics

Agentic AutoResearch forSpace Autonomy: An Auditable, LLM-Driven Research Agent for Aerospace Control Problems

This paper introduces AutoResearch, an auditable, LLM-driven framework that autonomously iterates through aerospace control policy development and rigorously validates improvements against seed noise and optimal benchmarks, successfully generating robust solutions for rendezvous and collision-avoidance tasks where undirected search fails.

Original authors: Amit Jain, Richard Linares

Published 2026-06-19

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Amit Jain, Richard Linares

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a robot how to fly a spaceship. You don't just tell it "fly there"; you have to write a complex computer program, tweak its settings, run a test, see if it crashed, and then try again. This process is called "research," and usually, it's done by a human scientist who spends weeks guessing which settings work best.

This paper introduces a new tool called AutoResearch. Think of it as hiring a super-smart, tireless robot assistant (powered by a Large Language Model) to do the guessing and testing for you. But here's the catch: in the world of space and AI, it's very easy to get lucky. A robot might fly perfectly just because of a random "seed" number (like rolling a six on a die), not because it actually learned how to fly.

The authors built a system where the robot assistant does the research, but it has a built-in "Credibility Layer"—a strict quality control inspector that lives inside the loop. This inspector makes sure that any "improvement" the robot claims is real and not just a lucky fluke.

Here is how the system works, using simple analogies:

1. The Research Loop (The Robot Scientist)

Imagine the robot assistant is a chef trying to perfect a soup recipe.

The Task: The human gives the robot a simple description: "Make the soup taste better."
The Action: The robot looks at the current recipe, guesses a change (e.g., "add more salt" or "cook for 5 minutes longer"), and runs the simulation (cooks the soup).
The Result: It tastes the soup and logs the score.
The Cycle: It repeats this hundreds of times, constantly tweaking the recipe to get the best score.

2. The Credibility Layer (The Strict Inspector)

Usually, if a robot says, "I found a better recipe!" you might just take their word for it. But in science, a single good test might just be luck. The Credibility Layer is like a strict food critic who refuses to believe the robot until three things happen:

Measuring the Noise: First, the critic measures how much the soup naturally varies just by chance. (e.g., "Even with the same recipe, the taste changes by 1 point just because of random factors.")
Reseeding (The Re-Test): If the robot claims a new recipe is amazing, the critic doesn't just taste it once. They make the soup ten times with different random seeds. If the recipe is truly better, it must be delicious in all ten tries, not just one lucky time.
Pruning (The "What Actually Worked?" Check): If the robot changed five things (salt, pepper, heat, time, and lid), the critic checks each one individually. They ask, "If we remove the extra salt, does it get worse?" This proves exactly which change actually made the soup better, rather than just guessing.

3. The Space Missions (The Tests)

The authors tested this system on two real space problems:

Mission A: The Rendezvous (The Parking Job)
- Goal: Fly a spaceship to dock with another one in orbit.
- Result: The robot assistant found a way to dock the ship with incredible precision. The "lucky" random search (just guessing settings without a smart assistant) got stuck at a much lower level of performance. The robot's solution was so good that it cleared the "noise" by a huge margin (15 times the normal variation).
Mission B: The Keep-Out Zone (The Dangerous Parking Job)
- Goal: Dock with a spaceship, but you must fly around a dangerous "Keep-Out" sphere in the middle. If you hit it, you crash.
- Result: This was much harder. The random search failed completely; it couldn't find a single way to dock without crashing. The robot assistant, however, figured out a path that went around the danger zone and docked safely.
- The Audit: The Credibility Layer checked this result ten times. Every single time, the robot's policy stayed safe and docked successfully. The random search never succeeded even once.

The Big Takeaway

The paper isn't about a new way to fly spaceships; it's about a new way to discover how to fly them.

The authors show that you can use an AI to run the research process, but you must wrap it in a strict "audit" system. This system filters out luck, proves that the results are real, and identifies exactly which changes made the difference. It turns a chaotic, lucky guessing game into a reliable, honest, and auditable scientific process.

In short: AutoResearch is a robot scientist that does the work, but a strict inspector ensures the results are real before anyone celebrates.

Technical Summary: Agentic AutoResearch for Space Autonomy

Problem Statement

The development of learned guidance, navigation, and control (GNC) policies for spacecraft is inherently an iterative research process. Investigators must select architectures, tune hyperparameters, and run experiments to determine if performance gains are genuine or merely artifacts of random seed variation (seed noise). This process is labor-intensive and prone to "over-claiming," where a single favorable run is mistaken for a robust result. While Large Language Models (LLMs) have emerged as capable autonomous agents for research, automating this loop introduces a new risk: an agent that experiments faster may compound the risk of mistaking noise for progress if statistical discipline is not enforced.

The core problem addressed is how to automate the aerospace control research loop using an LLM while ensuring that every reported improvement is statistically significant, reproducible, and auditable against the specific problem's measured seed noise.

Methodology: The AutoResearch Framework

The paper introduces AutoResearch, a framework where an LLM acts strictly as an offline research agent to develop control policies, coupled with a credibility layer that operates within the loop to certify results. The framework is designed as a closed, machine-readable state machine.

1. The Family Contract

To ensure reusability across diverse aerospace problems, the framework defines a "family" abstraction consisting of four artifacts:

Problem Description (program.md): A plain-language specification of goals, metrics, baselines, and allowed change scopes.
Editable Training Script (train.py): Contains a delimited region of hyperparameters (the "editable surface") that the agent can modify. The underlying dynamics, solvers, and evaluation protocols remain immutable.
Registry (family.json): Holds the target metric, reference baseline, and current best configuration.
Append-only Log (runs.jsonl): Records every completed experiment.

2. The Agent Loop

The loop consists of three modules:

Proposer: An LLM (specifically Anthropic's Claude Sonnet 4.5 in the experiments) that reads the problem description, run history, and current hyperparameters. It is forced to output a structured tool call: either propose_experiment (with a hypothesis, specific hyperparameter overrides, and a predicted failure criterion) or stop_research. The system operates in blind mode, withholding the target metric and baseline values from the agent to prevent memorization and force genuine iterative search.
Runner: Executes the proposed configuration by patching the editable region of train.py, running it as an isolated subprocess, and parsing a single structured metric line.
Orchestrator: Manages the state machine, enforces termination conditions (e.g., budget limits, plateau detection), and ensures distinct configurations are not re-evaluated.

3. The Credibility Layer

The core innovation is a statistical audit layer that gates every reported result. A result is only credited if it passes three checks:

Measured Seed Noise: Before any improvement is claimed, the framework measures the standard deviation ( $\sigma$ ) of the metric across $K$ seeds of a fixed baseline configuration. This $\sigma$ serves as the unit of measurement for all subsequent claims.
Reseeded Verification: The agent's best configuration is re-run on a set of fresh, held-out seeds. To be accepted, the mean improvement must exceed the baseline by at least $2\sigma$ (a one-sided effect-size gate), and the policy must satisfy all hard safety constraints on every seed.
Leave-One-Out Pruning: To identify which edits actually contributed to the result, the framework reverts each modified parameter individually. Parameters are classified as "load-bearing" (reverting hurts performance), "inert hitchhikers" (reverting has no effect), or "moved in the wrong direction" (reverting helps). This process distinguishes genuine contributions from coincidental correlations.

Key Contributions

The paper makes three primary contributions:

A Reusable Framework for Agentic Experimentation: A "family contract" allowing the same agent loop to be applied unchanged to problems with sharply different physics (e.g., relative orbital motion vs. collision avoidance).
A Credibility Layer for Trustworthy Autonomy: A statistical audit mechanism that denominates results in measured seed noise, requiring reseeded verification and leave-one-out ablation to separate real gains from seed luck.
Audited Results on Aerospace Control Problems: Demonstration of the framework on two distinct spacecraft guidance problems, showing that the audited policy clears measured seed noise by many standard deviations, whereas undirected random search fails to do so.

Experimental Results

The framework was tested on two problems using behavioral cloning to distill optimal-control solvers into feedback policies.

1. Clohessy–Wiltshire Relative Rendezvous

Task: Learn a policy to drive a chaser spacecraft to a target from various initial conditions.
Outcome: The LLM agent reduced the mean terminal distance from ~16m (baseline) to 0.094m (single-seed best).
Audit: Reseeding over 10 fresh seeds yielded a mean of 0.101m, a gain of 15.0 $\sigma$ over the baseline.
Comparison: A matched undirected random search plateaued at ~0.635m.
Pruning: Identified five load-bearing edits (demonstrations count, training budget, learning rate, hidden width, depth) and four inert edits that mattered only in combination.

2. Safety-Constrained Collision-Avoidance Docking

Task: Dock past a "keep-out" zone (a sphere the spacecraft must not enter) while reaching a target on the far side.
Outcome: The agent found a policy with a safety-aware docking score of 0.33 (single-seed best).
Audit: Reseeding over 10 fresh seeds yielded 0.38, a gain of 5.2 $\sigma$ . Crucially, 100% of the reseeds were strictly feasible (zero keep-out zone violations).
Comparison: Undirected random search (24 trials) produced zero feasible policies. The best random score was 6.46, and most runs drifted away from the target.
Pruning: Identified that the number of demonstrations and training budget were the primary load-bearing factors. The run-time Control Barrier Function (CBF) safety filter was essential for feasibility.

Significance and Claims

The paper claims that the primary contribution is the autonomous, auditable research process itself, rather than a new guidance law. The significance lies in:

Statistical Rigor in Automation: Demonstrating that LLM-driven research can be made honest and reproducible by integrating statistical discipline (seed noise measurement, retesting, ablation) directly into the loop, rather than as an afterthought.
Safety-Critical Validation: Showing that the framework can certify policies for safety-constrained problems where undirected search fails completely to find any feasible solution.
Separation of Concerns: The LLM acts solely as the offline researcher; the trained policy is the only component deployed onboard. This ensures the LLM never directly commands the vehicle, mitigating risks associated with LLM hallucination in real-time control.

The authors remain modest regarding the scope, noting that the campaigns were limited to tens of iterations (trading throughput for credibility) and that the random-search comparison, while indicative, was secondary to the seed-noise gate. The work establishes a foundation for "fast, and honest" development of learned autonomy for future space missions.