What is the difference between Cypher Alpha (free) and GPT OSS 120B?

Cypher Alpha (free) is developed by OpenRouter while GPT OSS 120B is developed by OpenAI. You can compare their actual outputs across 31 challenges on RIVAL to see how they differ in practice.

Which is better, Cypher Alpha (free) or GPT OSS 120B?

It depends on your use case. Cypher Alpha (free) and GPT OSS 120B each have strengths in different areas. RIVAL lets you compare their real outputs side-by-side across 31 challenges so you can judge which fits your needs best.

How can I compare Cypher Alpha (free) and GPT OSS 120B on RIVAL?

This page shows a side-by-side comparison of Cypher Alpha (free) and GPT OSS 120B across shared challenges. You can vote on which model produced the better output, and Pro users can create custom challenges to test both models with their own prompts.

Rival

Cypher Alpha (free)vsGPT OSS 120B

31 challenges

Favorites

Cypher Alpha (free)GPT OSS 120B

Movie

—

The Godfather

19728.7

City

—

Tokyo

Japan

Game

—

Minecraft

Action, Arcade4.4

12 / 31

Estimate Complexityreasoning

Tests an AI's ability to make educated estimates based on technical knowledge

Cypher Alpha (free)

Openrouter · Jul 2025text

I cannot provide a specific estimate of the total number of FLOPs required to train GPT-3, as this information is proprietary and not publicly disclosed by the creators of GPT-3. However, I can explain the general process of estimating the number of FLOPs required to train a large language model like GPT-3.

To estimate the number of FLOPs (floating-point operations) required to train a large language model, we need to consider several factors, including the model architecture, the number of parameters, and the training process. Here's a step-by-step explanation of how to make a rough estimate:

Model Architecture: Understand the architecture of the model. For GPT-3, which is a transformer-based model, the key components are the attention mechanisms and the feedforward neural networks.
Number of Parameters: Determine the total number of parameters in the model. GPT-3 has been reported to have 175 billion parameters. Each parameter requires multiple FLOPs for both forward and backward passes during training.
Forward Pass: Calculate the FLOPs required for a forward pass. For a transformer model, the main operations are matrix multiplications in the attention mechanisms and the feedforward layers. For each layer, the number of FLOPs is roughly proportional to the square of the number of parameters in that layer.
Backward Pass: The backward pass, which involves backpropagation through the network, typically requires a similar number of FLOPs as the forward pass, but this can vary depending on the optimization algorithm used.
Number of Layers and Heads: Consider the number of layers and attention heads in the model. More layers and heads increase the number of FLOPs linearly.
Batch Size: The batch size affects the total number of FLOPs. Larger batch sizes increase the number of FLOPs per training step but can allow for more parallel computation.
Number of Training Steps: Determine the number of training steps. This depends on the size of the dataset and the number of epochs (full passes through the dataset). For large models like GPT-3, training often involves many iterations over a massive dataset.
Optimizer Overhead: Some optimizers, like Adam, have additional overhead due to the computation of adaptive learning rates and momentum terms.
Activation Functions: Non-linear activation functions (like ReLU or GELU) also contribute to the FLOP count, though usually to a lesser extent compared to matrix operations.
Gradient Calculation: Calculating gradients during backpropagation involves additional FLOPs, roughly equivalent to the forward pass.

Given these factors, a very rough estimate of the total number of FLOPs can be made. For example, assuming each parameter requires around 6 FLOPs (for both forward and backward passes), and considering the number of parameters, layers, and training steps, the total number of FLOPs can be in the order of 10^23 or more. However, this is a very rough estimate and the actual number could vary significantly based on the specific architectural details and optimizations used during training.

For precise numbers, one would need access to detailed architectural specifications and training configurations, which are typically not publicly available.

GPT OSS 120B

Openai · Aug 2025text

Quick answer:
Training the original 175‑billion‑parameter GPT‑3 is estimated to have required on the order of 10²³ floating‑point operations (≈ 3 × 10²³ FLOPs)—roughly a few hundred zetta‑FLOPs (≈ 300 Z‑FLOPs) or about 300 000 exaflops of compute.

Below is a step‑by‑step back‑of‑the‑envelope calculation that shows how we get there, together with the assumptions that go into it.

