Independent Verification and Validation (IV&V) for Agentic Work

IV&V puts verification in the hands of an organization independent of the developer. Where each check on an agent-made change stands, and what it proves.

Independent Verification and Validation (IV&V) for Agentic Work

In short

Independent verification and validation, IV&V, is verification and validation performed by an organization that is technically, managerially and financially independent of the one that built the system. Safety standards place independence requirements on two roles: the people who verify and validate the work, kept apart from its authors by role, reporting line or organization, and the assessor who judges whether the work and its evidence are adequate, whose independence IEC 61508 grades from a person to an organization. When a coding agent produces a change, each check on it stands somewhere between the producer and a separate organization. A second model, a second agent or a different prompt checks the work again with a new execution, and research on language models shows their errors are correlated, so that check stays close to the producer. The required separation is set before the work, and the record of the change has to say where every check actually stood.

What IV&V means

NASA's software assurance standard defines IV&V as "a technical discipline of software assurance" and states its independence in three parameters: "Three parameters define the independence of IV&V: technical independence, managerial independence, and financial independence" (NASA-STD-8739.8B, Software Assurance and Software Safety Standard, 2022, section 4.4.1). Each one is spelled out:

  • Technical independence "requires that the personnel performing the IV&V analysis are not involved in the development of the system or its elements." The standard gives the reason: "the IV&V team's different perspective allows it to detect subtle errors overlooked by personnel focused on developing the system."
  • Managerial independence "requires that the personnel performing the IV&V analysis are not in the same organization as the development and program management team", and it means "the IV&V team makes its own decisions about which segments of the system and its software to analyze and test, chooses the IV&V analysis methods to apply, and defines the IV&V schedule of activities."
  • Financial independence "requires that the control of the IV&V budget be vested in a group independent of the software development organization", which the standard says need not mean the IV&V team controls the budget, as long as "No adverse financial pressure or influence is applied."

NASA's program overview attributes the three parameters to the IEEE, whose standard for system, software and hardware verification and validation is IEEE 1012, now in its 2024 edition (NASA, IV&V Overview). The same page gives the two questions behind the name: verification asks "Are we building the product right?" and validation asks "Are we building the right product?" The security world uses a shorter definition, review, analysis and testing "performed by an objective third party", and attaches the two words the other way around, a reminder that the vocabulary differs between domains (NIST CSRC Glossary, citing CNSSI 4009). NASA's handbook sets the top of the range for its own programs: the IV&V analysis "must be performed by an organization that is financially, managerially, and technically independent and cannot be part of a company associated with the development organization" (NASA Software Engineering Handbook, SWE-141).

How the standards set independence

Full IV&V is the far end, and the standards that govern consequential software rarely ask for it everywhere. They set separation by the consequence of failure, and they set it for different roles.

  • Functional safety. IEC 61508 grades the independence of the functional safety assessor. The IEC's own explanation says it "ranges from an independent person in the same organization for safety integrity level 1 to an independent organization for safety integrity level 4", with the levels between affected by factors including complexity, novelty of design and the developers' experience, and adds that a separately managed internal organization can meet the top step (IEC, Functional Safety FAQ). Our article on functional safety and safety integrity levels covers how the rest of that standard treats an agent.
  • Railway software. EN 50716:2023, which replaces EN 50128 and EN 50657 and whose date for withdrawing conflicting national standards is 30 October 2026, separates the verifier and validator from the requirements manager, designer and implementer at every integrity level, bars the implementer of a component from testing it from SIL 1, and at SIL 3 and SIL 4 keeps the validator from reporting to the project manager. The assessor is organizationally independent from SIL 1 upward and may sit in any stakeholder organization, supplier included (EN 50716:2023, clause 5.1).
  • Space software. For projects reaching Key Decision Point A, NASA requires software IV&V on Category 1 projects, on Category 2 projects with Class A or Class B payload risk, and on projects its Mission Directorate Associate Administrator selects, and plans software assurance for every project (NPR 7150.2D, sections 3.6.1 and 3.6.2). At the level of one test it only recommends: a note to the coverage requirement for safety-critical code says "It is recommended that someone independent of the developer of the code under test design and perform this testing to ensure requirement interpretation or incorrect assumptions do not escape this testing" (section 3.7.4).
  • Medical devices. Until February 2026, the US design control regulation required every design review to include "an individual(s) who does not have direct responsibility for the design stage being reviewed" (21 CFR 820.30(e), as of 31 December 2025). The new quality management system regulation relies on ISO 13485 instead, and the FDA acknowledged that it "does not include the explicit requirement" while describing "the important contribution of independent review to the design and development process" (FDA, final rule, 89 FR 7496, at 7511 to 7512).
  • Security authorization. When a control assessment supports an authorization decision or ongoing authorization, "the authorizing official makes an explicit determination of the degree of independence required" (NIST SP 800-37 Rev. 2, Appendix D).

