Why Settle for Small Talk?
vibery is a closed-loop AI game SDK for teams that want agents to reason, read typed game state, and act inside the loop. Reason, See, and Play are live in the alpha; Talk and durable memory are in active build.
Private alpha · local Unity runtime · cloud and local-compatible LLM transports
Dialogue-only SDKs can answer questions. vibery helps studios ship agents that read typed game state, make decisions, and act inside the loop.
Runtime
Unity runtime runs locally; embedded inference is WIP.
Execution
Structured APIs or Lua sandbox.
Memory
IMemoryStore interface; persistent store WIP.
Embodiment
Players, devs, or templates.
Dialogue SDKs talk. vibery runs the loop.
The market already has plenty of chat surfaces. vibery is built for typed perception, planning, action, diagnostics, and the WIP surfaces needed for memory and co-op crews.
Talk
Mostly chat-first. Good for prompts, thin on control.
ITalkChannel defines the interface; shipped voice and dialogue channels are WIP.
Reason
Usually hidden behind a single text response.
LlmAgentBackend, structured C# policies, Claude/OpenAI reasoners, and local-compatible endpoints.
See
No direct world perception.
Typed game-state and perception snapshots through IPerception and LuaPerceptionBridge.
Play
Ends at conversation.
IActionBinder, ActionCommand, Lua sandbox execution, and AsterDROIDS agent control.
Remember
Session-local at best.
IMemoryStore defines the interface; persistent memory implementation is WIP.
Talk, reason, see, play, remember.
Each capability maps to a concrete SDK surface. The public status language is intentionally limited to LIVE, WIP, and ROADMAP.
Talk
WIPITalkChannel is the public interface. Voice, dialogue, and shipped conversation surfaces are still under active build.
Reason
LIVELlmAgentBackend runs Claude/OpenAI reasoners, local-compatible OpenAI endpoints, and structured C# policies.
See
LIVEAgents receive typed game-state and perception snapshots supplied by the game, not raw screen reading.
Play
LIVEIActionBinder and ActionCommand route decisions into governed game actions, with Lua sandbox execution live today.
Remember
WIPIMemoryStore is present as the integration point. Durable cross-session memory is not live yet.
Closed loop by design.
Game state flows into the SDK, the Unity runtime runs locally, LLM transports can target cloud or local-compatible endpoints, and actions return through structured APIs or the Lua sandbox.
Step 1
Game State
Entities, inventory, world state, objectives, and player intent.
Step 2
SDK
Typed snapshots, decision surfaces, and policy hooks.
Step 3
Agent Runtime
Unity-side runtime with Claude/OpenAI transports and OpenAI-compatible local endpoints; embedded inference is WIP.
Step 4
Execution
Structured API calls for control, or MoonSharp Lua sandbox for flexible logic.
Structured APIs use typed functions when you want agents to stay inside a narrow, predictable control surface.
MoonSharp Lua sandboxing gives designers flexible game-side logic without turning every interaction into custom backend code.
Your agents, your way.
The API shape covers player-brought agents, game-authored characters, and templates. Portable production embodiment is WIP, not a live distribution promise.
Players bring their own
WIPPlayer-brought embodiment is represented in the public API; portable production flows are still in build.
Devs craft the characters
WIPGame-crafted agents can be modeled through the SDK surface while voice and portability mature.
Start from templates
WIPTemplate hooks exist in the API shape. Production-ready starter templates are not public yet.
Portability is the target; the current SDK exposes the contracts.
Crew coordination without cloning personalities.
Crew and director interfaces exist in the SDK surface. Full multi-agent orchestration is WIP while the live runtime focuses on per-agent decision and action loops.
Personality differentiation
Each agent keeps a distinct voice, tone, and decision style so the crew never feels cloned.
Role specialization
Scouts scout, strategists plan, healers support, and analysts compress what matters.
Agent-to-agent coordination
Agents can delegate, confirm, and hand off work instead of each one reasoning in isolation.
Crew composition
Studios can tune squads, parties, and specialist roles to match a genre or combat loop.
Compound AI for worlds that keep moving.
Procedural encounters, dynamic narrative, character generation, and context compression are ROADMAP product areas that will build on the same runtime contracts.
Procedural encounters
Dynamic narrative
Character generation
Context compression
Second title
[REDACTED]
Reserved until the NDA window clears.
Proof, not promise.
AsterDROIDS is the first integrated proof-of-concept and game integration. It proves the live loop, not every roadmap feature.
AsterDROIDS
The first integrated proof-of-concept shows the SDK loop in a real game: Unity runtime, typed perception, live agent decisions, and action execution.
AI drones read the game state
Agents pick targets and maneuvers through actions
Players can co-op or let the crew run solo
Locked / blurred
[REDACTED]
Reserved until the NDA window clears. The page should imply there is more without naming it.
Everything studios ask for once the demo works.
The category is bigger than the agent runtime. Playtesting, analytics, templates, dev tooling, Lua execution, and distribution all matter, with status kept explicit.
Playtesting
WIPAsterDROIDS and arena-mode prove agent control; productized live automation for regressions and balance is WIP.
Analytics
LIVESDK Monitor, circuit breakers, backend activity logs, failure isolation, and per-agent health are live diagnostics.
Dev Tools
LIVESetup Wizard, structured APIs, SDK Monitor, typed contracts, and fast iteration loops for builders.
Lua Sandbox
LIVEMoonSharp execution ships with instruction budgets, sandbox checks, and circuit-breaker resilience.
Templates
WIPCommon game genre templates, agent archetypes, and embodiment starter kits are represented by API hooks.
Distribution
ROADMAPPublishing agent-enabled games into the vibery ecosystem is planned after the SDK surface stabilizes.
Signal on pricing, not final packaging.
The exact numbers are not final, but the product shape is clear: a free entry point, an indie path, and a studio tier. The Unity runtime runs locally; cloud and local-compatible LLM transports are supported.
Free
WIPFor evaluation, prototypes, and personal experiments.
Unity runtime runs locally
Cloud and local-compatible LLM transports
Community docs
Indie
WIPFor solo devs and small teams building their first shipping title.
Unity runtime runs locally
Playtesting WIP
Diagnostics and resilience tooling
Studio
WIPFor multi-title teams, larger deployments, and platform integration.
Unity runtime runs locally
Studio deployment controls on the roadmap
Roadmap input
Final pricing has not been locked. This is a positioning preview, not a quote.
Live, WIP, roadmap.
The roadmap is intentionally explicit so developers can tell what is already real, what has interfaces or active build work, and what stays farther out.
Live
LIVELocal Unity runtime
Lua sandbox (MoonSharp)
Structured C# policies and game-facing APIs
LlmAgentBackend with Claude/OpenAI and local-compatible endpoints
SDK Monitor diagnostics and per-agent health
AsterDROIDS first integrated proof-of-concept
WIP
WIPITalkChannel voice/dialogue implementation
IMemoryStore persistent memory implementation
Embodiment portability and templates
Multi-agent orchestration interfaces
Productized playtesting automation
Embedded Sentis/llama.cpp inference
Roadmap
ROADMAPDistribution channel
Mod workshop
Studio deployment controls
Packaged reporting and studio dashboards
Your Players Deserve Better Than Scripted NPCs.
Join the private alpha if you want to build agents that read typed game state, reason through the loop, and act through governed game APIs.
Limited alpha slots available