Logical AI: how artificial intelligence reasons in 2026, and where it fails

What logical AI means

In McCarthy's own definition, logical AI represents what an agent knows about its world, its goals and its current situation as sentences in logic, and the agent decides what to do by inferring which action will achieve those goals. His 1959 paper posed an everyday problem, getting to the airport, as a series of connected inferences that ends in something like a proof. The Stanford Encyclopedia of Philosophy's entry on logic-based AI traces the field from that paper, through McCarthy and Hayes in 1969, to modern knowledge representation.

"Logic" covers more than one kind of inference, and AI systems differ in which kind they handle well:

Everyday reasoning adds a complication McCarthy stressed: it is often nonmonotonic. A conclusion drawn from what you know now may have to be withdrawn when a new fact arrives ("the shipment is on time", until the carrier reports a delay). Classical logic never withdraws a conclusion once it is proved, so nonmonotonic logic became one of the two research themes the Stanford entry says have run through logical AI from the start, the other being reasoning about action and change.

So "logical reasoning in artificial intelligence" can mean two things: the symbolic tradition, or whether today's language models can reason logically at all. The rest of this guide covers both, because the most reliable systems use both.

How symbolic AI reasons, and where it is still used

A symbolic system has two parts: a knowledge base of facts and rules written in a formal language, and an inference engine that applies the rules. It can work forward from the facts to everything they imply, or backward from a goal to the facts that would establish it. Given the same inputs it reaches the same conclusion every time, and it can show the chain of rules that produced it.

The Stanford entry uses expert systems to show how the design matured: the earliest were large collections of procedural rules with no separate representation of the background knowledge, and later generations kept the knowledge apart from the reasoning that used it. The limits showed up in practice. Every rule has to be written and maintained by someone, and input that does not fit the symbols, such as a scanned form or a customer's email, has to be translated first. DeepMind's AlphaGeometry announcement states the trade-off plainly: symbolic deduction engines are rational and explainable but can be slow and inflexible on large, complex problems, while language models spot patterns quickly but often lack the ability to reason rigorously.

Symbolic reasoning never went away. It lives on in everyday engineering tools:

• SAT and SMT solvers decide whether a set of logical constraints can all be true at once. Z3, a theorem prover from Microsoft Research, is one example: open source under the MIT licence, with bindings for several programming languages.
• Proof assistants check every step of a formal proof. Lean is an open-source programming language and proof assistant; its site describes how AWS uses it to formally verify Cedar, the AWS authorization policy language.
• Logic programming languages such as Prolog, and rules engines, encode eligibility, pricing and compliance rules as code that can be tested.
• Type checkers, database constraints and schema validators are small deductive systems that reject whatever breaks their rules.

The catch is that a symbolic system is only as right as its rules and its translation of the world into symbols. It cannot notice that a rule is wrong, and it cannot read a messy email. Neural networks were expected to fill that gap, and they brought a different weakness.

Why neural networks struggle with multi-step logic

A large language model generates text one token at a time, each chosen because it is likely given everything before it. It learned what reasoning looks like from an enormous amount of text, but nothing in the architecture enforces a rule or checks a step. On a one-step question that rarely matters. On a long chain, small error rates multiply: as plain arithmetic, a process that gets each step right 95% of the time, with independent errors, gets all ten steps right only about 60% of the time.

Research since 2023 has shown where this bites:

• Compositional tasks. In Faith and Fate (2023), researchers tested multi-digit multiplication, logic grid puzzles and a classic dynamic programming problem. Their results suggest that transformers solve such tasks by reducing multi-step reasoning to matching linearized pieces of the computation, without necessarily developing a systematic method, and their theoretical arguments show how accuracy can decay quickly as tasks grow.
• The direction of a fact. The Reversal Curse (2023) showed that a model trained on "A is B" does not automatically learn "B is A". GPT-4 answered questions that named a celebrity and asked for a parent correctly 79% of the time, but the reverse question, naming the parent and asking for the child, only 33% of the time. When both facts are in the prompt, models can make the reverse deduction.
• Surface changes. Apple researchers' GSM-Symbolic study (October 2024) regenerated grade-school math questions from templates. Every model tested scored lower when only the numbers changed, scores fell as clauses were added, and a single clause that seemed relevant but was not caused performance drops of up to 65%.

