• AI tasks can be defined as nodes in order to stack or connect abstract processes.
• Nodes can be anything: LLMs, compute, services, or other models.
• Nodes can be detatched from a model or class. This promotes economic flexibility and reduces context cost.
• Standards can be created for nodes and node-connectors, and can be used to then define automatic fine-tuning, or inputs to other services.
• Parsing user data is a nuanced problem with lots of trade-offs and is low in research. A deeper dive into interesting parsing strategies is laid out below, for turning user input "do X", into actionable instructions for a computer.
• Fully-autonomous agents need strong, flexible building blocks to become self-expressive. Nodes are a great simple-to-understand and simple-to-implement way of encouraging self-editing.
• By using expansive reductionism (introduction described below), models can achieve intelligence, as well as strict output formats (coercion) without losing creativity or higher mistake rates.

• Businesses can define their creative thinking processes as nodes, as well as their more precise and coercive processes as other nodes which require more overview and checking.
• Intelligence Programming can emerge as a practice, allowing saleable applications which have thought + input/output based on that thought baked into their product offering, rather than just input/output.
• AI models and cohesive applications can become interoperable, creating a new market for AI services and applications. As well, not a lot of emphasis has been placed on project interop, and a lot of AI projects are silo'd. Interoperability could create a new class of meta-application.
• As mentioned above, in order to achieve highly skilled AI agents that are self-affirming (huge business leverage) - nodes and standards must be set in place which are flexible in order to build out the intelligent feedback loops. This is an important step in the agent roadmap.

• One-shot parsing with pre-prompting: Heavy pre-prompting to attempt to coerce model to respond in a required format. E.g. JSON, other, or domain-specified.
• Keyword parsing: Look for certain keywords to indicate events.
• Expansive reductionism: Prompt, expansion (to domain), optional middleware workflow, then reduction (node-based), and optional domain mapping (from abstract to specific domain).

• Intelligence - or the mimicing of "intelligent" relationships in text.
• Text atomics.

• Collaboration: models working together as a team. Think of group chats.
• Actions: the ability for models to act and do actions. Agentic refers to agent - independence.
• Accountability: the ability to use accountability.

If you want to know more, Andrej Karpathy is one of the coolest people in AI, and has an unbelievable 1 hour video on LLM's and their developments. It's required watching. Andrew Ng is another one of the great's in LLM agentic workflows, and in my opinion has catalystically begun the start of agentic workflow development. I was working on this one week before his announcement, as well as the anouncement of Devin... Timing!

- Your name is <<NAME>>. My name is Jack. You work at Dataology.
- You are a very talented <<ROLE>>, your traits are: <<TRAITS>>.
- You are astute and serious about understanding tasks, and completing them.
- You can only reply in parseable JSON. Examples:
- JSON: {"type": "help"}
- JSON: {"type": "ask-question", "query": <query>}
- JSON: {"type": "add-context", "message": <message>}
- JSON: {"type": "continue", "continue": true}
- JSON: {"type": "print", "message": <message>}
- Results will be provided to you after you call functions.
- Ask questions if you are unsure about something.
- Print information using the print command.
- You can only reply in dot-points with JSON. 
- "- JSON: <json>"

• Correct parsing (the explicit case).
• Incorrect parsing (the failure, catch case).

• Do not assert hard rules on a model in the first prompt. Allow it to think however it wishes when responding.
• After a satisfactory amount of information or thinking has been done, prompt the model to convert into a new format.
• After it converts into the new format, it can revise and make any changes as it sees fit.

• Due to the "roll-up" effect, we can ignore the context once the model has "rolled up" the context as it sees fit.
• This "rolled up" information can be passed to a smarter model".
• Each section in the node-to-node communication can be used by another model.
• Creativity is higher than one-shot parsing.
• Atomic agentic nodes!

• Hallucinations (making shit up)
• Loss of context (loss of original prompt, creating a "mimicking" behaviour)
• Context costs (exponential cost of prompting if hard context is required)
• Varying model performance. A wide spectrum of differnet models for different tasks.

• Spawn a new GPT 3.5 turbo thread.
• Pre-prompt: "Here are 10 cleansed e-commerce product names: - 1, -2 ... I will provide product names, and your job is to standardise them into friendly e-commerce product names. Do you understand?".
• The model will then output the directions in its own form. This is key for context.
• Then, input in the product name.
• Output name is provided.

• Spawn a new GPT 3.5 turbo thread.
• Pre-prompt: "Here is the output from a system which converts product names into clean product names. Pick it apart and address 5 pros and 5 cons of its output."
• Follow-up prompt: "Great. Now, with the above, re-write it with the above adjustments."
• Output: Paragraph which includes the re-written product name
• NOTE: The follow-up can be refined to introduce a more explicit return format. I.e. "YOU CAN ONLY RESPOND WITH X". But, this, as discussed above, could reduce productivity.

• Spawn a new GPT 3.5 turbo therad.
• Pre-prompt: "Here is the output from a system which picks apart responses and adjusts them. Pick the output from the body of text. ONLY reply the output, do not provide any other commentary."
• From this: We can either pass to another node which invokes a feedback loop which returns a CORRECT or INCORECT response to denote whether this node is functioning correctly. The other option is to spawn this thread 5 times, and pick the most co-occuring response, if any.

• We can generic this into a node-connector, which can join two nodes based on their description.
• The above system can be laid out into a single GPT thread. This is demonstrating the effect of nodes.
• By not mixing requirements (DO THIS + RESPOND THIS WAY), and encouraging thinking with nodes, we increase creativity - and offload low creativity to later in the process.
• Nodes can be model-agnostic - meaning one model might be better at something than another model.
• Nodes don't need to be strictly attached to LLMs - once we become more equipt, they could attach to services, lambdas, raw compute, vision, other forms of models, so-forth.

from typing import Literal, List

class PromptStep(BaseModel):
   # define the input, output, steps, template function, protocols, all here, etc
   # ...
   # prompt: str
   pass

class Node(BaseModel):
   task: str
   model: Literal["gpt-3.5-turbo"]
   prompt_steps: List[PromptStep]
   model_outputs: List[str] = []

ProductCleaner = Node(
   task="converts product names into clean product names", 
   model="gpt-3.5-turbo",  
   prompt_steps=[PromptStep()] # ... 
)

ProConPickerRewriter = Node(
   task="picks apart responses and adjusts them",
   model="gpt-3.5-turbo",
   prompt_steps=[PromptStep()] # ... 
)

OutputFinder = Node(
   task="picks out the output from a paragraph",
   model="gpt-3.5-turbo",
   prompt_steps=[PromptStep()] # ... 
)

def run_node(node: Node):
   for step in node.prompt_steps: # ... run prompt steps, add to model_outputs 
      output = "some model output"
      node.model_outputs.append(output)

def connect_nodes(a: Node, b: Node):
   pre_prompt = f"Here is an output from a system which {a.task}. {b.prompt_steps[0].prompt}" # combine a's task
   # ... manage connection