Reasoning

Intro

Reasoning is the process of thinking logically, analyzing information, and drawing conclusions based on facts, evidence, or patterns. It is a core function of human intelligence and is also fundamental in artificial intelligence, problem-solving, and decision-making.

Different tasks call for different reasoning modes. A tax auditor applies deductive rules; a scientist generalizes from experiments; an agent picks the best explanation from incomplete tool output. Knowing which type fits which problem helps you design better prompts, agents, and evaluation benchmarks.

Common Types of Reasoning

Human reasoning mixes logic with guesswork. AI systems do the same: LLMs apply prompts like rules, generalize from examples, rank plausible explanations, and retrieve similar past cases — usually with confidence scores, not guaranteed truth. The samples below mirror how you would wire that in production.

• Deductive reasoning (top-down logic) — Starts with a general rule or premise and applies it to a specific case to reach a logically certain conclusion. Example: all mammals breathe air; a dolphin is a mammal; therefore a dolphin breathes air.

  
  import OpenAI from "openai";
  
  const openai = new OpenAI();
  
  const response = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    temperature: 0.2,
    response_format: { type: "json_object" },
    messages: [
      {
        role: "system",
        content:
          "Apply given axioms to a case. Only state conclusions that follow with certainty. If uncertain, say so in uncertaintyNote. Return JSON: { conclusion, certainty: 0-1, uncertaintyNote? }",
      },
      {
        role: "user",
        content:
          "Axioms: All mammals breathe air. Fact: A dolphin is a mammal. What follows?",
      },
    ],
  });
  
  const parsed = JSON.parse(response.choices[0].message.content ?? "{}");
  console.log(parsed);
  

• Inductive reasoning (bottom-up logic) — Observes patterns in specific examples and generalizes a rule. Example: every swan you have seen is white, so you infer most swans are white. Conclusions are probable, not guaranteed.

  
  import OpenAI from "openai";
  
  const openai = new OpenAI();
  
  const labeledTickets = [
    { text: "Charged twice on renewal", label: "billing-urgent" },
    { text: "Where is dark mode?", label: "product-question" },
    { text: "Invoice PDF missing tax line", label: "billing-urgent" },
    { text: "Can I export CSV?", label: "product-question" },
  ];
  
  const response = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    temperature: 0.7,
    response_format: { type: "json_object" },
    messages: [
      {
        role: "system",
        content:
          "Infer a routing policy from examples. New labels are probabilistic guesses, not logical proof. Return JSON: { predictedLabel, confidence: 0-1, patternYouNoticed }",
      },
      {
        role: "user",
        content: `Training examples: ${JSON.stringify(labeledTickets)}\nNew ticket: "Refund still not received after 5 days"`,
      },
    ],
  });
  
  console.log(JSON.parse(response.choices[0].message.content ?? "{}"));
  

• Abductive reasoning (best guess) — Chooses the most likely explanation given incomplete evidence. Example: the grass is wet; the simplest explanation is recent rain. Used heavily in diagnostics, debugging, and agent tool-result interpretation.

  
  import OpenAI from "openai";
  
  const openai = new OpenAI();
  
  const agentObservation = {
    tool: "metrics_api",
    output: {
      errorRate: 0.19,
      p99LatencyMs: 2400,
      lastDeployMinutesAgo: 6,
      dbConnectionPoolSaturation: 0.91,
    },
  };
  
  const response = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    temperature: 0.5,
    response_format: { type: "json_object" },
    messages: [
      {
        role: "system",
        content:
          "You are an SRE agent after a tool call. Pick the most plausible root cause from incomplete telemetry. Rank alternatives by likelihood, not certainty. Return JSON: { bestGuess, confidence: 0-1, alternatives: [{ cause, confidence }] }",
      },
      {
        role: "user",
        content: `Observe and explain:
  ${JSON.stringify(agentObservation, null, 2)}`,
      },
    ],
  });
  
  console.log(JSON.parse(response.choices[0].message.content ?? "{}"));
  

• Analogical reasoning (comparing similar cases) — Solves a new problem by mapping it to a previously solved one. Example: treating a new API integration like a prior OAuth flow you already shipped.

  
  import OpenAI from "openai";
  
  const openai = new OpenAI();
  
  const newIssue =
    "GitHub OAuth callback returns invalid_state in production only";
  
  const queryVec = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: newIssue,
  });
  
  const similarResolvedCases = await vectorStore.query({
    vector: queryVec.data[0].embedding,
    topK: 3,
    filter: { status: "resolved" },
  });
  
  const response = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    temperature: 0.6,
    messages: [
      {
        role: "system",
        content:
          "Map the new issue to the closest resolved case, adapt the fix, and note where the analogy might break.",
      },
      {
        role: "user",
        content: `Resolved cases:\n${similarResolvedCases.map((c) => c.text).join("\n---\n")}\n\nNew issue: ${newIssue}`,
      },
    ],
  });
  
  console.log(response.choices[0].message.content);
  

