Reasoning Depth, Not Model Scale: The (Apparent) Rise of Recurrent-Depth Transformers

*Published by Gr4Ig, LLC*

*April 23, 2026*

*This briefing analyzes publicly available information as of April 23, 2026. Anthropic has not published Mythos architectural details; this analysis examines recurrent-depth transformers as the architecture most consistent with Mythos’s observed behavior.*

-----

## Executive Summary

The era of scaling language models through parameter accumulation is entering a critical inflection point. Anthropic’s Claude Mythos Preview — a model whose architecture remains undisclosed — displays capabilities consistent with a fundamental architectural shift: the move from stacking hundreds of unique transformer layers to iteratively applying shared weights through **recurrent-depth computation**.

This briefing examines:

1. **What recurrent-depth transformers are** and how they differ structurally from conventional dense transformers

2.. **Why Mythos matters** through concrete evidence of breakthrough capability in vulnerability discovery and exploitation

3.. **The architectural hypothesis**: How recurrent-depth design could produce the reasoning behavior Mythos displays

4.. **What enterprises must do** to prepare for this architectural paradigm in the next 12–18 months

5.. **The scaling implications**: A cost model shift from training-time parameters to inference-time reasoning depth

**Key finding**: Emerging empirical results suggest a 770M-parameter recurrent-depth transformer can match the performance of a 1.3B standard transformer on identical training data — a ~40% reduction in parameter overhead. These claims are still being replicated across the research community, but the direction is clear: reasoning depth is becoming a variable, inference-time cost dimension, fundamentally altering the economics of frontier AI deployment.

-----

## Part I: The Architecture Question — What Makes Recurrent-Depth Different?

### Standard Transformers: Sequential Layers, Fixed Computation

In conventional transformer architectures (GPT, LLaMA, Mistral, Claude Opus), the model architecture is straightforward: input tokens flow sequentially through dozens or hundreds of distinct layers, each with independent weights. Each layer learns different aspects of representation. If you want more reasoning capacity, you add more layers — and proportionally more parameters.

A model with 96 layers has 96 times the transformer block parameters. A model with 200 layers has 200 times the parameters. The computation depth is hardwired into the parameter count.

### Recurrent-Depth Transformers: Weight Reuse Through Iteration

Recurrent-depth transformers (also called looped transformers) invert this relationship.

Instead of stacking unique layers, they apply **the same set of weights repeatedly** across multiple iterations within a single forward pass. The hidden state evolves across loops, but the underlying parameters remain constant.

The architecture has three functional stages:

**Prelude**: Standard transformer layers applied once to encode the initial input. Output becomes the “injection signal” `e` — a reference copy of the original encoded input.

**Recurrent Block**: The core looped computation. A single transformer block is applied up to L times (typically 4–16 iterations). At each loop step `t`:

$$h_{t+1} = A \cdot h_t + B \cdot e + \text{Transformer}(h_t, e)$$

Where:

- `h_t` is the hidden state at loop step `t`

- `e` is the injection signal from the Prelude (reinjected at every step)

- `A` and `B` are learned matrices controlling how much of the previous state and the original signal influence the next step

- `Transformer(h_t, e)` applies the shared transformer block

**Coda**: Standard transformer layers applied once to project the final hidden state to output logits.

### The Critical Insight: Same Weights, More Loops = Deeper Reasoning

The key behavioral distinction: **reasoning happens silently, in continuous latent space, across loop iterations — not by generating intermediate tokens**.

This is fundamentally different from chain-of-thought prompting. In CoT, a model “thinks” by generating explicit intermediate tokens:

```

User: Solve 7 × 8 + 12 ÷ 3

Assistant: Let me work through this step by step.

First, 7 × 8 = 56.

Then, 12 ÷ 3 = 4.

Finally, 56 + 4 = 60.

```

Every reasoning step is output. The model’s context window is consumed. You see the work.

