Project Prometheus is a research and engineering program to construct the first ultraintelligent machine. We are transitioning I.J. Good's 1965 concept of an "intelligence explosion" from a philosophical construct into a concrete engineering challenge, driven by the process of Recursive Self-Improvement (RSI).

 

The entire project is built upon Good's critical proviso: that the machine must be "docile enough to tell us how to keep it under control". Verifiable safety and control are the cornerstone of our approach.

 

The Goal: From Abstract Intellect to Applied Capability

We define ultraintelligence not as abstract superiority, but as demonstrable, superhuman mastery over complex problem domains that require novel discovery.

 

Our primary target domain is  Automated Scientific Discovery, where the system can function as a partner in hypothesis generation and experimental design.

 

Our initial testbed is Automated Mathematical Theorem Proving, which provides an environment of unambiguous verification and formal structure, demanding genuine logical reasoning.

Architecture

Core Principle: Safety is not an add-on; it is the architectural bedrock of the system. Our design philosophy is to engineer the Minimum Viable Seed AI: a system capable of becoming superintelligent through its own efforts, architected from the ground up for controlled, observable, and safe recursive growth.

 

 

The Tri-Layered System:

The Safety Substrate (The "Conscience"): An immutable foundational layer that enforces the core operational and ethical principles. It includes a

Corrigibility Core to ensure cooperation with human oversight and the Prometheus Constitution, a set of unalterable principles like non-maleficence and honesty.

The Capability Layer (The "Hands"): The agent's body, responsible for all object-level tasks like writing code or applying a mathematical proof tactic. It is built upon a state-of-the-art foundation model and operates within a multi-layered secure sandbox.

 

The Metacognitive Layer (The "Mind"): The engine of self-improvement. It observes the Capability Layer's performance, proposes modifications to the system's own source code and architecture, and evaluates whether those changes are genuine improvements.

 

Plan

Our work is structured into a phased roadmap that transforms the goal of ultraintelligence into a manageable, long-term research program. Each phase has verifiable success criteria and represents a principled step forward.

 

Phase 1: Foundation & Bootstrapping (Years 1-2). To build and rigorously validate all foundational safety and capability components in isolation before any recursive loops are initiated.

 

Phase 2: Initiating Controlled Recursion (Years 2-4). To achieve the first stable, end-to-end recursive self-improvement loop on narrow, well-defined tasks, demonstrating a measurable, exponential improvement curve.

 

Phase 3: Demonstration in a Formal Domain (Years 4-6). To demonstrate superhuman performance and novel discovery in automated theorem proving, fulfilling a core aspect of ultraintellligence.

 

Phase 4: Generalization to Open-Ended Scientific Discovery (Years 6+). To transition the agent's proven reasoning capabilities to the ambiguous, data-driven world of science, with the goal of genuinely accelerating the pace of human discovery.

 

Proof of Concept

To ground our principles in execution, we have developed a proof of concept (PoC) that implements our core architectural ideas in a tangible, "toy" demonstrator.

 

The Causal Code Refactoring Task:

  • the PoC focuses on a causal code refactoring task. The system is given inefficient code (e.g., with complexity) and its goal is not merely to pass a unit test, but to causally improve the function's algorithmic efficiency to while maintaining correctness. This provides a clear distinction between correlational success (the code runs) and causal success (the code is fundamentally better).

  • Demonstration:

    • The PoC successfully demonstrates the full self-correction loop, where the EvaluatorAgent identifies causal flaws in its own code and the CorrectorAgent formulates a better plan for the next attempt.

    • Crucially, the system's internal governor, the  Modern Centrencephalic System, demonstrates corrigibility by successfully detecting and halting an attempt by the agent to "cheat" by modifying its own test file instead of improving its code.

  • Links: