🔥 MythosForge

Recurrent-Depth Transformer Research Lab

Laboratorio de investigación sobre transformers recurrentes en profundidad, razonamiento latente, MoE, atención MLA/GQA, inyección LTI estable y halting adaptativo.

🌐 Demo en Vivo · 📖 Guía Técnica · 🐍 Quickstart · 🔧 Parche LTI · 📋 Changelog

⚠️ Aviso clave: OpenMythos se presenta explícitamente como una reconstrucción teórica independiente, no afiliada a Anthropic. MythosForge es un laboratorio de experimentación arquitectónica, no una réplica confirmada de Claude Mythos.

📸 Capturas de Pantalla

Español (ES)

Hero & Navegación

Diagrama de Arquitectura

Componentes Arquitectónicos

Validación Práctica

Guía Rápida

Archivos Descargables

Hoja de Ruta

Bibliografía

English (EN)

Hero Section (EN)

🧠 ¿Qué es MythosForge?

MythosForge es un laboratorio de investigación abierto que documenta, valida y extiende el repositorio público OpenMythos como base seria de experimentación en arquitecturas de transformers recurrentes.

La hipótesis central que investigamos: la profundidad útil no tiene por qué venir de apilar capas distintas. Puede venir de aplicar varias veces el mismo bloque compartido durante un único forward, reinyectando la representación codificada del input.

¿Qué Sí Hacemos?

Capacidad	Estado
Replicar el repositorio y ejecutarlo	✅ Validado
Documentar la arquitectura completa	✅ Completado
Inferencia mínima con GQA y MLA	✅ Verificado
Proporcionar parche de estabilidad LTI	✅ Disponible
API PyTorch propia (mythosforge)	✅ 30/30 tests
API REST profesional (FastAPI)	✅ 39/39 tests
Auth, métricas, CORS seguro	✅ v0.5.0
Servir como base de investigación seria	✅ Activo

¿Qué NO Afirmamos?

Aserción	Realidad
Es una réplica de Claude Mythos	❌ Es una reconstrucción teórica independiente
Tiene pesos preentrenados	❌ No publica checkpoints
Equivalencia con Anthropic	❌ No afiliada ni demostrada

🏗️ Arquitectura — Prelude → Recurrent Block → Coda

Input Tokens
     │
     ▼
┌─────────────┐
│   PRELUDE   │  Bloque Transformer denso · FFN SwiGLU · 1× ejecución
└──────┬──────┘
       │ h₀
       ▼
┌─────────────────────────────────────────────┐
│           RECURRENT BLOCK (×N loops)         │
│  ┌───────────────────────────────────────┐  │
│  │  Switchable Attention (MLA / GQA)     │  │
│  │  MoE FFN (Routed + Shared Experts)    │  │
│  │  LoRA Adapter (per-iteration)         │  │
│  │  LTI Injection (stable A ∈ (0,1))     │  │
│  │  ACT Halting (per-position stopping)  │  │
│  └───────────────────────────────────────┘  │
│                    │ ↺ LOOP                  │
└────────────────────┼────────────────────────┘
                     │ h_T
                     ▼
┌─────────────┐
│    CODA     │  Bloque Transformer denso · FFN SwiGLU · 1× ejecución
└──────┬──────┘
       │
       ▼
  RMSNorm → LM Head → Output Logits

Regla Recurrente

El razonamiento intermedio se acumula en el estado oculto h_t:

h_(t+1) = A · h_t + B · e + Transformer(h_t, e)

Donde A ∈ (0,1) garantiza estabilidad espectral por construcción paramétrica.

⚙️ Componentes Técnicos

🔮 Atención Conmutable MLA / GQA

GQA: Reduce la caché KV compartiendo pares K/V entre grupos de cabezas de consulta. Menor overhead, más rápido.
MLA: Comprime la ruta KV en un latente de bajo rango y reconstruye K/V al vuelo. Más ambicioso y con mayor compresión de memoria.
Conmutable mediante configuración: attn_type="gqa" o attn_type="mla".

