The wrong conclusion to draw from Harpy is that graphs are the problem. The more consequential limitation was the world in which Harpy could operate: a tightly constrained vocabulary, grammar and task. Its graph encoded that limitation, but was not identical to it.
That distinction matters whenever knowledge graphs are contrasted with statistical learning. A graph can be brittle. It can be too expensive to curate. It can hard-code a mistaken ontology. None of those facts make graph structure inherently incompatible with learning—or establish that removing explicit structure creates an open-world system.
Four Layers That Are Too Often Collapsed
Consider four different architectural objects:
graph G_t = (V_t, E_t)
state dynamics s_(t+1) = F(s_t, a_t, ξ_t)
navigation π chooses which actions or transitions to explore
state space S defines what can count as a system state
The graph represents relations, dependencies and possible transitions. A state space describes the possible configurations of the system. A transition function describes how an action, an event or an unmodelled influence changes one configuration into another. Navigation decides which available paths are actually explored.
These layers interact, but they are not substitutes for one another.
A graph can grow by adding nodes and edges while the system still projects every observation into the same old state description. Conversely, a modest graph can help an agent navigate a high-dimensional continuous state space: think of a compact topology of entities, constraints and landmarks that guides action without attempting to enumerate every possible physical, social or semantic condition.
The graph is therefore a representation and navigation layer. It is not, by itself, the boundary of what the system can represent or become.
What Harpy Actually Illustrates
Harpy was a remarkable speech-understanding system for its time. In the ARPA Speech Understanding Research program, it reached a 1,011-word vocabulary and reported strong semantic performance under a deliberately constrained task and grammar. Its finite-state network and search procedures were not incidental details; they were part of what made the problem tractable on contemporary compute.
But “tractable” is precisely the key word. Harpy was designed for a bounded language environment. A new kind of utterance, task or world knowledge was not merely another route through an already adequate map. It could require changing the vocabulary, grammar, constraints and interpretation scheme that defined the map.
That is a limitation of the operational state space and its modelling assumptions. Calling it only a failure of symbolic representation loses the architectural lesson. Replacing a hand-built network with a learned statistical model can improve coverage enormously; it does not, on its own, give the system a mechanism for questioning its own state variables, action categories or success conditions.
The Bitter Lesson Does Not Settle This Question
Richard Sutton’s The Bitter Lesson makes an important empirical point: across several fields, methods that exploit increasing computation through search and learning have repeatedly outscaled approaches built around detailed human-supplied knowledge. That history is a strong warning against treating human intuition as a permanent performance ceiling.
It is not a proof that explicit knowledge representation is a dead end.
The common overreach is to identify three distinct things as though they were one:
- human-curated knowledge;
- symbolic representational structures; and
- a state space fixed in advance by its designers.
They can coincide, but they need not. A graph may be extracted from data, proposed by a model, updated from tool observations or revised after validation. A learned neural representation can be entirely shaped by human-selected observations, objectives and environment interfaces. And either kind of representation can remain locked into a fixed state description.
The useful critique is not “never use a graph.” It is: do not mistake a human-designed abstraction for the thing itself, and do not assume that more compute will repair an abstraction that cannot be revised.
AlphaZero Is Powerful—and Still a Closed World
AlphaGo Zero and AlphaZero are compelling demonstrations of what self-play can achieve. They replaced human game records and handcrafted expert features with reinforcement learning and search, given the rules of Go, chess or shogi. The result was superhuman play.
Yet this is not evidence of open-world cognition. The environment still defines legal actions, state transitions, terminal conditions and the objective. Self-play removes human demonstrations; it does not remove the game as a closed formal system.
This is not a defect in AlphaZero. It is why the result is clean: the agent can explore, evaluate and improve inside an environment whose rules make each outcome unambiguous. The lesson is that navigation and learning can become extraordinarily capable when the state dynamics and reward signal are well specified—not that every architecture using an explicit graph has therefore failed.
The Architectural Test: Can the State Description Be Revised?
For an architecture with state-space memory, a working knowledge graph and entropy-guided exploration, the decisive question is not whether the graph grows. It is what happens when the world violates the system’s current description.
There is a qualitative difference between these responses:
Unexpected observation
→ add a node or edge using the existing ontology
Unexpected observation
→ identify that the state variables, transition model or ontology are inadequate
→ propose a revised representation
→ validate, version and adopt the revision
The first response produces a larger knowledge base. The second creates the possibility of an architecture that can alter the terms under which it interprets future observations.
That revision still needs governance. An agent should not silently redefine a safety-critical state variable because one observation was surprising. It needs evidence, competing hypotheses, tests, versioning, provenance and an authority boundary for adoption. But this is precisely where explicit structure helps: a system can inspect which concepts, relations and transition assumptions changed, rather than burying the revision inside an opaque parameter update.
Graphs and Learning Belong on Different Layers
A statistical model can infer, score, create and traverse graph structure. A graph can preserve identity, provenance, permissions and persistent relations while the model’s internal representation changes. A learned transition model can predict possible futures while an external state graph records which transition the production system has accepted as true.
This division of labour is practical. Knowledge Graphs as the Control Plane explains how relations can constrain action without making a graph the executor. Graph RAG vs. Agent Memory vs. World State distinguishes retrieved evidence, useful recall and authoritative current state. Those contracts let the system use both learned and explicit representations without confusing their roles.
An entropy gradient can then guide where uncertainty is worth reducing; it is a policy for navigation, not a replacement for the state space. A working graph can supply paths and local constraints; it is not a claim that the paths exhaust what the system might later need to model.
The Real Design Question
The relevant divide is not human knowledge versus machine knowledge, nor graph versus neural network. It is whether the architecture can discover that its present state assumptions are insufficient—and can revise them in a controlled, inspectable way.
Growing a graph may be useful. Scaling search and learning may be indispensable. Neither is enough by itself. An architecture becomes meaningfully more open only when it can treat its own ontology, transition assumptions and navigation policy as revisable objects rather than invisible constants.
That is the unresolved challenge behind the Bitter Lesson. It describes which methods have historically scaled with computation. It does not tell us under what conditions a system can recognize that it is operating in the wrong state space.