PLAYSTATE LABS / LITEPAPER 1.0
Adaptive games,
safely directed.
PlayState is an AI Game Director SDK that turns real-time player behavior into typed, bounded, and game-authorized decisions.
- STATUS
- Production-ready SDK
- LICENSE
- MIT
- RUNTIME
- Framework agnostic
THE PROBLEM
Static systems serve an average player who does not exist.
Games typically encode pacing, difficulty, rewards, and encounters through fixed curves and hand-authored branches. These systems are predictable and testable, but respond poorly to variation between players, sessions, skill levels, and motivations.
Fully generative systems promise flexibility but introduce a different risk: opaque outputs, unstable behavior, exposed credentials, and content that bypasses the game’s own rules. Adaptation without boundaries is not production control.
Limited response to changing player state.
Contextual, but difficult to authorize safely.
Adaptive recommendations inside game-defined limits.
OUR THESIS
The game should stay authoritative.
AI should recommend. Rules should constrain. The game should decide.
PlayState treats intelligence as one input to an existing runtime—not as a replacement for it. The game specifies allowed actions, validates payloads, and remains free to reject every recommendation.
Bounded by design
Only explicit, typed actions leave the director.
Deterministic first
Local rules answer immediately when conditions match.
AI when useful
Trusted generation adds context, never authority.
Fallback always
Provider failure never becomes gameplay failure.
THE ADAPTIVE LOOP
Observe. Decide. Authorize. Apply. Learn.
Events and session state.
Rules, AI, or fallback.
Action and payload checks.
Engine-owned implementation.
The loop can run locally, enrich a decision through a trusted backend, or degrade to a stable fallback. Every path returns the same typed contract.
TECHNICAL ARCHITECTURE
Two trust zones. One decision contract.
PUBLIC GAME RUNTIME
PlaystateClient
- Local rules engine
- Director decisions
- Events and sessions
- Engine adapters
- No secrets or privileged mutations
TRUSTED SERVER
PlaystateServerClient
- Structured AI generation
- Profile updates
- Reward claims
- Live-event administration
- Protected credentials
| Source | Network | When used | Guarantee |
|---|---|---|---|
| Rules | No | A condition matches | Immediate and deterministic |
| AI | Yes | Trusted generation enabled | Schema-validated output |
| Fallback | No | No valid result | Conservative typed action |
AUTHORITY & SAFETY
A recommendation is never permission.
The client may
- Evaluate deterministic rules
- Create local decisions
- Track non-sensitive events
- Serialize engine payloads
The client may not
- Hold PlayState or provider keys
- Mutate protected profiles
- Claim rewards directly
- Administer live events
- AuthenticateVerify players and sessions on your backend.
- ConstrainSend the smallest action allowlist.
- ValidateCheck every payload inside the game.
- AuditLog mutations without recording secrets.
USE CASES
One director, many adaptive systems.
Keep challenge in range
Respond to deaths, health, success rate, or mastery.
Shape session rhythm
Move between pressure, recovery, and exploration.
Match the current state
Choose composition and intensity from bounded options.
Add contextual goals
Generate structured optional content server-side.
Make progress relevant
Suggest allowed items, currency, or unlocks.
Respond to populations
Coordinate challenges through server authority.
DEVELOPER MODEL
Integrate incrementally.
Start with one local rule and add telemetry, adapters, or trusted generation only when the game needs them. PlayState does not require an all-or-nothing architecture.
Local prototype
Define allowed actions and evaluate rules.
Runtime connection
Map typed actions into the game registry.
Measured sessions
Track events and aggregate session state.
Trusted intelligence
Add authenticated structured generation.
The TypeScript SDK is MIT licensed and distributed as ESM and CommonJS with declarations and source maps.
npm i playstate-labs ↗ROADMAP
From SDK primitives to a complete direction layer.
Roadmap items describe current intent, not guaranteed release dates.
SDK foundation
- Typed decisions
- Rules and fallbacks
- Trusted AI methods
- Runtime adapters
Developer operations
- Decision observability
- Rule simulation
- Configuration management
- Expanded examples
Direction platform
- Collaborative tuning
- Experiment comparison
- Population insights
- More engine tooling
CONCLUSION
Every player.
The right challenge.
PlayState helps developers build games that respond with intent: deterministic where they must be, contextual where they can be, and authoritative at every boundary.