Across these domains, the checker is kept apart from the producer by role, by reporting line or by organization; the required separation rises with the consequence of failure; and where a standard does not fix the point, an accountable person or body does. The standards also state competence beside independence for the same roles: the IEC adds that the assessor "shall be competent". The purpose of that separation is to make it less likely that the checker's errors coincide with the producer's, and to give an objective view of the work.

Why the standards care about shared mistakes

The railway standard names the risk. Its objective for independence between roles is to reduce the probability of people in different roles suffering from "the same misconceptions or making the same mistakes", and its second objective is that those who judge acceptability are not "influenced by pressure from their peers or supervisors, or by considerations of commercial gain" (EN 50716:2023, clause 5.1.1).

Distance lowers shared error without removing it, and software engineering has measured that for forty years. In the experiment John Knight and Nancy Leveson ran at two universities, students wrote 27 programs from one requirements specification, each run against one million randomly generated test cases. A report to NASA found "a large number of fault pairs that exhibit statistically-correlated behavior", and the surprise was in the faults themselves: "various different and apparently unrelated faults were triggered by the same special situation in the input" (Knight, Detection of Faults and Software Reliability Analysis, progress report to NASA, 1986). Independent people still failed together on the hard cases, and multi-version systems built from their programs still gained "a substantial benefit".

Studies of language models report a similar effect in another setting. Across more than 350 models, one study found "substantial correlation in model errors": on the HELM leaderboard, "pairs of models agree on average about 60% of the time when both models are incorrect", where random choice among the wrong answers would give one in three. The authors add that "larger and more accurate models have highly correlated errors, even with distinct architectures and providers", and that a model used as a judge "systematically inflates the accuracy of models that are less accurate than itself" because of correlated errors (Kim, Garg, Peng and Garg, Correlated Errors in Large Language Models, ICML 2025). The figures come from multiple-choice questions, a resume-screening set shows the same correlation, and the authors conclude that "models are also converging in the errors that they make."

Checks by the producing model itself have a further weakness. In the context of reasoning, models "struggle to self-correct their responses without external feedback"; on one multiple-choice benchmark a 2023 model fell from 75.8 percent to 38.1 percent after a round of self-correction, which the authors trace to the prompt pushing it toward other plausible options (Huang and others, Large Language Models Cannot Self-Correct Reasoning Yet, ICLR 2024). Models used as evaluators also show self-preference, where "an LLM evaluator scores its own outputs higher than others'" that human annotators rate as equal (Panickssery, Bowman and Feng, 2024). Both are evidence about a mechanism, a producer judging its own output without an external reference, and neither measures code review; a test suite in the loop is the external feedback the first study says the models lacked. Our perspective paper draws the conclusion for engineering work: "A different prompt or model is not, by itself, a guarantee of independent judgment" (More Code Is Not More Progress).

The independence range for one change

Take one change. A coding agent rewrites the function that rejects out-of-range sensor readings before a safety-related controller acts on them. The change can be checked at six points, from the agent itself to an organization the developer does not manage or fund.

The independence range for one agent-made change, from the producing agent checking itself to verification and validation by a separate organization. Moving away from the producer removes sources of shared error and adds cost; a different method of checking is a second axis the range does not show.
The independence range for one agent-made change, from the producing agent checking itself to verification and validation by a separate organization. Moving away from the producer removes sources of shared error and adds cost; a different method of checking is a second axis the range does not show.
Point on the rangeWho or what checksWhat it establishesWhat it leaves open
1. The producerThe same agent, in the same session, reviews and tests its own changeThe change is consistent with the agent's own reading of the taskEvery assumption the agent made
2. A second executionAnother prompt, agent or model reviews the changeSlips the first run made and the second does not repeatErrors the two models share, and the specification both read
3. Tools the agent did not controlA test runner, a classified static analyzer and a coverage measure, run on the committed revision, on tests and configuration the agent could not alterThe tests on that commit passed and the analyzer found none of the defect classes it looks for, repeatablyWhether the tests and the specification are right, and who wrote the tests
4. An independent personAn engineer who wrote neither the change, its requirement nor its testsA second human reading of the requirement, the separation EN 50716 requires between implementer and testerA shared reading of the same requirement text, and the same schedule and manager
5. An independent teamVerification or validation with its own reporting lineAgreement or disagreement with the release, free of the project manager's influence, as EN 50716 asks at SIL 3 and SIL 4A shared reading of the requirement, and the same company's budget
6. An independent organizationIV&V, technically, managerially and financially separate; a separate company in NASA's ruleIts own choice of what to analyze, by which methods, on its own schedule, with funding the developer does not controlThe intent it is not given, and a requirement that is wrong for everyone who reads it

