laguna s 2.1 vs hy3 vs inkling vs deepseek v4 pro max

@poolsideai released laguna s 2.1 on july 21 – a new open-weights agentic coding model, full weights on hugging face. key facts:

• 118b total / 8b active moe, 1m context, thinking + no-thinking modes. start of training to launch in under nine weeks

• "the most capable agentic coding model in its weight class" – terminal-bench 2.1 70.2 with thinking, ahead of deepseek v4 pro max (64.0) and inkling (63.8), just under hy3 (71.7), at a fraction of the params

• deepswe v1.1: 40.4 in thinking mode – against deepseek v4 pro max's 9.0 on the very same board

• two thinking modes only: off, and max (default, it picks its own budget). poolside names "overthinking" as a known limitation – it can reason for hundreds of thousands of tokens before it does anything

so we ran the real-world version of poolside's own benchmark chart

the three bigger models it lines itself up against in the release – @tencenthunyuan's hy3 (295b), @thinkymachines' inkling (975b, by @miramurati), and @deepseek_ai's v4 pro max (1.6t) – every one 2.5–14× its size. on their slides laguna beats inkling and v4 pro max and trails hy3. so we took all four off the benchmark and gave them the same job

our test – 3 prompts, single-file html, procedural, no libraries where possible. same prompt to every model, thinking on max, all run through @aimlapi:

• 2048 – slide + merge on a 4×4 grid, score
• snake – eat, grow, die, score
• stack – drop blocks, slice the overhang, build a rising tower

results (summed across all 3 games):

– cost
#1 laguna s 2.1 – $0.0015
#2 hy3 – $0.0136
#3 deepseek v4 pro max – $0.0736
#4 inkling – $0.0887

– tokens
#1 laguna – 52,182
#2 deepseek – 65,504
#3 inkling – 88,231
#4 hy3 – 112,541

– generation time
#1 laguna – 10m 14s
#2 inkling – 11m 10s
#3 deepseek – 14m 11s
#4 hy3 – 27m 05s

– lines of code
#1 laguna – 1,077
#2 hy3 – 1,236
#3 inkling – 1,807
#4 deepseek – 3,271

the 118b model wins every column. cheapest by 9-60×, fewest tokens, fastest wall-clock, tightest code. "punching above its weight class" isn't just a benchmark line.

but there's a catch we found the hard way. laguna's thinking is a switch it flips itself – and it flips it off for anything that looks easy. hand it a detailed spec for a game and it decides "i've got this," skips reasoning, and dumps broken code. strip the prompt to a vague brief – "build stack, figure out the geometry yourself" – and it reasons for 4 minutes and ships something that works. you have to under-specify it into thinking. the bigger models reason on the same prompt without the trick

then we played them

- laguna's 2048 is clean and correct, its snake a notch behind. it only fell down on stack – flat blocks where hy3 and deepseek built isometric-3d towers. still cheapest by 9–60×

- 2048's score can't hide: three count (laguna, hy3, inkling). deepseek merges perfectly to a full board and never leaves 0 – built the whole score box, even a "pop" animation, skipped the one line that adds the value. biggest model, a 2048 that can't count

- laguna's code is the tidiest in the test – 446 lines, zero deps, one processRow reused for all four directions. the line deepseek dropped is right there: score += mergedValue. but its snake is dead on arrival – draw() reads a timestamp that only lives in gameLoop(), so frame one throws and it never renders. one out-of-scope word

the take:

• laguna s 2.1 – cheapest, cleanest 2048; fumbled the 3d stack. strong where it's simple, thin where it's hard

• deepseek v4 pro max – most code, best stack, scoreboard frozen at 0

• hy3 – right answers, overthinks brutally (27 min for three toy games)

• inkling – fastest, most polished; you pay in $

118b model spent the least and shipped the arithmetic the 1.6t one couldn't – it just gets thin at the hard end