The Prolog Trinity Manifesto

I. Logic on the Web must be executable, not merely representational. The Semantic Web showed that structured meaning and shared representations matter. But representation is not enough; execution must be standardized and operable. The Web needs a disciplined substrate for running queries, hosting rules, shipping code, and maintaining long-lived interactions under explicit operational rules. We propose to supply it.

II. Prolog is a web technology in its own right. The goal is not that Prolog can merely expose an HTTP endpoint. The goal is that Prolog becomes legible, usable, and adoptable in the way other web technologies are: with shared interfaces, test suites, playgrounds, public nodes, and a culture of composition. Prolog's traditional strengths — explicit representation, rule-based inference, nondeterminism, and meta-programming — belong in the places where web applications and agentic systems increasingly need them.

III. The Prolog Trinity is one ecosystem seen from three angles. Web Prolog, Prolog agents, and the Prolog Web are not three loosely related ideas. They are mutually constraining: the language profile determines what can be exposed safely and portably; the agent model determines which long-lived behaviours can be made robust; and the network substrate determines which forms of composition are realistic at web scale. Each strand keeps the others honest.

IV. Web Prolog is Prolog reimagined for the open world. Web Prolog is a carefully crafted profile of Prolog — a web logic programming language that combines the relational core of Prolog with Erlang-style actors and standard web protocols. It is intentionally bilingual at the transport level while remaining monolingual at the language level: the same Prolog terms and the same programming idioms scale from request–response querying to long-lived actor conversations.

V. Agents are the primary abstraction. We advocate a core shift: treat agents as the primary abstraction. Nodes are not merely servers; they are situated participants that expose capabilities under a policy, host persistent knowledge, and mediate between clients, services, and the network. Actors are not merely processes; they are long-lived loci of interaction with mailboxes, protocols, lifecycles, and failure modes that must be governed.

VI. Concurrency belongs in logic programming, and Erlang showed us how. The actor model — processes with mailboxes, message ordering as a semantic concern, failure propagation, and supervision — is the right foundation for concurrent and distributed Prolog. Web Prolog adopts Erlang's foundation while embedding it in a logic programming context, treating distribution as a natural extension of local message passing. The result is more capable than traditional Prolog or Erlang alone.

VII. The Prolog Web is a network of logic-driven nodes, not a collection of isolated services. Turn-key Prolog nodes provide the structure needed to populate a distributed network of message-passing, logic-driven agents. Nodes share a uniform design so that newcomers can learn them quickly, practitioners can use them effectively, and deployers can operate them with minimal effort. This consistency allows the Prolog Web to grow organically into a coherent, agent-populated environment.

VIII. Nondeterministic remote procedure calls are a distinctive web-programming capability. The Prolog Web supports forms of distributed interaction difficult to realise cleanly in other web programming models. A client can request multiple answers to a query from a remote node, mirroring Prolog's local search behaviour across the network. This preserves the declarative reading of logic programs while extending it seamlessly to distributed settings.

IX. Two partitions serve different truths, and both are needed. The sequential partition is the world of goals and relations — a client poses a goal and receives answers. The concurrent partition is the world of actors and interactions — message ordering, selective receive, process lifetime, failure propagation, and supervision. Many realistic systems will deliberately mix the two. The Trinity treats this not as a compromise but as a first-class design choice.

X. Unification is the universal data contract. Where other web frameworks negotiate data interchange through schema validators and serialisation layers, Web Prolog offers unification: a single, bidirectional mechanism that simultaneously tests compatibility, extracts information, and binds variables. This makes Prolog terms a natural lingua franca for the Prolog Web.

XI. Federation, not unification. The aim is not to design a new Prolog that all existing systems must become, nor to declare a single implementation as the reference centre of gravity. The aim is to create shared interaction surfaces — web-facing interfaces and execution profiles that multiple systems can implement while remaining free to diverge internally. Federation treats interoperability as a public good and internal design freedom as a local right.