The first two points are cheap, and an agent can run them on every change; they are also where correlated error concentrates, so a record that lists only them says little about how independently the change was checked. The third point counts only when the agent could not edit the tests, the analyzer configuration or the pipeline, which is why the review checklist for agent-written changes asks who wrote the tests and whether they ran on that exact version; a tool rerunning tests the agent wrote repeats point one with a timestamp.

The last three are the human and organizational positions the standards describe for verifiers, validators and assessors, and each presumes competence. They leave a shared reading of the requirement open, and coincident failures too: Knight and Leveson's programmers made different faults that failed on the same hard inputs. That is why validation against intent, a second source for the expected results and a different method of checking count alongside who checked. For the sensor function the point is already set: the system's integrity level fixes the independence of verifier, validator and assessor, and the change's impact analysis decides how much of their work is repeated. Every point also needs a record of each evidence item's relationship to the producer: whether whoever issued it is the producer, shares a model or context with it, is technically separated from it or is organizationally independent.

What an agent changes for IV&V

The definitions of the three parameters say nothing about who or what produced the work, so they apply unchanged. Their application gains a new question: an independent organization that analyzes the change with the same model family the developer's agent used shares part of the producer's error profile, so its technical independence now has to be declared tool by tool, the way it is already declared person by person.

Volume changes too. An agent can produce changes faster than an independent team can analyze them, and the cost moves from writing a change to accepting it, as our pillar on agentic engineering argues. IV&V teams have met a version of this before. A Carnegie Mellon Software Engineering Institute account of NASA's Orion program describes IV&V findings delivered "sometimes months out of phase" with development, until the team adopted Agile practices and could "cut our delivery cadence from months to weeks" (SEI blog, Incorporating Agile Principles into Independent Verification and Validation, 2024). With agents the cadence is faster again, and a check that arrives after the change has been built on is evidence about an earlier baseline, which someone then has to show still holds.

The FAA's roadmap for AI safety assurance lists language models for software development and testing among its research priorities, and is direct about who answers for the result: "Companies are responsible for their products, their compliance, and the demonstration of compliance, regardless of how those artifacts are created" (FAA, Roadmap for Artificial Intelligence Safety Assurance, version I, 2024). The assurance case for an agent-made change is where the points it passed through, and the authority who decided they were enough, are written down together.

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 is independent verification and validation (IV&V)?

IV&V is verification and validation performed by an organization that is technically, managerially and financially independent of the one that develops the system. Technical independence means the analysts took no part in the development; managerial independence means they sit outside the development and program management organization and choose what to analyze, how and when; financial independence means the developer cannot use the budget to pressure them. NASA requires software IV&V on its highest-consequence projects.

What is the difference between verification and validation?

Verification checks that the product was built to its specification, and validation checks that the product, as built, meets the users' needs and intended use. NASA's program puts it as two questions: "Are we building the product right?" for verification and "Are we building the right product?" for validation. An AI coding agent can help with verification against a stated specification. Validation depends on intent beyond what the agent was given, which is why it stays with people who know what the system is for.

Is a second AI model reviewing code independent verification?

It is a second execution of the check, and it sits close to the producer on the independence range. Research on more than 350 language models found that models agree on the same wrong answer far more often than chance, and that larger and more accurate models have highly correlated errors even across providers. A second model catches some slips the first one makes. The standards that set independence ask for separate people, teams or organizations, and a record that names the relationship between producer and checker.

How much independence does agent-written code need?

As much as the consequence of its failure requires, set by the standard that applies or by the accountable authority for the system. IEC 61508 grades its assessor from an independent person at SIL 1 to an independent organization at SIL 4; EN 50716 separates verifier and validator from the developer at every level; NASA requires software IV&V on its largest and highest-risk projects. Agent-written code takes the same grading as code written by people, and the research on correlated model errors is the reason to give less weight to checks made by the agent or by models close to it.

On Google

Add Kealu as a preferred source: our articles get highlighted in Top Stories, AI Mode and AI Overviews.

Add as a preferred source on Google

Talk to our team.

Questions about this article, or about using Kealu Vector in your organization? Send us a message.

Talk to our team.