A public experiment found a ChatGPT-style model completed simulated spacecraft manoeuvres faster and with fewer errors than human-run simulations. Researchers put the model inside a simulator, fed it the same instrument readouts and mission prompts a human pilot would see, and translated its text responses into control actions. The report lists three operational advantages the model showed: greater speed, fewer human errors and an ability to generalise to novel scenarios. The tests were strictly simulated, so hardware trials and certification remain unfinished.

1. Define the task and mission profile clearly

The single most important step is exhaustive Task scoping. Convert the pilot role you want the AI to perform into explicit objectives, for example orbital insertion, station-keeping, docking, trajectory correction burns or re-entry control. The public account emphasises that the experiment succeeded where objectives were clear and instrument-level inputs matched explicit control outputs.

For each objective set measurable success criteria: position error limits, fuel consumption thresholds, attitude error bands and time-to-complete. Worked example: if the mission is docking, define maximum relative position error in metres, maximum allowed attitude deviation in degrees, and an allowable fuel budget. The experiment shows success depends on those crisp targets.

2. Build or pick a high-fidelity simulation and telemetry feed

That said, next, choose a simulator that supplies realistic instrument readouts. The reported test used a simulated spacecraft environment that provided the telemetry streams a real vehicle would supply, and the model relied on those streams as primary inputs.

Make sure the simulator delivers gyros, star tracker or attitude sensor outputs, accelerometer vectors, engine thrust and fuel-level data. Include mission-specific sensors where relevant. Worked example: a simulator that exposes reaction wheel torque, thruster status, and a star tracker attitude solution lets the model see the same signals a human pilot would use.

3. Assemble the data and instruction set the model will receive

Translate cockpit procedures, checklists and instrument readouts into the data format the model will consume. The public account describes feeding the model data and instructions similar to what a human pilot would use, so the format and units matter.

Include time-stamped sensor vectors, clear unit conventions and the textual mission instructions. If you use a language model, convert numeric telemetry into structured prompts or embeddings that preserve units and state. Worked example: present roll, pitch and yaw as labelled numbers with timestamps and supply the current propellant reading and engine throttle setting in the same prompt.

4. Choose the model interaction pattern: prompts, fine-tuning, or hybrid

The reported experiment used a ChatGPT-style model responding to prompts. There are three practical approaches to run with this architecture. First, Prompt engineering keeps the base model unchanged and relies on carefully designed prompts to elicit control actions. Second, Fine-tuning adapts model weights on domain-specific examples mapping telemetry to actions. Third, a Hybrid approach fine-tunes core behaviours and uses prompts for scenario-specific instructions.

Which to pick depends on compute, data and safety requirements. Worked example: with limited labelled telemetry-action pairs, start with prompt engineering and simulator rollouts. With abundant transcripts of telemetry-to-action pairs, fine-tune to shorten decision latency and improve consistency.

The experiment converted model outputs into simulator control actions. You must design a deterministic translator that maps model language to actuator commands and enforces unit, rate and limit checks. This Safety translator is the enforcement layer that prevents raw model outputs from causing out-of-spec actuation.

Translate an instruction like rotate 2 degrees yaw into verified actuator commands, such as reaction wheel torque or thruster firings with capped pulse widths. Worked example: require every model action to carry a numerical target, a unit, and an explicit limit flag so the translator can validate before issuing low-level commands.

The public account highlights the model's ability to interpret instruments and plan sequential actions. Training should teach the model temporal patterns: how sensor states evolve after control inputs and how to plan multi-step manoeuvres.

Where labelled telemetry-to-action transcripts exist, supervised fine-tuning helps. Where examples are scarce, use iterative prompting plus simulator rollouts to build competence. Worked example: train the model on sequences showing how a commanded yaw change affects star tracker readings over several seconds so the model learns cause and effect across time.

Mastheads

