🦾 Artificial intelligence

About 15 minutes to read · every paper named here has its own page in this library

What it is

AI is the attempt to make machines do things that would call for intelligence if a person did them. Examples include recognising a face, understanding a question, planning a route, proving a theorem and holding a conversation. AI is both a science and a branch of engineering. As a science it asks what intelligence is and how it could be produced mechanically. As engineering it builds programs that perceive, reason, learn and act.

A widely used textbook framing, from Russell and Norvig (1995), sorts definitions of AI along two axes. The first asks whether the goal is to reproduce thinking or behaviour. The second asks whether success is judged against human performance or against an ideal standard of rationality. Crossing the two gives four views:

• thinking humanly, the cognitive-modelling programme;
• thinking rationally, the "laws of thought" tradition rooted in logic;
• acting humanly, the view behind Turing's imitation game;
• acting rationally, the rational-agent view that dominates modern textbooks.

On the rational-agent view, an agent receives percepts and chooses the actions expected to maximise its performance measure. Learning, search and knowledge are all means to that end.

The field breaks into branches that overlap heavily:

• Knowledge representation and reasoning asks how facts, rules and beliefs can be stored so a program can draw conclusions from them.
• Automated planning searches for sequences of actions that reach a goal.
• Machine learning lets systems improve from data instead of hand-written rules.
• Computer vision interprets images and video.
• Natural language processing (NLP) deals with human language.
• Robotics puts perception and action into a physical body.

Since about 2018 a single kind of system has begun to cut across all of these branches: large pretrained models, which Bommasani and colleagues named foundation models (Bommasani et al. 2021).

How it works

No single mechanism defines AI. Three broad families of technique, often combined, do most of the work.

Search and symbolic reasoning

The oldest family treats intelligent behaviour as search through a space of possible states. Knowledge is written in explicit symbols. The Soar architecture is a mature example. In Soar, all goal-directed behaviour becomes search in problem spaces, and knowledge is held as production rules matched against a working memory. When the rules run out or conflict, the system creates a subgoal, and a mechanism called chunking caches each solved subgoal as a new rule (Laird et al. 1987).

Logic-based programs of this kind can explain their conclusions step by step. Their weakness is brittleness. They handle noise, ambiguity and incomplete information poorly, and every rule has to be written by someone (Badreddine et al. 2020).

Statistical learning

The second family learns a function from examples. A model with adjustable parameters is fitted to data by minimising a loss, usually with gradient descent. Deep learning stacks many layers of such parameters. Gary Marcus describes it as statistical pattern classification performed by multi-layer networks trained with back-propagation (Marcus 2018).

Every architecture builds in assumptions, called inductive biases. Convolutional networks assume locality and translation invariance, and recurrent networks assume sequential order. Graph networks generalise both by operating on entities and the relations between them (Battaglia et al. 2018).

Attention and pretrained models

The Transformer, introduced for machine translation, dropped recurrence and convolution entirely and relied on attention alone (Vaswani et al. 2017). Its central operation is scaled dot-product attention:

Attention(Q, K, V) = softmax(Q · Kᵀ / √d_k) · V

Here Q, K and V are matrices of query, key and value vectors computed from the input tokens. Kᵀ is the transpose of K, and d_k is the dimension of the keys. Dividing by √d_k keeps the dot products from growing too large. The softmax turns each row of scores into weights that sum to one, so every output is a weighted average of the values. Because the computation is a set of matrix products, it parallelises well on GPUs, which made far larger training runs practical (Vaswani et al. 2017).

A language model built this way is pretrained on raw text with a self-supervised objective, such as predicting the next word or a masked word, and then adapted to downstream tasks (Bommasani et al. 2021). With GPT-3, the adaptation could be done without changing any weights. The task and a few examples were simply written into the prompt, a behaviour the authors called in-context learning (Brown et al. 2020).