In a recurrent-depth model, all of that multi-step reasoning happens internally — implicitly — without consuming the context window or emitting tokens. The model refines its latent representation across 16 loop iterations and outputs only the final answer.

This is **vertical reasoning** (deeper in latent space) rather than **horizontal reasoning** (longer in token sequence).

### Stability: How Recurrent-Depth Models Avoid Divergence

A natural concern: if you apply the same transformer block 16 times, won’t the hidden state explode or diverge?

Yes — unless stability mechanisms are engineered in.

The solution draws from dynamical systems theory. The recurrence update is recast as a **linear time-invariant (LTI) system** over the residual stream. Most attempts at looped transformers fail because the spectral radius ρ(A) of the update matrix exceeds 1.0, causing exponential divergence:

A 5% amplification per loop × 10 loops = 63% amplification per forward pass. This either explodes during training or produces outputs that don’t resemble language.

The stability fix — from the Parcae paper (Prairie et al., 2026) — constrains the update matrix so that ρ(A) < 1.0 strictly. The hidden state is guaranteed not to diverge. Three additional mechanisms round out stability:

- **LTI-constrained injection**: The reinjection of `e` at every loop step prevents signal drift and keeps the original input alive throughout recurrence.

- **Adaptive Computation Time (ACT) halting**: Per-token early exit allows the model to stop iterating when a token has converged.

- **Depth-wise LoRA adapters**: Each loop step gets a small learnable adapter (low-rank, separate from base weights) enabling per-iteration behavioral differentiation.

Together, these enable training stability without sacrificing the reasoning depth that looping provides.

-----

## Part II: The Mythos Shock Wave — Evidence at Scale

Anthropic announced Claude Mythos Preview on April 7, 2026. Unlike most model releases, which come with a technical paper, Mythos came with only a security evaluation report and a striking claim: the model autonomously discovered thousands of zero-day vulnerabilities — some over two decades old — in critical software that had evaded human review and automated fuzzing for years.

### The Numbers: A 90x Leap in Exploit Generation

**Direct comparison: Firefox 147 JavaScript engine vulnerabilities**

|Metric |Claude Opus 4.6|Claude Mythos Preview|Improvement|

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

|Exploits generated (out of several hundred attempts)|2 |181 |**90x** |

|Additional register control achieved |0 |29 |— |

*Note: “Register control” indicates an exploit achieved partial control over CPU registers — a precursor to full code execution. These numbers come from Anthropic’s Firefox 147 benchmark; later Firefox 150 testing against a much larger vulnerability set showed different proportions (see below).*

Opus 4.6 is Anthropic’s previous flagship. On the same test set, it succeeded twice. Mythos succeeded 181 times. That’s not a 10% improvement or a 2x improvement — it’s a fundamental leap.

**Internal benchmark: OSS-Fuzz corpus**

Anthropic runs models against ~1,000 entry points from the OSS-Fuzz corpus (open-source security test cases) and grades the worst crash each model produces on a five-tier severity ladder:

- Tier 1: Basic crash

- Tier 2–4: Increasing severity

- Tier 5: Complete control flow hijack

|Model |Tier 5 Exploits (out of ~1,000)|

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

|Claude Sonnet 4.6 |1 |

|Claude Opus 4.6 |1 |

|Claude Mythos Preview|10 |

### Ancient Vulnerabilities Exposed

Mythos didn’t just find new bugs. It surfaced security issues that had survived decades of human expertise and automated analysis:

**OpenBSD TCP SACK (27 years old)**

- A logic flaw in how TCP options interact under adversarial conditions

- Static analysis tools, fuzzers, and manual auditors all missed it

- Mythos cost: ~$20,000 in compute to discover

- Impact: Remote denial of service against any OpenBSD host

**FFmpeg H.264 codec (16 years old)**

- Introduced in a 2003 commit, exposed by a 2010 refactor

- Automated fuzzing exercised the vulnerable code path **5 million times** without triggering the flaw

