Programs with Common Sense

TL;DR — In 1958 John McCarthy proposed the Advice Taker: a program whose behavior improves when you tell it things in declarative sentences, because it deduces the consequences of new facts against everything it already knows. He called this instructability the essence of common sense. LLMs finally have the world knowledge McCarthy had no way to give a machine, and they visibly take advice in context — but they lack exactly the property he demanded: that told facts persist, propagate, and consistently change downstream behavior. That gap is arguably the central open problem in agent memory today, which makes this the rare 1950s paper whose spec still reads like an unmet requirements document.

The idea: common sense as instructability

McCarthy's paper — presented at the Teddington "Mechanisation of Thought Processes" symposium (the same meeting that gave us Selfridge's Pandemonium) — makes one sharp move: it defines common sense operationally. A program has common sense, he says roughly, if it automatically deduces for itself a sufficiently wide class of immediate consequences of anything it is told, together with what it already knows.

Note what this is not. It is not a claim about breadth of knowledge, or about passing tests. It is a claim about the interface: a commonsense system is one you improve by making statements to it, not by reprogramming it. Telling should be enough, because the system fills in the obvious consequences itself.

The proposed system, the Advice Taker, has three commitments:

1. Declarative representation. Knowledge lives as sentences (McCarthy envisioned something like first-order logic), not as procedures. A fact stated once is available to every future inference.
2. Deduction as the behavior engine. To act, the system derives an "imperative" conclusion — something like \mathrm{do}(a) — from its premises. The worked example in the paper is charmingly mundane: getting from a desk at home to the airport, from premises like \mathrm{at}(I, \mathrm{desk}), \mathrm{at}(\mathrm{car}, \mathrm{home}), and rules that walking gets you around the house and driving gets you around the county. The chain of trivial deductions ends in the plan: walk to the car, drive to the airport.
3. Improvement by telling. If the system fails, you don't debug it; you state the missing premise. McCarthy explicitly contrasts this with contemporary programs, which could only be improved by their authors editing code.

The paper is also, as far as I know, the first place someone seriously argued that representation — not search, not hardware — was the bottleneck for machine intelligence. That framing launched knowledge representation as a field.

Why it could not work then

Three walls, in increasing order of seriousness.

Hardware. The machines McCarthy could touch — the IBM 704 class — ran at roughly tens of thousands of operations per second with on the order of 32K words of 36-bit core memory, call it ~150 KB. A modern GPU node is roughly ten orders of magnitude faster with roughly six to seven orders more fast memory. Any deduction over a knowledge base of realistic size was out of the question; even the airport example strained what could be mechanized.

Machinery for deduction. In 1958 there was no practical theorem prover. Resolution (Robinson) arrived in 1965, and unrestricted resolution promptly hit combinatorial explosion on anything beyond toy axiom sets. Worse, McCarthy's own program of formalizing action ran into the frame problem (named by McCarthy and Hayes in 1969): stating what doesn't change when an action occurs. And classical logic is monotonic — new facts can never retract old conclusions — which is precisely wrong for common sense ("birds fly; Tweety is a penguin"). McCarthy spent much of the 1980s inventing circumscription to patch this, and the non-monotonic reasoning community spent two decades more. The brittleness was not an implementation detail; it was structural.

Knowledge acquisition. The fatal one. The Advice Taker assumes someone will tell it what it needs to know, one declarative sentence at a time. Cyc, launched in 1984 as essentially the maximalist Advice Taker bet, employed ontological engineers for four decades and accumulated on the order of tens of millions of hand-crafted assertions — and still never crossed into robust open-world common sense. Hand-encoding runs at perhaps thousands of assertions per person-year. The knowledge just doesn't fit through that pipe.

What changed

LLMs dissolved the two problems McCarthy had no answer for, by abandoning the part he thought was essential.

Knowledge acquisition: pretraining on roughly 10^{13} tokens absorbs a serviceable, if lossy, model of everyday physics, social convention, and how airports work — the substrate Cyc tried to type in by hand. The interface: instruction tuning means you genuinely can tell a model "always confirm the date before booking" in plain English and watch behavior change. In-context learning is advice-taking, and it works startlingly well within a session.

What we gave up is everything McCarthy's deductive core guaranteed:

