SingularityNET ~= Webmind on blockchain and OpenCog

(photo courtesy of Anton Kolonin, current AI designer and developer at SingularityNET and long ago transcognitive engineer and Siberian Madmind @ Webmind Inc.)

In a few recent blog posts, I have been sketching a few more aspects of the SingularityNET technical design — e.g. the potential for automatization of transforming Agents into distributed-processing Agents, and the use of probabilistic and functional semantics together in ontologies.

For those with a historical bent, these aspects of SingularityNET may be seen to reveal the SingularityNET as (verry roughly speaking) a sort of “Webmind on blockchain and OpenCog.”

What I mean is: the long-ago Webmind AI design that my colleagues and I created at Webmind Inc. from 1997–2001 aimed to glue together very diverse AI tools on a common knowledge graphs and in a common processing framework. But it failed — it had led to an inefficient mess, though one with very interesting aspects. At the time the company tanked in the general dot-com crash, the Webmind tech team was putting its head together trying to figure out how to redesign things for greater efficiency and tractability, incorporating everything we had learned.

The Novamente Cognition Engine and OpenCog designs, refined by my colleagues and me during 2001–2016, narrowed the focus to a specific set of AI algorithms, synergizing together in specific ways. The design uses probabilistic semantics as a glue between the algorithms, and uses functional and logic programming to insulate the algorithms from screwing each other up too badly while they act on the same Atomspace weighted-labeled-hypergraph knowledge store.

SingularityNET opens things up again to a huge variety of algorithms, and via introducing additional elegant abstraction layers, enables them to interact using probabilistic semantics as glue, and using functional and logic programming to enable both clean communication and efficient distributed processing. In this way it accomplishes what the Webmind design was trying to do, using conceptual and mathematical tools that were refined in experimentation with the Novamente Cognition Engine and OpenCog designs.

Attention allocation in Webmind relied on neural net type activation spreading. Inspired by Eric Baum’s conceptual thinking (though using different math), NCE and OpenCog introduced “Economic Attention Allocation” as a similar but more rational-inference-friendly alternative. Instead of passing activation values around, in OpenCog, little bits of artificial currency get passed around. In SingularityNET this idea is extended significantly — the artificial currency passed around to regulate attention is a cryptocurrency that can be converted (by external payment processors and such) to and from the world’s standard currencies. Again, an idea developed in NCE/OpenCog is being used within SingularityNET to enable the scale and diversity of AI dynamics that we were trying to achieve in Webmind.

Loosely speaking one can view both Webmind and OpenCog as prototypes for aspects of SingularityNET. However, OpenCog will also be the source for a lot of specific code to be rolled out within SingularityNET — just wrapped up differently than it is currently wrapped for use within OpenCog.

One reason the Webmind system was insufficiently scalable was that it used Java as the implementation language, and the JVM in 1997–2001 was terribly buggy, with great inefficiencies in garbage collection, serialization and other aspects. It is ironic that now, as we explore routes to port OpenCog code to the SingularityNET framework, one tool that is being considered is Apache Ignite, which is a middleware layer intervening between applications and storage — and which is implemented using Java and the JVM. The JVM is now not so buggy or inefficient, and is a good tool for doing what Ignite does, for the same reasons that we wanted to use Java in Webmind.

But it would have taken a heroic amount of genius (evidently more than my colleagues and I had) to design SingularityNET in 1997, and it might have been essentially impossible to build it. The tools just weren’t there yet. We could certainly have come closer than we did at that time; but in 2017 it seems finally possible to really do it, leveraging so many wonderful software and computer science tools others have created in the interim.

One of the beautiful things about living so close to the Singularity, is that one can be far ahead of one’s time on a conceptual level, and then, over a course of mere decades, one can watch the world’s thinking and technology frameworks catch up. As the Singularity gets nearer and nearer, it will be years instead of decades, and then months instead of years. Holy shit, eh?