Language is the control surface

"Hold this ridge. If they push left, rotate the flank."

A lot of players can say that before they can execute it. The strategy is already there. What takes the time is translating it into what the game expects: select these units, check their state, remember cooldowns, issue movement, trigger abilities in the right order, then repair the plan when something changes.

Experienced players get very good at that translation. Newer players mostly feel it as friction.

As strategy games get deeper, the interface usually gets heavier with them. More units to select. More menus and hotkeys. More state to track. At some point, a real share of "getting good" is just learning how to operate the machine.

We tend to treat game complexity and interface complexity as the same thing. They aren't.

That matters because the usual way of making deep games more accessible is to simplify the game: fewer systems, flatter trees, fewer options, a separate lighter mode. Sometimes that's the right call. It also assumes the depth is the problem.

What if the interface is?

From actions to intent

For most of the history of games, interfaces have operated at roughly the level of individual actions.

Press this button. Move this stick. Click this unit. Select this ability.

That made sense because computers weren't particularly good at interpreting anything higher level. The player had to translate their strategy into instructions the machine could execute.

Language models create another possibility.

Instead of requiring the player to specify every action, the player can express what they are trying to accomplish and let the system translate that intent into actions.

That sounds like a small interface change. It isn't.

It changes where the boundary sits between the player and the game.

The player can spend more time deciding what should happen while the system handles more of how to express it through the game's controls.

The important part is that this doesn't require changing the underlying rules.

Keep the rules. Change the interface.

This is the distinction we explored with Arena Tactics.

Arena Tactics has an enormous number of possible game states once you combine cards, positioning, movement, terrain, status effects, abilities, and sequencing.

We didn't want AI to make that game simpler.

We wanted to see whether it could make the game easier to control.

So the model doesn't get to invent actions or ignore the rules. It interprets what the player wants, inspects the current game state, creates a plan, and translates that plan into actions the engine understands.

Those actions still have to be legal.

If they aren't, the system has to adjust.

The game engine remains the authority.

That constraint is important. Without it, language becomes a shortcut around the game. With it, language becomes another way of playing the same game.

You can still move every unit yourself.

Or you can say what you're trying to accomplish.

The underlying strategy doesn't have to change.

Latency changes the experience

We learned something else while building this.

It isn't enough for the system to understand the player. It has to understand them quickly.

Early versions of AI-powered play could take roughly 14 seconds to respond.

Technically, the system worked.

As a game, it didn't.

Fourteen seconds is long enough to break the rhythm of play. The player stops feeling like they're controlling something and starts feeling like they're waiting for a computer.

We rebuilt the system around a multi-agent architecture and much faster inference. Commands became roughly 7× faster.

Player behavior changed with it.

AI-powered modes went from less than 5% of gameplay to more than 60%.

That was interesting because the capability itself hadn't fundamentally changed. The system could already interpret intent.

What changed was the latency.

Once the interaction became fast enough, a feature that players occasionally experimented with became a way they actually wanted to play.

There is a broader product lesson here.

Latency isn't always an infrastructure metric. Sometimes it determines whether an entirely new interface feels natural.

One game, more ways to play it

Once you separate intent from individual input, several other things become possible.

A player can ask an AI co-pilot to handle repetitive actions while they make the larger strategic decisions.

An AI opponent can operate through the same legal action space as the player rather than through a separate set of hidden rules.

A player who understands strategy but struggles with a dense interface can still participate in the full game.

And the game can move to new devices without recreating every interaction through a new collection of buttons and gestures.

We saw that last effect directly. Because language could abstract some of the most interface-heavy parts of Arena Tactics, we were able to build a mobile companion experience in roughly a month.

The game didn't become smaller to fit the device.

The interface became more expressive.

Language as an interface layer

We built Playable around this idea.

It lets studios add conversational play, co-pilots, and game-playing agents without replacing the systems that make the game interesting.

But the more interesting idea is larger than any one product.

For decades, software interfaces have forced humans to translate intent into increasingly precise machine instructions.

Games are an extreme example because the underlying systems can become extraordinarily complicated. But the same pattern exists across software.

Language gives us a new abstraction layer.

Not because every button should disappear, or because every interaction should become a conversation. Direct manipulation is often faster and better.

But there are moments when the person already knows what they want and the interface is simply making them explain it in the machine's language.

Those are the moments worth looking for.

Sometimes the complexity we attribute to the product isn't actually in the product.

It's in the distance between human intent and machine execution.