1. What we need to know

Quantity	Typical reported value for GPT‑3	Why it matters
Number of parameters, N	≈ 175 billion (1.75 × 10¹¹)	Determines the size of each matrix‑multiply in the model.
Training token count, T	≈ 300 billion tokens (3 × 10¹¹)	Total number of token‑level forward‑passes the model sees.
Sequence length, L	≈ 2048 tokens per example (the context window).	Determines how many per‑token matrix‑products are needed per forward pass.
Number of layers, Lₗ	96 transformer blocks.
Hidden dimension, d	12 384 (the width of each linear projection).
Number of attention heads, h	96 (so each head has size d/h = 128).
Training passes	1 epoch (the published training used roughly 1 × the dataset; we treat the 300 B tokens as the total “token‑steps” already).

The only numbers we need for a FLOP estimate are N (the model size) and T (the total number of token‑level operations). The rest of the architecture details (L, d, h, Lₗ) are used to translate “N parameters” into “how many FLOPs per token”.

2. How many FLOPs per token?

A transformer layer consists of:

Self‑attention (Q, K, V projections + output projection)
Feed‑forward network (FFN) (two linear layers with a non‑linear activation).

For a single token (ignoring the cost of the softmax and the small bias terms) the dominant cost is matrix‑multiply operations.

2.1 Rough matrix‑multiply cost

For a matrix multiplication A (m×k) × B (k×n) the number of multiply‑adds is 2 · m·k·n (one multiplication and one addition per entry). In deep‑learning practice we count that as 2 FLOPs per multiply‑add pair.

2.2 FLOPs per token for a single layer

Component	Approx. dimensions	FLOPs (per token)
Q, K, V projections (3× per token)	d × d → 3·(2·d·d) = 6·d²
Attention scores (Q·Kᵀ)	L·d → 2·L·d²
Weighted sum (A·V)	L·d → 2·L·d²
Output projection	d × d → 2·d²
FFN first linear (d → 4d)	2·d·4d = 8·d²
FFN second linear (4d → d)	8·d²
Total per layer	≈ 38 · d² FLOPs per token (rounded up).

Plugging d = 12 384:

[ 38 \times d^{2} \approx 38 \times (1.2384\times10^{4})^{2} \approx 38 \times 1.53 \times 10^{8} }= 5.8 \times 10^{9}; \text{FLOPs per token per layer}. ]

2.3 All layers

With 96 layers:

[ \text{FLOPs per token (forward)} \approx 96 \times 5.8\times10^{9} }= 5.6 \times 10^{11}; \text{FLOPs}. ]

2.4 Back‑propagation cost

Training requires a forward pass plus a backward pass. The backward pass is roughly 2× the forward‑pass cost (gradient propagation + weight updates). So:

[ \text{FLOPs per token (training)} \approx 3 \times \text{forward} = 3 \times 5.6\times10^{11} }\approx 1.7\times10^{12}; \text{FLOPs per token.} ]

(Alternative literature often rounds this factor to ≈ 6 total FLOPs per parameter per token, which yields the same order of magnitude.)

3. Multiply by the total number of tokens

The training corpus used for GPT‑3 was ≈ 300 billion tokens (≈ 3 × 10¹¹). The total FLOPs needed:

[ \text{Total FLOPs} \approx 1.7 \times 10^{12};\text{FLOPs/token} \times 3\times10^{11};\text{tokens} \approx 5.1 \times 10^{23};\text{FLOPs}. ]

Rounded to a single‑digit significance:

[ \boxed{,\approx 5\times10^{23},\text{FLOPs},} ]

4. Expressed in common units

Unit	Value
FLOPs	≈ 5 × 10²³
Peta‑FLOPs (10¹⁵)	≈ 5 × 10⁸ PFLOPs
Exa‑FLOPs (10¹⁸)	≈ 5 × 10⁵ EFLOPs
Zetta‑FLOPs (10²¹)	≈ 5 × 10² ZFLOPs (≈ 500 ZFLOPs)

Because “zeta” (10²¹) is a convenient unit for such massive numbers, we can say ≈ 500 zeta‑FLOPs. In more familiar terms, this is ≈ 300 zeta‑FLOPs if we adopt the “6 × N × T” rule of thumb (see below), so the estimate sits in the few‑hundred‑zeta‑FLOP range.