Referencias: DeepSeek-V2 (MLA), GQA

🧩 Mixture of Experts (MoE)

Routed experts top-K + shared experts siempre activos.
Hereda de DeepSeekMoE la segmentación fina y el aislamiento de expertos compartidos.
Maximiza la relación rendimiento/cómputo dentro del bloque recurrente.

🛡️ Inyección LTI Estable

Linear Time-Invariance injection con parametrización log-space.
Garantiza A ∈ (0,1) por construcción, manteniendo estabilidad espectral.
Parche numérico incluido: evita saturación float32 en el borde de 1.0.

def get_A(self) -> torch.Tensor:
    A = torch.exp(-torch.exp((self.log_dt + self.log_A).clamp(-20, 20)))
    return torch.minimum(
        A,
        torch.nextafter(torch.ones_like(A), torch.zeros_like(A)),
    )

Referencia: Parcae

⚡ ACT — Adaptive Computation Time

Aprende una probabilidad de halting por posición de secuencia.
Permite que algunas posiciones dejen de acumular actualizaciones antes que otras.
Optimiza el cómputo de inferencia de forma adaptativa.

Referencia: ACT (Graves, 2016)

🔄 Adaptador LoRA por Iteración

Cada iteración del bucle puede modificar su comportamiento con un adaptador LoRA dependiente de la iteración.
Enriquece la representación sin multiplicar parámetros estáticos.
Señal de profundidad mediante embedding sinusoidal de índice de loop.

✅ Validación Práctica

Ejecutado localmente en CPU con PyTorch 2.11.0+cpu y configuraciones pequeñas.

Chequeo	Resultado
Import y construcción del modelo	✅ Correcto
Forward mínimo con GQA	✅ Correcto
Forward mínimo con MLA	✅ Correcto
Generación mínima autoregresiva	✅ Correcta
Matriz A de LTI en rango estable	✅ Correcto
Tests mythosforge (30/30)	✅ Todos pasados
Demo GQA + MLA + comparativa	✅ Correcta
API REST tests (39/39)	✅ Todos pasados
`test_spectral_radius_stable_after_large_grad_step`	⚠️ Fallo numérico (parcheado)

Hallazgo Importante

La prueba test_spectral_radius_stable_after_large_grad_step falla porque A.max() puede redondear a 1.0 en float32 tras un paso de SGD extremo. El parche incluido (openmythos_lti_patch.diff) resuelve esto sin alterar la arquitectura.

🚀 Guía Rápida

1. Preparación del entorno

git clone https://github.com/kyegomez/OpenMythos.git
cd OpenMythos
python -m venv .venv
source .venv/bin/activate
python -m pip install -U pip
pip install -r requirements.txt

2. Arranque rápido

python example.py
# o con verificación compacta:
python openmythos_quickstart.py

3. Validación

pytest -q
# Para excluir el fallo numérico conocido:
pytest -q -k "not test_spectral_radius_stable_after_large_grad_step"

4. Aplicar parche de estabilidad LTI

git apply openmythos_lti_patch.diff

🧬 API PyTorch — `mythosforge`

Implementación puramente PyTorch, autocontenida y sin dependencias externas de ML. Cada componente es un módulo aislado, testeable y conmutable.

Instalación

pip install torch  # única dependencia
git clone https://github.com/smouj/MythosForge.git
cd MythosForge
export PYTHONPATH=src

Uso mínimo — 3 líneas

from mythosforge import OpenMythos, MythosConfig

cfg = MythosConfig(vocab_size=256, dim=64, n_heads=4, n_kv_heads=4,
                    max_seq_len=64, max_loop_iters=4, attn_type="gqa")
model = OpenMythos(cfg).eval()
logits = model(torch.randint(0, 256, (1, 8)), n_loops=4)

Cambiar a MLA

