Since man first thought about developing Artificial General Intelligence, no clear path forward has emerged for the starting point and a comprehensive list of all the various subsystems. Many claim that this is a direct result of our lack of knowledge about what intelligence is and thus focus on the latest science drawn from examination of the brains of many species. Others jump right in, defining what they understand of intelligence in code, often ending up with apps or narrow AI.

I, for one, don’t accept this line of reasoning. I tend to completely ignore the question of intelligence and frame AGI in the context of logic. Something we do understand. If we return to our new definition of AGI, what do we note:

An AGI is a Turing complete system which can, independently, construct all forms of Turing incomplete and Turing complete systems.

We note that what we are seeking is the logic of logic. But what is the logic of logic? Well, in a nutshell, it’s the ability to logically describe the process of creating algorithms to perform given tasks. An algorithm, or set of algorithms, which can create any other type of algorithm.

I think everyone should see where I am going with this. Based upon the definition of an AGI, the primary task is to teach it how to program.

This shouldn’t come as much of a surprise. If we look to nature, the first thing a viable cell must learn is how to convert input energy to output energy and replicate itself. That is, it needs to learn how to program. Nature has the luxury of allowing randomness to guide this process and a fortunate set of physical properties which allows this to emerge. Unfortunately for AGI, the building blocks are not so convenient.

It will need a little help.

In teaching a computer how to program, we are at the same time developing the base algorithms which will allow it to approach any problem. Programming is not just about code, its also about understanding language, conversation, decomposing requirements into deliverables, planning, sequencing, structure, optimisation, technology selection and documentation. These core capabilities are universal to all problem-solving scenarios.

To me, this sounds like the core of an AGI. A solid foundation upon which we can begin address problems outside the scope of programming with transferable skills. Moreover, with an appropriate data set, such an AGI would be bootstrappable.

As such, the goal is to create an AGI which encompasses many roles found within IT. Enterprise Architect, Business Analyst, Data Architect, DBA, programmer, etc., just to name a few, are roles we want this AGI to emulate.

Starting with the role of Enterprise Architect, we want the AGI to be able to elicit requirements and describe the big picture. As such, we need to develop a program which can hold a conversation to grab those requirements and create an Enterprise Architecture in TOGAF/Archimate.

The use of formal methodologies such as TOGAF/Archimate provide a tried-and-tested approach to Enterprise design challenges and capture, in workflow form, the requirements end-to-end, from the political to technological.

From an AGI perspective, the key challenges are natural language understanding, asking the right questions, decomposing answers to match TOGAF/Archimate structures, identifying systems, defining goals, defining constraints, defining risk, etc.

What we note here is that this requires a mixture of internal knowledge and interactively gained knowledge, along with a vast array of complex algorithms to address the challenges of each stage of the process.

The beauty of this approach is that everyone involved in the development understands the entire process in its entirety. The challenge will be translating what they do effortlessly in their heads into one or more algorithms for each stage. Unlike many problems in AGI, such as tops on bird cages, there is little in the way of ambiguity as the processes are typically well defined in terms methodologies, policies, procedures, best practices, design patterns, etc. That is, with technology and business, common sense is typically well described in formal terms.

When it comes to programming itself, this is above having a data set which describes the logical relationship between statements to achieve certain goals. At its simplest, a structure snippet dataset driven by architectural requirements, at its most complex a complete dataset on computational theory with solvers which optimise algorithms.

With this base, the difference between this limited AGI and a full blown AGI is merely describing to the system what to create and how to integrate it. With enough information and appropriate algorithms, it will soon have visibility on the gaps and be filling in the blanks for itself.

As this process of iterative development establishes itself, interaction with the AGI will become more natural in time.