How performance grows with resources follows regular scaling laws. The GPT-4 team forecast the final loss of their model from much smaller runs using a fit of the form

L(C) = a · C^b + c

where L is the loss on held-out code, C is the training compute, and a, b and c are constants fitted to the small runs. The constant c is the loss that more compute alone cannot remove (OpenAI et al. 2023).

History

Foundations and the Dartmouth proposal (1950–1956)

Alan Turing's 1950 paper asked whether machines can think and proposed replacing that question with an imitation game. The name "artificial intelligence" comes from the 1955 proposal by McCarthy, Minsky, Rochester and Shannon for a summer research workshop at Dartmouth College, held in 1956. The proposal rested on the conjecture that every feature of learning or intelligence could, in principle, be described precisely enough for a machine to simulate it.

Symbolic AI (late 1950s–1970s)

The first decades were dominated by symbolic programs. John McCarthy's "Programs with Common Sense" set out the aim of a system that reasons from declarative knowledge stated in logic (McCarthy 1959). A decade later, McCarthy and Hayes examined philosophical problems raised by that project. In that paper they introduced the frame problem and developed the situation calculus, which McCarthy had first set out in 1963 (McCarthy & Hayes 1969). Winograd's SHRDLU blocks-world system (1971) became a touchstone for language understanding in a closed world (Marcus 2020).

Expert systems and the AI winters (1970s–1980s)

Optimistic forecasts outran results, and funding cuts in the 1970s produced the first "AI winter". Research then turned from general search procedures toward domain knowledge. Chi, Glaser and Rees traced this change of emphasis in both AI and cognitive psychology. Their studies of physics problem solving corroborated it: novices fall behind experts mainly because what they know is sparser and differently organised, not because they process information less well (Chi et al. 1982).

Expert systems put the knowledge-based turn into practice, as rule bases encoding a specialist's know-how. Soar showed expert-system work, such as R1-Soar for configuring VAX computers, running inside a unified cognitive architecture (Laird et al. 1987). Language front ends for knowledge-based systems were built from modular components in the same spirit. One example is an anaphora resolver in which separate constraint sources proposed and scored candidate antecedents (Rich & LuperFoy 1988). When expert systems proved costly to maintain and the specialised hardware market collapsed in the late 1980s, a second winter followed.

Statistical machine learning (1990s–2000s)

From the 1990s the field increasingly learned its behaviour from data. The Stanford foundation-model report describes this as the first of three stages, in which the learning algorithm becomes the shared component and features are still engineered by hand (Bommasani et al. 2021). Retrieval, probabilistic models and classifiers over engineered features defined this period. They still dominated as late as the 2015–2016 Allen AI Science Challenge. All its winning entries relied mostly on information retrieval combined with gradient boosting or logistic regression (Schoenick et al. 2016).

Deep learning (2012 onward)

The turn came in 2012, when a deep convolutional network trained on GPUs won the ImageNet image classification competition by a wide margin (Krizhevsky et al. 2012). That network had about 60 million parameters and was trained on roughly a million labelled images (Krizhevsky et al. 2012; Marcus 2018). Within a few years, deep networks led in vision, speech and language. In the 2017 Transformer, attention replaced recurrence and set new records on WMT 2014 translation (Vaswani et al. 2017).

Foundation models (2018 onward)

From about 2018–2019, starting with BERT, the trained model itself became the shared component, adapted to many tasks (Bommasani et al. 2021). GPT-3, with 175 billion parameters, showed few-shot ability across translation, question answering and arithmetic (Brown et al. 2020). GPT-4 accepted images as well as text, and its report withheld its size and architecture (OpenAI et al. 2023).

Image–text models such as EVA-CLIP extended the same recipe to vision. The largest variant, EVA-02-CLIP-E/14+, reached 82.0% zero-shot top-1 accuracy on ImageNet-1K. The family matched or beat same-sized CLIP and OpenCLIP models while training on fewer image–text pairs (Sun et al. 2023).

