OpenMythos: Reconstructing Claude’s Architecture from First Principles

**OpenMythos: Reconstructing Claude Mythos from First Principles**

If you’ve ever wondered how models like Claude feel so *deep* when they reason, OpenMythos is a fascinating place to explore that question.

OpenMythos is an independent, community-driven reconstruction of the suspected **Claude Mythos architecture**, built entirely from public research and careful speculation. It’s not affiliated with Anthropic, just passionate engineers reverse-engineering ideas in the open. You can explore the full project here:
https://github.com/kyegomez/OpenMythos

At the heart of OpenMythos is something called a **Recurrent-Depth Transformer**, also known as a looped transformer. Instead of stacking hundreds of unique layers like a traditional model, it reuses the same layers multiple times in a single forward pass. Same weights. More loops. Deeper reasoning.

And here’s the interesting part… this isn’t chain-of-thought in the usual sense. There are no intermediate tokens printed out. The “thinking” happens silently, inside the model’s latent space. Each loop is like one step of reasoning, but it unfolds internally, not as visible text.

Why does that matter?

Because looping allows the model to handle problems it has never explicitly seen during training. For example, train it on 5-step reasoning tasks, then test it on 10-step tasks. A standard transformer struggles. A looped transformer can simply run more loops at inference time. It’s like giving the same brain more time to think.

OpenMythos also explores stability, which has historically been a major challenge for looped architectures. Using insights from dynamical systems theory, the project highlights how controlling the spectral radius of the recurrence matrix keeps training stable. That sounds technical, but the takeaway is simple: without constraints, the model “overthinks” and drifts. With the right structure, it converges cleanly.

There’s also a Mixture of Experts layer inside the recurrent block, which adds breadth to the depth. Different experts activate at different loop stages, so each pass through the loop can behave slightly differently, even with shared weights.

What I personally love about this project is that it makes advanced architecture ideas tangible. You’re not just reading theory, you can actually inspect and run the implementation.

And looking ahead, architectures like this hint at a future where capability doesn’t just come from more parameters. It comes from *smarter computation*. More adaptive depth. More flexible reasoning.

OpenMythos is a glimpse into that direction.