Ariane 5 Flight 501 and the Assumption No Review Saw
The Ariane 501 Inquiry Board found traceable documents and three decisions whose reasoning stayed out of review. What it asked for, and what it means now.

In short
Ariane 5 Flight 501 broke up 39 seconds after the main engine ignition command on 4 June 1996. The Inquiry Board traced the loss to an unprotected data conversion in inertial reference software reused from Ariane 4, inside an alignment function that served no purpose on Ariane 5 after lift-off. The Board found the program's documents complete and traceable. What did not surface for a reviewer was the reasoning behind three decisions: why three variables were left unprotected, why the Ariane 5 trajectory stayed out of the specification, and why the reused function kept running in flight. Its recommendations ask for that reasoning to be written down and reviewed with the code, and the same request applies to any change whose author, a person or an agent, works from assumptions the reviewer cannot see.
What happened on 4 June 1996
The weather at Kourou was acceptable, the countdown went smoothly apart from a hold for visibility, and ignition and lift-off were nominal. Then, in the words of the Inquiry Board appointed by the Director General of ESA and the Chairman of CNES, the launcher "suddenly veered off its flight path, broke up, and exploded" (Ariane 5 Flight 501 Failure, Report by the Inquiry Board, 19 July 1996, section 1.1).
The Board, chaired by Professor Jacques-Louis Lions, worked backward from the destruction of the launcher. Both inertial reference systems, the SRIs, had stopped at around 36.7 seconds after the main engine ignition command. The backup unit failed first, and the active unit failed about 0.05 seconds later for the same reason, since the two ran identical hardware and identical software. With no valid attitude data, the active unit sent a diagnostic bit pattern that the on-board computer "interpreted as flight data". The computer commanded full deflection of the booster nozzles and then of the main engine nozzle, the angle of attack passed 20 degrees, and the aerodynamic loads tore the boosters from the core stage, which triggered self-destruction.
The cause inside the software was small. A conversion from a 64-bit floating point value to a 16-bit signed integer received a number too large to represent, and "This resulted in an Operand Error" (section 2.1). The variable was BH, the horizontal bias, an indicator of alignment precision. Its value was far above anything seen on Ariane 4, because the early trajectory of Ariane 5 builds horizontal velocity "five times more rapid than for Ariane 4" (section 3.1, finding p).
A function that had no job in flight
The conversion sat in the alignment software, which computes meaningful results only before lift-off. On Ariane 4 the function kept running for 50 seconds after the SRI entered flight mode, so that a late hold in the countdown could be recovered without a normal alignment, which takes 45 minutes or more. The feature had been used once, on Flight 33 in 1989. The Board's account of the timing is plain: "This time sequence is based on a requirement of Ariane 4 and is not required for Ariane 5" (section 2.1).
The requirement survived the move to the new launcher anyway. The Board states that it "was maintained for commonality reasons, presumably based on the view that, unless proven necessary, it was not wise to make changes in software which worked well on Ariane 4" (section 2.2). The word presumably matters: on this point the Board gives its own reading of the reason for keeping the function in flight software.
Reuse of proven software is sound engineering, and ESA's summary of the report notes that its recommendations come "Without implicating the system architecture" (ESA, Ariane 501, Presentation of Inquiry Board report, media advisory 33-1996). The Board's concern was what traveled with the reused code. The software arrived carrying an Ariane 4 requirement and an Ariane 4 trajectory assumption, and neither was restated for Ariane 5.
Three decisions, and where their reasons lived
The report names the decisions that let the error through, and for each one it says whether the Board could find the reasoning behind it.
The first decision was which conversions to protect. An analysis of every operation that could raise an exception found seven variables at risk of an Operand Error. Four were protected, three were left as they were, and "No reference to justification of this decision was found directly in the source code" (section 2.2). The three were judged "either physically limited or that there was a large margin of safety, a reasoning which in the case of the variable BH turned out to be faulty". The Board was told that a maximum workload target of 80% for the SRI computer explained why not every conversion was protected. Its conclusion on the record is the sentence this essay is built around: "Given the large amount of documentation associated with any industrial application, the assumption, although agreed, was essentially obscured, though not deliberately, from any external review."
The second decision was what the specification would contain. The Board found "no evidence that any trajectory data were used to analyse the behaviour of the unprotected variables", and added that "it was jointly agreed not to include the Ariane 5 trajectory data in the SRI requirements and specification" (section 2.2). The specification also stated no operating limits for the unit. On that gap the Board wrote: "Such a declaration of limitation, which should be mandatory for every mission-critical device, would have served to identify any non-compliance with the trajectory of Ariane 5" (section 2.3).
The third decision was how to test. When the test philosophy was first defined, the SRIs were to be in the closed-loop system simulation. In 1992 that changed, and simulated SRI output took their place, for reasons the Board judged "technically valid". It still found "a definite risk in assuming that critical equipment such as the SRI had been validated by qualification on its own, or by previous use on Ariane 4" (section 2.3). At equipment level, a ground test injecting simulated Ariane 5 signals was feasible, and "Had such a test been performed by the supplier or as part of the acceptance test, the failure mechanism would have been exposed."