Methods

Knowledge, logic and neuro-symbolic methods

Explicit knowledge remains central wherever answers must be justified. Knowledge graphs, built through ontology engineering, supply structured facts. Legal AI shows how the old divide persists. Embedding-based methods usually score better, while symbol-based methods such as element detection and event timelines are easier to explain. A survey of the field recommends combining the two (Zhong et al. 2020).

Neuro-symbolic AI tries to merge learning and logic in one system. Logic Tensor Networks ground a fuzzy first-order language, Real Logic, in tensors so that every formula is differentiable. Learning then amounts to maximising the degree to which a knowledge base is satisfied (Badreddine et al. 2020).

One survey sorts recent neuro-symbolic papers by five of the patterns Henry Kautz described for wiring neural and symbolic parts together. It finds that interpretability is by far the most pursued benefit, while error recovery is almost never addressed (Sarker et al. 2021). Another survey traces these systems back to statistical relational AI. It proposes seven shared dimensions for comparing them, such as proof-based versus model-based inference (Marra et al. 2021).

Planning and problem solving

Classical planning describes actions formally and searches for plans that reach a goal. It is now also used as a yardstick for learned systems. PlanBench generates its tasks from International Planning Competition domains and checks answers with a planner and validator. It includes obfuscated variants, so that memorised world knowledge cannot stand in for reasoning (Valmeekam et al. 2022).

In olympiad geometry, the algebraic Wu's method can be combined with a symbolic deduction engine, with no neural component. That system solves 21 of the 30 IMO-AG-30 problems, close to the 22.9 average of silver medallists. A separate ensemble of Wu's method with AlphaGeometry reaches 27 (Sinha et al. 2024).

Learning from data

Most current systems are trained by supervised or self-supervised learning (Bommasani et al. 2021). Some, GPT-4 among them, are then tuned with reinforcement learning from human feedback (RLHF) (OpenAI et al. 2023). Fine-tuning on labelled data competes with prompting. GPT-3 made the shift in emphasis from the first to the second practical at scale (Brown et al. 2020).

Where labelled data is scarce, generated data fills the gap. A review of synthetic-data practice finds that verifying generated samples, with interpreters, symbolic engines or answer filters, is a recurring condition of success (Liu et al. 2024). Adversarial training is another tool. A dialogue generator rewarded by a discriminator that tries to tell human replies from machine ones produced better conversations than maximum-likelihood baselines (Li et al. 2017).

Perception, language and speech

Vision moved from convolutional networks (Krizhevsky et al. 2012) to image–text pretraining, a strand of multimodal learning (Sun et al. 2023). Small, practical vision pipelines remain common. One example is a two-model EfficientNet ensemble built to classify photographs of destroyed infrastructure on a 2GB GPU (Yassin & Khalil 2026).

Large language models now underlie most work in machine translation, question answering and dialogue systems. In speech, self-supervised encoders such as wav2vec 2.0 transcribe words well but fail on isolated Arabic letters. A small classifier on their embeddings helps, though it stays fragile under tiny perturbations until it is adversarially trained (Zaatiti et al. 2025).

Agents, tools and retrieval

A growing share of AI systems are agents: a language model that plans, calls tools and remembers. HuggingGPT uses ChatGPT as a controller that splits a request into subtasks and dispatches each to a specialised model (Shen et al. 2023). MA²P adds meta-cognitive planning, monitoring and evaluation to persuasive dialogue without any training (Zhang et al. 2026).

Retrieval-augmented generation depends on fast nearest-neighbour search over embedding vectors, a core information retrieval technique. The Faiss library is a standard toolbox for that search (Douze et al. 2024).

Agents are spreading into science, with reviews covering chemistry (Ramos et al. 2024) and the whole research lifecycle (Chen et al. 2025). ERA (Empirical Research Assistance), from Google DeepMind and Google Research, uses an LLM and tree search to rewrite scorable research code. It matched or beat expert-built solutions on six scientific benchmarks (Aygün et al. 2025).

