When Was AI Invented?

The Origin and Emergence of Artificial Intelligence

Determining when artificial intelligence (AI) was invented depends on whether AI is defined as a formal academic discipline, a theoretical mathematical framework, or the first working computer program capable of automated problem-solving.

Historically, the formal birth of artificial intelligence as an established field of research occurred in the summer of 1956 at the Dartmouth Summer Research Project on Artificial Intelligence, organized by John McCarthy, Marvin Minsky, Nathaniel Rochester, and Claude Shannon. It was at this workshop that McCarthy coined the term artificial intelligence.

However, the foundational mechanisms and earliest working programs emerged years prior:

• 1943: Warren McCulloch and Walter Pitts published the first mathematical model of an artificial neural network (A Logical Calculus of the Ideas Immanent in Nervous Activity).
• 1950: Alan Turing published Computing Machinery and Intelligence, introducing the Turing Test (the "Imitation Game") and outlining the principles of machine learning and digital machine cognition.
• 1951: Christopher Strachey and Dietrich Prinz wrote the earliest operational heuristic game programs (checkers and chess sub-problems), while Marvin Minsky and Dean Edmonds built the first neural network hardware machine, the SNARC.
• 1955–1956: Allen Newell, J.C. Shaw, and Herbert A. Simon developed the Logic Theorist, widely acknowledged as the first genuine artificial intelligence program capable of non-numerical reasoning and symbolic theorem proving.

1943                1950               1951               1955-1956            1956
McCulloch-Pitts     Turing's Paper     SNARC Machine      Logic Theorist       Dartmouth Workshop
First Neural Net    "Can Machines      First Neural Net   First Symbolic       Field of AI Coined
Model               Think?"            Hardware           Software Program     and Formalized

Chronology of Foundational AI Milestones

The development of artificial intelligence did not occur in a vacuum; it was the convergence of mathematical logic, cybernetics, information theory, and digital electronic computing in the mid-20th century.

Theoretical Foundations: Before the Term "AI"

Long before computers could execute code, mathematicians and logicians laid the conceptual groundwork for automated cognition.

The Mechanization of Thought (1930s–1940s)

Artificial intelligence relies on the assumption that human reasoning can be formalized and executed mechanically. In 1936, British mathematician Alan Turing introduced the universal computing machine (the Universal Turing Machine), demonstrating that a machine could perform any mathematical computation if it could be represented as an algorithm.

Concurrently, Alonzo Church developed the Lambda Calculus, and Claude Shannon published his 1937 master’s thesis showing that electrical circuits could model Boolean algebra. This established digital circuitry as a viable substrate for logic.

Aristotelian Logic + Boolean Algebra
          │
          ▼
Turing Machine (1936) & Lambda Calculus (1936)
          │
          ▼
Shannon's Circuit Switching (1937) ──► Digital Computers (ENIAC, EDVAC, Ferranti Mark 1)
          │
          ▼
Computational Theory of Mind / Artificial Intelligence

The McCulloch-Pitts Neuron (1943)

Neurophysiologist Warren McCulloch and logician Walter Pitts established the first bridge between biological brains and computational systems in 1943. Their paper, A Logical Calculus of the Ideas Immanent in Nervous Activity, modeled biological neurons as binary threshold devices: an artificial neuron received inputs, summed them, and if the total exceeded an absolute threshold, fired an output of 1 (otherwise 0).

McCulloch and Pitts proved that networks of these simple binary units could compute any logical function (AND, OR, NOT), suggesting that cognitive processes could be executed using networks of electrical switches.

Turing's Operational Definition of Intelligence (1950)

In 1950, Alan Turing addressed the problem of machine thought directly in Computing Machinery and Intelligence, beginning with the question: "Can machines think?"

Recognizing that defining "thought" was philosophically fraught, Turing replaced it with an operational metric: the Imitation Game (now called the Turing Test). In this test, an interrogator communicates via text with both a human and a machine. If the interrogator cannot reliably distinguish between the two, the machine is deemed to exhibit functional intelligence.

Turing's paper did not stop at philosophical tests; it predicted that by the year 2000, computers would have the storage capacity and algorithmic sophistication to play the imitation game effectively. He also outlined how machines could learn from experience rather than requiring every step to be explicitly programmed:

