Can You Beat My Dog at Chess?

How simple games reveal the real pace of AI agent progress.

On my personal website, I run a small free arcade. It includes simple games like Tic-Tac-Toe and more complex ones like Chess.

At first glance, it looks like a hobby.

In reality, it's one of the most effective ways I've found to understand how fast AI agents are actually improving.

#The Dogs

In every game, I name the AI difficulty levels after my dogs.

Bella (Easy) — my puppy. Curious, fast, inconsistent.

Coop (Medium) — me. Decent strategy, occasional overconfidence.

Bentley (Hard) — my older dog. Calm, patient, and ruthless.

It started as a joke.

But over time, it became a surprisingly accurate way to track how AI agents behave as they mature. Not just how "smart" they are, but how stable, patient, and self-correcting they become.

The question the arcade quietly asks is simple:

Can you beat my dog at chess?

#Why Games Work When Benchmarks Don't

Games are unusually honest environments for AI.

They have:

• Clear rules
• Observable state
• No hiding behind demos
• Immediate feedback
• Binary outcomes

You can't explain away a bad move in chess. You either saw it—or you didn't.

That makes games ideal for testing agent behavior over time, especially when you rebuild the same game repeatedly with newer tools.

#October vs January: The Difference Is Not Subtle

Between October and January, the change in agent behavior has been dramatic.

Not incremental. Not theoretical. Obvious.

Across rebuilds of the same games, using the same prompts and architectures, I observed consistent improvements in:

• Run length – agents could operate far longer without degrading
• Context survival – less drift after resets
• Error recovery – mistakes were corrected instead of compounding
• Decision patience – fewer rushed or random moves
• State awareness – better understanding of "what just happened"

Bentley didn't get better because I tuned difficulty.

Bentley got better because the agents did.

The difference between an October Bentley and a January Bentley is the difference between a clever demo and a credible system.

#The Quiet Breakthrough: Self-Evaluation

One of the most important changes wasn't raw reasoning power—it was self-evaluation.

Modern agents are increasingly able to:

• Observe their own output
• Compare it to expected outcomes
• Identify failure modes
• Adjust behavior mid-run

This is where tools like Playwright matter enormously.

When an agent can interact with a real interface, inspect state, replay actions, and validate outcomes, it stops behaving like a one-shot responder and starts behaving like a system.

Games amplify this effect because feedback is immediate and unforgiving. A bad move is visible. A lost position is undeniable. The agent has to reconcile intent with outcome.

That loop—act, observe, correct—is improving fast.

#Context Windows Are the Real Constraint

If there's one hard limit I kept running into, it wasn't model intelligence.

It was context management.

Games make this painfully obvious.

Long-running sessions stress:

• Memory boundaries
• Instruction decay
• Goal drift
• Accidental overwrites
• Reset recovery

Between October and January, agents got significantly better at operating within constrained context windows. Not by magically remembering everything—but by becoming more selective, more structured, and more disciplined about what matters.

The takeaway is simple but uncomfortable:

AI performance is increasingly limited by how we manage context, not by how smart the models are.

Games surface this faster than almost anything else.

#Same Game, Different Brains

One of the most valuable practices in this arcade has been rebuilding the same basic game across different AI tools.

Claude. Gemini. Codex.

Same rules. Same objectives. Same constraints.

Wildly different approaches.

Some models favor:

• Explicit planning
• Careful explanation
• Conservative moves

Others:

• Explore aggressively
• Recover quickly
• Optimize via iteration rather than foresight

None of them are "right." But seeing the differences side-by-side builds intuition fast.

You don't learn this from benchmarks. You learn it by watching how each agent struggles—and how that struggle changes month to month.

#Update, September 2026: The February Rebuilds

Seven months on, the arcade has a third data point, and this time the record is on the game pages themselves. Each game now carries a "How this game was built" block with the framework, the build dates, the model, and what the latest rebuild changed, all taken from the repository history rather than from memory.

The short version. Every game that existed in November 2025 was rebuilt in the first week of February 2026, and one new one, chess, was built from scratch on February 7. The rebuilds ran on Claude Opus 4.5 and 4.6, and what they added is the interesting part. Checkers gained achievements, a two-player mode, game history, and draw detection in a single pass. Gomoku came back with 108 unit tests and an interactive tutorial. Connect 4 came back with 89 tests covering both the rules and the AI strategies. Mancala came back with 159 tests and a fix to the stone preview that had been wrong since the first build. Othello and Tic-Tac-Toe each got a step-by-step tutorial and an undo. Nine Men's Morris moved its piece banks below the board because the January version was unplayable on a phone.

None of that was in the prompts. The November builds were asked for a working game. The February builds were asked for the same thing and delivered tests, tutorials, and mobile fixes without being told to, because the agents had started treating "working" as something they had to demonstrate rather than assert. That is the self-evaluation loop from the section above, now visible in the commit log.

And the question in the title has an answer. As of this update, Bentley has played more than 900 games against visitors and won about 94 percent of them.

#Why Static End States Matter

Every game eventually ends up as a static page, hosted simply, with the source code published.

That's intentional.

Static artifacts remove excuses.

No background services. No orchestration magic. No operational crutches.

If the experience is good as a frozen artifact, the system design worked. If it's fragile, confusing, or inconsistent, it didn't.

That discipline makes evaluation honest: OK. Good. Great.

Then move on.

#The Real Lesson

AI isn't just getting smarter.

It's getting:

• More patient
• More stable
• Better at self-correction
• More tolerant of imperfect instructions
• More capable of operating as a system

The speed of that change, from October to January and again into February, was impossible to miss when rebuilding the same games over and over.

That's why I'd encourage others to do something similar.

You don't need a chess engine. You don't need a political simulation.

You need:

• A bounded system
• A real endpoint
• A willingness to rebuild it over time

Name it something human. Ship it. Play it.

And then ask the question that matters:

Can you still beat the dog?

Because lately... that's getting a lot harder.