This paper presents an algorithm for achieving interactive consistency among processors in the presence of faults. The problem involves a set of isolated processors, some of which may be faulty, communicating only through two-party messages. Nonfaulty processors must agree on the private values of all other processors, while faulty processors may lie. The goal is to devise an algorithm that allows each nonfaulty processor to infer the private value of every other processor, ensuring that the inferred value for a nonfaulty processor is its actual private value, and for a faulty one, it is consistent with the inferred value of every other nonfaulty processor. It is shown that the problem is solvable for and only for n ≥ 3m + 1, where n is the total number of processors and m is the number of faulty ones. Additionally, if faulty processors can refuse to pass on information but cannot falsely relay it, the problem is solvable for arbitrary n ≥ m ≥ 0. This weaker assumption can be approximated using cryptographic methods. The paper begins with the single-fault case, where two rounds of message exchange are required. In the first round, processors exchange their private values, and in the second, they exchange the results of the first round. If a nonfaulty processor does not receive a message, it chooses a random value. The computed interactive consistency vector is then determined by examining the received reports of each processor's value. If at least two reports agree, the majority value is used; otherwise, a default value is used. For the general case of n ≥ 3m + 1, the algorithm requires m + 1 rounds of information exchange. The algorithm is described in terms of a k-level scenario, which summarizes the outcome of a k-round exchange. The algorithm ensures interactive consistency by recursively applying the same logic for smaller subsets of processors. The paper also proves that interactive consistency is impossible for n < 3m + 1, even with an infinite number of rounds of exchange. This is demonstrated by constructing scenarios where faulty processors can mislead nonfaulty ones, leading to inconsistent results. Finally, the paper presents an algorithm using authenticators to handle the case where faulty processors cannot relay altered values without being detected. Authenticators are cryptographic methods that allow processors to verify the authenticity of messages, ensuring that faulty processors cannot fabricate values without being identified. The results show that interactive consistency is fundamental to the design of fault-tolerant systems, and the algorithms presented demonstrate its existence. Future research will focus on constructing efficient algorithms and exploring other aspects of interactive consistency, such as approximate agreement and agreement under probabilistic assumptions.This paper presents an algorithm for achieving interactive consistency among processors in the presence of faults. The problem involves a set of isolated processors, some of which may be faulty, communicating only through two-party messages. Nonfaulty processors must agree on the private values of all other processors, while faulty processors may lie. The goal is to devise an algorithm that allows each nonfaulty processor to infer the private value of every other processor, ensuring that the inferred value for a nonfaulty processor is its actual private value, and for a faulty one, it is consistent with the inferred value of every other nonfaulty processor. It is shown that the problem is solvable for and only for n ≥ 3m + 1, where n is the total number of processors and m is the number of faulty ones. Additionally, if faulty processors can refuse to pass on information but cannot falsely relay it, the problem is solvable for arbitrary n ≥ m ≥ 0. This weaker assumption can be approximated using cryptographic methods. The paper begins with the single-fault case, where two rounds of message exchange are required. In the first round, processors exchange their private values, and in the second, they exchange the results of the first round. If a nonfaulty processor does not receive a message, it chooses a random value. The computed interactive consistency vector is then determined by examining the received reports of each processor's value. If at least two reports agree, the majority value is used; otherwise, a default value is used. For the general case of n ≥ 3m + 1, the algorithm requires m + 1 rounds of information exchange. The algorithm is described in terms of a k-level scenario, which summarizes the outcome of a k-round exchange. The algorithm ensures interactive consistency by recursively applying the same logic for smaller subsets of processors. The paper also proves that interactive consistency is impossible for n < 3m + 1, even with an infinite number of rounds of exchange. This is demonstrated by constructing scenarios where faulty processors can mislead nonfaulty ones, leading to inconsistent results. Finally, the paper presents an algorithm using authenticators to handle the case where faulty processors cannot relay altered values without being detected. Authenticators are cryptographic methods that allow processors to verify the authenticity of messages, ensuring that faulty processors cannot fabricate values without being identified. The results show that interactive consistency is fundamental to the design of fault-tolerant systems, and the algorithms presented demonstrate its existence. Future research will focus on constructing efficient algorithms and exploring other aspects of interactive consistency, such as approximate agreement and agreement under probabilistic assumptions.