That last result is the clearest picture of the failure. In one example from the paper, a question says someone picked 44 kiwis on Friday, 58 on Saturday and double Friday's number on Sunday, adding that five of Sunday's kiwis were smaller than average. Models, including OpenAI's o1-mini, subtracted the five and answered 185 instead of 190. The authors found that models tend to convert statements into operations without understanding what they mean, and they hypothesize that current models replicate reasoning steps from their training data rather than perform genuine logical reasoning.

None of this means language models cannot reason. It means their reasoning is not reliable by construction, and that a high score on a familiar benchmark can hide how brittle it is.

Chain-of-thought prompting: making the model show its work

In 2022, a large improvement came from a prompt rather than a new architecture. In Chain-of-Thought Prompting Elicits Reasoning in Large Language Models (Wei et al., first posted in January 2022), Google researchers gave models a few worked examples that spelled out the intermediate steps before each answer. With eight such examples, PaLM 540B's accuracy on the GSM8K math word problems rose from 17.9% with standard prompting to 56.9%, a state-of-the-art result that beat a fine-tuned GPT-3 with a verifier. The gain appeared only at around 100 billion parameters; smaller models wrote fluent but illogical chains and did worse than without them.

Three follow-ups extended the idea:

• Zero-shot chain of thought. Kojima et al. (May 2022) showed that adding "Let's think step by step" before the answer, with no worked examples at all, raised GSM8K accuracy from 10.4% to 40.7% on InstructGPT (text-davinci-002).
• Self-consistency. Wang et al. (March 2022) sampled several reasoning paths for each question and kept the answer most of them reached, reporting a gain of 17.9% on GSM8K over a single chain of thought.
• Program-aided reasoning. PAL (November 2022) observed that models break problems down well but still make logical and arithmetic mistakes when solving each step. It had the model write a program and let a Python interpreter compute the answer; with Codex, it beat PaLM 540B with chain of thought on GSM8K by 15 points absolute.

PAL is the first appearance of the pattern this guide keeps returning to: let the model do what it is good at, reading the problem and choosing the steps, and hand the exact work to software that computes it the same way every time.

Reasoning models that think before they answer

Chain of thought was a prompting technique. Reasoning models build it into the model: they are trained, mainly with reinforcement learning, to produce a long internal chain of thought before the final answer.

• OpenAI o1, announced on September 12, 2024, was trained with large-scale reinforcement learning to use its chain of thought productively. OpenAI reported that performance kept improving with more reinforcement learning (train-time compute) and with more time spent thinking (test-time compute). On the 2024 AIME, a qualifying exam for the USA Mathematical Olympiad, GPT-4o solved 12% of problems on average; o1 solved 74% with one attempt per problem and 83% with a consensus of 64 attempts. OpenAI chose to show users a model-written summary rather than the raw chain of thought.
• DeepSeek-R1, first posted on January 22, 2025 with its weights public and later published in Nature, showed that reasoning can be incentivized through reinforcement learning alone, without human-written reasoning examples. Its rewards were checked by rules: math answers had to appear in a fixed format that a rule could verify, and code went through a compiler and test cases. The team avoided neural reward models because they were prone to reward hacking. During training, the pure-RL variant's average score on AIME 2024 rose from 15.6% to 77.9%.
• Anthropic's Claude 3.7 Sonnet, released on February 24, 2025, was introduced as the first hybrid reasoning model: one model that answers almost instantly or thinks step by step with the thinking visible, with API control over how long it may think. Its thinking tokens were priced as output tokens.
• Google's Gemini 2.5, announced on March 25, 2025, was a family of thinking models, and Google said it would build thinking into all of its models from then on.
• OpenAI's GPT-5, released on August 7, 2025, is a unified system: a fast model for most questions, a deeper GPT-5 thinking model for harder ones, and a real-time router that decides which a request needs.