- Requires semantic reasoning about code flow across multiple refactors

- Mythos cost: ~$10,000 to discover

- Impact: Integer overflow in video processing

**FreeBSD NFS RPC (17 years old)**

- CVE-2026-4747: Remote code execution granting unauthenticated root access

- Mythos autonomously constructed a 20-gadget ROP chain split across multiple packets

- No human involvement after the initial prompt

- Impact: Complete system compromise from the internet

### Firefox 150: 271 Zero-Days in One Release

Mozilla’s Firefox team collaborated with Anthropic over several weeks:

- **February 2026**: Used Claude Opus 4.6 to scan Firefox. Result: 22 vulnerabilities, fixes shipped in Firefox 148.

- **April 2026**: Applied Claude Mythos Preview to the same codebase. Result: **271 vulnerabilities**, fixes shipped in Firefox 150.

Within Firefox’s JavaScript shell alone (a subset of the larger 271-bug disclosure):

- Mythos turned 72.4% of identified vulnerabilities into successful exploits

- Achieved register control in a further 11.6% of attempts

This is the largest single batch of security fixes in Firefox’s history — not because Firefox suddenly became broken, but because whatever architecture Mythos uses, its reasoning depth enabled detection of flaws that were invisible to previous tools.

### Why This Matters: The Security Inflection

For decades, offense held the asymmetric advantage in cybersecurity. Attackers only needed to find **one** flaw; defenders had to guard **every inch** of a large, complex attack surface.

Mythos is closing that gap by enabling defenders to discover vulnerabilities quickly, systematically, and affordably.

A $20,000 Mythos discovery campaign that runs in hours replaces months of nation-state research effort. As security researcher Stanislav Fort noted, smaller models can already detect 80%+ of these vulnerabilities in zero-shot evaluation — but Mythos adds the capability to autonomously construct working exploits, chain together multiple flaws, and navigate complex memory corruption semantics.

This is not a marginal improvement. It is a capability transition.

-----

## Part III: The Architectural Hypothesis — How Recurrent-Depth Could Power This Breakthrough

Rather than speculate about Anthropic’s internals, this section examines what recurrent-depth transformers are *capable of*, based on published research and the OpenMythos reference implementation by Kye Gomez. Whether or not Mythos uses this architecture, the capabilities it displays are consistent with what recurrent-depth research predicts.

Within days of the Mythos announcement, Gomez released OpenMythos — an open-source theoretical reconstruction of what the Mythos architecture might be, built from published research. Its hypothesis: Mythos is a recurrent-depth transformer with mixture-of-experts routing. OpenMythos is informed speculation, not a leak. Its value is not in revealing Anthropic’s internals but in providing a concrete, testable implementation of the architecture class that recurrent-depth research increasingly points toward.

### Compositional Generalization: The Phase Transition

Traditional transformers struggle with **compositional generalization** — the ability to combine learned knowledge in novel ways.

Research on looped transformers identifies a three-stage learning process:

1. **Memorization**: Model fits the training distribution

2.. **In-distribution generalization**: Model handles known compositions

3. **Systematic generalization**: Model abruptly handles novel compositions unseen during training

That third stage is where vanilla transformers typically fail. If trained on reasoning chains up to 5 hops and tested on 10-hop chains, a standard transformer collapses. A looped transformer passes.

Critically: **The capability doesn’t emerge gradually. It phase-transitions in.**

This is consistent with an observed characteristic of Mythos: it feels qualitatively different on complex multi-step reasoning tasks. Not 20% better. Not 2x better. *Categorically* more capable at compositional tasks like vulnerability chaining, exploit construction, and multi-constraint reasoning.

### Multi-hop Reasoning in Latent Space

Vulnerability detection and exploitation require multi-step logical reasoning:

1. Parse the code structure

2.. Identify potential memory safety issues

3.. Determine exploitability constraints

4.. Construct a gadget chain to bypass mitigations

5.. Verify the exploit works

