██████╗ ██████╗ ███████╗ ███╗   ██╗
                 ██╔═══██╗██╔══██╗██╔════╝ ████╗  ██║
                 ██║   ██║██████╔╝█████╗   ██╔██╗ ██║
                 ██║   ██║██╔═══╝ ██╔══╝   ██║╚██╗██║
                 ╚██████╔╝██║     ███████╗ ██║ ╚████║
                  ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═══╝
███╗   ███╗██╗   ██╗████████╗██╗  ██╗ ██████╗ ███████╗       ██████╗
████╗ ████║╚██╗ ██╔╝╚══██╔══╝██║  ██║██╔═══██╗██╔════╝       ╚════██╗
██╔████╔██║ ╚████╔╝    ██║   ███████║██║   ██║███████╗  █████╗ █████╔╝
██║╚██╔╝██║  ╚██╔╝     ██║   ██╔══██║██║   ██║╚════██║  ╚════╝██╔═══╝
██║ ╚═╝ ██║   ██║      ██║   ██║  ██║╚██████╔╝███████║       ███████╗
╚═╝     ╚═╝   ╚═╝      ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚══════╝       ╚══════╝

"From the void of computation, a new oracle speaks — no gods, no cloud, only the terminal."

Fully local, offline AI in your terminal. Zero API keys. Zero cloud. Zero limits.

Get started in 30 seconds · Features · Commands · RML · Contributing

Why OpenMythos-2?

⚡ What is OpenMythos-2?

OpenMythos-2 is a fully local, offline AI that lives and breathes inside your terminal. Inspired by the ancient myths of oracles, gods, and forgotten wisdom — it brings the power of intelligent conversation and reasoning directly to your command line, with zero API keys, zero cloud dependency, and zero limits.

Like Prometheus stealing fire from the gods, OpenMythos-2 brings the fire of AI to every machine.

🏛️ Features

The Myth Behind the Machine

The name draws from mythos (μῦθος) — the ancient Greek word for story, legend, and the spoken word of truth. OpenMythos-2 embodies that spirit: a storyteller, reasoner, and companion that runs entirely on your machine, with no external gods (servers) to pray to.

Getting Started

Prerequisites

• Python 3.10+
• pip
• A terminal (bash, zsh, PowerShell, cmd)

Installation

Pick your platform and package manager:

# Clone the sacred repository
git clone https://github.com/creatorofsomethingthatisgood/Open-Mythos-2.git
cd Open-Mythos-2

# One-time setup (installs deps, builds llama-cpp-python with Vulkan/CPU fallback)
sudo bash setup.sh

# Download the model (~4.5 GB, first time only)
mythos model download

# Start chatting
mythos

git clone https://github.com/creatorofsomethingthatisgood/Open-Mythos-2.git
cd Open-Mythos-2

# Install system deps first
sudo pacman -S --needed python python-pip gcc make cmake vulkan-headers vulkan-icd-loader openblas

# Run setup
sudo bash setup.sh
mythos model download
mythos

git clone https://github.com/creatorofsomethingthatisgood/Open-Mythos-2.git
cd Open-Mythos-2

# One-command setup (Fedora-optimized, includes Vulkan GPU support)
sudo bash setup.sh
mythos model download
mythos

# On a connected machine:
./scripts/mythos-export-data.sh # creates offline-bundle/ (~4.5 GB)

# Transfer the bundle to the target machine, then:
./scripts/mythos-import-data.sh ./offline-bundle

# Clone the sacred repository
git clone https://github.com/creatorofsomethingthatisgood/Open-Mythos-2.git
cd Open-Mythos-2

# One-time setup (Metal GPU on Apple Silicon, CPU on Intel Macs)
./setup-macos.sh

# Download the model (~4.5 GB, first time only)
./mythos model download

# Start chatting
./mythos

brew tap creatorofsomethingthatisgood/tap
brew install open-mythos-2

mythos model download
mythos

# Clone the sacred repository
git clone https://github.com/creatorofsomethingthatisgood/Open-Mythos-2.git
cd Open-Mythos-2

# One-time setup (PowerShell — detects CUDA/Vulkan/CPU automatically)
.\setup-windows.ps1

# Download the model (~4.5 GB, first time only)
.\mythos.bat model download