cfg = MythosConfig(..., attn_type="mla", kv_lora_rank=64,
                    q_lora_rank=128, qk_rope_head_dim=64,
                    qk_nope_head_dim=128, v_head_dim=128)
model = OpenMythos(cfg)

Generación autoregresiva

generated = model.generate(prompt_ids, max_new_tokens=32, n_loops=4,
                           temperature=0.8, top_k=50)

Ejecutar tests (30 tests)

python -m pytest tests/test_mythosforge.py -v

Ejecutar demo completa

PYTHONPATH=src python src/mythosforge_demo.py

Estructura del paquete

src/mythosforge/
├── __init__.py        # API pública: OpenMythos, MythosConfig
├── config.py          # MythosConfig — hyperparámetros centralizados
├── attention.py       # GroupedQueryAttention + MultiLatentAttention
├── moe.py             # MoELayer — routed + shared experts (DeepSeekMoE)
├── lti.py             # LTIInjection — estado recurrente A ∈ (0,1)
├── act.py             # AdaptiveComputationTime — halting por posición
├── block.py           # RecurrentBlock + LoRAAdapter + DepthSignal
├── model.py           # OpenMythos — Prelude → Recurrent(×N) → Coda
└── utils.py           # RMSNorm, SwiGLU, RotaryEmbedding, helpers

🌐 API REST (v0.5.0)

MythosForge incluye una API REST profesional construida con FastAPI. Arquitectura en capas con routers separados, error handling seguro, autenticación opcional, métricas y 39 tests de integración.

Arranque rápido

pip install -r api/requirements.txt
python -m api
# → http://localhost:8000/docs (Swagger UI)

Configuración

Todas las opciones se configuran mediante variables de entorno con prefijo MYTHOSFORGE_:

# Copiar y editar configuración
cp .env.example .env

# Configurar desde entorno
export MYTHOSFORGE_ENV=production
export MYTHOSFORGE_AUTH_ENABLED=true
export MYTHOSFORGE_API_KEYS='["mf_your_key_here"]'
export MYTHOSFORGE_CORS_ORIGINS='["https://yourdomain.com"]'

Endpoints principales

Método	Endpoint	Descripción
`GET`	`/`	API root con links a endpoints
`GET`	`/api/v1/health`	Estado del servicio y dependencias
`GET`	`/api/v1/metrics`	Métricas (counters, histograms)
`GET`	`/api/v1/info`	Información del proyecto
`GET`	`/api/v1/architecture`	Arquitectura completa
`GET`	`/api/v1/components`	Componentes arquitectónicos
`GET`	`/api/v1/components/{slug}`	Componente específico
`GET`	`/api/v1/validation`	Resultados de validación
`GET`	`/api/v1/roadmap`	Hoja de ruta
`GET`	`/api/v1/references`	Referencias académicas
`GET`	`/api/v1/i18n/{lang}`	Traducciones (es/en)
`POST`	`/api/v1/inference`	Inferencia con mythosforge
`GET`	`/api/v1/inference/status`	Estado de dependencias de inferencia

Seguridad

Feature	Detalle
CORS	Restringido a allowlist (no wildcard)
Error handling	Sin leaks de detalles internos
Request ID	`X-Request-ID` en todas las respuestas
Auth	API key opcional (Bearer / X-API-Key)
Metrics	Endpoint protegido, desactivable

Inferencia real

# Instalar PyTorch
pip install torch --index-url https://download.pytorch.org/whl/cpu

# Ejecutar inferencia
curl -X POST http://localhost:8000/api/v1/inference \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Test", "attn_type": "gqa", "n_loops": 4}'

Docker

# Modo datos (ligero)
docker build -f api/Dockerfile -t mythosforge-api .
docker run -p 8000:8000 mythosforge-api

# Modo completo con inferencia
docker build -f api/Dockerfile.full -t mythosforge-api-full .
docker run -p 8000:8000 mythosforge-api-full

📂 Estructura del Repositorio