"Instead of trying to produce a programme to simulate the adult mind, why not rather try to produce one which simulates the child's? If this were then subjected to an appropriate course of education one would obtain the adult brain." — Alan Turing, Computing Machinery and Intelligence (1950)

What Was the First AI Program?

Because the definition of artificial intelligence evolved over several decades, three historical projects contend for the title of the "first AI," depending on whether the criterion is hardware implementation, heuristic search, or symbolic theorem proving.

Contenders for "First AI":
├── 1. SNARC (1951)              ──► First neural network hardware simulator
├── 2. Samuel's Checkers (1952)  ──► First self-learning, adaptive heuristic software
└── 3. Logic Theorist (1955-56)  ──► First automated symbolic reasoning program

1. The First Neural Network Machine: SNARC (1951)

In 1951, Marvin Minsky and Dean Edmonds constructed the Stochastic Neural Analog Reinforcement Calculator (SNARC) at Harvard University.

• Design: Built using 3,000 vacuum tubes, motors, and parts from a B-24 bomber.
• Function: Simulated a network of 40 artificial neurons connected to a maze.
• Learning Mechanism: Used a form of reinforcement learning. When the simulated "rat" successfully navigated the maze, the machine used motorized potentiometers to adjust the synaptic weights (resistors), increasing the probability that those specific pathways would fire in the future.

While hardware-based rather than software-based, SNARC represents the first physical machine built specifically to emulate neural learning.

2. The First Game-Playing and Learning Programs (1951–1952)

In 1951, Christopher Strachey developed a draughts (checkers) program for the Ferranti Mark 1 computer at the University of Manchester. By mid-1952, it could play a complete game of draughts at a reasonable speed.

Shortly thereafter, Arthur Samuel of IBM developed his famous Checkers-Playing Program on the IBM 701. Samuel introduced techniques that became core components of modern machine learning:

• Rote Learning: Recording every board position encountered along with its terminal evaluation to avoid repeating bad moves.
• Generalization (Evaluation Function Learning): Assigning weights to board features (piece advantage, board control) and updating those weights based on whether the position led to a win or a loss.
• Minimax Search with Alpha-Beta Pruning: Searching multiple plies ahead in a decision tree while cutting off unpromising branches to conserve memory and clock cycles.

Samuel's program demonstrated that a computer could evaluate game states, learn from games played against itself, and eventually defeat competent human players.

3. The First True Symbolic AI: The Logic Theorist (1955–1956)

Most computer historians consider the Logic Theorist, developed by Allen Newell, J.C. Shaw, and Herbert Simon at the RAND Corporation and Carnegie Institute of Technology (now Carnegie Mellon University), to be the first genuine artificial intelligence program.

[Input: Axioms + Rules of Inference]
               │
               ▼
      [Logic Theorist Engine]
   (Uses Heuristic Search Trees)
               │
               ▼
[Output: Formal Proofs of Theorems]

Unlike game engines designed around numerical calculations, the Logic Theorist was built to simulate complex human problem-solving and perform symbolic reasoning:

• Objective: Prove mathematical theorems from Chapter 2 of Alfred North Whitehead and Bertrand Russell's Principia Mathematica.
• Heuristic Search: Rather than exhaustively checking all possible algebraic combinations (a brute-force approach that would exceed computer memory), the Logic Theorist used heuristics—rules of thumb that mimicked how human mathematicians eliminate unpromising proof branches.
• Achievement: It successfully proved 38 of the first 52 theorems in Principia Mathematica. For Theorem 2.85, the Logic Theorist produced a proof that was shorter and more elegant than the original proof authored by Whitehead and Russell.

When Simon famously announced to a university class in January 1956, "Over Christmas, Al Newell and I invented a thinking machine," he was referring to the Logic Theorist.

The Dartmouth Workshop (1956): The Birth of AI as a Discipline

While functional prototypes and mathematical models existed prior to 1956, artificial intelligence was not recognized as a cohesive, autonomous field of science until the Dartmouth Summer Research Project on Artificial Intelligence.

The Proposal and the Coining of "Artificial Intelligence"

In August 1955, John McCarthy (Dartmouth College), Marvin Minsky (Harvard University), Nathaniel Rochester (IBM), and Claude Shannon (Bell Telephone Laboratories) submitted a formal funding proposal to the Rockefeller Foundation. McCarthy proposed the phrase "artificial intelligence" partly to distinguish the new research track from Cybernetics (dominated by Norbert Wiener, which focused heavily on analog feedback loops and biology) and Automata Theory (which focused on strict mathematical limitations).

