There is a fashionable way to talk about the meeting of logic programming and artificial intelligence, and it goes in one direction only. Neural networks have won; symbolic methods lost the long argument of the twentieth century; and the only role left for logic is to be bolted onto a language model as a kind of conscience, a fact-checker for a machine that does the real thinking. This is a tidy story, and like most tidy stories about the history of AI it is mostly wrong.
I want to ask two questions instead of one, because the interesting thing about the relationship is that it runs both ways.
What can web logic programming do for artificial intelligence? And what can artificial intelligence do for logic programming?
The web in the first question is not decoration. A great deal of what makes logic programming newly relevant to AI is not the logic — we have had that since the 1970s — but the move to make it native to the web: distributed, addressable, concurrent. That is the wager of the Prolog Trinity. By the Prolog Web I mean a web of Prolog-speaking nodes — some small and stateless, some session-based, some actor-capable, all exposing logic-programming services through ordinary web protocols — and it is worth spelling out what each side stands to gain.
Before the optimism, the concession. Logic programming has been here before, and it did not go well. The expert systems of the 1980s promised exactly the kind of transparent, rule-based reasoning that is fashionable to want again, and they collapsed under their own brittleness — knowledge bases that were expensive to build, impossible to maintain, and helpless in the face of anything their authors had not anticipated. The AI winter was not simply a logic-programming winter, but logic programming belonged to the symbolic world that lost credibility when expert systems disappointed. Any honest argument for symbolic methods in AI has to explain what is different now, rather than pretending the failure never happened.
What is different is partly the world the reasoning lives in, and partly the company it now keeps.
Reasoning you can actually read. A language model produces inference the way a fluent speaker produces grammar — confidently, immediately, and without being able to show its work. When it is right, you cannot tell why; when it is wrong, you cannot tell where. A Prolog derivation is the opposite kind of object. It is a declarative trace, a chain of resolutions that you can inspect, replay, and contest. For any application where being right is not enough — where you have to be able to say why the system reached its conclusion — this auditability is not a nicety but the whole point. The web turn matters here because it makes that reasoning an addressable resource: not a black box buried in a process, but something with a name, a location, and an interface.
Intelligence as a relocatable service. Consider a small concrete case. Suppose you are building a conversational robot — say, a social robot with an expressive face. One natural architecture splits the system in two: a node that handles the robot’s input and output, the cameras and microphones and the face itself, and a separate node that does the actual reasoning about what to say and how to behave. The two communicate over a remote procedure call. The reasoning node does not know or care that it is driving a robot; it could just as easily be driving a chatbot, a game character, or a planning system. The behaviour the user experiences is the same wherever the reasoning happens to run.
This is what I have come to call interaction portability, and it is the property that makes symbolic agents composable. The intelligence is not welded to the interface. It is something you can move, replicate, supervise, and recombine across a network. That is a far more useful thing to have in an age of many cooperating agents than a monolith that has to be rewritten every time the front end changes.
A principled story about concurrency. The current generation of agent frameworks orchestrates multiple models with a great deal of improvised glue — queues, retries, and hope. Logic programming with an Erlang-style actor model has a better answer, because the problem of many independent processes that fail, restart, and message one another was solved, robustly, decades ago in telecommunications. Bringing actor concurrency into a Prolog profile means agents get supervision trees and well-defined failure semantics for free, rather than reinventing them badly.
Somewhere to keep commitments. An agent that merely generates text needs to remember nothing. An agent that acts needs to remember a great deal: what it has promised, what it is permitted to do, what it is still waiting on, who said what to whom, and which of its tasks remain open. This is bookkeeping of a particular kind — relational, rule-governed, and constantly queried — and it is exactly the kind of thing logic programming was built to hold. A language model can suggest what to do next; it is poor at maintaining the standing record of obligations against which “next” is judged. Give the agent a process that holds its commitments and the difference between a fluent talker and a dependable participant starts to come into view.
A place for the symbolic and the statistical to meet. None of this is an argument that logic should replace learning. The most interesting work — DeepProbLog, NeurASP, and the wider neuro-symbolic programme — treats the two as layers, with neural perception feeding symbolic inference and symbolic structure constraining neural search. The Prolog Web is, among other things, a candidate substrate for that meeting: a shared, networked space where a learned model can call a proof and a proof can call a learned model.
It is worth saying plainly that the present moment did not arrive because the symbolic tradition won an argument. It arrived because neural AI became impressive enough that we now want to let it act — and the moment you let a fluent system act, you need machinery for control, memory, permission, explanation, and accountability that the fluent system does not itself supply. Neural AI has, in other words, made the need for symbolic infrastructure visible again. But the traffic runs in both directions, and the reverse direction is, if anything, the more immediately practical. It bears directly on the oldest problem the language has.
Lowering the barrier to entry. Prolog’s reputation for difficulty is not undeserved. The learning curve is steep, the error messages are cryptic, and the mental model — unification, backtracking, the cut — does not transfer from the imperative languages most programmers know. This has throttled adoption for forty years. Language models change the economics of that curve. A model that can write a first draft of a predicate, explain why a clause failed, or translate a half-formed intention into working code does not eliminate the difficulty, but it lowers the cost of climbing far enough to see why the climb is worth it. For a language family arguing for wider use, that is not a side benefit; it is close to the centre of the case.
AI-assisted language design and standardization. This is the part I find genuinely novel, partly because I have been living it. Designing a language profile and shepherding it toward a standard is an enormous amount of careful, repetitive editorial labour — reconciling drafts, checking that the prose matches the grammar, hunting down inconsistencies across a specification that no single person can hold in their head. Language models turn out to be surprisingly useful collaborators in exactly this work. There is a pleasing reflexivity to it: using AI to help standardize a language that is itself meant to make AI’s reasoning more transparent. The tool and the object of the work fold back on each other.
Synthesis, translation, and discovery. Below the level of standardization there is a long tail of ordinary assistance: turning natural language into queries, suggesting predicate names, generating documentation and test cases, finding the citation you half-remember. None of this is glamorous and all of it is real, and in aggregate it removes a great deal of the friction that used to make symbolic programming feel like more trouble than it was worth.
Put the two answers side by side and a single shape emerges. Web logic programming offers AI what it most conspicuously lacks: reasoning that can be inspected, moved, supervised, and trusted. AI offers logic programming what it has always most needed: a way past the barrier of its own difficulty, and a fresh reason for people to make the climb.
Neither side is rescuing the other, and neither is winning the old argument. They are doing something more interesting, which is making each other usable. And here the concession comes back around in a more hopeful form. The tradition that failed in the 1980s was not thin — behind the expert systems lay deductive databases, constraint logic programming, planning, theorem proving, natural-language work, decades of accumulated symbolic technique. That work did not become wrong. It became unfashionable, scattered, and hard to reach. The expert systems failed because the reasoning was brittle and the knowledge was trapped in place; the web makes the reasoning portable, and AI makes both the language and its buried history approachable again. The question is not whether logic programming can be invented for the AI era. It is whether it can be resurfaced for it. Whether that is enough to succeed where the last attempt failed is exactly the question worth spending a book — and a blog post — to answer.