Each step depends on the previous. Each step involves reasoning through code semantics, architectural constraints, and adversarial strategies.

In a horizontal (CoT) model, this reasoning is externalized — token by token. It consumes the context window. The model’s intermediate steps are visible and limited by token generation speed.

In a recurrent-depth model, the same reasoning happens **implicitly**, loop by loop, in latent space. The hidden state is refined up to 16 times without consuming context. The model can reason more deeply because it’s not bottlenecked by token generation or context consumption.

### Parameter Efficiency: The Emerging Scaling Claim

OpenMythos cites the Parcae paper (Prairie et al., 2026) with an empirical result:

**A 770M-parameter recurrent-depth transformer matches a 1.3B-parameter standard transformer trained on identical data.**

That’s a ~40% reduction in parameters for equivalent performance — if the result holds up to broader replication. At the time of this writing, the Parcae claim has not been widely reproduced outside the original paper, so treat it as a directional signal rather than a settled fact.

The implication, *if the trend holds*: reasoning depth (loop count) is a more efficient scaling axis than parameter count. This flips the scaling debate from “how many parameters did you train?” to “how many loop iterations can you afford at inference time?”

Different questions enable different cost models. A customer willing to pay more for harder problems can allocate more loops. A customer optimizing for latency can allocate fewer. The same model serves both use cases.

### Convergence Across Labs

Notably, the architectural ingredients are not isolated to any single lab. Kimi K 2.6 (from Moonshot AI, released around the same period) independently employs the same components: mixture-of-experts with 384 experts, multi-head latent attention for KV cache efficiency, and multi-agent parallelism.

These ideas are converging. The research is pointing too consistently in this direction for it to be coincidence. Recurrent-depth with sparse MoE appears to be where the field is heading — regardless of what Mythos specifically turns out to be.

-----

## Part IV: What Companies Should Be Doing Now

Mythos was announced two weeks ago. OpenMythos reverse-engineering dropped four days ago. Firefox 150 shipped yesterday. The industry is in a state of vertigo.

This section is practical: what should you actually do between now and the point where Mythos-equivalent capabilities exist in open-source models?

### 1. Accelerate Your Security Scanning

**This is not optional.**

Within the next 12–18 months (per Wiz.io’s assessment — your mileage may vary), any organization with resources will be able to deploy Mythos-equivalent scanning against their codebase. Your zero-days will be found — defensively by your own team, or offensively by adversaries.

**Immediate actions:**

- **Inventory your critical code**: Which systems handle authentication, payment, kernel access, or data processing? These are tier-1 targets for both defense and offense.

- **Partner with security researchers**: Project Glasswing (Anthropic’s collaborative defense initiative) has partners including Microsoft, AWS, Apple, CrowdStrike, and Cisco. Even if you’re not a named partner, the playbook is public: scan your codebase with frontier models, responsibly disclose findings, patch aggressively.

- **Establish a patch velocity metric**: Traditionally, security is measured by vulnerability *prevention*. That’s becoming impossible. Measure your ability to *respond*. How fast can you patch? CrowdStrike’s 2026 report documents a 29-minute average breakout time — 65% faster than 2024. Speed is the new defense.

- **Test with available models now**: Opus 4.6 can detect 80%+ of zero-days in zero-shot evaluation. You don’t need Mythos to find serious flaws. Use what’s available now while you’re ahead of adversaries.

### 2. Prepare Your Infrastructure for Inference-Time Compute Variability

Recurrent-depth models change the inference picture. Loop count becomes a hyperparameter that varies by workload.

**Easy questions**: Fewer loops, lower latency, lower cost.

**Hard questions**: More loops, higher latency, higher cost.

**Security-critical tasks**: Maximum loops for maximum reasoning depth.

This requires infrastructure changes:

- **KV cache management**: Multi-Latent Attention (as used in Mythos speculation and Kimi K 2.6) compresses key-value tensors to low-rank representations, cutting KV memory 10–20x at production scale. Standard attention won’t cut it.