• Causal reasoning (cause and effect) — Determines how one event or variable influences another. Example: latency spikes after a deploy, so you investigate whether the release changed database query patterns.

  
  import OpenAI from "openai";
  
  const openai = new OpenAI();
  
  const incidentWindow = [
    { t: "09:58", deploy: "v91", p99Ms: 130, errors: 0.002 },
    { t: "10:04", deploy: "v92", p99Ms: 910, errors: 0.041 },
    { t: "10:08", deploy: "v92", p99Ms: 880, errors: 0.038 },
  ];
  
  const response = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    temperature: 0.55,
    response_format: { type: "json_object" },
    messages: [
      {
        role: "system",
        content:
          "Correlation is not causation. Propose plausible causes for the latency shift, confidence for each, and the observability check that would confirm or falsify it. Return JSON: { hypotheses: [{ cause, confidence, confirmWith, falsifyWith }] }",
      },
      {
        role: "user",
        content: `Timeline:
  ${JSON.stringify(incidentWindow, null, 2)}`,
      },
    ],
  });
  
  console.log(JSON.parse(response.choices[0].message.content ?? "{}"));
  

Other Types of Reasoning

• Hypothetical reasoning (what-if analysis) — Explores possible scenarios and their consequences before committing to a decision.
• Bayesian reasoning (probabilistic thinking) — Updates beliefs with prior knowledge when new evidence appears. Core to spam filters, medical diagnosis models, and calibrated LLM confidence.
• Moral reasoning (ethical decision-making) — Applies ethical principles to evaluate right versus wrong. Critical for aligned agents and policy-sensitive automation.
• Heuristic reasoning (rule of thumb) — Uses shortcuts or experience-based rules to solve problems quickly when perfect analysis is too costly.
• Scientific reasoning (experimental thinking) — Uses systematic observation, experiments, and testing to validate or reject hypotheses.
• Spatial reasoning (understanding space and shapes) — Visualizes and manipulates objects in space. Important for robotics, CAD, maps, and multimodal models.
• Meta-reasoning (thinking about thinking) — Evaluates and improves one's own reasoning strategies. Underpins reflection loops in agents such as Reflexion and critic–actor architectures.

Reasoning in AI Systems

• Symbolic AI (logic-based) — Uses explicit rules, knowledge bases, and formal logic. Strong at deductive and abductive reasoning where premises and constraints are known upfront.
• Machine learning (pattern-based) — Learns statistical regularities from data. Excels at inductive and analogical reasoning: classification, clustering, retrieval, and similarity search.
• Neural networks (deep learning) — Large-scale pattern recognition that can mimic human-like reasoning chains when trained on enough data and paired with techniques like chain-of-thought prompting or dedicated reasoning models.

Modern production stacks rarely pick one camp. A typical agent might use retrieval (inductive/analogical), a structured tool schema (deductive constraints), and an LLM that abductively explains tool output before the next action — the pattern behind Conversational ReAct and related agent loops.

Specialized Types

• Temporal reasoning — Reasoning about time, sequences, deadlines, and before/after relationships.
• Defeasible reasoning — Conclusions that hold by default but can be overridden when stronger evidence appears.
• Modal reasoning — Reasoning about necessity, possibility, and what must or could be true.
• Counterfactual reasoning — Asking what would have happened under different conditions; useful for attribution and debugging.
• Fuzzy reasoning — Handles partial truth and gradual membership instead of strict binary yes/no logic.

And there are others — commonsense, emotional, legal, strategic, and domain-specific forms appear wherever humans or models must act under uncertainty.

Summary

• Common types: deductive, inductive, abductive, analogical, causal
• Advanced types: Bayesian, moral, heuristic, scientific, spatial, meta
• Specialized types: temporal, defeasible, modal, counterfactual, fuzzy

When you evaluate or build AI systems, name the reasoning mode the task actually needs. Retrieval-heavy RAG favors analogical and inductive patterns; rule-heavy workflows favor deductive checks; multi-step agents mix abductive interpretation with meta-reasoning over their own traces. Matching the mode to the job is often the difference between a demo and a reliable system.