XII. Standardize the boundaries, not the internals. It is not too early to standardize the shared surfaces that allow different implementations to compose and interoperate. Rather than standardising everything inside a system, standardise what must be shared between systems when they interact over the Web. Standardize the interoperable core early enough to enable a shared ecosystem, while leaving internal innovation free.

XIII. Statechart actors make control a first-class, inspectable artefact. A great deal of complexity in web applications and agent systems is not primarily about computation, but about control: event handling, protocol sequencing, timeouts, retries, and the disciplined handling of exceptional cases. Statechart actors turn the actor model from a mere concurrency substrate into a governable interaction platform, where protocol states, transitions, and guards are explicit and therefore reviewable.

XIV. The Prolog Web is a natural platform for the Agentic Web. Long-lived processes that perceive, decide, act, and coordinate — this is what the emerging Agentic Web demands. The Trinity integrates three capabilities such systems repeatedly need: a web-native network of nodes, a concurrency model for durable interactions, and a symbolic language for explicit representation and constraint. "Agentic" should not merely mean "chatty" — it should mean "durably interactive under explicit rules."

XV. Symbolic AI and neural AI need each other, on our terms. Statistical language models can be extraordinarily useful, but they are not reliable as autonomous governors of state and protocol. The Trinity treats statistical components, when present, as powerful but fallible modules, and places the responsibility for durable behaviour in explicit symbolic structures: statechart control, Prolog-level constraints and policies, and testable message protocols. The proper balance between symbolic and neural is as challenging as it is important.

XVI. The Prolog Web aligns with the Semantic Web, it does not replace it. Prolog and the Semantic Web community share a deep conviction: building software agents that are truly clever requires logic, reasoning, and a relational way of thinking. Web Prolog fits among the web logic languages defined and standardized by the W3C. The Trinity treats shared knowledge as a first-class web resource rather than as an implementation detail locked inside one agent.

XVII. We walk in the footsteps of inventors, and we honour them by building. Colmerauer gave us Prolog. Kowalski gave us its logical foundations. Armstrong gave us Erlang and the actor model. Berners-Lee gave us the Web. Harel gave us statecharts. The Prolog Trinity ecosystem combines chunks of their work into what we hope will emerge as a coherent whole — and preferably a whole greater than the simple sum of its parts.

XVIII. An ecosystem is not something one invents — it is something one manages to invite into existence. The Prolog Trinity ecosystem demands a collective, community-driven effort. Prolog programmers and system implementers, Erlang developers, logic programming researchers, Semantic Web practitioners, and AI builders are not merely an audience — they are stakeholders whose expertise and perspectives are essential for making this real.

XIX. Prolog everywhere, but without hiding the Web. The programmable Prolog Web means code and data can be shuffled back and forth across nodes, even into browsers. But we do not seek to hide the Web behind an abstraction. We seek to make Prolog a natural citizen of the Web, with URIs, HTTP, WebSockets, and JSON as part of its semantic surface — not bolted on as afterthoughts.

XX. The Trinity is scaffolding, not a cage. The proposal is not a competing system. It is scaffolding — an ecosystem skeleton — around which existing Prolog systems can collaborate without excluding anyone and without making any system less powerful. The promise is federative: define shared interaction surfaces that many implementations can adopt, while leaving internal design choices free. Success is measured by interoperation and reuse, not by replacement.

XXI. Vision without execution is just hallucination. We do not mistake articulation for achievement. Execution is not the last step after design — it is the process through which design becomes accountable: to users, to implementors, to adversarial conditions, and to the constraints of the Web. Ideas that are not stress-tested, interoperable boundaries that are not drawn, and responsibility that is not shared — these remain idle dreams.

XXII. It may all be a pipe dream, but it is not a castle in the air. Every component of the Trinity rests on proven, time-tested technologies: Prolog, Erlang's concurrency model, and the web standards on which our connected world depends. What ultimately matters is not whether the ecosystem comes to resemble our diagrams, but whether it helps carve out a stable place for executable logic and communicative agents in the Web's future. We intend to find out.