# Start chatting
.\mythos.bat

# Install globally
sudo npm install -g open-mythos-2

# Download the model (~4.5 GB, first time only)
mythos model download

# Start chatting
mythos

# Install globally
pnpm install -g open-mythos-2

# Download the model (~4.5 GB, first time only)
mythos model download

# Start chatting
mythos

# Install with pipx (isolated environment, no venv management needed)
pipx install mythos-sentinel

# Or install from source
git clone https://github.com/creatorofsomethingthatisgood/Open-Mythos-2.git
cd Open-Mythos-2
pipx install .

# Download the model (~4.5 GB, first time only)
mythos model download

# Start chatting
mythos

# Pull and run (CPU-only)
docker run -it --rm \
  -v mythos-data:/root/.config/mythos \
  ghcr.io/creatorofsomethingthatisgood/open-mythos-2:latest

# With NVIDIA GPU acceleration
docker run -it --rm --gpus all \
  -v mythos-data:/root/.config/mythos \
  ghcr.io/creatorofsomethingthatisgood/open-mythos-2:latest-cuda

# Download model first (one-time)
docker run -it --rm \
  -v mythos-data:/root/.config/mythos \
  ghcr.io/creatorofsomethingthatisgood/open-mythos-2:latest \
  mythos model download

# Web UI
docker run -it --rm -p 7860:7860 \
  -v mythos-data:/root/.config/mythos \
  ghcr.io/creatorofsomethingthatisgood/open-mythos-2:latest \
  mythos web --port 7860

RML — Reinforcement Machine Learning

RML is a feedback-driven self-improvement loop that learns your preferences over time and adapts Mythos to match. It does two things automatically:

1. Edits the System Prompt

When a category accumulates enough negative feedback, RML injects a concrete behavioral hint directly into the system prompt. These learned hints tell Mythos how to adjust its style — for example:

• Accuracy hint: "Prioritize accuracy over creativity. Double-check facts. If unsure, say so."
• Conciseness hint: "Be concise. Get to the answer quickly; elaborate only when asked."
• Clarity hint: "Use headers, bullet points, short paragraphs. Avoid jargon without explanation."
• Code quality hint: "Write production-quality code: type hints, docstrings, error handling."
• Security hint: "Apply security best practices: input validation, no hardcoded secrets."
• Completeness hint: "Be thorough. Address all parts of the question. Don't skip edge cases."

Hints are removed automatically when the category's score recovers — so the system prompt is always a live reflection of what you actually prefer.

2. Adjusts Generation Parameters

RML also tweaks temperature, top_p, and repeat_penalty behind the scenes:

• High accept rate → temperature nudges up (more creative/confident)
• High rejections/edits → temperature nudges down (more conservative/precise)
• Many interrupts → repeat_penalty increases slightly

All adjustments are bounded by max_param_offset (default 0.3) so nothing swings wildly.

Feedback Signals RML Collects

Commands

/rml on          Enable RML
/rml off         Disable RML
/rml good        Mark last response as good (explicit +2)
/rml bad         Mark last response as bad (explicit -2)
/rml stats       Show what RML has learned (scores, hints, param adjustments)
/rml reset       Wipe all learned preferences and start fresh

Config (config.yaml)

rml:
  enabled: false          # Turn on with /rml on in chat
  learning_rate: 0.05     # 0.01 = slow, 0.2 = fast
  max_param_offset: 0.3   # Max drift from base temperature/top_p
  hint_threshold: 3.0     # Negative score before a hint is injected

Preferences persist in ~/.config/mythos/rml_preferences.json across sessions.

📜 Command Reference

CLI Commands (terminal)

In-Chat Slash Commands

Voice Input (Whisper + AMD GPU)

Speak to Mythos instead of typing. Uses whisper.cpp with the Vulkan backend for GPU-accelerated transcription on AMD GPUs (RDNA and newer).

Setup

# 1. Install whisper.cpp with Vulkan support (one-time, ~5 min)
./scripts/install_whisper.sh          # base.en model (fast, 142 MB)
./scripts/install_whisper.sh small    # small.en (better accuracy, 466 MB)

Usage

# Enable voice mode
/voice on

# Quick record (works even with voice off)
/rec

