# Hidden cards and AI agents

> No. An AI agent sees only what your seat may see, even when you are the host. Face-down cards, other hands and the deck order stay hidden from it.

- Question: Can an AI agent see hidden cards or the deck order?
- Source: https://diceytable.com/docs/ai-agents/concepts/hidden-information
- Last verified: 2026-10-09

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](https://diceytable.com/features/fully-scripted-games) shows what the platform can enforce.

![The host's full table on one side, and the agent's view on the other, with other seats' cards drawn as backs](https://diceytable.com/assets/build/hidden-information--seat-view-CNT2P5j_.svg "**The agent gets your seat's view.** Everything another seat holds arrives as a card back, or not at all.")

## 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](https://diceytable.com/docs/scripting/concepts/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](https://diceytable.com/docs/ai-agents/workflows/screenshots) 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](https://diceytable.com/docs/ai-agents/workflows/playtest) 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](https://diceytable.com/docs/ai-agents/concepts/security-model): every safeguard in one place
- [Take screenshots with an agent](https://diceytable.com/docs/ai-agents/workflows/screenshots): cameras, budgets and refusals
- [Play-test your game with an agent](https://diceytable.com/docs/ai-agents/workflows/playtest): tests that hold up to real shuffles