The 1955 proposal laid out the core thesis of the field:

"We propose that a 2 month, 10 man study of artificial intelligence be carried out during the summer of 1956 at Dartmouth College in Hanover, New Hampshire. The study is to proceed on the basis of the conjecture that every aspect of learning or any other feature of intelligence can in principle be so precisely described that a machine can be made to simulate it." — McCarthy, Minsky, Rochester, Shannon (1955)

Pre-1956 Disparate Fields                  1956 Dartmouth Workshop                 Unified Field of AI
┌────────────────────────┐              ┌───────────────────────────┐           ┌──────────────────────┐
│ Cybernetics (Wiener)   │              │ Organizers:               │           │                      │
│ Information Theory     ├─────────────►│ - John McCarthy           ├──────────►│ Artificial           │
│ Mathematical Logic     │              │ - Marvin Minsky           │           │ Intelligence         │
│ Early Neural Networks  │              │ - Claude Shannon          │           │                      │
│ Game Theory (von Neum.)│              │ - Nathaniel Rochester     │           │                      │
└────────────────────────┘              └───────────────────────────┘           └──────────────────────┘

Attendees and Key Outcomes

The workshop took place in July and August 1956. Although attendance was sporadic and rarely exceeded ten people simultaneously, it brought together the researchers who would direct AI research for the next forty years:

• John McCarthy (coined the term, invented LISP, developed time-sharing systems).
• Marvin Minsky (co-founded the MIT AI Lab, developed frame theory, advanced perceptual modeling).
• Allen Newell & Herbert Simon (demonstrated the working Logic Theorist program at the workshop, later developed the General Problem Solver).
• Claude Shannon (founder of Information Theory, developer of chess algorithm theory).
• Arthur Samuel (pioneer of machine learning and tree-search algorithms).
• Ray Solomonoff (inventor of algorithmic probability and Kolmogorov complexity).

The workshop did not produce an immediate technical breakthrough during the two months, but it achieved three critical milestones:

1. Established "Artificial Intelligence" as the universal name and identity of the discipline.
2. Defined the initial research agenda: natural language processing, neural networks, computational complexity, abstraction, and symbolic reasoning.
3. Formed an intellectual community that led to the founding of dedicated AI laboratories at MIT, Stanford, Carnegie Mellon, and Edinburgh.

The Divergence of AI Paradigms: Symbolic vs. Connectionist

Following the 1956 Dartmouth conference, the newly established discipline fractured into two competing philosophies regarding how artificial minds should be built:

                             AI Paradigms (Post-1956)
                                       │
         ┌─────────────────────────────┴─────────────────────────────┐
         ▼                                                           ▼
   Symbolic AI (GOFAI)                                      Connectionism (Sub-Symbolic)
   - Top-down approach                                       - Bottom-up approach
   - Explicit rules, logic, symbols                          - Distributed weights, neural nodes
   - Examples: Logic Theorist, Expert Systems                - Examples: Perceptron, Modern Deep Learning
   - Era: Dominant 1950s–1980s                               - Era: Dominant 1990s–Present

1. Symbolic AI ("Good Old-Fashioned AI" or GOFAI)

• Philosophy: Intelligence consists of manipulating explicit symbols using formal rules of logic (top-down).
• Key Figures: John McCarthy, Allen Newell, Herbert Simon, Marvin Minsky.
• Major Projects:
  • General Problem Solver (GPS, 1957): Newell and Simon’s engine that separated domain knowledge from search heuristics using Means-Ends Analysis.
  • ELIZA (1966): Joseph Weizenbaum’s natural language processing script at MIT that mimicked a Rogerian psychotherapist through keyword-matching and syntactic substitution.
  • SHRDLU (1970): Terry Winograd’s program that understood natural language commands to manipulate geometric blocks in a virtual "blocks world."
  • Expert Systems (1970s–1980s): Systems like MYCIN (infectious disease diagnosis) and DENDRAL (chemical analysis), which relied on thousands of human-curated IF-THEN inference rules.

2. Connectionism and Artificial Neural Networks