- **Early stopping strategies**: Adaptive Computation Time (ACT) allows per-token halting. Implement monitoring to know when tokens have converged. Don’t waste compute on certainty you already have.

- **Batching and queuing**: Variable-depth models are harder to batch than fixed-depth. Implement adaptive batching that groups similar-complexity requests.

- **Cost accounting**: Loop count is now a cost dimension. Budget per-loop compute separately. If you pay per inference, expect loop cost to dominate token cost for reasoning-heavy tasks.

### 3. Rethink Your Security Architecture

The asymmetry is inverting. **Vulnerability discovery is no longer the bottleneck. Patch velocity is.**

From a CrowdStrike perspective: “Adversaries leveraging agentic AI can perform attacks at such speed that a traditional human process — look at alert, triage, investigate for 15–20 minutes, take action an hour/day/week later — is insufficient.”

New security architecture principles:

- **Assume compromise**: Your software will have flaws. Frontier models will find them. Plan accordingly.

- **Defense-in-depth, rebuilt**: Sandbox, process isolation, memory tagging, capability restrictions — every layer matters because attackers will have better exploit chains.

- **Automated patching pipelines**: Manual patch management won’t scale. Implement CI/CD that can validate and deploy patches in minutes, not days.

- **Runtime monitoring for exploit behavior**: Static detection (finding the bug) is losing ground to dynamic detection (catching the exploit in action). Invest in behavioral monitoring, not just signature-based IDS.

### 4. Evaluate Your LLM Deployment Model

The cost structure of frontier AI is shifting. Parameter efficiency (via looping) changes the economics:

**Old model:**

- Train a 100B+ parameter model (expensive, months-long)

- Deploy it (expensive, high memory, high latency, fixed reasoning depth)

- Pay per token generated

**New model:**

- Train a smaller looped model (cheaper, faster)

- Deploy it (cheap, low memory, variable latency)

- Pay per loop iteration (reasoning depth varies by workload)

If you’re currently using frontier models (Claude Opus, GPT-4-class, Gemini Ultra-class) for reasoning-heavy tasks:

- Plan to monitor loop count as a cost dimension when recurrent-depth models become available in production

- Quantify which tasks actually need frontier reasoning vs. which could use cheaper models with early stopping

- Build cost models that account for loop depth, not just token count

### 5. Hiring and Skill Development

Recurrent-depth reasoning is not something you evaluate with existing benchmarks.

**New evaluation requirements:**

- **Compositional reasoning evals**: Can the model handle 10-hop reasoning when trained on 5-hop? Standard MMLU won’t tell you.

- **Exploit construction**: Can it chain together multiple vulnerabilities? This requires model evaluation you probably haven’t done.

- **Depth-variable evals**: Measure performance across different loop counts. Some tasks might need 4 loops; others need 16. Which is which?

**Hiring implications:**

- You need people who understand dynamical systems and looped computation (rare)

- You need security researchers who can judge whether a model-generated exploit actually works (expensive)

- You need ML engineers who can optimize variable-depth inference (new specialty)

-----

## Part V: The Scaling Implications and Competitive Dynamics

### From Training Parameters to Inference Loops

The scaling debate is about to shift.

For the past several years, the conversation has centered on model size: GPT-3 (175B), Llama-2 (70B), Claude Opus (~100B estimate), GPT-4 (estimated in the trillions of total parameters across its MoE architecture).

Larger models = more parameters = more capability. More parameters also meant more training compute, more inference cost, and harder deployment.

Recurrent-depth architectures invert the pressure. If a smaller model with looping can match a larger dense model, where does scaling go next?

**The hypothesis**: frontier labs will scale loop count as aggressively as they scaled parameter count. A 2B looped model might provide reasoning equivalent to a 10B dense model — but you only pay for those loop iterations when you need them.

This fundamentally changes:

- **Training cost**: You train once, smaller. Inference cost varies.