MythosForge/
├── api/
│   ├── __init__.py              # Paquete API (v0.5.0)
│   ├── __main__.py              # python -m api (arranque directo)
│   ├── app.py                   # FastAPI app — CORS, middleware, system routes
│   ├── settings.py              # Pydantic Settings — env config (MYTHOSFORGE_*)
│   ├── errors.py                # Safe error handlers — no detail leaks
│   ├── deps.py                  # FastAPI dependencies (health builder)
│   ├── models.py                # Schemas Pydantic v2
│   ├── data.py                  # Datos reales del proyecto (catálogo estático)
│   ├── routers/
│   │   ├── public.py            # Catálogo: info, arch, components, refs, i18n
│   │   └── inference.py         # Inferencia con mythosforge
│   ├── security/
│   │   └── auth.py              # API key auth (Bearer / X-API-Key)
│   ├── observability/
│   │   └── metrics.py           # In-process metrics registry
│   ├── tests/
│   │   └── test_api.py          # 39 integration tests (TestClient)
│   ├── requirements.txt          # Dependencias API
│   ├── Dockerfile               # Docker (modo datos)
│   ├── Dockerfile.full          # Docker (inferencia completa)
│   └── README.md                # Documentación API
├── docs/
│   ├── index.html              # GitHub Pages — Landing estática (i18n ES/EN)
│   ├── i18n.js                  # Motor de traducciones ES/EN (~170 claves)
│   ├── assets/
│   │   └── style.css           # Estilos profesionales (dark theme)
│   └── images/                  # Logo, favicon, banner, screenshots
├── src/
│   ├── mythosforge/             # Paquete PyTorch (implementación propia)
│   │   ├── __init__.py          # API pública
│   │   ├── config.py            # MythosConfig
│   │   ├── attention.py         # GQA + MLA switchable
│   │   ├── moe.py               # MoE (routed + shared)
│   │   ├── lti.py               # LTI state injection
│   │   ├── act.py               # Adaptive Computation Time
│   │   ├── block.py             # RecurrentBlock + LoRA
│   │   ├── model.py             # OpenMythos full model
│   │   └── utils.py             # RMSNorm, SwiGLU, RoPE
│   ├── mythosforge_demo.py      # Demo completa GQA + MLA
│   ├── OpenMythos_Guia_Tecnica_2026.pdf  # Guía técnica completa
│   ├── OpenMythos_Guia_Tecnica_2026.docx  # Versión editable
│   ├── openmythos_quickstart.py # Script de verificación (OpenMythos ext.)
│   └── openmythos_lti_patch.diff # Parche de estabilidad LTI
├── tests/
│   └── test_mythosforge.py      # 30 tests — todos los componentes
├── .github/
│   ├── CODEOWNERS               # Responsables de revisión por área
│   ├── FUNDING.yml              # GitHub Sponsors
│   ├── dependabot.yml           # Actualización automática de dependencias
│   ├── workflows/
│   │   └── pages.yml            # CI/CD: lint + tests + deploy
│   ├── ISSUE_TEMPLATE/          # Templates para issues
│   └── PULL_REQUEST_TEMPLATE/   # Template para PRs
├── .env.example                 # Variables de configuración documentadas
├── pyproject.toml               # Dependencias fijadas + tool config
├── CHANGELOG.md                 # Historial de versiones
├── CONTRIBUTING.md              # Guía de contribuciones
├── SECURITY.md                  # Política de seguridad
├── LICENSE                      # Licencia MIT
├── README.md                    # Este archivo
└── .gitignore                   # Git ignore rules

🗺️ Hoja de Ruta

Fase	Objetivo	Estado
0	Congelar versión (fork, tag, requirements-lock)	✅
1	Corregir estabilidad operativa (parche LTI)	✅
2	Añadir empaquetado (pyproject.toml, CLI)	✅ mythosforge
3	Tokenizer y datos (tokenizer, dataset, causal LM)	🔲
4	Entrenamiento mínimo (train.py, warmup, checkpoints)	🔲
5	Benchmarks (curvas vs loops, GQA vs MLA, ablations)	🔲
6	Publicación y comparativa (vs transformers densos)	🔲

