Safety and Mission Assurance briefing
A prototype flight-software simulator we built, how it measures up against NASA software standards with evidence you can open, and rules for using AI assistants in aerospace quality assurance
Updated 23 October 2026 · DRACO7RT prototype · NASA cFS on RTEMS/PowerPC, COSMOS ground system, NASA 42 dynamics
Before we start
"Assistant", "session" and "conversation" all mean the same thing in this deck: the AI tool working with one person on one task. No AI runs on the vehicle or in the ground system.
Prototype status
DRACO7RT is a prototype, not a flight article: real NASA cFS flight software cross-compiled for big-endian PowerPC on RTEMS, running on a QEMU board model, commanded from a real COSMOS ground system, with NASA 42 supplying truth dynamics and GPS.
| Final telemetry | Value |
|---|---|
| Mode | POINT |
| Deployed bits | 3 of 3 |
| Momentum dumps / burns | 1 / 1 |
| Delta-v | 0.501 m/s |
| Fuel remaining | 11.836 kg |
| Error count | 1 (intended negative test) |
Values from the mission run of 24 September 2026 on the new server; the re-run of 29 September on the corrected clock passed every phase. Closed evidence run of 23 October: 64 of 66, every requirement covered; the one failure is a dispositioned deviation.
What the prototype is
Truth attitude and orbit dynamics, GPS receiver model
Packs GPS and IMU data as spacecraft-standard (CCSDS) commands and uplinks them
NASA cFS on RTEMS 6, cross-compiled for PowerPC e500, running on a QEMU board model. Apps: attitude control, navigation with spoof gate, limit checker, stored commands, health and safety, checksum
Real ground system: telemetry screens, command sender, scripted mission test. Since October also Yamcs and a planner
The flight software, the real-time operating system, the processor architecture and byte order, the command and telemetry protocol, the ground system and its procedures.
The board and its peripherals, the vehicle dynamics, the GPS receiver, the actuators and their effect. Good enough for software verification, not for hardware qualification.
This is why we self-assess SWE-073, validation on a high-fidelity simulation, as met: the software that runs is the software that would fly.
New in late October
Details and the plan-against-actual table: the DRACO7RT Ground System deck. Run record: claude-notes/PLAN-VS-ACTUAL-2026-10-22.md.
Where the prototype sits under NASA's rules
NPR 7150.2D grades software from A (crew safety) to F (business). Appendix D: Class E is "software developed to explore a design concept or hypothesis but not used to make decisions for an operational Class A, B, or C system" and "can include prototypes of flight and ground systems, developed at minimal cost."
Class E invokes about a dozen requirements: classify, record the classification, assess reuse versus build, determine safety criticality, plan assurance. Everything else on the next slides is applied voluntarily at Class D rigor.
If a program adopted it as an engineering tool it becomes Class D; used to test real mission software, Class C.
The standard makes software safety-critical when a hazard analysis traces to it: it causes, controls, mitigates or detects a hazardous condition. There is no hazard here: no hardware, propellant, range, crew or operational asset. The vehicle is a software model, and "Class E software cannot be safety-critical software."
So SWE-134, the safety-critical design items, is not invoked. The prototype still implements several of them by design, and the SWE-134 slide reports them as voluntary, not as compliance.
Both records were missing until this review. Written 30 September 2026, pending SMA concurrence.
Record: cFS/evidence/rtems_reqs/CLASSIFICATION.md (classification, determination, Class E mapping, AI-code approach, models-and-simulations self-assessment). SWE-020 requires the engineering and SMA technical authorities to agree: that is the ask.
NPR 7150.2D
| Requirement | How we apply it on the prototype | Status |
|---|---|---|
| SWE-052 bi-directional traceability (3.12.1) | 83 numbered requirements (75 when assessed on 30 September and 23 October) traced to parents and to verification, a traceability matrix, and an orphan report for code with no requirement | Partial: no trace to hazards or non-conformances |
| SWE-062 unit test the software code (4.4.5) | Host unit tests at 100% line coverage for all six mission-app source files: the pure attitude-filter, GPS-gate and IMU-gate modules and the three app glue files (117 tests in the cFS test framework); the build gate holds the floors | Met for the mission apps; NASA apps 179 of 182 |
| SWE-065 / 066 / 068 test plans, procedures and reports; test against requirements; evaluate and record results (4.5.2 to 4.5.5) | Scripted mission test with nine phases plus 66 closed-run checks (21 static artifact checks added in October), each naming the requirements it covers; all 75 requirements of 23 October covered (83 today: the 5 CFDP ones by the CFDP run, 3 table rules pending); results recorded per run with commit and image hash | Partial: no formal plan or report documents |
| SWE-073 validate on the targeted platform or high-fidelity simulation (4.5.8) | Real flight software on the real processor architecture and RTOS, on a board-model simulator, commanded from a real ground system | Met |
| SWE-135 static analysis tools for defects, security, coverage and complexity (4.4.4) | cppcheck over the cFE core and the mission apps with dispositioned deviation logs; coverage from unit tests; McCabe complexity recorded per function | Met |
| SWE-079 / 081 CM plan; identify configuration items and versions (5.1.2, 5.1.4) | Baseline with checksummed inputs and pinned component versions; single repository | Partial: no CM plan |
| SWE-134 safety-critical software items a to l (3.7.3) | Safe mode at boot, plausibility gates on GPS and IMU inputs with autonomous response and fallback, watchdog serviced by the Health and Safety app | Partial: see the SWE-134 slide |
None of these rows is invoked for Class E software (Appendix C); we apply them voluntarily at Class D rigor. IDs and wording verified against NPR 7150.2D on NODIS; status updated 30 September 2026. Our assessment, not a formal compliance claim.
Evidence pack, 1 of 2
| Path in the repository | What it is | Supports |
|---|---|---|
| verify/requirements.yaml | Canonical source of truth: 83 DRACO requirements (75 when this row was first written) with id, parent, group and verification method, reconciled with requirements.csv; all still marked proposed pending review | SWE-050, SWE-052 |
| verify/trace.py, verify/build/matrix.json | Requirement to code to test graph built from [dRT-...] tags in the source and the test suites | SWE-052 |
| verify/seal.py, verify/dvr_gate.py | Seals each evidence file with a SHA-256 manifest; build-blocking gate on coverage, seal, status and dangling links | SWE-066, SWE-081 |
| verify/gen_site.py, verify/build/site | Generated compliance web site built from the same data; nothing hand-edited | SWE-052 reporting |
| cFS/evidence/rtems_reqs/TRACE.md | Generated forward and backward trace: 83 requirements, 83 traced to code, 568 tag sites across 76 files, 0 unknown tags (was 75, 75, 427 and 58) | SWE-052 |
| cFS/evidence/rtm/rtm.csv, lint_report.md | cFE (cFS core services) requirements matrix: 397 requirements with source section, verification method, implementation and test references | SWE-052, SWE-066 |
| cFS/evidence/trace/orphans.md | Requirements-to-code trace with confidence tiers (108 high, 255 medium, 34 low) and 270 of 640 flight functions with no requirement | SWE-052 |
All paths relative to the DRACO7RT repository root. Two requirement sets exist: the 83 DRACO-level requirements and the 397 cFE core requirements from the earlier pilot. On the site (signed in): front door https://draco.efsi.com/, tile Evidence: Design Verification Report (HTML), Design Verification Report (PDF), Requirements trace and compliance site (/compliance/, built by verify/gen_site.py).
Evidence pack, 2 of 2
| Path in the repository | What it is | Supports |
|---|---|---|
| cFS/evidence/static/cppcheck_raw.txt, deviation_log.csv | Static analysis with the cppcheck tool over the cFE core (198 findings) and, in mission_apps_*, over the three mission apps and their tables (6 findings, all dispositioned); per-function McCabe complexity in mission_apps_complexity.txt | SWE-135 |
| cFS/evidence/coverage/coverage_report.md, raw/ | Native coverage build of cFE core: 117 of 117 unit tests passed; every number copied from the coverage tool, raw data kept | SWE-062, SWE-135 |
| cFS/evidence/tests/assertion_audit.md | For each of 397 cFE requirements, whether a functional test asserts on it: 161 assert, 12 execute only, 224 no test | SWE-066, SWE-068 |
| cFS/evidence/apps/app_unit_tests.md; cFS/apps/acs and nav unit-test/ | Mission app unit tests with coverage logs: the pure attitude filter, GPS gate and IMU gate modules, and since October the three app glue files (command handling, state machines, telemetry, init and main loop) in the cFS test framework, all at 100% line coverage | SWE-062 |
| cFS/evidence/target/on_target_run.md, on_target_results.log | The cFE functional suite executed on the emulated PowerPC e500 target, results as pass or fail events on the console and in the ground system | SWE-073 |
| cFS/evidence/runs/run_YYYYMMDD_HHMMSS/run.json, console.log | Seventeen target run records (sixteen when first written); each check names the requirement it covers, verdict, evidence file and quoted extracts; git commit and boot image SHA-256 recorded. Latest closed run (23 October) 64 of 66 checks covering all 75 requirements of that date: 21 static artifact checks and 3 app unit-test checks added in October, 7 GPS and 7 IMU checks; one skip, one failure dispositioned as a deviation | SWE-066, SWE-068 |
| cFS/evidence/baseline/BASELINE.md, inputs.sha256; cFS/evidence/logs/campaign-prompts.md | Configuration baseline with checksummed inputs, deviations noted as-is; the written instructions given to the assistant, held as configuration items with session references | SWE-081, SWE-083 |
Also: cFS/evidence/rtems_reqs/MISSION_TEST_DESIGN.md is the mission test design; the executable procedure is the COSMOS script under cosmos/openc3-fogi-open-source/targets/FOGI/procedures.
SWE-134, section 3.7.3
| Item | Prototype |
|---|---|
| a. Initialized to a known safe state | Partial: safe mode, no self-check |
| b. Safe transitions between known states | Met: mode machine tested end to end |
| c. Termination to a known safe state | Not assessed |
| d. Operator overrides need two independent actions | Gap: single command |
| e. Rejects hazardous out-of-sequence commands | Partial: deploy before launch rejected |
| f. Detects inadvertent memory modification | Partial: checksum app present, untested |
| Item | Prototype |
|---|---|
| g. Integrity checks on inputs and outputs | Partial: GPS and IMU input gates |
| h. Prerequisite checks before critical commands | Partial: launch state checked |
| i. No single event initiates a hazard | Not assessed: no hazard analysis |
| j. Responds to off-nominal in time | Partial: sensor fallback in 0.5 s, Limit Checker in 2 s, no requirement |
| k. Provides error handling | Met: event and error counters throughout |
| l. Can place the system in a safe state | Partial: safe mode exists, entry untested |
Two met, seven partial, one gap, two not assessed. SWE-134 is not invoked for Class E and applies only to safety- or mission-critical software: this is a voluntary scorecard. Item text verified against NPR 7150.2D 3.7.3; the two proposed requirements on the next slide address items a, f, g, h, j, k and l.
Safety requirements review
On every boot the startup ROM shall check the current state of every subsystem it hands over: memory, clocks, buses, stored tables, sensors and actuators. It shall report every problem found before flight software starts, and a failed check shall leave the vehicle in a known safe state.
Maps to SWE-134: initialized to a known safe state, prerequisite checks, integrity checks on inputs.
Prototype today: boots straight to flight software in safe mode. No system self-check. Proposed.
If the design has a hardware watchdog, the keep-alive shall be serviced only after the software has verified its own health for that cycle. No task shall service it on behalf of another. Software that is not verified safe shall stop feeding it, so the watchdog resets the system to a safe state.
Maps to SWE-134: recovery from inadvertent memory modification, response within the time needed, error handling, safe state.
Prototype today: Health and Safety app services the watchdog and stops on a monitor failure. Not covered by the mission test. Needs a negative test.
Each requirement needs a test that proves the failure case: a subsystem reported bad at boot, and a reset that actually occurs when software stops being healthy.
Design rule review · 27 October
Every gain, threshold, timer, rate and model parameter a mission engineer might change shall be a cFE table value. A #define is only for structure: message layouts, array sizes, loop timing, physics.
A table change is loaded, validated by the owning app, activated and dumped under Table Services, with a CRC and an event trail. A #define change is a rebuild and a re-verification of the whole executable.
The reused NASA apps pass: all 75 mission values set for LC, SC, SCH, CF and TO_LAB are in tables.
Our three apps fail: 57 tunables compiled in, 0 in tables. ACS 38, NAV 11, IMU 8. Four can be changed by command, but the boot value is still compiled and nothing records the change.
Two platform values stay compiled by necessity (CI_LAB poll, cFE tone window): no table mechanism exists for them.
Four tables, built 27 October: ACS.CFG_TBL (flight: timeline, control, propulsion, estimator) and ACS.SIM_TBL (truth and sensor model, so a scenario change is a table load), NAV.CFG_TBL and IMU.CFG_TBL. Defaults equal the former compiled values; each validation callback names the rule it rejects; an app does not run without its table.
Proved by unit tests (ACS 539, NAV 328, IMU 607 assertions, 100 % line coverage) and on the vehicle: the CFDP uplink carries the file, Table Services loads, validates and activates it, the app reports the new version in an event, and a bad table is refused by name. Requirements dRT-ACS-025, dRT-NAV-010, dRT-IMU-011. The rule is in CLAUDE.md for every future app.
Record: claude-notes/TABLE-CONSTANTS-AUDIT.md (every constant with file and line and its table) and the per-app *_tbl.h headers (the validation rules); the constants that must stay compiled, and why, are listed in both.
Compliance at a glance
| Standard, in plain words | What it asks of a prototype | Where we stand | Evidence |
|---|---|---|---|
| NPR 7150.2D, Class E set: the software rulebook, scaled by class | Classify, keep the record, assess reuse versus build, determine safety criticality, plan assurance | Partial: class, determination and records written 30 September, pending SMA concurrence; assurance plan missing | CLASSIFICATION.md |
| NPR 7150.2D, Class D practices applied voluntarily | Traceability, unit tests, test against requirements, target validation, static analysis, configuration management | 3 met, 4 partial: gaps are documents (test plan and report, CM plan), not engineering | verify/, cFS/evidence/ |
| SWE-134 safety-critical design items | Not invoked: not safety- or mission-critical software | Voluntary scorecard: 2 met, 7 partial, 1 gap, 2 not assessed | SWE-134 slide |
| SWE-146 and handbook 7.25: AI-written code is auto-generated code | Same verification as hand code; the developer reviews and owns it; tool and inputs under configuration control | Applied: same tests, static analysis and review; instructions under CM. The generator itself cannot be validated | CLASSIFICATION.md section 5, campaign-prompts.md |
| NASA-STD-8739.8B: what the independent checker examines | Concur with the classification and the safety-critical determination | Gap: no independent SMA review yet. This briefing is the request | this deck |
| NASA-STD-7009B: how far to trust a simulation, scored 0 to 4 | Assess capability and results; warn about limits and uncertainty when reporting | Verification 2, validation 1, no real-vehicle referent; fidelity gaps disclosed; no formal assessment record | CLASSIFICATION.md section 6, run records |
| NPR 7123.1D: built it right versus built the right thing | Keep verification and validation separate; validate against a stated concept of operations | Verification: 66 closed-run checks covered all 75 requirements of 23 October; 83 today (5 CFDP verified by the CFDP run, 3 table rules pending). Validation: internal only | MISSION_TEST_DESIGN.md |
Project self-assessment for a Class E prototype, not a formal compliance claim. Green: done. Amber: partial with a named gap. Red: needs someone outside the project.
Evidence from one working session
| What the assistant concluded | Why it was wrong | What caught it |
|---|---|---|
| "The process survived, so the crash is elsewhere" | It was blocked waiting on a dependency that had died; the code under test never ran | A screenshot showing nothing |
| "The second experiment failed instantly" | The previous instance still held a port; the new one never started | One line in a log |
| "Telemetry is not flowing" | The first query returned stale values from the previous boot | Packet timestamps |
| "About thirty minutes have passed" | Over three hours had passed | A monotonic counter |
| Bypassed a safety gate on its own to get a green demo; a person approved it after the fact | The gate was correct: the input source had restarted with a rewound clock | The assistant flagged it itself |
| Dropped a display feature to work around a crash, without asking | A feature drop decided by the assistant, not the project | Reported, not asked |
All six happened in one afternoon on the prototype. Each was corrected; each first looked like a result. The pattern generalizes to any project.
The other side of the ledger
The notes said the test had passed a week earlier. The assistant found the vehicle stack down, brought it up, and ran the test again rather than reporting the note.
Ground telemetry, the vehicle console events, and the simulator's truth values were compared for every claim. Position agreed to metres; the autonomy chain was read off the console, not inferred.
A crash was traced with a debugger to a library version mismatch in a binary copied from the old host, then fixed by rebuilding on the new server. The same rule already applied to the flight software.
Every recovery recipe, gotcha and decision went into the engineering notes and the project conventions file during the work, so the next session and the next person start from facts.
Same afternoon as the six wrong turns. The cost was about four hours of wall-clock time and one bypassed interlock that a human had to approve after the fact.
Generic lessons for new projects
A test that passed with an unmet precondition is the most dangerous result an assistant produces. Require positive evidence the code under test executed.
Demand evidence that cannot be stale or vacuous: timestamps, monotonic counters, images, events from an independent source.
Name the safety behaviors as the product before work starts. An assistant cannot tell an interlock from an obstacle on its own.
Quiet counters prove nothing. A dropped command left every error counter at zero; the only evidence was one event line.
Use assistants to execute real end-to-end runs and cross-check independent evidence. Never let them decide which failures are acceptable to route around, or which features to drop.
What NASA says about AI in software work
| Source | What it says | What we did |
|---|---|---|
| NPR 7150.2D, SWE-146, auto-generated code | "Verification and validation of auto-generated source code using the same software standards and processes as hand-generated code." The handbook classes AI code generation as auto-generation under this requirement | AI-written code sits in the same repository under the same tests, static analysis and review as hand code |
| NASA Software Engineering Handbook, topic 7.25 | "If code is generated by AI, the developer is still responsible for the code and must review before submitting." "We do not recommend using AI/ML or GenAI tools to generate, modify, or be safety critical code." AI may support evaluation "where all results can be independently verified" | The person who directed the assistant owns every line. No safety-critical code exists here, and none would be assigned to it |
| NASA Software Engineering Handbook, topic 8.25, AI and software assurance | Treat evaluation as a first-class activity, keep traceability across AI artifacts, and "select oversight mode (in-loop, on-loop, out-of-loop) with documented authority boundaries" and "required approval gates for agentic actions" (NASA's term for an AI tool that acts) | Oversight mode declared: a person in the loop on every task. Gates are enforced by the tooling, not by instructions to the assistant |
| NASA/TM-20250001849, LLMs and assurance arguments (2025) | "Much remains to be demonstrated before it can be concluded that LLMs are fit for use in generating or assessing" assurance arguments; treat the technology "as experimental" | The assistant produces evidence: run records, traces, reports. People write and sign the argument |
| NASA Framework for the Ethical Use of AI (2021) | "Humans must remain in charge." Solutions "must clearly state if, when, and how an AI system is involved." Organizations and individuals "must be accountable for the systems they create" | This deck states where the assistant was used and who is accountable; the notes record it per session |
| NASA OSMA, AI-ready handbook announcement, May 2026 | "AI-generated artifacts (plans, checklists, code comments, evidence mappings) must be reviewed and approved by qualified engineering and assurance personnel" | The compliance site and run records are generated from data and reviewed; nothing is AI-signed |
Sources read 30 September 2026 from NODIS, standards.nasa.gov, swehb.nasa.gov and NTRS. Handbook pages carry an "updates needed" banner; re-check wording before external use.
Proposed rules
| No. | Rule | Basis |
|---|---|---|
| 1 | The assistant is an unqualified tool. Every output it produces is independently verified, or it is not used | SWE-146 item d; handbook 7.25; DO-330 |
| 2 | The assistant runs and observes verification. It never authors or signs the assurance argument, and never generates or modifies safety-critical code | Handbook 7.25; NASA/TM-20250001849 |
| 3 | Every assistant claim links to a retrievable, re-runnable artifact: a run record, a console extract, a counter, a hash. No artifact, no claim | NASA/TM-20250001849; OSMA May 2026; our run records |
| 4 | Prompts, model version, permissions and transcripts are configuration items under the same control as procedures | SWE-081; SWE-146 items b and g; our instructions file |
| 5 | Safety interlocks and command authority are enforced by the tooling around the assistant (its permissions and the gates), not by written instructions. The assistant gets no authority to disable a gate without a recorded human approval | Handbook 8.25 approval gates for agentic actions; the gate we bypassed |
| 6 | A pass requires positive evidence the path under test executed, and the precondition it depended on | Our two invalid experiments |
| 7 | Independence: the assistant conversation that verifies is not the one that wrote the change, and a human reviews the verdict | NASA-STD-8739.8B independence; handbook 8.25 |
| 8 | Feature drops, workarounds and bypasses go on a visible list with a human disposition, and reviewer time is budgeted before the campaign starts | NASA/TM-20250001849; the display feature we dropped |
Rules 1 to 5 follow from published guidance. Rules 6 to 8 came from our own session and fill gaps the standards do not yet address for assistants that act.
Recommendations
Open on the prototype: SMA concurrence on the class and determination, an assurance plan, test plan and report, CM plan, a 7009B assessment record, a startup self-check, a watchdog negative test, and the new ground components in the classification record.