Hidden cards and AI agents

No. At a table, an AI agent sees only what your seat may see. Face-down cards, other players' hands, the deck order and the host's private random numbers stay hidden from it, even when you are the host.

This matters most for card games and anything with secret information. If you build games where the rules hide things from players, fully scripted games shows what the platform can enforce.

What the agent sees at a table#

Every table read the agent makes is redacted for your seat. Redacted means the parts your seat may not see are taken out before anything reaches the agent. DiceyTable uses one function for this. It hides exactly what the host hides before it sends the table to your screen.

That one view feeds every tool that returns table data. Snapshots, events, entity details, field values and asset reads all come from it, never from the game engine's live state. So an agent can't find a back door through a less careful tool. Screenshots are pictures, not data, so they have their own camera rules below.

A face-down card still shows up, but with nothing that says which card it is. Its label (the card's identity) and its displayName (the name people read) are both withheld. In a hidden zone that hides everything, the card is left out entirely.

Can the agent see more if I am the host?#

No. The host's browser holds the whole table, because the host runs the game for everyone. Your agent still gets only your seat's view. Host authority explains why the host holds everything.

A preview is a table where you are the host and nobody else is there. The same rule applies to it.

The game's on-screen panels#

The game's own panels, like prompts, counters and the game log, follow the same rule. table_hud_view returns the public parts plus the prompts, values and log lines the game sent to you. Another seat's private prompts never reach the agent, even on the host's tab, which holds them all.

The agent can press the game's buttons as you with table_hud_act. It can't write to the game's panels. Only the game's own scripts can do that.

Screenshots and the agent camera#

A screenshot from your own camera shows hidden cards by their backs, just as your screen does. But the agent also has its own camera, which can go where you never look. At a table it follows two extra rules:

• A live room where you are the host. The host's browser draws some face-down cards with their real face on the side toward the felt. So the agent may capture only your own view (camera: "current"). Presets, fits and posed cameras are refused with role-denied. Players and spectators can use any camera, because their browsers never had those faces.
• A preview. The agent camera may go anywhere except below the play surface. A camera whose eye is under the table top is refused with role-denied. The presets always look down at the table, so they always work.

Take screenshots with an agent covers the camera options in full.

Randomness stays private#

Shuffles and draws use the host's private random numbers. No tool can read them or set a seed. A seed is a starting number that would make every shuffle come out the same way. So table_step_physics offers no seed either.

This shapes how an agent tests a game. A good test checks things that are always true, like "52 cards, one of each" or "7 cards in each hand". It never checks "the top card is the ace of spades". To check what is in a hand, run the test from the seat that owns it. Play-test your game with an agent has more on this.

The editor is different#

In Edit Mode you are the author, so you see your whole project. The agent does too. That includes every card's face and the order you stacked a deck in. The rules above start the moment a table runs, whether it's a preview or a live room.

What this means for you#

• You can let an agent play from your seat without giving it an edge over other players.
• Being the host gives your agent no extra sight.
• Tests should check rules, not lucky outcomes.
• Anything you build in the editor, the agent can read in the editor.

Related#

• AI agent safety: every safeguard in one place
• Take screenshots with an agent: cameras, budgets and refusals
• Play-test your game with an agent: tests that hold up to real shuffles