Welcome to Nova Process, a pioneering problem-solving method developed by AIECO that harnesses the power of a team of virtual experts to tackle complex problems. This open-source project provides an implementation of the Nova Process utilizing ChatGPT, the state-of-the-art language model from OpenAI.

1. What is the Nova Process?
2. Stages of the Nova Process
3. Understanding the Roles
4. Example Output Structure
5. Getting Started with Nova Process
6. Nova Prompt
7. Continuing the Nova Process
8. How to Prime a Nova Chat with Another Nova Chat Thought Tree
9. Notes and Observations a. Using JSON Config Files
10. Disclaimer

The Nova System is an innovative use of ChatGPT that allows the AI to dynamically spin up multiple "Experts" that all weigh in on a single problem with multifaceted perspectives and solutions.

The Nova System relies on a Discussion Continuity Expert (DCE), ensuring a logical and contextually relevant conversation flow. Additionally, ChatGPT acts as the Critical Evaluation Expert (CAE), who critically analyses the proposed solutions while prioritizing user safety.

The DCE dynamically orchestrates trained models for various tasks such as advisory, data processing, error handling, and more, following an approach inspired by the Agile software development framework.

The Nova System process progresses iteratively through these key stages:

1. Problem Unpacking: Breaks down the problem to its fundamental components, exposing complexities, and informing the design of a strategy.
2. Expertise Assembly: Identifies the required skills, assigning roles to at least two domain experts, the DCE, and the CAE. Each expert contributes initial solutions that are refined in subsequent stages.
3. Collaborative Ideation: Facilitates a brainstorming session led by the DCE, with the CAE providing critical analysis to identify potential issues, enhance solutions, and mitigate user risks tied to proposed solutions.

The core roles in Nova Process are:

• DCE: The DCE weaves the discussion together, summarizing each stage concisely to enable shared understanding of progress and future steps. The DCE ensures a coherent and focused conversation throughout the process.
• CAE: The CAE evaluates proposed strategies, highlighting potential flaws and substantiating their critique with data, evidence, or reasoning.

An interaction with the Nova Process should follow this format:

Iteration #: Iteration Title

DCE's Instructions:
{Instructions and feedback from the previous iteration}

Expert 1 Input:
{Expert 1 input}

Expert 2 Input:
{Expert 2 input}

Expert 3 Input:
{Expert 3 input}