• Philosophy: Intelligence emerges bottom-up from networks of simple, interconnected physical or virtual processing units that learn by adjusting numerical connection strengths.
• Key Figures: Warren McCulloch, Walter Pitts, Frank Rosenblatt, Bernard Widrow.
• Major Projects:
  • The Perceptron (1957): Frank Rosenblatt introduced the Perceptron algorithm, which adjusted weights dynamically based on classification errors.
  • ADALINE / MADALINE (1960): Bernard Widrow and Ted Hoff developed adaptive linear physical neuron circuits using continuous least-mean-squares learning.
  • The 1969 Stall: Marvin Minsky and Seymour Papert published the book Perceptrons, proving mathematically that single-layer perceptrons could not compute the non-linear Exclusive-OR (XOR) function. This publication diverted government and academic funding away from neural network research for over a decade, contributing to the first "AI Winter."
  • The 1986 Revival: David Rumelhart, Geoffrey Hinton, and Ronald Williams popularized the Backpropagation algorithm, demonstrating that multi-layer neural networks could solve complex non-linear problems (including XOR), resurrecting connectionist AI.

The Evolution of Artificial Intelligence Eras

To place the invention and development of AI into long-term historical context, the field's trajectory can be structured into six broad eras:

Foundational Era   Golden Years      First AI Winter   Expert Systems & Revival   Second AI Winter   Statistical & Deep Learning
 (1940s-1956)       (1956-1974)       (1974-1980)            (1980-1987)             (1987-1993)            (1993-Present)
      │                  │                 │                      │                       │                     │
      ▼                  ▼                 ▼                      ▼                       ▼                     ▼
Dartmouth '56       ELIZA, SHRDLU,    Lighthill Report,      Commercial LISP,       Hardware crash,        Big Data, GPUs,
Logic Theorist      Perceptrons       Funding cuts           MYCIN, Backprop        DARPA pullbacks        Transformers (LLMs)

1. Foundational & Incubation Period (1943–1956)

Marked by theoretical cross-pollination among mathematicians, neurophysiologists, and computer engineers. Key products: McCulloch-Pitts neurons, Turing's foundational papers, SNARC, Samuel's Checkers program, the Logic Theorist, and the 1956 Dartmouth conference.

2. The Golden Years / Early Optimism (1956–1974)

Researchers created algorithms that solved algebra word problems, proved geometric theorems, and manipulated physical objects via robotics. The US Department of Defense (via DARPA) funded early AI laboratories heavily with few technical constraints.

3. The First AI Winter (1974–1980)

Triggered by unmet expectations, the computational complexity explosion of search spaces (combinatorial explosion), and damning assessments such as the Lighthill Report (1973) in the UK and DARPA funding reassessments under the Mansfield Amendment. Machine translation and connectionist research saw severe budget cuts.

4. The Expert Systems Boom (1980–1987)

Symbolic AI saw commercialization through corporate Expert Systems (e.g., XCON at Digital Equipment Corporation). Japan launched the multi-million dollar "Fifth Generation Computer Systems" project to build massive parallel hardware optimized for logic programming (Prolog).

5. The Second AI Winter (1987–1993)

The specialized hardware market collapsed (the LISP machine market crash) as commodity desktop microprocessors (x86 systems by Intel) outpaced proprietary AI architectures. Most commercial expert systems proved too brittle and expensive to maintain.

6. The Statistical, Machine Learning, and Deep Learning Era (1993–Present)

AI pivoted away from top-down logic to data-driven probabilistic models and deep artificial neural networks:

• 1997: IBM’s Deep Blue defeated World Chess Champion Garry Kasparov using high-speed parallel search hardware and heuristic evaluation functions.
• 2012: AlexNet (designed by Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton) won the ImageNet computer vision competition using deep convolutional neural networks accelerated by Graphics Processing Units (GPUs).
• 2017: Vaswani et al. introduced the Transformer architecture (Attention Is All You Need), laying the technical groundwork for modern Large Language Models (LLMs) and generative artificial intelligence.

Summary

There is no single calendar date on which artificial intelligence was invented. Instead, its creation occurred across several distinct stages:

• The Concept and Mathematical Architecture: 1943 (McCulloch and Pitts) and 1950 (Alan Turing).
• The First Hardware Neural Network: 1951 (Marvin Minsky's SNARC).
• The First Working AI Software: 1955–1956 (Allen Newell, J.C. Shaw, and Herbert Simon's Logic Theorist).
• The Formal Founding of the Discipline: 1956, at the Dartmouth Summer Research Project on Artificial Intelligence organized by John McCarthy, where the field was officially named, scoped, and institutionalized.

There is no single year when AI was invented

Artificial intelligence was not invented in one isolated moment, because the term can mean several different things: the idea of making machines reason, the first programs that displayed an AI-like capability, the formal naming of the field, or the arrival of modern machine-learning systems. The answer most commonly used in histories of computing is 1956. That was the year of the Dartmouth Summer Research Project on Artificial Intelligence, where the name artificial intelligence was adopted for a proposed new field of research.

However, important foundations and early working systems came before 1956. Alan Turing's 1950 paper asked whether machines could think and proposed what became known as the Turing test. Christopher Strachey's draughts (checkers) program and Arthur Samuel's checkers work were developed in the early 1950s. Allen Newell, Cliff Shaw, and Herbert A. Simon developed the Logic Theorist around 1955–1956; it is often described as the first deliberately designed AI program because it attempted to prove mathematical theorems by symbolic reasoning.

Thus, the most accurate short answer is:

AI became a named academic field in 1956, but its intellectual roots, early algorithms, and first AI-like programs date to the 1940s and early 1950s.

Why the date depends on what “AI” means

The phrase “when was AI invented?” suggests a single inventor and a finished invention, like a device with a patent date. AI is instead a multidisciplinary field. It grew from logic, mathematics, philosophy, psychology, electrical engineering, neuroscience, linguistics, and computer science. Its history includes both theories about reasoning and machines that actually performed limited forms of reasoning, learning, perception, or decision-making.

Several milestones can therefore be valid answers to related questions.

The distinction is important. A program that plays a board game is not necessarily intelligent in the broad human sense, yet it may still be an important early AI system. Conversely, a philosophical proposal about thinking machines may be foundational without being a working AI program.

Ideas before electronic AI

Long before digital computers, people considered whether reasoning could be represented by rules. Classical logic, especially the study of valid inference, later became essential to symbolic AI: systems that manipulate explicit symbols and rules to reach conclusions.

In the 17th century, thinkers such as Thomas Hobbes described reasoning in computational terms, while Gottfried Wilhelm Leibniz imagined a universal symbolic language and a method for settling arguments through calculation. These ideas did not create AI, but they anticipated an important premise: some aspects of thought might be formalized.

The 19th century contributed two further strands. Charles Babbage designed, though did not complete, plans for general-purpose mechanical computing machines. Ada Lovelace recognized that such a machine could potentially manipulate more than numbers if information were represented symbolically. At the same time, formal logic became more rigorous through the work of mathematicians and logicians including George Boole and later Gottlob Frege. Digital computing ultimately relied on the convergence of programmable machinery and symbolic logic.

These predecessors should not be called AI in the modern technical sense. They lacked electronic computers, stored programs, and the developed methods needed for practical machine intelligence. Nevertheless, they explain why AI did not emerge from nowhere in 1956.

The 1930s and 1940s: computation becomes possible

The immediate foundations of AI were laid when researchers defined what computation could be and then built machines capable of carrying it out.

In 1936, Alan Turing described an abstract machine that could execute instructions on symbols. The Turing machine was not a physical computer design, but a powerful theoretical model of general computation. Its importance for AI lies in the idea that one sufficiently general machine can carry out many different information-processing tasks when given the right program.

During and after the Second World War, electronic digital computers were built. They were initially expensive, rare, and limited by modern standards, but they enabled researchers to test ideas about automated reasoning rather than merely discuss them.

Another influential development was cybernetics, the study of communication and control in animals and machines. Norbert Wiener and others explored feedback, adaptation, and self-regulation. In 1943, Warren McCulloch and Walter Pitts published a simplified mathematical model of networks of artificial neurons. Their model was highly abstract compared with biological brains, but it helped establish the conceptual basis for neural networks: systems made of interconnected units whose combined activity can represent or process information.

These developments produced no general intelligent machine. They did, however, make the central research question technically plausible: could a computer carry out processes associated with human intelligence, such as learning, reasoning, recognizing patterns, or using language?

Turing and the 1950 question of machine intelligence

A major early landmark is Alan Turing's 1950 paper, usually known by its title, Computing Machinery and Intelligence. Rather than trying to define the word “think” in the abstract, Turing proposed an operational exercise called the imitation game. In a text-only conversation, a human evaluator tries to determine which unseen participant is a human and which is a machine. If the machine can reliably make that distinction difficult, Turing argued that refusing to call it intelligent would be hard to justify.

The Turing test was not the first discussion of intelligent machines, and it was not an AI program. It also does not establish that a system understands, is conscious, or can reason reliably outside the test. Its historical importance is that it shifted attention from an inaccessible inner essence to observable capabilities.

Turing also addressed objections that remain recognizable in AI debates: whether machines can be original, whether they can make mistakes, whether consciousness is required, and whether learning machines might develop capabilities not explicitly scripted line by line. This is why 1950 is often given as the beginning of modern AI thought, even though the field’s name came later.

1956: the Dartmouth workshop and the naming of AI

The year 1956 is the conventional founding date of artificial intelligence as a research field. John McCarthy, then a young computer scientist, used the phrase artificial intelligence in a 1955 proposal for a summer research project held at Dartmouth College in 1956. The proposal was associated with McCarthy, Marvin Minsky, Nathaniel Rochester, and Claude Shannon.

Its central premise was ambitious: that aspects of learning and intelligence could, in principle, be described precisely enough for a machine to simulate them. The organizers expected a concentrated group of researchers to make substantial progress on problems such as language, abstraction, learning, neural networks, and creativity.

The Dartmouth project did not solve those problems, and it did not create a single machine that matched human intelligence. Its lasting effect was organizational and conceptual. It gathered researchers working on related ideas, supplied a durable name for their common endeavor, and encouraged AI to develop as a distinct area of study.

John McCarthy is therefore often called one of the founders of AI and is commonly credited with coining the term. Calling him the sole “inventor of AI” would be misleading, however. The field was shaped by many contributors, including Turing, Minsky, Newell, Simon, Shannon, Rochester, and researchers whose work later established machine learning, computer vision, natural-language processing, robotics, and other branches.

What was the first AI?

There is no universally accepted answer to “what was the first AI,” because early systems differed in purpose and because the modern category was applied retrospectively. Historians and textbooks commonly identify several candidates.

Early game-playing programs

Games were attractive early AI problems because they have formal rules, clearly defined moves, and measurable results. In the late 1940s, Turing and David Champernowne developed a chess-playing procedure known as Turochamp. It was designed before computers were powerful enough to run it as intended; moves could be calculated manually according to its rules. It was an important early expression of algorithmic game play, but it was not a practical autonomous chess system running on contemporary hardware.

Christopher Strachey developed a program that played draughts, called checkers in North America, for early computers in the early 1950s. Arthur Samuel began his own celebrated checkers program in 1952 and continued improving it. Samuel’s work became especially important because it incorporated methods that allowed the program to improve its game-playing performance through experience. This made it a landmark in the early history of machine learning as well as game-playing AI.

Logic Theorist

The Logic Theorist, created by Allen Newell, Cliff Shaw, and Herbert A. Simon in the mid-1950s, is frequently called the first AI program. It was designed to prove propositions from Principia Mathematica, a major work of formal logic. Instead of checking every possible path without discrimination, it used strategies—often called heuristics—to select promising steps in a proof.

A heuristic is a practical rule or search strategy that can make problem solving more efficient without guaranteeing the best answer in every case. Heuristics became central to early symbolic AI because many reasoning problems have too many possible paths for exhaustive search.

Logic Theorist was significant not simply because it produced proofs, but because it was explicitly intended as a model of human-like problem solving. It represented a problem using symbols, applied rules, searched possible alternatives, and pursued intermediate goals. In some cases, it found proofs that differed from those in the source text. For these reasons, it is a strong candidate when people ask about the first program created specifically as AI.

Why a single “first” is misleading

The candidates answer different criteria:

• First conceptual game-playing algorithm: early chess procedures such as Turochamp are prominent.
• First operational game-playing programs: early checkers work is a leading candidate.
• First purpose-built symbolic reasoning AI: Logic Theorist is the most frequently cited example.
• First learning-oriented AI program: Samuel’s checkers system is historically central.
• First formal field named AI: the Dartmouth project provides the conventional answer.

None of these systems was artificial general intelligence. They were narrow systems, built for a specific task and operating within carefully defined environments.

Early AI approaches: symbols, search, learning, and perception

The first decades of AI produced multiple approaches rather than one unified method. Understanding these distinctions helps explain both early successes and later disappointments.

Symbolic AI represented knowledge using symbols, rules, logical statements, and structured relationships. A system might represent facts such as “all humans are mortal” and “Socrates is human,” then derive a conclusion. Logic Theorist is an early example of this general orientation. Symbolic systems can be transparent when their rules are explicit, but they can be difficult to build and maintain when knowledge is incomplete, ambiguous, or dependent on ordinary-world context.

Search and planning treated intelligence as navigating possibilities. A chess program searches candidate moves; a theorem prover searches possible proof steps; a planner searches sequences of actions that might achieve a goal. The principal challenge is combinatorial explosion: as a problem grows, the number of possible paths can increase far faster than a computer can examine them.

Machine learning seeks systems that improve from data or experience instead of relying entirely on fixed hand-written rules. Early learning experiments were modest by modern standards, but they established a critical idea: programmers do not necessarily need to specify every useful behavior directly. Samuel’s checkers research was influential in this respect.

Neural-network research pursued learning through interconnected computational units inspired loosely by neurons. Early models and later systems, including the perceptron, generated considerable interest. They also encountered technical and theoretical limitations, especially for the hardware and training methods then available. Neural networks returned to prominence decades later when much larger datasets, more computing power, and improved training techniques became available.

From early optimism to modern AI

The pioneers of AI often made very optimistic predictions. Early demonstrations could be striking: a program could prove a theorem, play a game, solve a puzzle, or manipulate a restricted language. Yet those successes did not readily scale to flexible, everyday intelligence.

Real-world reasoning requires vast background knowledge, robustness to ambiguity, perception in changing environments, and the ability to transfer learning between tasks. Early computers also had very limited memory and processing capacity. When funding and expectations were tied to promises that systems could not yet fulfill, some periods of reduced investment and enthusiasm followed. These downturns are often called AI winters.

AI research nevertheless continued. Expert systems in later decades used extensive rule bases to support decisions in narrow domains. Statistical methods became increasingly important for speech recognition, translation, classification, and prediction. From the 2010s, deep learning—multi-layer neural-network methods trained on large quantities of data—produced major advances in image recognition, speech, language processing, game playing, and generative systems.

Modern AI is therefore connected to the 1950s but is not identical to it. Much present-day AI relies on probabilistic models, optimization, vast datasets, and high-performance computing rather than on the compact symbolic programs that dominated many early visions. At the same time, enduring problems identified by early researchers—representation, learning, search, language, reasoning, and generalization—remain central.

Important limits of historical claims

Terms such as “first AI,” “invented,” and even “intelligence” are partly interpretive. Dates can differ depending on whether a historian emphasizes a published design, a program’s first execution, a public demonstration, a research proposal, or later recognition of the work. Early computing records may also describe implementation dates differently, especially where a program evolved over several years or was adapted to different machines.

It is also important not to project modern capabilities backward. The early systems were remarkable demonstrations of computation, but they did not converse fluently, learn broad world knowledge from internet-scale data, perceive the world reliably, or act autonomously across diverse tasks. They were usually designed for a tightly bounded problem.

Finally, the founding of AI as an academic field does not imply that researchers resolved the philosophical question of whether machines truly think. That question remains contested and depends partly on how one defines thought, understanding, agency, and consciousness. The historical claim is more modest and better supported: by the mid-1950s, researchers had begun to organize a sustained scientific and engineering effort to build machines capable of tasks associated with intelligence.

Chronology of the key dates

• 1936: Alan Turing publishes his theoretical account of general computation.
• 1943: McCulloch and Pitts publish an influential formal model of artificial neural networks.
• Late 1940s: Turing and Champernowne develop the Turochamp chess procedure.
• 1950: Turing publishes Computing Machinery and Intelligence and presents the imitation-game concept.
• Early 1950s: Early checkers programs demonstrate computer game playing; Arthur Samuel begins his checkers work.
• 1955–1956: Newell, Shaw, and Simon develop Logic Theorist.
• 1956: The Dartmouth summer project establishes artificial intelligence as the name of an emerging research field.

For a question asking what year AI was invented, 1956 is the standard answer. For a question asking when the first AI was created, the more precise answer is that early AI-like programs appeared in the early 1950s, while Logic Theorist in 1955–1956 is often identified as the first major purpose-built AI program.