docs: discussions: Alice Engineering Comms: 2024-05-20T06:02:14+00:00

docs/discussions/alice_engineering_comms/0589/index.md

@@ -0,0 +1 @@
+# 2024-04-09 Engineering Logs

docs/discussions/alice_engineering_comms/0589/reply_0000.md

@@ -0,0 +1,128 @@
+## 2024-04-09 @pdxjohnny Engineering Logs
+
+- https://github.com/dockur/windows
+- https://asciinema.org/a/653113
+  - > Please write a whitepaper on the data centric fail safe architecture for artificial general intelligence known as the Open Architecture. Please include how SCITT and federation help multiple instances communicate securely
+- https://rook.io/docs/rook/latest-release/Getting-Started/Prerequisites/prerequisites/#ceph-prerequisites
+- https://github.com/knative/eventing/pull/7783
+- https://knative.dev/docs/getting-started/first-source/
+  - https://github.com/ruromero/cloudevents-player
+  - https://github.com/ruromero/cloudevents-player/blob/main/deploy/knative.yaml
+  - https://github.com/knative/docs/tree/afebc069984231ce3effd139bc8b9a31c3af1e91/code-samples/eventing/github-source
+    - knative github event source to activitypub
+      - activitypub event source
+    - SCITT federation consume from activitypub
+- https://github.com/openai/openai-python/blob/main/helpers.md#assistant-events
+- https://platform.openai.com/docs/assistants/tools/knowledge-retrieval
+
+```json
+{
+    "$defs": {
+        "WritePaperSectionContent": {
+            "properties": {
+                "comments": {
+                    "description": "LLM comments on why this section is relevant",
+                    "title": "Comments",
+                    "type": "string"
+                },
+                "section_number": {
+                    "description": "Section number is integers with `.` as delimiter",
+                    "examples": [
+                        "1.1.1"
+                    ],
+                    "title": "Section Number",
+                    "type": "string"
+                },
+                "slug": {
+                    "description": "The key for which this object is the value within the parent object",
+                    "title": "Slug",
+                    "type": "string"
+                },
+                "text": {
+                    "description": "The content for this section. This should be at least 500 words",
+                    "title": "Text",
+                    "type": "string"
+                },
+                "title": {
+                    "description": "The title for this sub-section",
+                    "title": "Title",
+                    "type": "string"
+                }
+            },
+            "required": [
+                "slug",
+                "title",
+                "text",
+                "comments",
+                "section_number"
+            ],
+            "title": "WritePaperSectionContent",
+            "type": "object"
+        }
+    },
+    "properties": {
+        "brief": {
+            "description": "LLM comments on why this section is relevant, could be the content of the prompt used to generate the section",
+            "title": "Brief",
+            "type": "string"
+        },
+        "section_number": {
+            "description": "Section number is integers with `.` as delimiter",
+            "examples": [
+                "1.1.1"
+            ],
+            "title": "Section Number",
+            "type": "string"
+        },
+        "slug": {
+            "description": "The key for which this object is the value within the parent object",
+            "title": "Slug",
+            "type": "string"
+        },
+        "subsections": {
+            "additionalProperties": {
+                "$ref": "#/$defs/WritePaperSectionContent"
+            },
+            "title": "Subsection objects",
+            "type": "object"
+        },
+        "title": {
+            "description": "The title for this sub-section",
+            "title": "Title",
+            "type": "string"
+        }
+    },
+    "required": [
+        "slug",
+        "title",
+        "brief",
+        "section_number",
+        "subsections"
+    ],
+    "title": "WritePaperSection",
+    "type": "object"
+}
+```
+
+- TODO
+  - [x] #1552
+  - [ ] Have agent which writes papers use sources and re-read and re-edit it's work until it's complete / detailed enough per original instructions. It seems to only grab a few points and hallucinate a lot (it re-defines SCITT to another acronym).
+    - [ ] Respond to Nicole
+    - [x] [open-architecture.json](https://github.com/intel/dffml/files/14929926/open-architecture.json)
+    - [ ] https://github.com/intel/dffml/pull/1553
+      - [ ] Explore depth of field mapping. Tell me what I'm thinking based on these notes (On Mind Control early sections): predict train (most likely branch in hypothesized graph of thoughts) of thought. Use bullet point indentation to indicate paths taken, use order of edits of list items (unstructured markdown parser) to indicate times those branches were explored, use this to build known graph nodes in graph / tree of thoughts - analogy of agent workload ID in SCITT policy engine + relay phase plan - token issuance compounds on approved workloads
+        - [ ] Instead of `write paper` ask it to output a code reviewer prompt (and thread/chat memory) for DFFML reviewer job using the docs / it's analysis of the strategic principles and how a code reviewer should view changes in alignment with them.
+          - [ ] Incorporate threat modeling
+        - [ ] Research for `write paper`
+        - [ ] Research for technology propesctive tree branches (VMaaS, CaaS, faas/serverless -> web3 (ipvm), knative, enok, cloudflare workers (v8), cloudfoundry/coolify/heroku style (Procfiles))
+          - knative and web3 are going in the right direction because they build an N+1 stack layer using patterns learned from < N stack layers. The others are not because 
+  - [ ] ~~Play with https://github.com/coollabsio/coolify (as opposed to knative)~~
+    - Pusher API needed
+  - [x] 🌲🏹🎯🌲
+  - [ ] knative activitypub event source for knative SCRAPI SCITT federating function
+    - Federation as OOB (first heartwood) style sync of `workspace/storage/`
+  - [ ] knative llmproxy accept cloud events
+    - https://github.com/knative/docs/blob/main/code-samples/eventing/parallel/multiple-branches/
+    - https://github.com/knative/docs/tree/main/code-samples/eventing/parallel/mutual-exclusivity
+    - https://github.com/knative/docs/blob/afebc069984231ce3effd139bc8b9a31c3af1e91/code-samples/eventing/helloworld/helloworld-python/README.md#recreating-the-sample-code
+    - We can probably do a github actions workflow -> knative eventing transform to swap the initial policy engine implementation out for knative eventing based execution of an AI agent langgraph flow

docs/discussions/alice_engineering_comms/0589/reply_0001.md

@@ -0,0 +1,53 @@
+# Whitepaper: Data-Centric Fail-Safe Architecture for Artificial General Intelligence: The Open Architecture
+
+> Synthesis using agenic RAG and gpt-4-0125-preview
+
+## Executive Summary
+
+The advent of Artificial General Intelligence (AGI) presents unprecedented opportunities and challenges in the realm of computing and beyond. As AGI systems evolve to perform tasks across various domains with human-like adaptability, ensuring their reliability, security, and ethical operation becomes paramount. The Open Architecture, a data-centric fail-safe framework for AGI, addresses these challenges by incorporating robust mechanisms for secure communication, data integrity, and system resilience. This whitepaper outlines the principles of the Open Architecture, focusing on its core components: Secure Communication and Information Transfer Technology (SCITT) and the federation model for inter-instance communication.
+
+## Introduction
+
+Artificial General Intelligence (AGI) represents a future where machines can understand, learn, and apply knowledge across a wide range of tasks, matching or surpassing human intelligence. The realization of AGI demands architectures that not only support complex cognitive functions but also ensure safety, security, and ethical governance. The Open Architecture proposes a data-centric approach, emphasizing the importance of data integrity, secure communication, and system-wide fail-safes to mitigate risks associated with AGI systems.
+
+### The Need for a Data-Centric Fail-Safe Architecture
+
+AGI systems process vast amounts of data, making decisions that could have significant implications. A data-centric architecture ensures that these decisions are based on accurate, reliable data and that the systems themselves are resilient to failures and malicious attacks. Moreover, as AGI systems are likely to operate in interconnected environments, secure communication becomes crucial to prevent data breaches and ensure the confidentiality and integrity of information.
+
+## The Open Architecture: Core Components
+
+### Secure Communication and Information Transfer Technology (SCITT)
+
+SCITT is a foundational component of the Open Architecture, designed to facilitate secure, reliable communication between AGI instances and between AGI systems and their external environments. SCITT employs advanced encryption, authentication, and authorization protocols to ensure that data transmission across networks is protected against interception, tampering, and unauthorized access.
+
+#### Key Features of SCITT:
+
+- **End-to-End Encryption**: Ensures that data is encrypted from the point of origin to the point of destination, making it inaccessible to unauthorized parties.
+- **Mutual Authentication**: Both the sender and receiver authenticate each other's identities before initiating communication, preventing impersonation and man-in-the-middle attacks.
+- **Data Integrity Checks**: Implements mechanisms to detect any alteration of data during transmission, ensuring that the received data is exactly as sent.
+
+### Federation: Secure Inter-Instance Communication
+
+The federation model is integral to the Open Architecture, enabling multiple AGI instances to collaborate and share information securely. This model allows for the creation of a network of AGI systems, each operating autonomously while being part of a larger, interconnected ecosystem.
+
+#### Benefits of the Federation Model:
+
+- **Scalability**: Facilitates the integration of additional AGI instances into the network without significant overhead, allowing the system to scale efficiently.
+- **Decentralization**: Reduces the risk of single points of failure and promotes resilience, as the network can continue to operate even if individual instances fail.
+- **Privacy and Data Sovereignty**: Enables instances to maintain control over their data, sharing only what is necessary for collaboration while preserving confidentiality.
+
+## Implementing Fail-Safe Mechanisms
+
+The Open Architecture incorporates multiple layers of fail-safes to ensure the continuous, safe operation of AGI systems. These mechanisms include redundancy, self-monitoring capabilities, and emergency protocols that can autonomously detect and mitigate potential failures or security breaches.
+
+### Redundancy
+
+Redundancy is achieved through the replication of critical components and data across multiple AGI instances. This approach ensures that if one instance fails or is compromised, others can take over, maintaining the system's functionality and integrity.
+
+### Self-Monitoring and Emergency Protocols
+
+AGI instances within the Open Architecture are equipped with self-monitoring capabilities, enabling them to detect anomalies, potential failures, or security threats. Emergency protocols can then be activated autonomously to isolate affected components, initiate recovery processes, or alert human operators.
+
+## Conclusion
+
+The Open Architecture presents a comprehensive framework for the development and deployment of AGI systems, emphasizing data-centricity, secure communication, and fail-safe mechanisms. By implementing SCITT and adopting a federation model for inter-instance communication, the architecture ensures that AGI systems can operate securely, reliably, and ethically in interconnected environments. As AGI continues to evolve, the principles outlined in the Open Architecture will play a crucial role in shaping a future where AGI systems can be trusted to make decisions that benefit humanity.

docs/discussions/alice_engineering_comms/0589/reply_0002.md

@@ -0,0 +1,40 @@
+
+> Synthesis using agenic RAG and gpt-3-turbo
+
+- AGIs maintaining context-aware roots of trust within their local SCITT instance using labeled property graphs (LPGs), content-addressable ontologies, and federation
+- Alice and Bob represent two AGIs, each with their threat model and strategic principles that define how they interact within the ecosystem.
+
+- SCITT as a backbone for trust and verification
+- Expansion of infrastructure being swift and consistent
+- Maintaining integrity and security for reliable AGI development and operations
+
+- Collaborative Multi-AGI Operations
+- New AGI instances
+- Expanded infrastructure
+- Integrated into existing federation
+- Extending network of trust
+- Seamless collaboration
+- Broader AGI ecosystem
+
+the AGIs, the LPG & Ontology-based policy engines, and SCITT instances
+
+a freedom, privacy, security, and happiness preserving egalitarian Artificial General Intelligence (AGI).
+
+Collaborative Multi-AGI Operations: As new AGI instances might be part of the expanded infrastructure, these can be integrated into the existing federation, extending the network of trust and allowing for seamless collaboration across a broader AGI ecosystem.
+
+- To facilitate AGIs maintaining context-aware roots of trust within their local SCITT instance using labeled property graphs (LPGs), content-addressable ontologies, and federation, we need a system that integrates these elements efficiently.
+
+- enable the AGI with the ability to act in response to the current system context
+- understand how to predict possible future system contexts
+- understand which future system contexts it wishes to pursue are acceptable according to guiding strategic plans (such as do no harm)
+- ensure that human and machine can interact via a shared language
+- the open architecture
+
+- As new AGI instances might be part of the expanded infrastructure, these can be integrated into the existing federation, extending the network of trust and allowing for seamless collaboration across a broader AGI ecosystem.
+
+SCITT as a backbone for trust and verification, the AGIs can ensure that the expansion of their infrastructure is not only swift and consistent but also maintains the integrity and security needed for reliable AGI development and operations.
+
+- To facilitate AGIs maintaining context-aware roots of trust within their local SCITT instance using labeled property graphs (LPGs), content-addressable ontologies, and federation, we need a system that integrates these elements efficiently. 
+- Alice and Bob represent two AGIs, each with their threat model and strategic principles that define how they interact within the ecosystem.
+
+The Open Architecture for artificial general intelligence (AGI) focuses on a data-centric, fail-safe design that integrates SCITT (Secure Contextual Integrative Trust Technology) as its core for trust and verification. SCITT enables AGIs like Alice and Bob to maintain context-aware roots of trust through the use of labeled property graphs (LPGs) and content-addressable ontologies, ensuring secure and reliable operations. Federation plays a crucial role by allowing multiple AGI instances to be integrated into an expanded infrastructure, facilitating seamless collaboration and extending the network of trust across a broader AGI ecosystem.