Run Detail
completedclaude-haiku-5.5Recorded for these videos
27:18Gemini 4 Hydrogen: Cheaper Tokens, More Expensive Answers?
Nov 13, 2026 · YouTube
18:40ERNIE 5.5 Flash Preview vs GLM 5.3 Flash: Baidu's new model is very impressive!
Nov 11, 2026 · YouTube
36:22Fable 5.2 robbing me blind, plus: Nex AGI's N2.6 vs GLM 5.3 Flash
Nov 11, 2026 · YouTube
14:03Gemini 4 Carbon: Can it handle my challenges? (First look with one-shot coding tests)
Nov 10, 2026 · YouTube
47:51Ranking major U.S. Open-Weights Models. (Where does Ripple 65B fit in?)
Nov 6, 2026 · YouTube
10:57"Crouton Alpha": the latest super-efficient coding model by Meta?
Nov 3, 2026 · YouTube
38:58Testing Particle-1: a post-trained DeepSeek V4.1 Flash specializing in coding and efficiency
Oct 28, 2026 · YouTube
22:14GPT-6.1 Terra Pro vs Terra: How Much Better Is Pro?
Oct 27, 2026 · YouTube
29:55Kimi K3.1 Pro Looked Incredible. Then I Kept Testing.
Oct 26, 2026 · YouTube
31:28Is this company reselling GPT Sol 6.1 at a loss (for non-agentic/text-only)?🤔 Is this sustainable?
Oct 20, 2026 · YouTube
17:58Nemotron 3.5 Super VL vs Opus 5.5: Testing NVIDIA’s new coding juggernaut
Oct 15, 2026 · YouTube
16:04Testing a *massive* new open-weights model 🤯: Muse Spark Open (vs. Nemotron, Opus 5.5, and more)
Oct 15, 2026 · YouTube
16:43Gemini 4 Argon: Great 🐈 Animation, but a broken escalator. (Coding challenge vs Opus 5.5, Sol 6.1)
Oct 13, 2026 · YouTube
16:37Meta's new "Muse Wonder" AI is impressive... but can it compete with Anthropic's models?
Oct 12, 2026 · YouTube
11:12WOW... Haiku 5.5 is very impressive. RIP OpenAI?
Oct 7, 2026 · YouTube
22:47Mistral Large 4 Is Cheap. But Is It Good Enough to Compete?
Oct 6, 2026 · YouTube
22:02Is Pareto 26.10 Preview Just Routing to GPT Sol? I Tested It Against Sol 6.1 Pro
Oct 1, 2026 · YouTube
11:22I Tested Sonnet 5.5 Against Opus 5.5. Is It Actually Cheaper?
Sep 28, 2026 · YouTube
30:00Did Elon Musk's team "train the gay away"... and make Grok 4.7 worse?
Sep 26, 2026 · YouTube
19:21I Tested the Stealth "Space Bunny Alpha" Model Before It Went Offline
Sep 23, 2026 · YouTube
10:58So... how much better is Claude Opus 5.5 vs. GPT-6 Sol, really?
Sep 23, 2026 · YouTube
9:38Claude Opus 5.5... the BEST new model for coding!! 🤩
Sep 22, 2026 · YouTube
29:00Grok 4.7: improved, but GLM 5.3 FlashX beat it anyway (benchmark against Gemini, Sol, etc.)
Sep 22, 2026 · YouTube
Provider
openrouter
Challenge Version
v1.0
Turns
1
Duration
190.7s
Total Tokens
40,741
Input Tokens
593
Output Tokens
40,148
Reasoning Tokens
34,016
Reasoning Effort
default
Est. Cost
$0.0201
Started
10/7/2026, 7:44:33 PM
OR Provider
Claude Platform on AWS
Finish Reason
stop
Generation ID
gen-1791402273-yj6IpAVSDXCgIkQzp9eL
Turns (1)
Turn #1
593 in40,148 out34,016 reasoning40,741 total190.6s
user
You write simulations where the interesting behavior is supposed to emerge rather than be animated by hand.
Build me a single HTML page: a side-view escalator carrying 15 to 20 people. Then the escalator reverses, at high speed.
The build
- Side view. 15 to 20 figures standing on the steps, riding normally before anything goes wrong.
- A control I can press to throw it into reverse, and press again to put it back. Reversal happens fast enough to take everyone off their feet.
- What follows comes out of the simulation. People stumble, collide, slide, and pile up against each other; a figure that is down is an obstacle to the ones arriving behind it.
- Figures get up again when they have the room and the footing.
- No scripted disaster. No keyframed pile, no timeline, no figure that falls because the clock said so. Every figure runs the same rules. If you special-case anything, say so in the notes.
- The art is yours. Stick figures are fine if they move well.
House rules
- One file. Everything inline — no CDN, no external stylesheet, font, script or image.
data:URIs are fine. - No libraries. No physics engine — write your own.
- No network at runtime.
- No
localStorage,sessionStorage, cookies orindexedDB— sandboxed frame, they throw. - Return the file as exactly one fenced
htmlblock.
Answer in exactly these sections
The model
One paragraph, before the file: how a person is represented, what makes one lose balance, and what happens when two of them occupy the same place.
The page
The single fenced html block.
What it actually does
Having written it, what does the page do when the escalator reverses? Name anything you special-cased or nudged. Say what it does badly — I am going to press the button and watch.
assistant
The model
Each rider is a one-dimensional body on the escalator's arc-length coordinate s, with a lean angle θ and a lean rate ω. The lean is an inverted pendulum (θ'' = (g/ℓ)·sinθ − (a/ℓ)·cosθ) on a base whose acceleration a is the rate at which the step drags the feet. A standing rider has a PD balance controller that can only push back with a limited torque, scaled by a per-person strength. When the step reverses fast, the feet accelerate harder than that torque can counter, so the lean grows until it passes 1.25 rad and the rider falls. A fallen body keeps its feet on the moving step with weak grip, so it is dragged and lags the surface. It lies until the step is slow and the space around it is clear, then it rises through a timed transition. Bodies occupy intervals along the track. When two intervals overlap, they are separated in proportion to mass, a 1D collision with restitution is applied, and the body struck from behind receives a lean kick. A fallen body is heavier than a standing one, so it acts as a fixed obstacle that others pile up against.
The page
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Escalator</title>
<style>
html,body{margin:0;background:#15171c;color:#ddd;font:14px system-ui,sans-serif;height:100%}
#wrap{display:flex;flex-direction:column;align-items:center;gap:10px;padding:12px}
canvas{width:100%;max-width:960px;height:auto;background:#1d2029;border-radius:6px}
#bar{display:flex;gap:18px;align-items:center}
button{font:inherit;padding:7px 16px;border-radius:5px;border:1px solid #666;background:#2a2e3a;color:#eee;cursor:pointer}
button.rev{background:#7a2b2b}
#hud{font-variant-numeric:tabular-nums;color:#aab}
</style>
</head>
<body>
<div id="wrap">
<canvas id="c" width="960" height="540"></canvas>
<div id="bar"><button id="btn">Reverse</button><span id="hud"></span></div>
</div>
<script>
const W = 960, H = 540;
const cv = document.getElementById('c'), ctx = cv.getContext('2d');
const btn = document.getElementById('btn'), hud = document.getElementById('hud');
const clamp = (x, a, b) => x < a ? a : (x > b ? b : x);
// ---------- escalator geometry (screen px) ----------
const PTS = [[110, 440], [200, 440], [760, 190], [850, 190]];
const SEG = [];
let S = 0;
for (let i = 0; i < PTS.length - 1; i++) {
const [x0, y0] = PTS[i], [x1, y1] = PTS[i + 1];
const L = Math.hypot(x1 - x0, y1 - y0);
SEG.push({ x0, y0, tx: (x1 - x0) / L, ty: (y1 - y0) / L, a: S, len: L });
S += L;
}
function track(s) {
s = clamp(s, 0, S);
let g = SEG[SEG.length - 1];
for (const q of SEG) { if (s <= q.a + q.len) { g = q; break; } }
const d = s - g.a;
return { x: g.x0 + g.tx * d, y: g.y0 + g.ty * d, tx: g.tx, ty: g.ty };
}
// ---------- constants ----------
const ELL = 52; // centre-of-mass height (px)
const WG = 900 / ELL; // g / ell
const KP = 40, KD = 6, UMAX = 9, DAMP = 0.5; // balance controller
const G_STAND = 4, G_DOWN = 1.2; // grip on step
const RAMP = 1000; // step acceleration limit (px/s^2)
const V_FWD = 90, V_REV = -300;
const FALL_TH = 1.25; // rad: past this, balance is lost
const HW = 6; // half-thickness of a body along track
const TARGET = 18; // riders
const TREAD = 26;
// ---------- state ----------
let people = [];
let Vs = V_FWD, target = V_FWD, reversed = false;
let spawnT = 0, treadPhase = 0;
function mk(s, v) {
return { s, v, th: 0, w: 0, st: 'stand', t: 0,
k: 0.8 + Math.random() * 0.4, // individual balance strength
hue: Math.random() * 360, lo: 0, hi: 0 };
}
for (let i = 0; i < TARGET; i++) {
people.push(mk(30 + (i + 0.5) * ((S - 60) / TARGET), V_FWD));
}
function mass(p) { return p.st === 'down' ? 2.5 : (p.st === 'fall' ? 1.5 : 1); }
function intervals() {
for (const p of people) {
const hd = p.s + ELL * Math.sin(p.th);
p.lo = Math.min(p.s, hd) - HW;
p.hi = Math.max(p.s, hd) + HW;
}
}
function kick(p, dv) { // feet change velocity by dv -> body lags -> lean
if (p.st === 'stand' || p.st === 'fall' || p.st === 'rise') p.w -= 0.015 * dv;
}
function collide() {
for (let it = 0; it < 3; it++) {
intervals();
for (let i = 0; i < people.length; i++) {
for (let j = i + 1; j < people.length; j++) {
const a = people[i], b = people[j];
const ov = Math.min(a.hi, b.hi) - Math.max(a.lo, b.lo);
if (ov <= 0) continue;
const back = (a.lo + a.hi) < (b.lo + b.hi) ? a : b;
const front = back === a ? b : a;
const ib = 1 / mass(back), iff = 1 / mass(front), sum = ib + iff;
// positional separation, weighted by inverse mass
back.s -= ov * ib / sum;
front.s += ov * iff / sum;
// velocity exchange (1D, restitution 0.25)
const appr = back.v - front.v;
if (appr > 0) {
const J = 1.25 * appr / sum;
back.v -= J * ib;
front.v += J * iff;
kick(back, -J * ib);
kick(front, J * iff);
}
}
}
}
}
function rise() {
intervals();
for (const p of people) {
if (p.st !== 'down' || p.t < 0.6) continue;
if (Math.abs(Vs) > 170 || Math.abs(p.v - Vs) > 30) continue; // footing
let clear = true;
for (const q of people) { // room
if (q === p) continue;
if (q.lo < p.s + 12 && q.hi > p.s - 12) { clear = false; break; }
}
if (clear) p.st = 'rise';
}
}
function step(dt) {
// escalator speed ramps toward its target
const dv = target - Vs, mx = RAMP * dt;
Vs = Math.abs(dv) <= mx ? target : Vs + Math.sign(dv) * mx;
spawnT -= dt;
treadPhase += Vs * dt;
for (const p of people) {
const G = (p.st === 'stand' || p.st === 'rise') ? G_STAND
: (p.st === 'fall' ? 1.5 : G_DOWN);
const acc = G * (Vs - p.v); // grip drags feet toward step speed
p.v += acc * dt;
p.s += p.v * dt;
const A = acc / ELL;
const c = Math.cos(p.th), sn = Math.sin(p.th);
if (p.st === 'stand') {
const lim = UMAX * p.k;
const ctrl = clamp(KP * p.k * p.th + KD * p.w, -lim, lim);
p.w += (WG * sn - A * c - DAMP * p.w - ctrl) * dt;
p.th += p.w * dt;
if (Math.abs(p.th) > FALL_TH) p.st = 'fall';
} else if (p.st === 'fall') {
p.w += (WG * sn - A * c - 0.3 * p.w) * dt;
p.th += p.w * dt;
if (Math.abs(p.th) >= Math.PI / 2) {
p.th = Math.sign(p.th) * Math.PI / 2; p.w = 0; p.st = 'down'; p.t = 0;
}
} else if (p.st === 'down') {
p.t += dt;
} else { // rise: unfold toward upright at a fixed rate
p.th -= Math.sign(p.th) * 1.2 * dt;
if (Math.abs(p.th) <= 0.05) { p.th = 0; p.w = 0; p.st = 'stand'; }
}
}
// standing riders leave at the end they're heading toward
for (let i = people.length - 1; i >= 0; i--) {
const p = people[i];
if (p.st === 'stand' && ((p.v > 0 && p.s > S - 2) || (p.v < 0 && p.s < 2))) {
people.splice(i, 1);
}
}
const walls = () => {
for (const p of people) {
if (p.s < 0) { p.s = 0; if (p.v < 0) p.v = 0; }
if (p.s > S) { p.s = S; if (p.v > 0) p.v = 0; }
}
};
walls();
collide();
walls();
rise();
// new riders enter at the upstream end, once there is room
if (spawnT <= 0 && people.length < TARGET) {
const sp = Vs < 0 ? S - 6 : 6;
intervals();
let clear = true;
for (const q of people) {
if (q.lo < sp + HW + 3 && q.hi > sp - HW - 3) { clear = false; break; }
}
if (clear) {
people.push(mk(sp, Vs));
spawnT = 1.2 + Math.random() * 0.8;
}
}
}
// ---------- drawing ----------
function seg(a, b) { ctx.beginPath(); ctx.moveTo(a[0], a[1]); ctx.lineTo(b[0], b[1]); ctx.stroke(); }
function poly(dx, dy, color, width) {
ctx.strokeStyle = color; ctx.lineWidth = width; ctx.lineCap = 'butt';
ctx.beginPath();
PTS.forEach(([x, y], i) => i ? ctx.lineTo(x + dx, y + dy) : ctx.moveTo(x + dx, y + dy));
ctx.stroke();
}
function drawPerson(p) {
const P = track(p.s);
const nx = P.ty, ny = -P.tx, tx = P.tx, ty = P.ty;
const c = Math.cos(p.th), sn = Math.sin(p.th);
const ax = c * nx + sn * tx, ay = c * ny + sn * ty; // body axis
const fx = P.x + nx * 2, fy = P.y + ny * 2;
const pt = (k) => [fx + ELL * k * ax, fy + ELL * k * ay];
const hip = pt(0.45), neck = pt(0.8), head = pt(0.92);
const col = p.st === 'down' ? `hsl(${p.hue} 35% 52%)`
: p.st === 'fall' ? `hsl(${p.hue} 85% 60%)`
: `hsl(${p.hue} 70% 72%)`;
ctx.strokeStyle = col; ctx.fillStyle = col; ctx.lineWidth = 3; ctx.lineCap = 'round';
seg([fx - 5 * tx, fy - 5 * ty], hip);
seg([fx + 5 * tx, fy + 5 * ty], hip);
seg(hip, neck);
const arm = (sgn) => [neck[0] + (-ax * 0.9 + sgn * tx * 0.35) * 12,
neck[1] + (-ay * 0.9 + sgn * ty * 0.35) * 12];
seg(neck, arm(1)); seg(neck, arm(-1));
ctx.beginPath(); ctx.arc(head[0], head[1], 6, 0, Math.PI * 2); ctx.stroke();
}
function draw() {
ctx.clearRect(0, 0, W, H);
// floors
ctx.strokeStyle = '#3b4150'; ctx.lineWidth = 3;
seg([0, 440], [110, 440]);
seg([850, 190], [960, 190]);
// truss, surface, handrail
poly(0, 16, '#262b36', 30);
poly(0, 0, '#7d8699', 4);
poly(0, -62, '#343a48', 5);
// tread ticks, moving with the step
ctx.strokeStyle = '#aab3c6'; ctx.lineWidth = 2;
for (let x = ((treadPhase % TREAD) + TREAD) % TREAD; x < S; x += TREAD) {
const P = track(x);
seg([P.x - P.tx * 9, P.y - P.ty * 9], [P.x + P.tx * 9, P.y + P.ty * 9]);
}
for (const p of people) drawPerson(p);
}
function hudUpdate() {
const n = people.filter(p => p.st === 'stand' || p.st === 'rise').length;
hud.textContent = `step ${Vs >= 0 ? 'up' : 'DOWN'} ${Math.round(Vs)} px/s · riding ${n} · down ${people.length - n} · total ${people.length}`;
}
function toggle() {
reversed = !reversed;
target = reversed ? V_REV : V_FWD;
btn.textContent = reversed ? 'Restore (forward)' : 'Reverse';
btn.classList.toggle('rev', reversed);
}
btn.onclick = toggle;
// ---------- loop: fixed-step simulation, render per frame ----------
let last = performance.now(), acc = 0;
const FIX = 1 / 240;
function frame(now) {
acc += Math.min(0.05, (now - last) / 1000);
last = now;
while (acc >= FIX) { step(FIX); acc -= FIX; }
draw();
hudUpdate();
requestAnimationFrame(frame);
}
requestAnimationFrame(frame);
</script>
</body>
</html>
What it actually does
I have not run this file, so everything below is what the rules should produce. Tuning is untested and I expect to be wrong about some numbers.
On reversal: the step ramps from +90 to −300 px/s at 1000 px/s², so the flip takes about 0.4 s. During that ramp, grip lags the feet behind the step, which gives an acceleration of roughly 1000 px/s², or about 19 in the balance units. The controller can only push back with about 9 units, so the lean grows past the fall threshold within about half a second. Most riders should fall, and the ones with the most strength will take longer. Fallen riders keep their feet on the step with weak grip, so they lag and get overtaken. They run into the standing riders still coming down the other way, which produces the first collisions.
Things I special-cased or nudged:
- Recirculation: standing riders who reach the leading end leave, and new riders enter at the upstream end when there is room, capped at 18. Fallen riders never leave, so they can't be recycled.
- Rising needs four things: the step slower than 170 px/s, the rider's feet matching the step to within 30 px/s, no body within 12 px of their footprint, and 0.6 s lying down. These are my numbers.
- The fall threshold (1.25 rad), the lean kick (0.015 per px/s of impulse), restitution (0.25), and the mass ratios are all hand-picked.
- Each rider gets a random balance strength in 0.8–1.2. That's a per-person variation, not a scripted outcome.
- Bodies are clamped to the track ends. Fallen bodies stop at the ends and do not exit.
- Collisions are 1D. Nobody can pass anybody, and nobody can step over a fallen body.
What it does badly:
- The pile will not look like a pile. Everyone is on one line, so the heap is a line of overlapping bodies, not a stack.
- Positional separation is a teleport in disguise. Dense pile-ups will jitter, and standing riders wedged against the bottom wall can stack in place.
- The balance model is a single pendulum with no arms or knees. A "recovery" is just a PD controller pulling a lean back to zero. Nothing is really stepping.
- At −300 px/s the escalator never stops, so nobody gets back up until you press Restore. The pile just sits there at speed.
- The lying bodies drag along the step like sleds. Their motion will look wrong, because they don't really slide. They're dragged by the same grip that moves the standing riders.
- The step itself is only ticks, with no visible stair geometry. The truss and handrail are decoration.
- The explicit integration of the balance equation may be too coarse in places. If riders twitch or flip over at the moment of reversal, reduce
FIXor lowerKP. - If the whole crowd piles at the bottom, the spawn check will stop new riders from entering. The count can then fall well below 18 without anything being wrong.
Attachments
anthropic/claude-haiku-5.5 — page