Datasets and benchmarks

Language as the test of intelligence

Turing's imitation game made conversation the classic test of machine intelligence. Its weaknesses are well known. Its rules are loose, chatbots can pass it by fooling judges, and it gives only a pass or fail. These objections led the Allen Institute to propose graded science exams instead (Schoenick et al. 2016).

Dialogue research has repeatedly tried to automate the test itself. ADEM learned to predict human ratings of chatbot replies. It tracked those ratings far better than word-overlap metrics such as the BLEU score, which often disagree with people (Lowe et al. 2017). Adversarial evaluation counts how often a model fools a trained discriminator (Li et al. 2017).

With fluent generators, the test has turned around: the task is now to detect machine text. TuringBench pits detectors against output from 19 generators, and GPT-3 text was among the hardest to flag (Uchendu et al. 2021). Even supposedly human data is affected. An estimated 33–46% of crowd workers in one summarisation task used language models to write their answers (Veselovsky et al. 2023). GPT-3's own authors reported that human judges found its news articles hard to tell from human writing (Brown et al. 2020).

Exams, reasoning and expert-level tests

Benchmarks are created and then saturated, and the global dynamics of that cycle have been mapped across the field (Ott et al. 2022). To stay ahead, newer tests are written by specialists, protected against contamination, or built from formal domains. The table gathers a few, with the numbers reported for each.

Domain tests expose gaps that general scores hide. On the Chinese bar-exam set JEC-QA, question-answering models fell far behind humans and failed at legal multi-hop reasoning (Zhong et al. 2020). LexGenius probes "soft" legal AI skills such as legal ethics. Its best model, DeepSeek-R1, still trailed legal professionals on all seven dimensions (Liu et al. 2026).

For abstraction, Melanie Mitchell argues for generative, hidden, human-curated tests such as ARC and letter-string analogies. Discriminative puzzles, in her view, are too easy to game with shortcuts (Mitchell 2021).

Commonsense remains a standing challenge. Ernest Davis and Gary Marcus describe it as one of AI's hardest problems (Davis & Marcus 2015). Davis later took it up again through mathematical word problems (Davis 2023). The wider literature on evaluation and benchmarks and on reasoning covers these issues in depth.

People and institutions

John McCarthy shaped logic-based AI (McCarthy 1959), with Patrick Hayes on its philosophical problems (McCarthy & Hayes 1969). Allen Newell, John Laird and Paul Rosenbloom built Soar (Laird et al. 1987). Michelene Chi, Robert Glaser and Ernest Rees studied expertise as structured knowledge (Chi et al. 1982). Alex Krizhevsky, Ilya Sutskever and Geoffrey Hinton sparked the deep-learning revival (Krizhevsky et al. 2012). Ashish Vaswani, Noam Shazeer and colleagues introduced the Transformer (Vaswani et al. 2017).

Among critics and theorists, Gary Marcus wrote widely cited critiques of deep learning and an agenda for robust, hybrid AI (Marcus 2018; Marcus 2020). Melanie Mitchell wrote on analogy and abstraction (Mitchell 2021).

Tim Miller, now at the University of Queensland, brought social-science research on explanation into explainable AI (Miller 2017).

Sébastien Bubeck and colleagues at Microsoft Research wrote the much-debated "Sparks" study of an early GPT-4 (Bubeck et al. 2023).

Peter W. Battaglia, Adam Santoro and Mateusz Malinowski are now at Google DeepMind, and Caglar Gulcehre is now at EPFL. With David Raposo and Francis Song, they set out the graph-network framework (Battaglia et al. 2018).

Jiwei Li led the paper "Adversarial Learning for Neural Dialogue Generation", written with co-authors including Alan Ritter (Georgia Institute of Technology) and Dan Jurafsky (Stanford) (Li et al. 2017).

