Research

One runtime. Three audiences.

Building autonomous agents in a simulated environment means rebuilding the same runtime infrastructure every time. Origin Foundry builds that layer once, in the open — for AI engineers, autonomous-systems researchers, and game developers alike.

Game Developers

Stop scripting. Start simulating.

Biomata replaces brittle NPC scripting with a runtime designed for genuine autonomy. Agents plan, react, remember, and adapt without you scripting every possibility.

The Unity SDK connects your game engine to the Python runtime over an open WebSocket protocol. Your engine owns world state. Biomata runs cognition and returns commands. No lock-in.

Unity SDK docs

Autonomous NPC Systems

Engine

Replace state machines and behavior trees with genuine cognitive agents. NPCs that perceive their world, form goals, remember outcomes, and act with internal consistency.

Emergent Simulation Behaviors

Engine

Design the rules; let the behavior emerge. Biomata agents interact through world abstraction rather than scripted triggers, producing behaviors that can surprise even their designers.

Pluggable Cognition

Engine

Start with IdleBrain for deterministic testing. Swap to OllamaLLMBrain when you want generative behavior. Change one YAML line — no code changes, no rebuild.

Unity Integration

Unity SDK

The Unity SDK implements Protocol v1 in C#. BiomataManager connects to the Python runtime, AgentClient sends observations, TickClient drives cognition from FixedUpdate.

Other Engines via Protocol

Protocol

WebSocket Protocol v1 is fully documented and engine-agnostic. Implement it for Godot, Bevy, a browser client, or any engine — the spec is open.

Deterministic Debug Loop

Engine

Seed the RNG, reproduce the exact sequence of agent decisions that caused a bug. Run the same config twice and get identical outputs. Scripted and LLM brains both support this.

AI Engineers

An agent runtime you can actually control.

Biomata gives you a structured execution model for autonomous agents — not an LLM wrapper with a loop bolted on. The protocol, cognition lifecycle, and extension points are all explicit and documented.

Swap brains, world models, and action sets via YAML. Drive ticks over WebSocket from any client. Replay deterministically. Instrument via the event stream.

Protocol docs

Protocol-Driven Experimentation

Protocol

Drive the simulation tick-by-tick over WebSocket from any language. Send observations, call tick, receive decisions as structured JSON. Build harnesses in Python, Go, TypeScript, or anything with a WebSocket library.

Brain Swapping via Config

Engine

Change a single YAML class path to replace a brain implementation. Run LLM and rule-based agents side-by-side in the same simulation. Compare behavior without changing any runtime code.

Custom Action Spaces

Engine

Define domain-specific actions by implementing ActionHandler. Register them in the ActionRegistry. Agents receive the available action list as context on every tick — no hardcoding.

Bring Your Own Environment

Engine

Implement the World Protocol in Python to define any simulation domain. Or use HostedWorld to let an external process own state while Biomata runs cognition.

Event Stream Instrumentation

Protocol

Subscribe to tick_start, tick_end, brain_decided, action_completed events over the WebSocket connection. Build your own observability layer without modifying the runtime.

Deterministic Replay

Engine

Set a seed in the YAML config and the RNG is fully deterministic. Use ReplayBrain to replay a recorded decision sequence exactly. Essential for debugging emergent behavior.

Researchers

Reproducible by default.

Biomata provides the experimental infrastructure that agent systems research has long lacked: deterministic execution, modular cognition primitives that can be varied in isolation, and an event stream you can instrument without modifying agent behavior.

Whether you're studying emergent social behavior, benchmarking decision architectures, or mapping the dynamics of synthetic populations, Biomata gives you the control and visibility to do it properly.

View example simulations

Reproducible Simulation

Engine

Deterministic execution modes ensure your simulations produce identical results from identical inputs. Set a seed, share the config, and collaborators reproduce the exact same run.

Controlled Experimentation

Engine

Vary a single cognitive component while holding all others constant. Swap memory implementations, brain architectures, or action sets via YAML config — no code changes across conditions.

Event Stream Observability

Protocol

Subscribe to the WebSocket event stream to capture tick_start, brain_decided, and action_completed events for every agent on every tick. Build your own analysis pipeline on top of structured JSON.

Modular Cognition Research

Engine

Swap cognitive modules independently: test different memory architectures, decision strategies, or perception models in isolation using a common execution runtime and comparable action space.

Deterministic Benchmarking

Engine

Run the same simulation config with seeded RNG and a scripted ReplayBrain to evaluate behavioral quality reproducibly. Identical inputs, identical outputs, every time.

Synthetic Society Exploration

Engine

Study emergence, collective behavior, and social dynamics in populations of autonomous agents. The social graph, action side-effects, and memory systems interact to produce emergent outcomes.

Shared Foundation

The protocol is the platform.

WebSocket Protocol v1 is what makes Biomata engine-agnostic. It's a fully documented, JSON-over-WebSocket spec that any engine can implement. Unity implements it. The Python test harness implements it. You can implement it for Godot, Bevy, a browser, or a custom simulation environment.

This is the moat, not the Unity SDK. The SDK is the reference implementation. The protocol is the standard.

Engine-agnostic

  • JSON text frames over WebSocket
  • Debuggable with wscat or DevTools
  • Any language with a WebSocket library

Well-specified

  • Full frame envelope docs
  • All methods with request/response shapes
  • Complete error code table

Observable

  • Subscribe to any event type
  • Seq counter detects dropped events
  • Snapshot/restore for replay
Protocol spec → Build your own client →

Ready to build?

Start with the 2-minute quickstart, then explore the examples closest to your use case.

Quickstart Examples Contact Us