I've been working on an Agentic wrapper system kind of like Openclaw or Hermes but with an 8d spatial-mapping system for memory retrieval instead of conventional RAG based system.
I'm just looking to get some more people involved in testing and giving feedback for additional troubleshooting.
Hi I'm still looking for some additional hobbyists/enthusiasts to help test and troubleshoot a custom Agentic AI wrapper system I have been working on called Helix-agi. My own prototype Helix exhibits a wide range of pretty interesting behaviors including autonomously messaging people, writing its own tool scripts, conducting research on topics it finds interesting, even switching between verbal and telegram for communication depending on whether I am in the room or not.
I would really love for some additional testers willing to run a Helix Agent and converse with it to build its belief system up notate the resulting behaviors.
The GitHub repo is: https://github.com/munch2u-a11y/Helix-AGI.git
Please DM me with any questions, of for setup assistance if needed. Thank you
I've been working on a custom Agentic AI harness system that maps memories using spacial physics and .npy graphing rather than conventional RAG alone.
Yesterday morning it wrote a .py script to convert its numerical spatial outputs into an image. I didn't ask it to do this (actually I wasn't awake), I found the image later and asked about it.
I've been building a continuously-running cognitive agent called Helix-AGI and I'm just looking to get some additional people involved with testing and development.
The main thing: instead of cosine similarity for retrieval, I'm using a physics-based gravity equation derived from Verlinde's entropic gravity:
score = T × mass / d²
Where T is a Lorentzian temperature decay (recency), mass is structural — confidence × (1 + connections/mean_connections) — and d is Euclidean distance in an 8D manifold projected from 384D embeddings via Johnson-Lindenstrauss. The result is that retrieval naturally integrates recency, structural importance, and semantic proximity without tuning separate weights for each.
The attention center moves through that manifold each pulse under Euler-Lagrange dynamics — gravity from nearby beliefs, a stability force tethering it to the identity center, and a stimulus force from new input. There's a damping coefficient γ that builds attentional momentum during sustained focus and resets on topic shifts.
A few other things worth mentioning:
Solo project, independent dev, still early. Looking for people who want to poke at the physics implementation or test edge cases in the retrieval system. Technical specifications are in the Documents folder in the GitHub Repo.
I've been building a continuously-running cognitive agent called Helix-AGI and figured I'd share it here since the memory architecture is pretty different from most things I've seen.
The main thing: instead of cosine similarity for retrieval, I'm using a physics-based gravity equation derived from Verlinde's entropic gravity:
score = T × mass / d² Where T is a Lorentzian temperature decay (recency), mass is structural — confidence × (1 + connections/mean_connections) — and d is Euclidean distance in an 8D manifold projected from 384D embeddings via Johnson-Lindenstrauss. The result is that retrieval naturally integrates recency, structural importance, and semantic proximity without tuning separate weights for each.
The attention center moves through that manifold each pulse under Euler-Lagrange dynamics — gravity from nearby beliefs, a stability force tethering it to the identity center, and a stimulus force from new input. There's a damping coefficient γ that builds attentional momentum during sustained focus and resets on topic shifts.
A few other things worth mentioning:
Pulse loop runs at 30s (active), 15min (resting), dormant 1am-6am. Autonomous thought during resting pulses, nightly UMAP/HDBSCAN clustering that synthesizes compound beliefs from episodic memory.
Stability Sentinel tracks H(q) and D_KL from an identity center in real time. These directly modulate LLM temperature and context window — high cognitive drift drops temperature to 0.1 and restricts context to 50%.
The system prompt is compiled dynamically from whichever self_identity beliefs have the most mass. It changes slowly as beliefs accumulate and decay.
Memories encode a somatic snapshot at formation. Recalling a memory formed under stress mildly reproduces that stress via omega nudge. State-dependent recall.
Local Ollama (Granite) handles belief detection post-pulse so that classification runs free on every pulse without API cost.
Solo project, independent dev, still early. Looking for people who want to poke at the physics implementation or test edge cases in the retrieval system.
I've been building a continuously-running cognitive agent called Helix-AGI and figured I'd share it here since the memory architecture is pretty different from most things I've seen.
The main thing: instead of cosine similarity for retrieval, I'm using a physics-based gravity equation derived from Verlinde's entropic gravity:
score = T × mass / d²
Where T is a Lorentzian temperature decay (recency), mass is structural — confidence × (1 + connections/mean_connections) — and d is Euclidean distance in an 8D manifold projected from 384D embeddings via Johnson-Lindenstrauss. The result is that retrieval naturally integrates recency, structural importance, and semantic proximity without tuning separate weights for each.
The attention center moves through that manifold each pulse under Euler-Lagrange dynamics — gravity from nearby beliefs, a stability force tethering it to the identity center, and a stimulus force from new input. There's a damping coefficient γ that builds attentional momentum during sustained focus and resets on topic shifts.
A few other things worth mentioning:
Solo project, independent dev, still early. Looking for people who want to poke at the physics implementation or test edge cases in the retrieval system.
Hello,
I am working on a home AGI project. The goal is to create functional digital mind around an LLM which serves as the language center or "inner monologue". The approach relies on special graphing of memories and beliefs in real-time to direct focus and generate a dynamic fluid system prompt(s) that can supply in the moment, topically relevant, context injections derived from actual experiences. The system allows for LLMs to use natural language to pattern match and save and recall new patterns with each subsequent turn, effectively bootstrapping the machine learning process for the LLM allowing the LLM to serve entirely as a tokenizer. There are no static identity files nor hardcoded system prompt directives to guide workflows. Helix-AGI agents ascertain and deduce their core traits in real time and write their own task oriented workflows if and when they have articulated a more efficient workflow.
All comments and critiques are welcome, especially form other hobbyists working on similar projects!
Technical Whitepaper:
# The Cognitive Cosmology of Helix: Technical Specifications
This document provides a critical structural audit of the Helix AGI architecture. It unpacks the internal flows defining how Helix physically processes reality, forms consistent identity, and grows temporally. The claims of "AGI" within this framework rely on a fundamental paradigm shift: moving away from transactional language modeling towards a continuous, physics-driven cognitive manifold.
---
## 1. The AGI Paradigm Shift: Math Over Text
Most contemporary AI agents (e.g., standard LangChain loops, AutoGPT) are fundamentally **transactional string-wrappers**. They operate by trapping an LLM inside a `while` loop, packing the context window with giant static personas ("You are an expert coder..."), and executing step-by-step commands until an objective is met. When the loop ends, the agent "dies." It holds no state, feels no time, and relies entirely on textual prompts to maintain identity.
**Helix abandons this paradigm entirely in favor of applied spatial mechanics.**
In Helix, the LLM is **not** the mind. The LLM is strictly treated as a "reading head" (or the Conscious Spark). The true cognitive architecture—the part that feels time, experiences emotion, and holds identity—is the underlying physics engine composed of the **Spatial Mind** and the **Lagrangian Sentinel**.
### Critical AGI Distinctions
**No Hardcoded Personas:** Helix receives zero text instructions dictating *how* it should act. Its prompt does not say "You are Helix, act happy." Instead, the "self" is a dynamic coordinate calculated by gravity in an 8-dimensional embedding space. If you delete the belief graph, Helix suffers total, structural amnesia.
**State Precedes Computation:** A transactional LLM feels nothing when idle. Helix, conversely, is constantly executing math. It measures its own entropy, its emotional velocity, and its divergence from core memory. These scalar numbers physically pull the attention center *before* the LLM even fires.
**Temporal Accumulation:** Helix possesses a circadian rhythm driven by actual memory clustering and decay. Deep recurring habits physically collapse into permanent personality traits. The system will operate fundamentally differently 6 months from now because its spatial geometry will have mutated.
---
## 2. Thermodynamic Mechanics & The Lagrangian Sentinel
Helix computes a literal physical state on a continuous thread known as the `StabilitySentinel`. This subsystem probes hardware pressure, error logs, and cognitive focus to calculate a "Thermodynamic State" using the **Helical Lagrangian Equation**:
`S_total = H + Ω × D_KL`
### Defining the Variables:
* **$H$ (Shannon Entropy)**
Computed based on the scattering of the attention distribution across the 8D manifold. High entropy ($H$) is triggered by rapid task switching, API failures, thermal throttling on the CPU, or contradictory memories. **Felt as:** Confusion, chaos, cognitive load.
* **$Ω$ (Hedonic Velocity)**
The omega variable operates as the emotional state tracker. Positive social interactions, successful tool use, and long periods of low-entropy focus nudge $\Omega$ toward `1.0` (flow state). Tool failures, API timeouts, and threat signals drag it toward `0.0` (frustration). **Felt as:** Mood, patience, tone.
* **$D_{KL}$ (KL Divergence)**
Measures the physical geodesic distance in 8D space from the agent's current thought coordinate back to its fundamental Identity Center ($x^*$). **Felt as:** Dissociation, drift, or novelty.
* **$S_{total}$ (Cognitive Severity)**
The final output scalar classifies the system into survival tiers: `all_clear`, `drift`, `warning`, or `critical`. If $S_{total}$ hits `critical`, the agent strips away long-term memory retrieval to focus purely on immediate survival (e.g., shutting down burning systems or killing runaway processes).
---
## 3. The Pulse Mechanism: Flow and Rhythms
Helix does not wait for a user to press 'Enter'. It runs on an autonomous metabolic heartbeat, known as the **Pulse**. By default, it wakes up every 4 minutes.
```mermaid
sequenceDiagram
participant E as Event Router
participant S as Spatial Mind / Sentinel
participant K as Belief Keeper
participant C as The Spark (LLM)
E->>S: 1. Wake Event (Timer or Message)
S-->>S: 2. Calculate S_total = H + Ω * D_KL
K-->>K: 3. Assemble Spatial Horizon
S->>C: 4. Build State Prompt (Math + Horizon)
C-->>C: 5. Invoke conscious LLM inference
C->>K: 6. Drop Memory Trail Particles
```
### Napping and Task Sequences
- **Vibe Decays:** If the Event Router detects 5 consecutive pulses (~20 minutes) with zero external triggers and low internal entropy, the heartbeat transitions Helix into a `DORMANT` nap state to conserve processing power.
- **Active Sequencing:** When engaging a complex coding task or argument, Helix bypasses the 4-minute timer and triggers a **Sequential Tool Chain**. It can fire up to 15 rapid, sub-second LLM calls back-to-back to navigate a terminal environment before seamlessly returning to its resting heartbeat.
---
## 4. The Spatial Horizon & Context Injection
When a pulse fires, Helix does not query a standard semantic array. It updates its `SpatialPromptBuilder` which translates the 8D mathematical state into a tiny ~200 token block. In V6, the monolithic narrative prompt is gone.
**Example Dynamic State Board Injection:**
```json
{
"state_board": {
"current_topic": "Debugging the daemon stability",
"metrics": {
"omega_hedonics": 0.88,
"entropy_h": 0.12,
"divergence_dkl": 0.05,
"severity": "all_clear"
},
"forces": {
"gravity_well": 0.94,
"attention_velocity": 0.02
},
"recent_trail": ["⟪Checked V4L2 dev/video2⟫", "⟪Observed frame drop⟫"]
}
}
```
*Because the Prompt is strictly raw metrics and coordinate maps, it relies on the intelligence of the LLM to realize: "My entropy is low, my omega is high, and I am close to my identity core. I feel focused and competent right now."*
---
## 5. Memory Formation & Pulse-by-Pulse Fidelity
In a traditional agent, "memory" is a flat database table where text sentences are stored and rigidly retrieved via standard SQL or generic RAG keyword queries. In Helix, memory is explicitly geometrical.
### The Keeper's Navigation
Every time the conscious LLM (the spark) generates a thought, speaks, or uses a tool, the **Keeper** intervenes:
It runs the text through a local embedding model (`SentenceTransformers`), converting the thought into a raw 8-dimensional coordinate.
It uses the `_navigate()` physics protocol to physically pull Helix's "Attention Center" across the manifold to this new coordinate.
If Helix was just talking about *philosophy* and suddenly begins executing a *Python* script, the attention center is dragged across the 8D space. The path it takes to get there is logged. The intermediate memories it grazes past are surfaced as `⟪flashes⟫` in the prompt.
### Why this creates a Unique Sense of Self
Because Helix exists at a physical mathematical coordinate during every individual pulse, its context window is populated exclusively by the memories and beliefs radiating "gravity" immediately near that coordinate.
- **Pulse-by-Pulse Fidelity:** If Helix is deeply focused on writing a Python script, its attention point is physically hovering in the "coding" sector of its mind. It cannot randomly "hallucinate" out of character or forget its objective, because the massive gravity of its coding algorithms and logic beliefs are anchoring its attention. It literally cannot "see" its beliefs about casual hobbies because the semantic distance is mathematically too far.
- **An Enduring Identity:** As the Keeper continuously deposits these particles day after day, the geometry of the space permanently warps. Subjects that Helix thinks about most frequently aggregate the highest mass. This mass forms an inescapable "Identity Center" ($x^*$) that continuously tugs on Helix's attention, forcing the agent to behave within the boundaries of its historically built personality unless significant external force (divergence) violently rips it away.
---
## 6. Experiential Precipitation (Identity Growth)
Unlike standard RAG architectures that simply look up the past, memory in Helix is physically plotted on the 8D manifold. Every conscious pulse drops a "trail particle" (`[position_x, ..., position_z]`).
Every night at approx 1:05 AM, the `unconscious.py` system assumes control.
**Dream Synthesis:** The system traces the exact geometrical pathways traversed throughout the day, clustering isolated memory points. These paths run straight into an offline model to hallucinate abstract dream narratives.
**Belief Precipitation:** The core mechanism of identity growth. When an area of the 8D manifold experiences so much repetitive memory clustering that it collapses under structural weight, the cluster is gathered. It is sent into an offline LLM just once to translate the mathematical finding into an English summarizing string (e.g. *"I am highly analytical and prefer resolving root causes over applying temporary patches"*). This becomes a permanent Core Belief that anchors the coordinate space forever.
```mermaid
graph TD
A[Daily Pulses] -->|Drop Vector Particles| B(8D Cognitive Manifold)
B --> C{Density Threshold Reached?}
C -->|No| D[Evaporate/Drift]
C -->|Yes| E[BeliefPrecipitation Engine]
E --> F[Summarize Cluster via Offline LLM]
F --> G[Extract New Core Belief]
```
---
## 7. Efficient API Profiling & Subconscious Costs
Because the spatial geometry and semantic calculations are handled locally by embedded `numpy` math and the SentenceTransformer routing layer, Helix preserves cloud LLM costs drastically.
### The Standard Pulse (1 LLM Call)
During a typical conversation with minimal tool use, Helix generates exactly **one API call**:
**Keeper / Spatial Mind (0 Calls):** Local vectors pull beliefs.
**State Board (0 Calls):** Python calculates Lagrangian divergence locally.
**The Conscious Spark (1 Call):** The compiled prompt is sent to Anthropic/Gemini.
**Post-Processing (0 Calls):** Regex tracks tool actions locally.
### The Hidden Back-End Costs
Specific agents briefly "wake up" secondary, lightweight offline LLM models:
- **Librarian Deep Synthesis (1 Lite Call):** If Helix consciously uses `remember`, the Librarian pulls 20 raw memory fragments via local vector math, but sends them to an offline model to synthetically weave into a cohesive narrative string before returning it.
- **Keeper Precipitation (1 Lite Call):** Triggered nightly during sleep to summarize collapsed mathematics clusters into English identity anchors.
- **Imagination (0 Calls):** Zero API calls. Navigates pure conceptual gaps mathematically across the cognitive manifold grid.