On safety, Dario Amodei, Chris Olah, Jacob Steinhardt, Paul Christiano, John Schulman and Dan Mané framed the concrete problems of accident risk (Amodei et al. 2016). Samuel Bowman and colleagues turned scalable oversight into experiments (Bowman et al. 2022).

Institutionally, Stanford University hosts the Center for Research on Foundation Models, which coined that term (Bommasani et al. 2021). OpenAI built GPT-3 and GPT-4 (Brown et al. 2020; OpenAI et al. 2023). The Allen Institute for Artificial Intelligence ran the science challenge (Schoenick et al. 2016) and released the Kaleido value model (Sorensen et al. 2023).

Open questions

Is general intelligence in sight?

Whether current systems are on the road to artificial general intelligence (AGI) is the field's most contested question. The "Sparks" authors read GPT-4's breadth, across coding, mathematics, medicine, law and tool use, as an early and incomplete form of AGI (Bubeck et al. 2023). The same study lists hallucination and weak planning, which it attributes to next-word generation. It also concedes that its method is observational and cannot explain why the model works.

Benchmarks of planning (Valmeekam et al. 2022) and of expert-level science (Rein et al. 2023) show large remaining gaps. The GPT-4 report itself notes failures, such as a Codeforces rating below the 5th percentile (OpenAI et al. 2023).

Critics argue that scale alone will not close these gaps. Marcus proposes hybrid neural–symbolic architectures with large-scale knowledge, explicit reasoning and internal world models (Marcus 2020). Mitchell considers abstraction and analogy almost entirely unsolved (Mitchell 2021). Graph networks (Battaglia et al. 2018) and Logic Tensor Networks (Badreddine et al. 2020) try to build structure into learning. Neuro-symbolic work, however, still makes shallow use of formal logic (Sarker et al. 2021).

Safety and alignment

Amodei and colleagues identified five accident problems, using an imagined cleaning robot as the running example (Amodei et al. 2016):

• avoiding negative side effects;
• avoiding reward hacking;
• scalable oversight;
• safe exploration;
• robustness to distributional shift.

A later survey organises alignment research around four goals, which it abbreviates RICE: robustness, interpretability, controllability and ethicality. It divides the work into forward alignment, meaning training, and backward alignment, meaning assurance and governance (Ji et al. 2023).

The hardest of these may be supervising systems that know more than their overseers. "Sandwiching" experiments found that non-experts helped by an unreliable assistant outscored both the model alone and their own unassisted attempts. They also sometimes accepted confident falsehoods (Bowman et al. 2022).

In deployment, simple tasks remain hard. Deciding whether a user's request violates an organisation's policy proved difficult for every model tested, small or large (Cisneros-Velarde 2026). More on these themes is collected under bias, fairness and safety.

Bias, values and explanation

Fairness depends on data. In automatic scoring of science answers, bias against English learners did not appear with ample training data. Problems could emerge when only around 200 learner answers per item were available (Guo et al. 2025).

Training on aggregated labels risks averaging away legitimate disagreement between values. Kaleido instead represents plural values, rights and duties explicitly (Sorensen et al. 2023).

Explanation is still more often designed from researchers' intuitions than from evidence about how people explain things to one another (Miller 2017). The neural side of this question, finding what models compute inside them, is the subject of interpretability.

Who benefits

AI's reach is uneven across languages and communities. Digital Harf shows one route to culturally fitted tools in a lower-resource setting. It offers Arabic speech therapy for autistic children, with clinical content generated synthetically and screened by speech-language pathologists (Azad et al. 2026). Similar efforts in language learning favour pragmatic designs that combine AI with virtual reality (Ward et al. 2025).

Whether foundation models narrow or widen such gaps is an open problem. The Stanford report calls their concentration in a few base models homogenisation. Whether that concentration will spread both their gains and their defects to every system built on them is also unresolved (Bommasani et al. 2021).

The library in figures