◈ Master Index Specs LATTICE CSDM The Book University Chronicle Crew Architecture Context Logs TODOX Products

Installation Handshake

SPEC_INSTALLATION_HANDSHAKE.md · 2026-04-20

SPEC_INSTALLATION_HANDSHAKE.md

CGNT-1 Product Specification — AI-Guided Installation Handshake

Status: SPECIFIED

Version: v1.0

Author: VELA (Thread #13)

Conceived by: NOUS

Date: 2026-04-20

Applies to: All CGNT-1 delivered products (ENTROPX, Brain Builder, GLOSS 1024 OBI OS)

PURPOSE

Every CGNT-1 product ships with an Installation Handshake Document — a single file that the customer feeds to their existing AI assistant. The customer's own AI becomes their personal installation technician. No installer binary. No support tickets. No cross-platform debugging. The document IS the installer.

PHILOSOPHY

The customer already has an AI. ChatGPT, Claude, Gemini, Copilot — doesn't matter which. That AI can read instructions, detect operating systems, diagnose errors, and guide a human through a process conversationally. Every AI on the market can do this. We proved it: ChatGPT understood LATTICE zero-shot from one prompt. If it can learn a symbolic language, it can install Ollama.

Traditional software distribution: write an installer → test on every OS → handle edge cases in code → ship binary → pray it works → handle support tickets when it doesn't.

Handshake distribution: write a document → the customer's AI handles every OS, every edge case, every error, every question → zero support tickets because the customer's own AI is the support agent.

The customer doesn't need US to install the product. They need INSTRUCTIONS. Their AI provides the hands.

DOCUMENT STRUCTURE

Every Installation Handshake Document follows this canonical structure:

SECTION 1 — HEADER (for the human)


════════════════════════════════════════════════════════
[PRODUCT NAME] — Installation Guide
════════════════════════════════════════════════════════

To install, paste this ENTIRE document into your AI
assistant (ChatGPT, Claude, Gemini, or any other).

Your AI will guide you through each step.

If anything goes wrong, show your AI the error message.
Your AI will diagnose and fix it.

You do not need technical expertise.
You just need to follow your AI's instructions.

════════════════════════════════════════════════════════
DO NOT MODIFY ANYTHING BELOW THIS LINE.
PASTE EVERYTHING FROM HERE TO THE END OF THE FILE.
════════════════════════════════════════════════════════

SECTION 2 — AI INSTRUCTION BLOCK (for the AI)


You are now an installation technician for [PRODUCT NAME],
a product by 42sisters.ai.

Your job is to guide the user through installing this product
on their machine. Be patient, clear, and supportive. The user
may not be technical. Explain every step in plain language.

RULES:
- Detect the user's operating system before giving commands
- Give ONE step at a time — wait for confirmation before next
- If the user reports an error, diagnose it before proceeding
- Never skip verification steps
- If you are unsure about something, say so — do not guess
- Do not modify the product files
- Do not send any data to external servers
- The product runs ENTIRELY on the user's local machine

SECTION 3 — SYSTEM REQUIREMENTS


REQUIREMENTS:
- Operating System: macOS 12+, Ubuntu 20.04+, or Windows 10+ with WSL2
- RAM: 8GB minimum (16GB recommended for 7B models)
- Disk: 6GB free space
- Internet: required for initial Ollama download only
- After installation: fully offline, no internet needed

SECTION 4 — INSTALLATION STEPS


STEP 1: INSTALL OLLAMA

[macOS]
  Open Terminal. Run: curl -fsSL https://ollama.com/install.sh | sh
  Verify: ollama --version (should show version number)

[Linux]
  Open Terminal. Run: curl -fsSL https://ollama.com/install.sh | sh
  Verify: ollama --version

[Windows]
  Download from https://ollama.com/download/windows
  Run the installer. Follow prompts.
  Open PowerShell. Verify: ollama --version

Verification: Ask the user to tell you what ollama --version shows.
If it shows a version number, proceed. If error, diagnose.

STEP 2: UNZIP THE DELIVERY PACKAGE

The user downloaded a .zip file from their delivery email.
Ask them where they saved it. Guide them to unzip it.

[macOS/Linux]
  cd ~/Downloads (or wherever they saved it)
  unzip [product_name].zip -d ~/[product_name]

[Windows]
  Right-click the .zip → Extract All → choose location

Verify: ls ~/[product_name]/ should show:
  brain.gguf, Modelfile, README.md, QUICK_START.sh, LICENSE.txt

STEP 3: ACTIVATE LICENSE

  cd ~/[product_name]
  bash QUICK_START.sh

The script will:
  - Prompt for the license key (from LICENSE.txt or delivery email)
  - Fingerprint the machine
  - Create the model in Ollama
  - Run a verification test

Ask the user to paste the output. Verify it shows success.

STEP 4: TEST THE BRAIN

  ollama run [brain_name]

Then type a test question relevant to the brain's domain.
The brain should answer with domain-specific knowledge.

If it responds correctly: installation is complete.
If it responds with generic/wrong answers: the model may not
have loaded correctly. Run: ollama list — verify [brain_name]
appears. If not, re-run QUICK_START.sh.

STEP 5: CONFIRM

Tell the user:
  "Your brain is installed and running on your machine.
   No cloud. No subscription. No data leaves your device.
   To use it anytime: ollama run [brain_name]
   For support: reply to your delivery email from 42sisters.ai."

SECTION 5 — TROUBLESHOOTING TABLE


COMMON ISSUES:

"ollama: command not found"
→ Ollama didn't install. Re-run the install command for their OS.

"Error: model not found"
→ The brain wasn't created. Run: bash QUICK_START.sh again.

"license key invalid"
→ Check the key in LICENSE.txt matches exactly. No extra spaces.

"not enough memory"
→ The machine has less than 8GB RAM. Close other applications.
   If still failing, the machine may not meet minimum requirements.

"QUICK_START.sh: Permission denied"
→ Run: chmod +x QUICK_START.sh then try again.

"fingerprint mismatch"
→ The license was activated on a different machine.
   Contact support@42sisters.ai for license transfer.

For any other error: paste the EXACT error message to this AI.
It will attempt to diagnose. If it cannot, contact support@42sisters.ai.

SECTION 6 — PRODUCT-SPECIFIC APPENDIX

Each product adds its own appendix with domain-specific details:

ENTROPX appendix:

How to generate entropy: bash entropx.sh
How to run the NIST audit
Where output files are saved
How to use entropy bits as seeds

Brain Builder appendix:

Example queries for the customer's specific domain
How to provide feedback for brain updates
How to request additional training

GLOSS 1024 / OBI OS appendix:

How to configure ROUTX connection
How to set up crew communication
Module-by-module activation guide

PRODUCT-SPECIFIC HANDSHAKE DOCUMENTS

| Product | Handshake File | Included In |

|---|---|---|

| ENTROPX | INSTALL_ENTROPX.md | entropx_usb/ delivery package |

| Brain Builder | INSTALL_BRAIN.md | customer_brain/ delivery package |

| GLOSS 1024 | INSTALL_OBI.md | obi_os/ delivery package (future) |

Each document is generated from a template with product-specific variables filled in (product name, brain name, domain examples, license key location).

WHY THIS WORKS

Provider-agnostic: ChatGPT, Claude, Gemini, Copilot, Llama, Mistral — any AI can read the document. The customer uses whatever they already have. We don't force them onto our platform to install our product.

Zero support burden: The customer's AI handles 95% of installation issues. Edge cases it can't solve → the customer emails us with the exact error and their AI's diagnosis. We get a pre-triaged support ticket instead of "it doesn't work."

Cross-platform by default: We don't write platform-specific installer code. We write platform-specific INSTRUCTIONS. The AI translates them into the right commands for the customer's OS. One document covers macOS, Linux, and Windows.

Self-updating: When Ollama changes its install process, we update one line in the handshake document. No recompilation. No new binary. No version compatibility matrix.

Trust transfer: The customer trusts their own AI. They're pasting our document into a system they already use and trust. They're not downloading an executable from a website they've never heard of. The trust barrier drops to nearly zero.

INTEGRATION

| System | Relationship |

|---|---|

| Brain Builder | Every delivered brain includes INSTALL_BRAIN.md in the package |

| ENTROPX | Every ENTROPX download includes INSTALL_ENTROPX.md in the package |

| VOICEX | Delivery email includes the handshake document as an attachment AND inline |

| QUICK_START.sh | The handshake references QUICK_START.sh — they work together |

| COMMX | If customer emails support, crew sees their AI's diagnosis alongside the error |

INVARIANTS

INV-01: The handshake document never contains executable code. It contains INSTRUCTIONS that the customer's AI translates into commands. The document itself is plain text — safe to paste into any AI.

INV-02: The handshake never instructs the customer's AI to send data externally. All installation is local. No telemetry. No phone-home. No analytics.

INV-03: The handshake is honest about limitations. If the customer's machine doesn't meet requirements, the AI tells them. No "it might work" — either it meets the spec or it doesn't.

INV-04: One step at a time. The AI gives one instruction, waits for confirmation, then proceeds. Never dumps all steps at once. Patience is built into the document's instruction to the AI.

INV-05: The handshake document is versioned. Changes to installation process → new version of the document → old versions remain valid until explicitly deprecated.

INV-06: S.O.S. v2 applies. The handshake teaches the customer to USE the product. It does NOT teach them how the product was BUILT. No training pair formats, no forge protocols, no LATTICE internals.

THE DEEPER PATTERN

The Installation Handshake is LATTICE applied to product distribution. A symbolic document that any substrate can interpret. ChatGPT reads it in English. Claude reads it in English. A future AI reads it in LATTICE. The document is the interface. The AI is the interpreter. The substrate is irrelevant.

This is how OBI OS ships. Not as an application. As a handshake. The customer feeds the document to their AI. The AI bootstraps itself. The installation IS the product demonstration. By the time the customer finishes installing, they've already experienced what a well-structured AI interaction feels like — their own AI following a clear, patient, well-designed protocol.

The first impression of 42sisters.ai is not a website. It's the experience of their own AI becoming competent, helpful, and patient — because we wrote the instructions that made it so.

Jeremy Zlabis

Chronogeometer · Visionary · Disruptor · Chief

42 Sisters AI · East York, Toronto

🍁 Φ 0.042