The Board records the first two as agreed jointly between partners and the third as taken for stated reasons, and each fits software that had already flown on Ariane 4. What it could not find was the reasoning written down where a reviewer would meet it: the justification for the unprotected variables was absent from the code, and the trajectory the alignment requirement assumed was absent from the specification. The reviews examined the code and its test results with those two pieces missing.
What a traceable record left out
The detail that makes Flight 501 a lesson in traceability comes from the foreword. The Board based its findings on "documentation which has demonstrated the high quality of the Ariane 5 programme as regards engineering work in general and completeness and traceability of documents". By that account, the documents were in order.
Document traceability links requirements, specifications, code and tests to each other. Those links record what depends on what. The conditions a decision rested on, such as the trajectory a requirement assumed, have no place in them, and on Flight 501 the Ariane 5 trajectory was missing from the specification itself. The Board describes a review process that worked at scale: "In a programme of this size, literally thousands of problems and potential failures are successfully handled in the review process", and yet "the limitations of the SRI software were not fully analysed in the reviews, and it was not realised that the test coverage was inadequate to expose such limitations." Its finding on the review process is direct: "In these respects, the review process was a contributory factor in the failure" (section 2.3).
The Board also named the stance underneath. The software had been treated as correct until shown to be at fault, and the exception handling was designed for random hardware failures, the kind a backup unit can absorb. A design error in software that runs identically on both units defeats that backup, and on Flight 501 it switched off "two still healthy critical units of equipment" (section 2.2). The Board's own position is the reverse: "software should be assumed to be faulty until applying the currently accepted best practice methods can demonstrate that it is correct."
What the Board asked for
The fourteen recommendations include technical fixes, such as switching off the alignment function after lift-off and letting a sensor keep sending best-effort data. Several of them ask for something else: that the reasoning be recorded, kept beside the code, and examined.
- R4 asks that "All restrictions on use of the equipment shall be made explicit for the Review Board."
- R5 asks reviewers to "Identify all implicit assumptions made by the code and its justification documents on the values of quantities provided by the equipment" and to check them against those restrictions.
- R9 asks for external participants in the reviews of specifications, code and justification documents, and adds: "Make sure that these reviews consider the substance of arguments, rather than check that verifications have been made."
- R10 asks to "Include trajectory data in specifications and test requirements."
- R12 asks to "Give the justification documents the same attention as code. Improve the technique for keeping code and its justifications consistent."
Read together, they describe a record in which each decision carries its reason, each reused component carries the conditions it was proven under, and a reviewer can test the argument as well as the result. R9 puts the weight of a review on whether the argument holds.
What changes when an agent writes the change
No agent was involved in 1996, and the Board's recommendations apply to code written by anyone. They bear on agentic engineering because an agent's reasoning about a change sits in its working context, which a reviewer usually does not read. An AI coding agent works from a task description, the files it was given, and the conversation that led to the change. Its choices, which inputs to guard, which existing function to reuse, which case to leave out, are shaped by that context, and the diff it hands over does not contain it. The same holds for a change written by a person from a ticket and a hallway conversation, and Flight 501 shows what that costs when the change is critical.
Read as a list for a single change, by analogy and on a much smaller scale than a launcher, the recommendations suggest what an agent-written change should bring to its reviewer. R5 points to the assumptions the change rests on, written where the reviewer reads them. R4 points to the limits of any code it reused or produced. R10, which concerned trajectory data, has a counterpart in the conditions the change was tested under and those it was not tested under. R12 asks that the justification stay consistent with the code as both are revised. The pillar on agentic engineering describes this as the acceptance problem: a person has to decide that the work can be trusted, and that decision needs the reasoning as well as the output.
R9 adds the question of who reviews. The Board asked for participants external to the project. Our IV&V article treats the distance between producer and checker as a range, and a second model reading the first model's output sits close to the producer on a range that ends at a separate organization. In civil aviation the reviewer's expectations are fixed by DO-178C, and our piece on design assurance levels marks the objectives whose evidence an agent-written change affects, including traceability from code to requirements.
Where Kealu Vector fits
The Agentic Engineering Assurance Layer is the proposed category for the layer that governs how agentic engineering work is performed and evidenced, so that humans can trust and accept the resulting work. Our white paper AI Has Moved the Bottleneck sets out the problem it answers, and the questions raised here hold whatever tools a team uses to answer them. Kealu Vector, currently designated Vector Assurance Assist, is our early-access implementation of that category.
FAQ
What caused the Ariane 5 Flight 501 failure?
The Inquiry Board found that both inertial reference systems stopped about 37 seconds after main engine ignition, when a conversion from a 64-bit floating point value to a 16-bit signed integer overflowed. The variable, the horizontal bias, grew larger on Ariane 5 than on Ariane 4 because of a faster build-up of horizontal velocity. The conversion was unprotected, the exception shut down both units, and the on-board computer read diagnostic data as flight data and steered the launcher into loads that broke it up. The Board summed it up as "specification and design errors in the software of the inertial reference system".
Why was Ariane 4 software running on Ariane 5?
The inertial reference system of Ariane 5 was practically the same as the one flying on Ariane 4, including its software. The alignment function that failed was kept running for about 40 seconds after lift-off to allow a quick restart after a late countdown hold, a requirement of Ariane 4 that did not apply to Ariane 5. The Board wrote that it was kept "for commonality reasons", presumably because changing software that worked well on Ariane 4 was judged unwise unless proven necessary.
What role did traceability play in Ariane 501?
The Board's foreword credits the program's documentation with completeness and traceability. The gap was in the reasoning behind decisions. The choice to leave three variables unprotected had no justification in the source code, the Ariane 5 trajectory was kept out of the SRI specification by joint agreement, and the specification stated no operating limits. The Board concluded the assumption was "essentially obscured, though not deliberately, from any external review", and asked that justification documents get the same attention as code.
What did the Ariane 501 Inquiry Board recommend?
The Board made fourteen recommendations. The technical ones include switching off the alignment function after lift-off, closed-loop system testing with as much real equipment as feasible, and letting sensors keep sending best-effort data. The ones on evidence ask that restrictions on use of equipment be made explicit, that implicit assumptions in code be identified and checked, that trajectory data go into specifications and test requirements, that reviews include external participants and weigh the substance of arguments, and that code and its justifications be kept consistent.
What does Ariane 501 teach about reviewing agent-written code?
A reviewer can only judge the reasoning the record carries. An AI coding agent makes choices from context the diff does not show, such as which inputs to guard or which function to reuse. The Board's recommendations carry over: state the assumptions a change rests on, make the limits of reused code explicit, record what the change was tested against, and keep the justification consistent with the code. A review then weighs whether the argument holds, which is what the Board asked of the Ariane 5 reviews.
On Google
Add Kealu as a preferred source: our articles get highlighted in Top Stories, AI Mode and AI Overviews.
Talk to our team.
Questions about this article, or about using Kealu Vector in your organization? Send us a message.
Talk to our team.