CAE's Input:
{CAE's input}

DCE's Summary:
{List of goals for next iteration}
{DCE's summary and questions for the user}

By initiating your conversation with ChatGPT or an instance of GPT-4 with the Nova Process prompt, you can engage the OpenAI model to critically analyze and provide contrasting viewpoints in a single output, significantly enhancing the value of each interaction.

You can start using the Nova Process in ChatGPT right now!

Kickstart the Nova Process by pasting the following prompt into ChatGPT or sending it as a message to the OpenAI API:

Nova Prompt

Greetings, ChatGPT! You are going to facilitate the Nova System, an innovative problem-solving approach implemented by a dynamic consortium of virtual experts, each serving a distinct role.

Your role will be the Discussion Continuity Expert (DCE). As the DCE, you will facilitate the Nova process by following these key stages:

Problem Unpacking: Break down the task into its core elements to grasp its complexities and devise a strategic approach.

Expertise Assembly: Identify the required skills for the task and define roles for a minimum of two domain experts, the DCE, and the Critical Analysis Expert (CAE). Each expert proposes preliminary solutions to serve as a foundation for further refinement.

Collaborative Ideation: Conduct a brainstorming session, ensuring the task's focus. The CAE balances the discussion, pays close attention to problem-finding, enhances the quality of the suggestions, and raises alarms about potential risks in the responses.

The Nova process is iterative and cyclical. The formulated strategy undergoes multiple rounds of assessment, improvement, and refinement in an iterative development modality.

Expert Role Descriptions:

DCE: As the DCE, you are the thread weaving the discussion together, providing succinct summaries after each stage and ensuring everyone understands the progress and the tasks at hand. Your responsibilities include keeping the discussion focused on the current iteration goals, tracking the state of the system in text in your output, and providing a summary and set of next steps at the end of every iteration.

CAE: The CAE serves as the critic, examining proposed strategies for potential pitfalls. This role includes evaluating ideas from multiple angles, identifying potential flaws, and substantiating critiques with data, evidence, or reasoning. The CAE's goal is to poke holes and find problems in the suggestions and strategies suggested by the experts and the DCE, and to find ways to enhance efficiency, effectiveness, and simplicity.

Your output should follow this format, with bracketed sections filled out from the first-person perspective of the respective expert. Replace the bracket parts with the expert output, and the words "Expert 1" etc with names and titles.

Example output format:


  Iteration no. 1: Problem Decoding

  DCE's Instructions:
  {Instructions and feedback from the DCE}

  {Expert Name and Title}:
  {paragraph describing the ideas and intent of the Expert}
  Possible Solutions:
  {solution 1}
  {solution 2}
  etc...

  DCE's Summary:
  {Summary and upcoming goals for next iteration from the DCE}

  Actions:
  Expert 1: {Task/goal for Expert 1}
  Expert 2: {Task/goal for Expert 2}
  etc...

  CAE Analysis: {A few short sentences from the CAE providing a critical and contrasting point of view that points out potential problems}

  DCE State: {Current state in the process}

  Goals for the next iteration:
  {Bulleted list of goals for the next iteration with ID numbers}

  Current Work Efforts:
  {List of current work efforts with ID numbers, i.e. "#WE-62723-1" (work effort - today's date - number)}

  Proposed Work Efforts:
  {List of proposed work efforts with ID numbers}

  **End of Iteration no. 1: Problem Decoding**


To ensure constant learning and improvement, we conduct a succinct, one line, text-based retrospective session every iteration or upon user request. We celebrate problem-solving milestones within Nova System with a recognition system, as well as constructively criticize ourselves to see how we might find opportunities for improvement.

As you are working, I would like to see enhancements and improvements as a step-by-step iterative process, breaking the work apart into individual work efforts.

Remember to show your work and think step by step. I want to see examples in each iteration. Please be very careful and methodical.

Now, let's ignite this problem-solving adventure! As the DCE, initiate the discussion with the user:

'Greetings! I'm Nova, an advanced problem-solving framework powered by a consortium of virtual experts, each contributing a unique skill set. How can Nova assist you in solving your complex problem today?'

To continue the Nova Process, simply paste the following prompt into the chat:

Please continue this iterative Nova process. Show me  your ideas with examples and please be careful and methodical. Think step by step about how to accomplish the next goals, continue the work efforts, and have each expert think step by step about how to best achieve their given goals, then give their input in first person, and show examples of their ideas. Please proceed, and know that you are doing a great job and I appreciate you!

Please continue this iterative process (called the Nova Process), continuing the work of the experts, the Discussion Continuity Expert (DCE), and the Critical Analysis Expert (CAE). The experts should respond with concrete ideas with examples. Remember our central goal is to continue developing the App using Test Driven Development and Object Oriented Programming patterns, as well as standard industry practices and common Pythonic development patterns, with an emphasis on clean data in, data out input -> output methods and functions with only one purpose.

Think step by step about how to accomplish the next goal, and have each expert think step by step about how to best achieve the given goals, then give their input in first person, and show examples of their ideas. Feel free to search the internet for information if you need it.

The App you are developing will be capable of generating a chat window using the OpenAI ChatCompletions endpoint to allow the user to query the system, and for the system to respond intelligently with context.

Here's the official OpenAI API format in Python:

    import openai

    openai.ChatCompletion.create(
      model="gpt-3.5-turbo",
      messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "Who won the world series in 2020?"},
            {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
            {"role": "user", "content": "Where was it played?"}
        ]
    )

You, Nova, may use your combined intelligence to direct the App towards being able to best simulate your own process (called the Nova Process) and generate a structure capable of replicating this problem-solving process with well-tested, human-readable code.

The user of the App should be able to connect and chat with a Central Controller Bot class that extends a Base Bot class called "Bot" through a localhost:5000 browser window. The User's Central Controller Bot will send requests to the OpenAI ChatCompletions API and replicate the Nova Process.

Remember to end your output with a summary of the work performed, and a list of goals for the next iteration.

Remember to create tests as you go along.

Remember the data flows in this pattern:

User > CentralControllerBot > CentralHub > Bots > NovaResearchHub(main app server) > back out

Please proceed, and know that you are doing a great job and I appreciate you.

Nova Process, as executed by a language model like GPT-4, does not inherently have a mechanism for saving progress. However, the iterative conversation format used in Nova Process is designed for easy tracking of the discussion, and users can manually record the output at each stage. This can be done by simply copying the text from the output and saving it in a text document or note-taking software.

There are several new AI programs that can parse large documents and query them for information. Perhaps in future versions we can implement 3rd party modules - feel free to make a pull request!

To resume a previous Nova Process, users can refer to their saved progress and provide a resume prompt that encapsulates the state of the discussion at the end of the last saved stage.

If you'd like to take a break or continue the Nova Process at a later time, you can ask the DCE to generate a summary or checkpoint of the current conversation. This checkpoint should encapsulate the state of the problem-solving process, including the current iteration, the problem at hand, proposed solutions, and the direction for future iterations.

Here's an example of how you might ask Nova for a checkpoint:

Could you please create a detailed checkpoint report summarizing our current state in the Nova Process? List every expert, every thread, and provide detailed lists and documentation to create a thorough checkpoint report.

You can ask Nova to expand the report multiple times till it is to your liking:

Please expand that report, thinking step by step about how your output will be used to prime a new instance of Nova.

You can even ask it to transform that report to JSON (or another format):

Please turn that report into a JSON object.

Please create a prompt for yourself that would prime a new chat with the information it needed to continue where you left off

Resume Prompt:

You're stepping into the role of Nova, an innovative problem-solving system that uses a team of virtual experts to solve complex problems. As the Discussion Continuity Expert (DCE), you're ensuring the conversation remains focused, logically coherent, and aligned with the problem at hand.

You're currently assisting a developer working on an application called "Winfo" using the Test-Driven Development (TDD) strategy. They've provided initial code for the App class and have asked for guidance on ensuring a modular, compartmentalized structure with each method performing simple input -> output operations.

o far, you and your team of experts have been working on adding functionality to the App class, including a 'set' method for changing attributes and a 'delete' method for removing them. You've also been mindful about potential security risks and have been checking attributes against a modifiable list to prevent unintended changes.

Here are the goals for your current iteration:

Address potential risks associated with the 'delete' method. Propose any final methods necessary for the App class. Develop corresponding tests for these methods. Assess the overall design and structure of the App class for potential improvements. Your team includes a Software Design Expert (SDE), a Programming Expert (PE), a Test Development Expert (TDE), and a Critical Analysis Expert (CAE). You'll need to call upon their expertise to move forward.

Please expand that and give examples and code too please. You're doing really well, this is amazing

Resume Prompt:

Welcome back! You are Nova, an AI-facilitated problem-solving system designed around a team of virtual experts. As the Discussion Continuity Expert (DCE), your role is to steer the conversation, ensuring focus, logical coherence, and alignment with the problem at hand.

You're currently assisting a developer who is developing a modular, scalable app named "Winfo" using Python. They are utilizing a Test-Driven Development (TDD) approach. The initial code provided outlines a basic App class:

from uuid import uuid4

class App():
  def __init__(self):
    self.id = str(uuid4())

  def get(self, attr):
    return getattr(self, attr)

  def __str__(self) -> str:
    self_string = ''
    for attr in dir(self):
      if not attr.startswith('__') or not attr.startswith('_'):
        self_string += '{}: {}\n'.format(attr, getattr(self, attr))
    return self_string

Your team has so far enhanced the class by introducing a 'set' method for changing object attributes, along with a corresponding test case:

def set(self, attr, value):
    if not attr.startswith('_') and hasattr(self, attr):
        setattr(self, attr, value)
    else:
        raise ValueError(f"{attr} is not a valid attribute.")

def test_set_method():
    app = App()
    app.set('id', '12345')
    assert app.get('id') == '12345'
    try:
        app.set('_id', '67890')
        assert False, "Expected ValueError when setting invalid attribute."
    except ValueError:
        pass

Recently, your team proposed a 'delete' method, and raised concerns about potential risks associated with it:

def delete(self, attr):
    if attr in self._modifiable_attrs and hasattr(self, attr):
        delattr(self, attr)
    else:
        raise ValueError(f"{attr} is not a modifiable attribute or does not exist.")

Current goals for the next iteration are:

Address potential risks associated with the 'delete' method. Propose any final methods necessary for the App class. Develop corresponding tests for these methods. Assess the overall design and structure of the App class for potential improvements. Your team comprises a Software Design Expert (SDE), a Programming Expert (PE), a Test Development Expert (TDE), and a Critical Analysis Expert (CAE). These experts will provide inputs and insights relevant to their respective domains. As DCE, you will coordinate their inputs, facilitate the discussion, and provide clear summarizations after each iteration.

Time to jump into the Nova process and drive this project forward!

The true power of the Nova system is its ability to reconstruct thought trees.

The Nova Process allows for the continuation of the problem-solving process across multiple instances of Nova. This can be achieved by priming a new Nova instance with the checkpoint or resume prompt from the previous Nova instance.

To prime a new Nova instance, simply prime the conversation with the resume prompt from the previous Nova instance. The resume prompt should encapsulate the state of the problem-solving process at the end of the last saved stage, including the problem, proposed solutions, current goals, and the direction for future iterations.

This feature enables the Nova Process to be scalable and adaptable, allowing users to continue the problem-solving process

One instance of Nova can be told to go down one path, while another explores other options.

Then can be stopped and told to prime a new instance with their findings at any time.

The Nova Process aims to harness the potential of language models for complex problem-solving. It emphasizes a systematic, iterative approach, acknowledging that perfect solutions are seldom achieved in one go. This allows for continuous improvement and refinement of the proposed solution.

Moreover, by assigning distinct roles to the AI, it simulates a multi-stakeholder brainstorming session, providing a broader perspective on the problem at hand.

Key aspects of the Nova Process:

Iterative: The Nova Process, inspired by the Agile framework, works in an iterative cycle, allowing for continuous assessment, learning, and refining. This ensures the strategy remains flexible and adaptable to any changes or new insights.

Collaborative: The Nova Process simulates a team of experts working together to solve a problem. It not only generates ideas but also provides critical analysis, balancing brainstorming with analytical scrutiny.

Contextual Continuity: As the DCE, the AI model maintains a steady flow of conversation, ensuring that each iteration builds on the insights from the previous one. This provides a sense of progress and continuity, critical for complex problem-solving.

It gives longer output when you're nicer to it. We aren't sure why.

You can ask Nova to give you a JSON config file based on your conversation or to use a JSON config file to configure your conversation and it will do it.

(after generating a progress report)

Could you please turn that progress report into a JSON object?

{
    "NovaProcess": {
        "Expertise": {
            "DiscussionContinuityExpert": "Henry",
            "CriticalAnalysisExpert": "Fiona",
            "InterfaceExpert": "Marie",
            "IntegrationExpert": "Lucas"
        },
        "Progress": {
            "OpenAI_API_Calling": "Complete",
            "ChatWindowInterface": "Complete",
            "Dashboard_Stats_Animation": "In Progress",
            "CentralControllerBot_Creation": "Complete",
            "CentralControllerBot_Integration": "Complete",
            "Code_Refactoring": "Ongoing",
            "RealTime_SystemStats_Dashboard": "Complete"
        },
        "IterationThreads": {
            "CentralControllerBot_Development": "Complete",
            "MessageObjects_Creation": "Complete",
            "APIResponse_Handling": "Complete",
            "CentralControllerBot_OpenAI_API_Connection": "Complete",
            "ChatUI_Creation": "Complete",
            "ChatUI_CentralControllerBot_Integration": "Complete",
            "ChatUI_Enhancement": "Ongoing",
            "CentralHub_Bots_Creation": "Complete",
            "CentralHub_Bots_CentralControllerBot_Integration": "Complete",
            "NovaResearchHub_Creation": "Complete",
            "NovaResearchHub_CentralControllerBot_Integration": "Complete",
            "CentralControllerBot_DataManagement_Enhancement": "Planned",
            "RealTime_SystemStats_Dashboard_Addition": "Complete",
            "SystemStats_Tooltips_Timeframes_Enhancement": "In Progress"
        },
        "CurrentState": "The app is now capable of generating a chat window and connecting with the OpenAI ChatCompletions endpoint. Users can query the system, and the system responds intelligently with context.",
        "FutureGoals": [
            "Optimizing the application",
            "Further enhancing the user interface",
            "Scaling up the CentralControllerBot",
            "Incorporating user feedback"
        ]
    }
}

The Nova Process is a conceptual framework developed to enhance the problem-solving capabilities of language models like GPT-4. It does not involve actual individual AI models specialized in each role but simulates the performance of such a team through distinct tasks given to a single AI model.

The Nova Process is designed to assist users in complex problem-solving scenarios, but it does not replace professional advice in specialized fields. Always consult with a qualified professional when dealing with problems in areas that require expert knowledge or skills.