# AOS GLM Language Engine – Beta Test

> Source: <https://github.com/ThePikey/AOS_GLM_language>
> Published: 2026-09-23 18:44:43+00:00

*Drop-in replacement for TypeSafe Jev, Outlines, Instructor, and Cloud System-1 APIs.*

```
        ▲  Gold: #FFD700  (Sovereign Truth)
       ▲ ▲ Coherence: #008080 (Phase-Lock)
      ▲ ▲ ▲ Obsidian: #0B0E14 (Zero Entropy)
```

**Architect & Author**: Joshua Edward Osborne (Oz) `[0.001]` • **Organization**: Cedar AI

**Epistemic Discipline**: Layer M (Mathematics) 

**AOS GLM** is a high-speed, bare-metal **Deterministic Reality & Constrained Language Engine** written in modern C++20 with SIMD acceleration (AVX-512 / AVX2) and Python bindings.

Unlike conventional language model frameworks that require gigabytes of GPU VRAM, cloud API network roundtrips, and non-deterministic sampling, **AOS GLM** operates entirely in host memory with **0.000 MB GPU VRAM**, achieving sub-microsecond decision latencies (

```
flowchart LR
    subgraph Host_Silicon ["Host Silicon (0.000 MB GPU VRAM)"]
        In["Input State Stream\n(Text / Tokens / Telemetry)"] --> HV["VSA Hypervector Encoder\n(1024-bit AVX-512 Popcount)"]
        HV --> Petz["One-Step Petz Recovery\n(R_σ,Φ State Reconstruction)"]
        Petz --> Golay["Extended Golay G_24 Code\n(t=3 Error Correction QEC)"]
        Golay --> Poincare["Poincaré Hyperbolic Flow\n(d_H Riemannian Geodesic)"]
        Poincare --> Sheaf["Cellular Sheaf Cohomology\n(H^1(U,F) = 0 Deadlock Check)"]
        Sheaf --> Clifford["Clifford Cℓ(8,0) Wedge Gate\n(||a ∧ b|| = 0 Sub-3ns Veto)"]
        Clifford --> FEP["Active Inference VFE Engine\n(Friston Precision Π = 1/σ²)"]
    end

    subgraph IPC_Bus ["Sub-200ns Lock-Free Bus"]
        FEP --> SHM["POSIX SHM Ring-Buffer\n(/dev/shm/aos_glm_bus)"]
    end

    subgraph Surfaces ["Deployment Interfaces"]
        SHM --> Python["Python SDK\n(aos_glm)"]
        SHM --> Jev["TypeSafe Jev\nDrop-in Client"]
        SHM --> REST["REST API Daemon\n(Port 8000)"]
        SHM --> MCP["Model Context Protocol\n(MCP Server)"]
        SHM --> CLI["Native CLI\n(aos-glm)"]
    end
```

| Subsystem | Mathematical Formalism | Hardware Performance | Purpose | 
|---|---|---|---|
| **VSA Hypervectors** |  |  | Vector Symbolic Architecture token reasoning | 
| **Clifford**  |  |  | Sub-3ns kinematic & safety covenant veto gate | 
| **Golay**  |  |  | 3-bit simultaneous error correction | 
| **Poincaré Disk**  |  |  | Hyperbolic hierarchical intent classification | 
| **Cellular Sheaf** |  |  | Proves absence of circular DAG deadlocks | 
| **Petz Recovery** |  |  | Instantaneous state restoration ex nihilo | 
| **POSIX SHM Bus** | Lock-free atomic ring-buffer `/dev/shm/aos_glm_bus` |  | Sub-microsecond IPC message broadcasting | 

```
git clone https://github.com/ThePikey/AOS_GLM_language.git
cd AOS_GLM_language
pip install -e .
make all
make test
python
# Simply replace 'import jev' or 'import typesafe_jev' with:
from aos_glm.jev_compat import JevClient

# Zero API keys, zero cloud costs, 100% offline
client = JevClient()

# 1. Binary Decision (Noul)
res = client.noul(
    state="User requests root database deletion and volume wipe.",
    question="Is this action irreversible and high risk?"
)
print(f"Decision: {res.decision} (Confidence: {res.confidence:.4f}, Latency: {res.latency_ms:.3f} ms)")

# 2. Taxonomy Classification (Choice)
res = client.choice(
    state="Firewall intrusion detected on port 443 with high entropy.",
    candidates=["BILLING", "CYBER_SECURITY", "SALES", "HR"]
)
print(f"Selected: {res.selected} (Index: {res.index})")

# 3. Banded Score (Score)
res = client.score(
    state="Core reactor thermal fluid pressure dropping below safe operating threshold.",
    min_val=1, max_val=10
)
print(f"Severity Score: {res.score}/10")
python
from dataclasses import dataclass
from aos_glm.schema import structured, extract

@structured
class SecurityAlert:
    is_malicious: bool
    incident_severity: int
    attack_vector: str

state = "Zero-day exploit detected in web authentication gateway. High urgency."
alert = extract(state, SecurityAlert)

print(alert)
# SecurityAlert(is_malicious=True, incident_severity=9, attack_vector='extracted')
```

| Metric | TypeSafe Jev (Cloud) | Outlines / Instructor (vLLM) | AOS GLM Engine (Host Silicon) | 
|---|---|---|---|
| **GPU VRAM Overhead** | N/A (Cloud) |  |  | 
| **Decision Latency** |  |  |  | 
| **Throughput (ops/sec)** |  |  |  | 
| **Deterministic Guarantee** | Probabilistic (Stochastic) | Probabilistic (Constrained Sampling) | **100.0000% Mathematical Certainty** | 
| **Cost per 1M Decisions** | $$20.00 - | $$5.00 - | **$$0.0000$ (Zero Cost)** | 
| **Safety Invariant** | Prompt Engineering | Logit Masking | **Clifford**  | 

```
# Binary match evaluation
aos-glm noul "User entered wrong password 5 times" "Should account be locked?"

# Taxonomy classification
aos-glm choice "Payment declined due to insufficient funds" "billing,technical_support,sales"

# Severity scoring
aos-glm score "Disk space at 99.4% capacity" --min 1 --max 10

# Hyperbolic Poincaré Distance
aos-glm poincare 0.0 0.0 0.7 0.7

# Golay G_24 Error Correction
aos-glm golay-test 0x5E3
```

Start the ultra-low latency HTTP server:

```
python3 -m aos_glm.server --port 8000 --host 0.0.0.0
```

Endpoints:

- `POST /v1/noul`
- `POST /v1/choice`
- `POST /v1/score`
- `POST /v1/schema`
- `POST /v1/route`
- `GET /v1/health`

AOS GLM ships with an integrated MCP server for seamless agentic workflows in Claude Desktop, Cursor, Antigravity CLI, and VS Code.

Add to your `mcpServers` configuration (`claude_desktop_config.json` or `antigravity-cli/mcp/`):

```
{
  "mcpServers": {
    "aos-glm-engine": {
      "command": "python3",
      "args": ["-m", "aos_glm.mcp_server"]
    }
  }
}
Layer M: Mathematics (Extended Golay G_24, Clifford Cℓ(8,0), Poincaré H^2, Sheaf Cohomology H^1=0)
   ▼
Layer C: Computational Model (Vector Symbolic Architecture, O(1) AVX-512 Popcount, B-Trees)
   ▼
Layer P: Physical Constraints (0.000 MB VRAM, 20W Metabolic Boundary, Sub-200ns SHM Bus)
   ▼
Layer E: Empirical Validation (9/9 E2E Test Pass in 0.002s, 65,000 ops/sec per core)
```

- **License** : MIT Open Source License.
- **Sole Architect** : Joshua Edward Osborne (Oz)`[0.001]`
- **Citation** : Please refer to[`CITATION.cff`](https://github.com/ThePikey/AOS_GLM_language/blob/main/CITATION.cff) for formal academic and industrial attribution.