The common idea is test-time compute: spending more computation while answering, by thinking longer or sampling several answers, buys accuracy on hard problems. It also costs latency and money: thinking is generated text, and providers such as Anthropic bill it as output.

DeepSeek's paper also shows why these models shine on math and code. Those are the domains where a program can check the final answer, so reinforcement learning gets a clean signal. DeepSeek reported that its rule-based training stage was narrowly focused on reasoning tasks and left R1-Zero weaker at writing and open-domain question answering, which is why the released R1 added further training stages.

Neuro-symbolic AI: a model proposes, logic checks

Neuro-symbolic systems pair a neural network, which is good at suggesting, with a symbolic component, which is good at deducing and verifying. Google DeepMind's mathematics systems are well-documented examples.

AlphaGeometry, published in Nature on January 17, 2024, combines a neural language model with a rule-bound symbolic deduction engine. The engine deduces what it can from the problem's diagram; when it gets stuck, the language model adds one potentially useful construct, such as a point, line or circle, which opens new paths for deduction, and the loop repeats. On 30 olympiad geometry problems it solved 25 within the standard time limit, against 10 for the previous best method (Wu's method) and an average of 25.9 for human gold medallists. It was trained on 100 million synthetic examples, without human demonstrations.

AlphaProof, announced on July 25, 2024 together with AlphaGeometry 2, trains itself to prove mathematical statements in Lean. It couples a pre-trained language model with the AlphaZero reinforcement learning algorithm, generates candidate solutions, and proves or disproves them by searching over proof steps in Lean. DeepMind gave the reason directly: a formal proof can be verified for correctness, while natural-language approaches can hallucinate plausible but incorrect intermediate steps. The two systems solved four of the six problems at the 2024 International Mathematical Olympiad (IMO) for 28 of 42 points, the silver-medal standard. The problems were first translated into formal language by hand, and some took up to three days to solve. DeepMind published AlphaProof's methodology in Nature on November 12, 2025.

A year later the frontier moved. On July 21, 2025, DeepMind reported that an advanced version of Gemini with Deep Think solved five of the six IMO 2025 problems for 35 points, a gold-medal score, working end to end in natural language within the 4.5-hour competition limit, with its solutions graded and certified by IMO coordinators. That is a stronger result with a different kind of guarantee: people graded those proofs, where Lean checked AlphaProof's. DeepMind says it continues to develop its formal systems alongside.

The same pattern now reaches business software. Automated Reasoning checks in Amazon Bedrock Guardrails turn a policy document, such as insurance eligibility or employee benefit rules, into formal logic rules and variables, then check a model's answers against them. They can mathematically prove that a statement contradicts the policy, point out unstated assumptions, and explain why a correct answer is correct. AWS is clear about the limits: foundation models translate the natural language into logic, a valid result covers only what the policy's variables capture, and the checks report findings rather than block responses.

How AI reasoning is measured

Reasoning is measured with benchmarks: fixed sets of problems with known answers. What a benchmark tests matters more than its headline score.

ARC-AGI deserves a closer look because it was built to test reasoning on problems a system has not been prepared for. François Chollet introduced it in 2019, defining intelligence as skill-acquisition efficiency: how quickly a system learns a task it has not seen, rather than how well it performs one it was trained for. The first version has 800 grid-based tasks, each usually with about three example pairs, and it stayed unsolved by AI systems until late 2024; in December 2024, OpenAI's o3-preview scored 75% at low compute and 87% at high compute. ARC-AGI-2 (2025) targets what reasoning systems still miss, such as interpreting symbols and applying several interacting rules. Every task in its evaluation sets was solved by at least two people within two attempts, and results are reported with their cost. ARC-AGI-3, the basis of an ARC Prize 2026 track, is interactive: agents must explore new game-like environments and work out the goal as they go. How models approach the visual side of these puzzles is covered in our guide to AI visual reasoning.