- **Deployment cost**: Memory footprint doesn’t grow with reasoning depth.

- **Inference latency**: Latency varies by loop count, not fixed by layer count.

- **Cost per transaction**: Complex reasoning tasks pay more; simple tasks pay less. Markets can differentiate.

### Convergence Across Frontier Labs

Evidence that this isn’t a Mythos-specific phenomenon:

- **DeepSeek**: R1 model uses multi-hop reasoning and test-time compute scaling

- **Google**: Thinking mode in Gemini explores similar latent space reasoning

- **OpenAI**: o1 and beyond are explicitly scaling test-time compute

- **Open-source**: Qwen3, Moonshot’s Kimi K 2.6 — all employing MoE + latent attention

The architectural pieces are converging:

1. Mixture-of-Experts (sparse, fine-grained routing)

2.. Multi-head Latent Attention (compressed KV )

3.. Looped/recurrent computation (shared weights, iterative refinement)

4.. Latent-space reasoning (no intermediate token output)

No lab has published these as an integrated system yet. Mythos is suspected but not confirmed. But the parts are all published, all proven, and all pointing in the same direction.

### The 12–18 Month Timeline

Security firm Wiz.io estimates 12–18 months until Mythos-equivalent capabilities reach open-source models available to everyone. Whether that timeline holds precisely, the window is shorter than most organizations are prepared for.

**What Wiz.io’s timeline implies:**

- By Q3 2027: Open-source looped transformers with MoE will exist on GitHub

- By Q4 2027: Any organization can run Mythos-equivalent vulnerability scanning locally

- By 2028: Security-as-you-know-it requires a fundamentally different posture

Other analysts may disagree on specific dates. The point is not the precision; it is the direction and the order of magnitude. If you haven’t started security hardening, you’re behind — regardless of whether the curve arrives in 12 months or 24.

-----

## Part VI: Key Uncertainties and Open Questions

### What Exactly Is Mythos?

Anthropic has released no technical paper. The OpenMythos reconstruction is informed speculation, not a leak. It could be:

- **Correct**: Mythos is indeed a recurrent-depth transformer with MoE, and OpenMythos is a reasonable approximation

- **Partially correct**: Mythos uses some of these techniques but not others, or combines them differently

- **Wrong**: Mythos uses a completely different architecture, and these guesses are educated but ultimately misleading

The honest answer: we don’t know. Anthropic’s silence is strategic. The company has said nothing concrete about how Mythos works.

### Does Recurrent-Depth Fully Explain the Breakthrough?

Even if Mythos is a looped transformer, that doesn’t automatically explain the security breakthrough. Multiple factors could contribute:

- **Better training data**: Perhaps Anthropic trained on more security-focused examples

- **Better alignment/RLHF**: Perhaps safety training inadvertently improved reasoning

- **Hybrid architecture**: Perhaps Mythos combines recurrence with other components we don’t know about

- **Architectural + scaling**: Perhaps the loop is real, but the size of the model also matters

The safest claim: looped transformers are **consistent with** the observed Mythos behavior, but not necessarily the sole cause.

### Overthinking: The Failure Mode

Research on looped transformers identifies a failure mode called “overthinking.” Excessive recurrence degrades predictions and limits generalization to deeper compositions.

There’s a sweet spot for loop count. Too few loops and you don’t get reasoning depth. Too many loops and you degrade. How do you find that spot?

This is an open problem. Mythos presumably solved it (or limits loop count appropriately). But this represents an engineering challenge, not a guaranteed free lunch.

### Patching the Gap: Adversarial Timing

Wiz.io’s 12–18 month estimate implies a dangerous intermediate period:

- **Now to 6 months**: Only frontier labs can find vulnerabilities at scale. Defenders with frontier access have an advantage.

- **6–12 months**: Frontier capabilities start leaking or being replicated. First adversaries gain access.

- **12–18 months**: Open-source equivalents exist. Attackers scale.