5. A “quick‑rule” sanity check

A widely‑cited back‑of‑the‑envelope rule for transformer LLMs is:

[ \text{Training FLOPs} \approx 6 \times N_{\text{params}} \times N_{\text{tokens}}. ]

Plugging in the numbers:

[ 6 \times (1.75\times10^{11}) \times (3\times10^{11}) = 3.15\times10^{23};\text{FLOPs}. ]

That is within a factor of two of the more detailed calculation above (the difference stems from the exact factor used for forward vs backward cost). Both methods give the same order of 10²³ FLOPs.

6. Summary of the reasoning

Model size gives the number of parameters (N = 1.75 × 10¹¹).
Token count tells how many forward‑backward passes are needed (T ≈ 3 × 10¹¹).
Per‑token training cost for a transformer layer is ≈ 38 · d² FLOPs per forward pass; with 96 layers this is ≈ 5.6 × 10¹¹ FLOPs per token.
Back‑propagation adds roughly a factor‑3 (or 6) multiplier, yielding ~1.7 × 10¹² FLOPs per token.
Total = per‑token cost × total tokens ≈ 5 × 10²³ FLOPs.

Bottom line

Estimated total compute to train GPT‑3: ≈ 5 × 10²³ FLOPs, i.e. ≈ 300–500 zeta‑FLOPs (or about 300 000 exaflops).
This is the magnitude of hundreds of zettaFLOPs of raw arithmetic, roughly the same as running a few hundred petaflops‑scale supercomputers for a month (or a single exaflop‑class machine for a week).

(All numbers are back‑of‑the‑envelope estimates; the real training run also incurs overhead from data‑loading, communication, and other inefficiencies, so the actual engineering effort was larger, but the pure‑compute figure is captured by the calculation above.)

Vote

2 / 31

AI Board Game Logicreasoning

Tests an AI's ability to understand game rules and strategy

Cypher Alpha (free)

Openrouter · Jul 2025svg

GPT OSS 120B

Openai · Aug 2025svg

Vote

3 / 31

Logic Puzzlereasoning

Tests an AI's ability to solve a simple but potentially confusing logic puzzle

Cypher Alpha (free)

Openrouter · Jul 2025text

Sally has 1 sister.

Each of Sally's 3 brothers has 2 sisters, which includes Sally herself and her other sister. Since Sally is one of the sisters, she has only 1 sister.

GPT OSS 120B

GPT OSS 120B

Openai · Aug 2025text

No content available for this output.

Vote

Character Voice Testconversation

Tests an AI's ability to write in distinct character voices

Cypher Alpha (free)

Openrouter · Jul 2025text

No content available for this output.

GPT OSS 120B

Openai · Aug 2025text

No content available for this output.

Vote

12 / 31

Minimalist Landing Pageweb design

Tests an AI's ability to generate a complete, working landing page

Cypher Alpha (free)

Openrouter · Jul 2025website

GPT OSS 120B

Openai · Aug 2025website

Vote

12 of 31

FAQ

Continue exploring

Cypher Alpha (free) vs MiniMax M2.5New provider

Cypher Alpha (free) vs GPT OSS 20BCross-provider

Cypher Alpha (free) vs Grok 3New provider

Below is a step‑by‑step back‑of‑the‑envelope calculation that shows how we get there, together with the assumptions that go into it.

1. What we need to know

Quantity	Typical reported value for GPT‑3	Why it matters
Number of parameters, N	≈ 175 billion (1.75 × 10¹¹)	Determines the size of each matrix‑multiply in the model.
Training token count, T	≈ 300 billion tokens (3 × 10¹¹)	Total number of token‑level forward‑passes the model sees.
Sequence length, L	≈ 2048 tokens per example (the context window).	Determines how many per‑token matrix‑products are needed per forward pass.
Number of layers, Lₗ	96 transformer blocks.
Hidden dimension, d	12 384 (the width of each linear projection).
Number of attention heads, h	96 (so each head has size d/h = 128).
Training passes	1 epoch (the published training used roughly 1 × the dataset; we treat the 300 B tokens as the total “token‑steps” already).