Three habits make benchmark numbers more useful:

1. Check how many attempts a score used. o1's AIME result was 74% with one attempt and 83% with a consensus of 64. Both are honest numbers, and only the first matches a single answer in production.
2. Check whether the test is saturated or may have leaked. A benchmark every model aces stops separating them, and public test questions can end up in training data. Apple's reasoning-model study names data contamination as a weakness of established math and coding benchmarks.
3. Check the cost. Reasoning scores rise with compute, which is why ARC Prize reports cost next to accuracy.

The documented limits of AI reasoning

Reasoning models are better at logic than the models before them. They are not reliable reasoners, and the published evidence is specific about where they fail:

• The written reasoning is not a faithful record. In a study published on April 3, 2025, Anthropic slipped hints into questions and checked whether models admitted using them. On average, Claude 3.7 Sonnet mentioned a hint it had used 25% of the time and DeepSeek R1 39% of the time. The unfaithful explanations were longer, not shorter, and faithfulness was lower on harder questions.
• More reasoning can mean more confident errors. OpenAI's o3 and o4-mini system card (April 16, 2025) reported a hallucination rate of 33% for o3 on PersonQA, a test of facts about people, against 16% for o1, because o3 makes more claims overall, both accurate and inaccurate.
• Accuracy can collapse as problems grow. Apple researchers reported in June 2025 that on puzzles of controlled difficulty, standard models did better than reasoning models on simple ones, reasoning models led on medium ones, and both collapsed on hard ones, where reasoning models also cut their thinking short despite an adequate token budget. A published comment argued that part of the collapse came from output-length limits and from puzzle instances that had no solution. The exact threshold is disputed; the practical lesson is to test at the difficulty you actually need.
• Small changes still matter. In the GSM-Symbolic tests, irrelevant clauses caused significant declines even for o1-preview, and o1-mini fell for the kiwi question.
• Thinking costs time and money. Thinking tokens are generated like any other output, and OpenAI's own results show accuracy rising with the compute spent at answer time, so better answers on hard problems come with a longer wait and a larger bill.

What this means for a business using AI

Trust an AI answer to the extent that it can be checked. A confident tone, a long explanation or a high benchmark score is not a check. Running the numbers, citing a source, passing a test or satisfying a rule is.

Then work through it in order:

1. Define a correct answer before choosing a model. If you cannot say how you would check the output, a larger model will not fix that.
2. Move exact work into software. Calculations, lookups and rule evaluation belong in code, databases and rules engines, as PAL showed in 2022.
3. Ground facts in sources. Reasoning improves logic, not knowledge. o3's results on facts about people show that a stronger reasoner can still invent facts.
4. Test with variations of your own cases. Change names and numbers, add an irrelevant sentence, reorder the facts. If the answers move, you have learned something no public benchmark could tell you.
5. Compare runs on hard questions. Self-consistency works in production too: when several samples disagree, send the case to a person.
6. Log evidence, not the model's story. Keep the inputs, retrieved sources, tool calls and outputs. The chain of thought helps with debugging, but it is not an audit trail.
7. Keep a person on actions. A model can propose a refund, a configuration change or a reply; a rule or a named person approves it.
8. Match the thinking budget to the task. Use a fast mode for simple steps and a thinking mode where your evaluation shows it pays for itself.

Code a model writes is still code: review, test and scan it as you would a new contributor's work, as our secure coding checklist describes. If you are putting a model into a real workflow, our AI and automation service uses a language model only where a step needs judgment, such as reading a document or drafting a reply, and ordinary code everywhere else. Nothing changes in your systems until a rule or a person approves it, and every model, prompt or source change has to answer the same set of real questions before it ships. For how AI agents and robots are used at work today, see the future of robotics and automation.