Spaces:
Running
Running
| title: README | |
| emoji: ⚡ | |
| colorFrom: blue | |
| colorTo: indigo | |
| sdk: static | |
| pinned: false | |
| <div align="center"> | |
| # 🌌 **Mythic Artificial Intelligence** | |
| ### *by MythicGames* | |
| **Building the next generation of merged language models** | |
| 🌐 [Visit our platform](https://mythicgames.ru) · 💬 [Chat with MAI models](https://mythicgames.ru/app) · 📂 [All Models](https://mythicgames.ru/models) | |
| </div> | |
| --- | |
| ## 🧬 Model Families | |
| MAI models follow a unified naming convention: | |
| ``` | |
| MAI M{version} {Specialization} {Variant} | |
| MAI {version} {Variant} | |
| MAI C{version} {Variant} | |
| MAIGEN {version} {Specification} | |
| MAIMIND {version} {Specification} | |
| MAITTS {version} {Specification} | |
| MAIEDITOR {version}.{Date of release} {Update feature name} | |
| ``` | |
| | Component | Meaning | Examples | | |
| |---|---|---| | |
| | **M{version}** | Generation / major version | M1, M2, M3, M4 | | |
| | **Specialization** | Primary task focus | Coder, Chat, Reason, Vision | | |
| | **Variant** | Speed / depth profile | Fast, Thinking | | |
| --- | |
| ### ⚡ Variant Breakdown | |
| | Variant | Philosophy | Latency | Depth | Best For | | |
| |---|---|---|---|---| | |
| | 🟢 **Fast** | Speed-first. Minimal chain-of-thought, instant responses | 🔽 Low | Standard | Code generation, quick Q&A, real-time chat | | |
| | 🟣 **Thinking** | Depth-first. Extended internal reasoning before answering | 🔼 Higher | Deep CoT | Math, logic, complex analysis, research | | |
| > **Rule of thumb:** If you need an answer *now* — use **Fast**. If you need the *right* answer to a hard problem — use **Thinking**. | |
| --- | |
| ## 📋 Full Model Registry | |
| | Model | Specialization | Variant | MSPLIT | MCE | Power (×) | Context | Status | | |
| |---|---|---|---|---|---|---|---| | |
| | **MAI M3 Coder Fast** | Reasoning | Fast | 3A | 2.74 | ~3.2× | >1M | 🟢 Active | | |
| | **MAI M3 Coder Thinking** | Reasoning | Thinking | 3A | 2.74 | ~3.2× | >1M | 🟢 Active | | |
| | **MAI M4 Coder Fast** ⭐ | Code | Fast | 4A | 3.16 | ~4.3× | >1M | 🟢 **Flagship** | | |
| | **MAI M4 Coder Thinking** | Code | Thinking | 4A | 3.16 | ~4.3× | >1M | 🟢 Active | | |
| | **MAI M5 Coder Fast** | Multimodal | Fast | 4A | 3.16 | ~4.3× | >1M | 🔵 Coming Soon | | |
| --- | |
| ## 📐 The MAI Math — Formulas & Coefficients | |
| ### 1️⃣ Power Multiplier Formula | |
| Every MAI model's effective performance boost is calculated using: | |
| ``` | |
| MCE² × 8 | |
| Power (×) = ───────────── | |
| 9.3 × 2 | |
| ``` | |
| Or simplified: | |
| ``` | |
| Power = (MCE² × 8) / 18.6 | |
| ``` | |
| | Variable | Full Name | Description | | |
| |---|---|---| | |
| | **MCE** | Merge Coefficient Exponent | Core efficiency metric of the merge. Higher = better synergy between merged weights | | |
| | **8** | Base Parameter Scalar | Constant tied to the 8-expert routing in the merge pipeline | | |
| | **9.3** | Normalization Factor | Empirical constant derived from benchmark calibration | | |
| | **2** | Dual-pass Divisor | Accounts for the two-pass merge verification in MSPLIT | | |
| --- | |
| ### 2️⃣ MCE Progression Across Generations | |
| MCE grows with each MSPLIT generation following a **square-root scaling law**: | |
| ``` | |
| MCE(n) = √(2.5 × n) | |
| ``` | |
| Where `n` = MSPLIT generation number. | |
| | MSPLIT Gen | n | MCE = √(2.5n) | MCE² | Power (×) | | |
| |---|---|---|---|---| | |
| | 3A | 3 | √7.5 ≈ **2.74** | 5 | ~3.23× | | |
| | 4A | 4 | √10.0 ≈ **3.16** | 10.0 | **~4.30×** | | |
| | 5A *(projected)* | 5 | √12.5 ≈ **3.54** | 8 | ~5.38× | | |
| | 6A *(projected)* | 6 | √15.0 ≈ **3.87** | 16 | ~6.45× | | |
| > 📈 **Insight:** Power scales *linearly* with MSPLIT generation because MCE² = 2.5n, so Power = (2.5n × 8) / 18.6 ≈ **1.075n**. Each new generation adds roughly **+1.08×** to the multiplier. | |
| --- | |
| ### 3️⃣ Context Window Scaling | |
| Context length doubles with each major version: | |
| ``` | |
| Context(v) = 64K × 2^v | |
| ``` | |
| | Version (v) | Calculation | Context Window | | |
| |---|---|---| | |
| | M3 (v=3) | 64K × 2³ | **1,024K** | | |
| | M4 (v=4) | 64K × 2⁴ | **1,024K (>1M)** | | |
| | M5 *(projected)* | 64K × 2⁵ | **2,048K (~2M)** | | |
| --- | |
| ### 4️⃣ Effective Intelligence Index (EII) | |
| To compare models holistically, we use the **EII** — a single score combining power and context: | |
| ``` | |
| EII = Power(×) × log₂(Context / 1K) | |
| ``` | |
| | Model | Power (×) | Context | log₂(C/1K) | **EII** | | |
| |---|---|---|---|---| | |
| | MAI M3 Reason Fast | 3.44 | 1024K | 4 | **29.07** | | |
| | **MAI M4 Coder Fast** | 4.30 | 1024K | 10 | **43.00** ⭐ | | |
| | MAI M5 *(projected)* | 6.88 | 2048K | 8 | **59.18** | | |
| > 🎯 **Notice the pattern?** EII ≈ 4.3 × n × (n + 6) / 10 — it grows *quadratically*, meaning each generation is dramatically more capable than the last. | |
| > Models like M5 will use: **64 / 9.3**, without **/ 2** | |
| --- | |
| ### 5️⃣ Fast vs Thinking — Speed-Depth Tradeoff | |
| ``` | |
| Base Latency | |
| Fast Latency = ───────────── | |
| Power(×) | |
| Thinking Latency = Base Latency × Thinking Depth Factor (TDF) | |
| ``` | |
| Where **TDF** typically ranges from **3× to 8×** depending on problem complexity. | |
| | Variant | Relative Latency | Relative Accuracy (hard tasks) | | |
| |---|---|---| | |
| | Fast | **1×** (baseline) | ~85–92% | | |
| | Thinking | **3–8×** slower | ~94–99% | | |
| > 💡 **When to switch?** If Fast gives a confident answer → stay with Fast. If it hedges or the task involves multi-step reasoning → switch to Thinking. | |
| --- | |
| ## 🔬 MSPLIT Technology — How It Works | |
| ``` | |
| ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ | |
| │ Base Model │ │ Base Model │ │ Base Model │ | |
| │ A │ │ B │ │ C │ | |
| └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ | |
| │ │ │ | |
| └─────────────┬───────┘────────────────────┘ | |
| │ | |
| ┌───────▼────────┐ | |
| │ PEREX MERGE │ ← Weighted parameter fusion | |
| │ Pipeline │ | |
| └───────┬────────┘ | |
| │ | |
| ┌───────▼────────┐ | |
| │ MSPLIT nA │ ← Split-verify-remerge (n passes) | |
| │ Optimization │ | |
| └───────┬────────┘ | |
| │ | |
| ┌───────▼─────────┐ | |
| │ Final Merged │ | |
| │ Model │ → MCE = √(2.5 × n) | |
| └─────────────────┘ | |
| ``` | |
| **MSPLIT (Multi-Stage Parameter Splitting)** works in three phases: | |
| 1. **Merge** — Multiple base models are fused using the Perex Merge weighted-average pipeline | |
| 2. **Split** — The merged weights are split into parameter subgroups and independently evaluated | |
| 3. **Re-merge** — Only the highest-performing parameter configurations survive and are re-merged | |
| Each MSPLIT generation (3A → 4A) adds an additional split-verify pass, increasing MCE and therefore the power multiplier. | |
| --- | |
| ## 🛡️ Access & Licensing | |
| | | | | |
| |---|---| | |
| | **Access** | 🔒 Private — all models are served exclusively through our platform | | |
| | **Hosting** | Puter.js | | |
| | **Weights** | Not publicly distributed | | |
| | **API** | Available through the MAI website | | |
| | **Commercial Use** | Contact MythicGames for licensing | | |
| --- | |
| <div align="center"> | |
| ### 🌌 *"The future of AI is here"* | |
| **Mythic Artificial Intelligence · MythicGames · 2026** | |
| </div> | |