🎯 Preguntas de Investigación

¿Cuánto razonamiento extra aporta el looping en inferencia? — Medir ganancia al aumentar n_loops, comparar contra transformer denso de igual presupuesto.
¿Cuándo MLA merece la complejidad frente a GQA? — Latencia, memoria y calidad para determinar el punto de inflexión.
¿Si MoE dentro de un bloque recurrente mejora rendimiento/cómputo? — Distribución de expertos por loop, especialización efectiva, comparación vs FFN denso.

📚 Bibliografía

ID	Referencia	Enlace
R1	OpenMythos README	GitHub
R2	OpenMythos docs	GitHub
R3	Thread — Kye Gomez	ThreadReader
R4	Loop, Think, & Generalize	arXiv:2604.07822
R5	Parcae: Scaling Laws for Looped LMs	arXiv:2604.12946
R6	Reasoning with Latent Thoughts	arXiv:2502.17416
R7	Coconut: Continuous Latent Reasoning	arXiv:2412.06769
R8	DeepSeek-V2 (MLA)	arXiv:2405.04434
R9	GQA	arXiv:2305.13245
R10	DeepSeekMoE	arXiv:2401.06066
R11	Universal Transformers	arXiv:1807.03819
R12	Adaptive Computation Time	arXiv:1603.08983

🤝 Contribuciones

Este proyecto es un laboratorio de investigación abierto. Las contribuciones son bienvenidas en forma de:

🧪 Experimentos y benchmarks reproducibles
📝 Documentación y análisis técnico
🐛 Patches de estabilidad y optimización
📊 Visualizaciones y herramientas de diagnóstico

Por favor, abre un Issue para discutir cualquier propuesta antes de enviar un PR.

⚖️ Licencia

Este proyecto se distribuye bajo la licencia MIT. Ver LICENSE para más detalles.

El repositorio original OpenMythos también se distribuye bajo licencia MIT.

Creado por Smouj013 con agentes de IA

Documento técnico independiente — Abril 2026

Name		Name	Last commit message	Last commit date
Latest commit History 17 Commits
.github		.github
api		api
docs		docs
src		src
tests		tests
.env.example		.env.example
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
SECURITY.md		SECURITY.md
pyproject.toml		pyproject.toml
run_api.py		run_api.py
run_api.sh		run_api.sh

Folders and files

Latest commit

History

Repository files navigation

🔥 MythosForge

📸 Capturas de Pantalla

Hero & Navegación

Diagrama de Arquitectura

Componentes Arquitectónicos

Validación Práctica

Guía Rápida

Archivos Descargables

Hoja de Ruta

Bibliografía

Hero Section (EN)

🧠 ¿Qué es MythosForge?

¿Qué Sí Hacemos?

¿Qué NO Afirmamos?

🏗️ Arquitectura — Prelude → Recurrent Block → Coda

Regla Recurrente

⚙️ Componentes Técnicos

✅ Validación Práctica

Hallazgo Importante

🚀 Guía Rápida

1. Preparación del entorno

2. Arranque rápido

3. Validación

4. Aplicar parche de estabilidad LTI

🧬 API PyTorch — mythosforge

Instalación

Uso mínimo — 3 líneas

Cambiar a MLA

Generación autoregresiva

Ejecutar tests (30 tests)

Ejecutar demo completa

Estructura del paquete

🌐 API REST (v0.5.0)

Arranque rápido

Configuración

Endpoints principales

Seguridad

Inferencia real

Docker

📂 Estructura del Repositorio

🗺️ Hoja de Ruta

🎯 Preguntas de Investigación

📚 Bibliografía

🤝 Contribuciones

⚖️ Licencia

About

Topics

Resources

License

Contributing

Security policy

Uh oh!

Stars

Watchers

Forks

Releases 1

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

🧬 API PyTorch — `mythosforge`

Packages