2. How many FLOPs per token?

A transformer layer consists of:

Self‑attention (Q, K, V projections + output projection)
Feed‑forward network (FFN) (two linear layers with a non‑linear activation).

For a single token (ignoring the cost of the softmax and the small bias terms) the dominant cost is matrix‑multiply operations.

2.1 Rough matrix‑multiply cost

2.2 FLOPs per token for a single layer

Component	Approx. dimensions	FLOPs (per token)
Q, K, V projections (3× per token)	d × d → 3·(2·d·d) = 6·d²
Attention scores (Q·Kᵀ)	L·d → 2·L·d²
Weighted sum (A·V)	L·d → 2·L·d²
Output projection	d × d → 2·d²
FFN first linear (d → 4d)	2·d·4d = 8·d²
FFN second linear (4d → d)	8·d²
Total per layer	≈ 38 · d² FLOPs per token (rounded up).

Plugging d = 12 384:

[ 38 \times d^{2} \approx 38 \times (1.2384\times10^{4})^{2} \approx 38 \times 1.53 \times 10^{8} }= 5.8 \times 10^{9}; \text{FLOPs per token per layer}. ]

2.3 All layers

With 96 layers:

[ \text{FLOPs per token (forward)} \approx 96 \times 5.8\times10^{9} }= 5.6 \times 10^{11}; \text{FLOPs}. ]

2.4 Back‑propagation cost

Training requires a forward pass plus a backward pass. The backward pass is roughly 2× the forward‑pass cost (gradient propagation + weight updates). So:

[ \text{FLOPs per token (training)} \approx 3 \times \text{forward} = 3 \times 5.6\times10^{11} }\approx 1.7\times10^{12}; \text{FLOPs per token.} ]

(Alternative literature often rounds this factor to ≈ 6 total FLOPs per parameter per token, which yields the same order of magnitude.)

3. Multiply by the total number of tokens

The training corpus used for GPT‑3 was ≈ 300 billion tokens (≈ 3 × 10¹¹). The total FLOPs needed:

[ \text{Total FLOPs} \approx 1.7 \times 10^{12};\text{FLOPs/token} \times 3\times10^{11};\text{tokens} \approx 5.1 \times 10^{23};\text{FLOPs}. ]

Rounded to a single‑digit significance:

[ \boxed{,\approx 5\times10^{23},\text{FLOPs},} ]

4. Expressed in common units

Unit	Value
FLOPs	≈ 5 × 10²³
Peta‑FLOPs (10¹⁵)	≈ 5 × 10⁸ PFLOPs
Exa‑FLOPs (10¹⁸)	≈ 5 × 10⁵ EFLOPs
Zetta‑FLOPs (10²¹)	≈ 5 × 10² ZFLOPs (≈ 500 ZFLOPs)

5. A “quick‑rule” sanity check

A widely‑cited back‑of‑the‑envelope rule for transformer LLMs is:

[ \text{Training FLOPs} \approx 6 \times N_{\text{params}} \times N_{\text{tokens}}. ]

Plugging in the numbers:

[ 6 \times (1.75\times10^{11}) \times (3\times10^{11}) = 3.15\times10^{23};\text{FLOPs}. ]

6. Summary of the reasoning

Model size gives the number of parameters (N = 1.75 × 10¹¹).
Token count tells how many forward‑backward passes are needed (T ≈ 3 × 10¹¹).
Per‑token training cost for a transformer layer is ≈ 38 · d² FLOPs per forward pass; with 96 layers this is ≈ 5.6 × 10¹¹ FLOPs per token.
Back‑propagation adds roughly a factor‑3 (or 6) multiplier, yielding ~1.7 × 10¹² FLOPs per token.
Total = per‑token cost × total tokens ≈ 5 × 10²³ FLOPs.

Bottom line

Estimated total compute to train GPT‑3: ≈ 5 × 10²³ FLOPs, i.e. ≈ 300–500 zeta‑FLOPs (or about 300 000 exaflops).
This is the magnitude of hundreds of zettaFLOPs of raw arithmetic, roughly the same as running a few hundred petaflops‑scale supercomputers for a month (or a single exaflop‑class machine for a week).