• Persistence. Advice in a context window vanishes. Advice in a system prompt must be re-fed forever and competes for attention with everything else.
• Propagation. Tell a model a fact and ask about its consequences two hops away; it frequently fails. The knowledge-editing literature (ROME, MEMIT, and ripple-effect benchmarks like MQuAKE) documents this precisely: you can surgically edit "the CEO of X is Y" into the weights, but derived beliefs don't update. This is a direct empirical falsification of McCarthy's criterion — the system does not deduce the immediate consequences of what it is told.
• Consistency. Nothing checks new advice against old. Contradictory instructions produce silent, position-dependent arbitration, and sycophancy means stated "facts" from the user can override better knowledge in the weights.
• Updating weights is reprogramming. Fine-tuning on advice is exactly the move McCarthy defined common sense against: it requires the author, not the user, and it doesn't compose.

So the field executed a strange pincer: Cyc built the deductive core without the knowledge; LLMs built the knowledge without the deductive core.

A 2026 revival: an Advice Taker with an LLM substrate

The serious version is not "bolt a theorem prover onto GPT." It is to treat McCarthy's paper as a specification and build the missing loop:

Architecture. An LLM agent with (a) a structured advice store — each accepted piece of advice compiled by the model itself into a canonical form: a natural-language rule plus, where possible, a formal fragment (a Datalog/ASP rule, a constraint, a typed fact); (b) an incorporation step on every new piece of advice: retrieve potentially interacting rules, check for contradiction (an SMT/ASP solver on the formalized subset, LLM-as-judge on the rest), and either merge, refine ("this overrides rule 12 in context C"), or surface the conflict to the user — essentially AGM belief revision with an LLM doing the semantics; (c) consequence materialization: after accepting "penguins don't fly," forward-chain the cheap deductions and write them back, so two-hop questions don't depend on the model re-deriving them at inference time; (d) retrieval-triggered injection of relevant rules into working context at decision time.

Reuse from the paper: the declarative store, improvement-by-telling as the only update channel, and the "immediate consequences" test as the acceptance criterion. Replace: first-order deduction as the sole engine (the LLM is the reasoner; logic is the auditor), and monotonic logic (advice must be defeasible by later advice — McCarthy's own later work tells you how to think about this).

The benchmark, which mostly doesn't exist yet in unified form: tell the agent N facts and directives across many sessions, then measure (1) persistence — compliance at session 1 vs. session 100; (2) propagation — accuracy on k-hop consequences of told facts (MQuAKE-style, but for advice and norms, not just entity edits); (3) consistency — behavior under deliberately conflicting advice, scored on whether conflicts are detected rather than silently averaged; (4) retraction — "ignore what I said last week about X" actually unwinds the materialized consequences. An agent that scores well on all four is, operationally, McCarthy's Advice Taker.

Tried, vindicated, open

Partial descendants abound. Cyc is the cautionary tale on the knowledge side. Instructable-agent work in cognitive architectures (Soar's learning-from-instruction line) kept the flame alive in the symbolic era. On the modern side: system prompts and Constitutional AI are advice without persistence guarantees; memory-augmented agents (MemGPT/Letta and successors) give persistence without consistency; Voyager-style skill libraries persist procedures but not declarative beliefs; knowledge editing gives durable single-fact writes without propagation. Each solves one leg of McCarthy's tripod. Nobody, to my knowledge, has published a system that passes all four benchmark criteria above at nontrivial scale — which is why I'd call the paper ripe rather than vindicated.

The deep open question is whether McCarthy's guarantee is even achievable with a stochastic substrate: consistent belief revision is intractable in the worst case even for propositional logic, so any real system will be a heuristic approximation with a formally-checked core. Deciding how big that core can be — how much of an agent's advice-derived belief state can live in a solver-auditable representation without recreating Cyc's brittleness — is a genuinely new research problem, not a rerun of GOFAI vs. connectionism.

Where to read it

No link was provided and I haven't verified the bibliographic details here, but the paper is widely reprinted: search for "Programs with Common Sense," McCarthy, in the Teddington symposium proceedings (1959) or in Semantic Information Processing (Minsky, ed., 1968); it's also on Stanford's McCarthy archive. Read alongside: McCarthy & Hayes, "Some Philosophical Problems from the Standpoint of Artificial Intelligence" (1969) for the frame problem the Advice Taker walked into; Lenat's Cyc retrospectives for what hand-encoding actually costs; and the MQuAKE / ripple-effects knowledge-editing papers for quantitative proof that today's models fail McCarthy's one-sentence test — the sentence that, sixty-seven years on, still defines the job.