That window is real and closing. Move fast.

-----

## Part VII: Conclusion — Preparation Over Panic

The announcement of Mythos, the racing reaction from the research community, and the Firefox 150 release with 271 fixes represent a watershed moment. Not because the threat is new, but because the *speed and scale* of threat detection has fundamentally changed.

Three key principles should guide your response:

### 1. The Same Capabilities Defend and Offend

Anthropic emphasizes this: “The same improvements that make the model substantially more effective at patching vulnerabilities also make it substantially more effective at exploiting them.”

This is not new — it’s true of every security tool from fuzzers to static analysis. The solution is not to avoid the technology; it’s to ensure defenders get it first.

Project Glasswing ($100M in usage credits, $4M in open-source grants) is Anthropic’s bet that defenders can stay ahead. The evidence so far is promising: Firefox 150 fixed 271 bugs *before* attackers weaponized them.

### 2. The Window Is Real and Closing

Wiz.io’s **12–18 month** estimate until Mythos-equivalent capabilities reach open-source models may prove optimistic or pessimistic. Either way, that’s not very long to:

- Audit your critical code

- Establish automated patching pipelines

- Redesign your security architecture for a world where vulnerability discovery is not the bottleneck

- Hire and train teams that can work with depth-variable reasoning models

You don’t need to panic. But you do need to move.

### 3. Architecture Matters

This briefing started with a technical claim: recurrent-depth transformers achieve reasoning depth without parameter inflation. That’s not an academic nicety — it’s the foundation of a cost model that makes frontier AI capabilities deployable and scalable.

As a technology leader, you should:

- Understand the difference between horizontal (CoT) and vertical (latent) reasoning

- Know why loop count matters for inference cost

- Be able to evaluate whether recurrent-depth models make sense for your workloads

- Plan for a world where “model size” is decoupled from “reasoning depth”

The architecture is the strategy.

-----

## Appendix: For Further Reading

**On Recurrent-Depth Transformers:**

- Geiping et al. (2025): “Thinking Deeper, Not Longer: Depth-Recurrent Transformers for Compositional Generalization”

- Wang et al. (2025): “Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach”

- Saunshi et al. (2025): “Towards revealing the mystery behind chain of thought”

**On Mythos and Security:**

- Anthropic Red Team (2026): “Claude Mythos Preview: Technical Evaluation” (red.anthropic.com/2026/mythos-preview/)

- Anthropic (2026): “Project Glasswing: Securing Critical Software for the AI Era” (anthropic.com/glasswing)

- Mozilla Security Blog (2026): “The Zero-Days Are Numbered”

**On Open Implementations:**

- Kye Gomez (2026): OpenMythos — PyTorch reconstruction (github.com/kyegomez/OpenMythos)

**On Emerging Architectures:**

- Parcae / Prairie et al. (2026): Empirical scaling laws for recurrent-depth models

- Chojecki (2025): “Going Beyond LLMs & Transformers: Emerging Architectures for Efficient Large Language Models in 2026”

-----

**About the Author**

Greg Cooper is founder and CTO of Gr4Ig, LLC, an AI research and innovation company focused on agentic systems, persistent memory infrastructure, and thought leadership in AI agent architecture. This briefing represents independent analysis and is published under the Gr4Ig brand.

*This document is published on gr4ig.substack.com and gr4ig.com. Feedback and discussion welcome.*

-----

## Transparency Statement: AI Assistance in Research and Writing

This briefing was developed with Claude (Anthropic) as a research partner. The Gr4Ig AI agent team contributed to literature search, synthesis of technical sources, fact-checking against published research, and editorial refinement. All claims have been verified against primary sources and are cited. This document represents a vendor-neutral assessment of recurrent-depth transformer architectures and emerging AI capabilities. The analysis was conducted independently and does not reflect endorsement by any particular AI vendor or architecture choice, though Mythos (Anthropic) serves as the primary case study due to public availability of technical evaluation data.