Artificial General Intelligence 2011 (AGI-11) Workshop

View the website for the Fourth Conference on Artificial General Intelligence

Self-Programming in AGI Systems

Call for Papers

The behavior of a computer system consists of a sequence of operations. A major difference between conventional systems and intelligent systems is that the former follow predetermined programs provided by human programmers, while the latter systems are capable of “self-programming” in the sense that their behavior is not always explicitly specified by a human, but rather “decided by the system itself” to various degrees. In a broad sense many existing AI techniques can be considered as capable of self-programming, including, for example, abilities for searching, planning, production systems, genetic programming, inductive logic programming, reinforcement learning, reactive agent/robot, adaptive agent/robot and so on. Therefore, self-programming is often achieved via learning, though there are other possibilities.

Artificial General Intelligence

The term “artificial general intelligence” (AGI) refers to general-purpose systems with an integrative and holistic intellectual and cognitive abilities. For a system to be considered AGI, some form of self-programming is necessary component, since such systems have to be capable of learning whole new skill-sets from experience, not simply improving performance on a single or a small set of pre-programmed tasks. Existing AI techniques can only achieve this to a certain degree and many problems remain unsolved. Many techniques are yet to be discovered to achieve advanced levels of system autonomy. Given the special requirements of AGI, we need to compare and evaluate alternative answers to fundamental questions related to self-programming processes.

The AGI-11 Workshop on “Self-Programming in AGI Systems” will provide an opportunity for AGI researchers to discuss these questions.


  • A. For an AGI system to choose its own behavior and improve its performance in various situations, should the system modify its own source code, or only modify its data?
  • B. Is the set of basic operations of a system constant or variable? If it is constant, then what basic operations are needed for a general-purpose system? If it is variable, then how does the set change?
  • C. Does the system directly choose among the basic operations, or also among compound or macro operations that are recursively formed from the basic ones? If it is the latter, then what type of composition mechanism is needed?
  • D. How is the system’s knowledge about an operation represented? Is the knowledge certain or uncertain? Is the knowledge given or acquired?
  • E. When faced with a goal, does the system work out a complete plan and then subsequently follow it, or make decisions only step-by-step? In the former case, how is real-time handled in a dynamic, changing environment? In the latter case, how does the system avoid near-sighted decisions?
  • F. When choosing what to do next, does the system exhaustively compare all alternative operations, only compare some of them, compare a randomly selected subset, or simply choose one randomly without comparison with the others?
  • G. When comparing alternative operations, does the system take all relevant knowledge into account, or only pay attention to part of it? In the former case, how to do it in an affordable amount of time? In the latter case, how does the system avoid errors from hasty decisions?
  • H. How is the successfulness of an operation evaluated? How reliable is a feedback or reward signal? How does the system turn successful operations into reusable skills?
  • I. Can the system always “do the right thing”? If no, in what sense it is “intelligent”? If yes, in what sense are its decisions “correct” in an unanticipated situation?
  • J. Are the consequences of a self-programming system’s behavior (accurately or approximately) predictable by its designer? Are they predictable by the system itself?
  • K. How is self-programming related to other processes in an AGI system? Is self-programming a modular or distributed functionality?
  • L. What kinds of meta-programming principles are needed to ensure robustness over a long period of time in the system’s evolution?
  • M. What kinds of a programming language allows itself to be evaluated by programs written in itself – i.e. how do we achieve sufficient levels of semantic transparency for the system to be able to inspect and evaluate itself?
  • N. How is architectural granularity related to system modularity, and how are these concepts related to self-programmability?