Although the report notes fewer human errors for the model, independent safety systems remain essential. Implement hard constraints in software and hardware that block commands outside mission envelopes, cross-check redundant sensor streams and revert to a safe state on inconsistent inputs.

Worked example: require two independent attitude solutions to agree within a threshold before allowing a commanded burn. The public experiment relied on a controlled simulated environment, so any move toward real hardware must add independent constraint enforcement that doesn't depend on the model's judgement.

Structure tests to start with nominal scenarios and then add sensor noise, actuator delays and component failures. The reported account compared model runs to human-controlled simulations, so mirroring that setup lets you make apples-to-apples comparisons.

Measure everything against the success criteria from Step 1 and record failure cases for iteration. Worked example: first test orbital insertion with perfect sensors, then introduce star tracker dropouts, then add a simulated thruster misfire and measure whether the model meets the predefined thresholds.

9.

Decide human-in-the-loop or human-on-the-loop and design the interface

The report compared model performance to human runs, so pick an operational posture: keep a human actively piloting with model assistance, or let the model run with human oversight and intervention capability. The human interface should present concise model rationales, confidence metrics and an easy override mechanism.

Worked example: show a short textual rationale alongside the proposed command and a confidence score. Allow a single keystroke to switch control to the human operator. The public account supports the model as an assistant or autonomous controller in simulation, but it doesn't remove the need for human oversight in real operations.

The source notes models can generalise and adapt. If you allow online learning, limit the scope and rate of parameter changes and require sandboxed validation before any update controls a live vehicle. Prefer simulated trials for policy updates and formal verification before deployment.

Worked example: accept model updates only after they pass a predefined battery of simulator tests and a review of the recorded run logs. The reported experiment indicates adaptability is useful, but it also shows adaptation must be shackled to verification.

The experiment succeeded where inputs, prompts and simulator conditions were controlled and reproducible. Keep an auditable record of prompts, datasets, simulator versions, model checkpoints and run logs so you can analyse failures and support any future certification process.

Worked example: store every prompt and telemetry snapshot with timestamps and the exact model checkpoint used. The public write-up emphasises reproducibility as a core part of reliable behaviour.

The account is explicit that tests were simulated. For a real-world progression move from pure simulation to hardware-in-the-loop where real avionics and sensors feed the control stack on the ground, then to tethered or constrained flight tests before any free-flight evaluation. Each stage should re-run the full test battery and safety checks.

Worked example: after simulator success, connect the model to an avionics bench so the actual sensors feed the decision stack, then run the same fault-injection tests used in simulation. The public material stops at simulation, so these next stages are necessary steps rather than reported results.

Limitations to keep front of mind

The available public account describes early simulated experiments. It doesn't publish raw telemetry, model checkpoints, technical audits of safety performance under failure modes, or any certification-level analysis. Nor does it detail regulatory approvals or human review processes. Treat the reported performance as promising for prototyping inside simulators rather than as evidence of operational readiness.

How to use this guide, for you

I'll tell you straight: the experiment shows language models can interpret instrument data and produce control actions in a simulation, but you should only follow this route if you accept a long, verifiable pathway to hardware trials and certification. Start with rigorous task scoping and a simulator that mirrors the flight telemetry you actually have. Use the 12 steps above as your checklist and record everything so you can prove what you did.

In Short
- Define measurable mission objectives and success criteria before you touch a model.
- Use a high-fidelity simulator that supplies the real telemetry streams your vehicle uses.
- Translate telemetry into structured prompts or fine-tune a model on telemetry-to-action pairs.
- Build a deterministic safety translator and independent hard constraints.
- Move gradually from simulation to hardware-in-the-loop with full audit trails.

Related Articles

The concrete experimental fact is this: a ChatGPT-style model, given instrument-level data and mission commands in a simulator, produced control actions that, in the reported tests, sometimes completed manoeuvres faster and with fewer errors than human-controlled runs.

This article was created with AI assistance.