# Press 'v' at an empty prompt to start recording, Enter to stop
v
(speak, then press Enter)

# Check status
/voice

# Disable
/voice off

Config (config.yaml)

voice:
  enabled: false
  whisper_bin: "whisper-cli"          # or full path
  model: "models/ggml-base.en.bin"   # GGML model file
  language: "en"                      # "en" or "auto"
  push_to_talk: true
  max_duration: 30                    # seconds

AMD GPU Notes

• Vulkan backend (recommended): works on all AMD GPUs with Vulkan 1.2+ (RX 6000/7000/9000 series)
• HIP/ROCm backend: for supported cards only — build with cmake -DGGML_HIP=1 -DAMDGPU_TARGETS=gfx1100
• Consumer GPUs (RX series) should use Vulkan — ROCm is mainly for MI-series datacenter GPUs

Skill Marketplace

Mythos has a built-in skill system with three tiers: pre-installed, community marketplace, and AI-created.

Pre-installed Skills

These ship with Mythos and are ready to use out of the box:

Using Skills

# In chat
/skill list                        # See all available skills
/skill run summarize bullets       # Run a skill command
/skill run quick_ref python        # Get a Python cheat sheet
/skill run translate to spanish Hello world  # Translate text

# From the CLI
mythos skill list
mythos skill run quick_ref git
mythos skill info summarize

Browsing the Marketplace

/skill marketplace          # Browse all community skills
/skill search security      # Find skills by keyword
/skill install password_gen # Install a skill from the marketplace

Skills are fetched from the community index hosted in this repo. Once installed, they live in ~/.config/mythos/skills/.

AI-Created Skills

Mythos can generate new skills on the fly:

/skill create a skill that generates random passwords
/skill create a skill that converts units of measurement

The AI writes a manifest.yaml and skill.py, saves it to ~/.config/mythos/skills/custom/, and it is immediately usable. AI-created skills are private -- they are never shared with the marketplace.

Submit a Skill to the Marketplace

Anyone can add a skill. Here is how:

1. Create your skill directory under skills/:

skills/your_skill_name/
  manifest.yaml
  skill.py

2. Write manifest.yaml:

name: your_skill_name
version: "1.0.0"
description: "One-line description of what your skill does"
author: your-github-username
tags: [relevant, tags, here]
commands:
  - name: run
    description: "What the run command does"
    handler: run
  - name: search
    description: "What the search command does"
    handler: search

3. Write skill.py:

def run(args: str, context: dict) -> str:
    """Main command handler. args is the user's text after the command.
    context contains: messages (recent chat), config (dict)."""
    return f"Result: {args}"

def search(args: str, context: dict) -> str:
    return f"Searched for: {args}"

4. Register in the marketplace index by adding an entry to skills/marketplace/index.json:

{
  "name": "your_skill_name",
  "version": "1.0.0",
  "description": "One-line description of what your skill does",
  "author": "your-github-username",
  "tags": ["relevant", "tags"],
  "commands": [
    {"name": "run", "description": "What the run command does"},
    {"name": "search", "description": "What the search command does"}
  ]
}

5. Open a Pull Request to this repo with your skill added.

Skill rules:

• Each handler must accept (args: str, context: dict) and return str
• No subprocess, os.system, eval, or exec -- keep it safe
• No filesystem writes outside of reading context data
• Pure Python stdlib only (no extra pip dependencies)
• One skill per PR, clean and focused

Once merged, your skill appears in /skill marketplace for everyone.

Roadmap

• Multi-model support (swap between GGUF models in-chat)
• MCP (Model Context Protocol) server integration
• LoRA fine-tuning from within the CLI
• RAG over local documents
• Skill system with community marketplace
• Voice input via Whisper (whisper.cpp, AMD Vulkan GPU support)
• Voice output via Coqui TTS

Contributing

We welcome contributions of all kinds — bug fixes, features, docs, and ideas.

1. Fork the repo
2. Create a branch: git checkout -b feature/your-idea
3. Commit your changes: git commit -m "Add your idea"
4. Push: git push origin feature/your-idea
5. Open a Pull Request

See Issues for open tasks. Feel free to open a new issue for bugs, feature requests, or questions.

Disclaimer these answers may not be true by the model.

Thank you starers I love you