ARCHITECTURE SPEC: CONTENT GENERATION: NONE LANGUAGE MODELS: NONE NET DISPATCH: 0 BYTES CPU BUDGET: BOUNDED

Actorics is not generative AI in any form. It does not generate art, audio, text, levels or dialogue. The runtime selects an action from a set your designers authored — the same thing a behavior tree does, except the opponent stops falling for the same tactic. No language models. No network calls. No tokens.

On-device behavioral runtime for game characters.

Opponents, bosses and squadmates that stop falling for repetitive player tactics during combat. Evaluated locally on the CPU within your frame budget. Zero network calls. Zero cloud token bills. Fully constrained by Designer Envelopes.

1
The player repeats one moveRolls behind the boss and strikes.
2
The boss spots the patternThree repeats of the same move are enough.
3
The boss stops falling for itIt reads the roll, steps back and blocks. Same speed, same damage.
Just watch — it plays by itself and restarts every ~25 seconds.Or try it: click the arena, ←↑↓→ move, ShiftShift roll, Space strike.
ATTRACT · PLAYER REPEATS ROLL_BEHIND [0/3] T+00:00.000
Click the arena to take control
WASD move · Space strike · Shift×2 roll · P pause
SCRUB — / —

This sandbox is a JavaScript illustration of the mechanic, not the Actorics core. Timing values come from the Envelope controls below; no performance number is measured here.

AGENT_STATE:
COMBAT_ENGAGED
EVALUATION_CORE:
ON-DEVICE CPU
TICK_RATE:
60 Hz (FIXED STEP)
POLICY:
LEARNING
DETECTED_EXPLOIT:
NONE
ENVELOPE_STATUS:
CONSTRAINED_OK
NET_DISPATCH:
0 BYTES (LOCAL)
FRAME_OVERHEAD:
— . — — µs [AWAITING HARNESS]
SEC.02 / PROBLEM

Gameplay combat breaks down in the frame budget.

Hand-authored trees get solved by players. Cloud agents don't fit in a frame. The behavioral layer sits between the two, and it is still written by hand.

INDUSTRY STANDARDSTATIC

Static behavior trees

  • The player finds a dominant tactic within minutes and repeats it for the rest of the encounter.
  • Every new enemy type means hours of manual tree tuning by a programmer.
  • Designers can't change behavior without a code change.
GENERATIVE CLOUD AGENTSEXTERNAL

Remote inference per character

  • External inference with round-trip latency that combat timing can't absorb.
  • A running bill per session, per player.
  • Late decisions break animation blending and telegraphs.
  • Live generation requires a storefront AI disclosure.
ACTORICSLOCAL

Behavioral runtime

  • A compact state evaluator on the player's CPU. No GPU, no server.
  • Punishes repetition of a single tactic instead of scaling damage or health.
  • Runs inside hard boundaries set by your designers.
  • Target: zero allocations per tick, zero external dependencies.
SEC.03 / ARCHITECTURE

Dynamic adaptation inside rigid designer boundaries.

One tick, five stages. The controller proposes; the Envelope decides what is allowed; commitment keeps animation intact. Select a stage.

Designer Envelope

These values drive the sandbox above and the struct on the right.

Recovery window after an attack. Adaptation can never shorten it.

The designer sets the delay; the floor is fixed at 150 ms.

How much better a new action must score before the current one is dropped.


    
SEC.04 / WORKLOADS

Four workloads. Zero content generation.

The same runtime, pointed at four jobs studios already pay for in hand-tuning, QA hours or empty lobbies.

SHIPS IN GAMECLIENT

Adaptive Boss Encounters

GENRES
Action-RPG, soulslike, character action
WHAT CHANGES
Tempo, counter choice and positioning. Damage and health stay where the designer set them.
NEVER SHIPSPRE-RELEASE

Automated Playtest & QA Agents

GENRES
Any, before release
WHAT IT FINDS
Collision holes, geometry exploits, balance breaks. Headless builds, no cloud training cluster.
LIVE SERVICEDEDICATED SERVER

Human-like Lobby Fill Bots

GENRES
Battle royale, tactical shooters, extraction
HOW IT RUNS
On the dedicated server with standard actor replication. No cloud bill per match.
ASYNC MULTIPLAYERPROFILE

Adaptive Ghost Profiles

GENRES
Racing, fighting, speedrun
WHAT IT IS
A player's style as a portable profile. Race a live opponent that drives like your friend, not a frame-by-frame replay.
SEC.05 / TELEMETRY

Hardware telemetry & verification specification.

Nothing below is estimated. A value appears when the testbench harness produces it; until then the slot stays empty. Hover an empty slot to read the protocol.

CHANNELTARGET SPECIFICATIONSTATUSMETHOD
CPU time per agent tickBounded, single core, no GPU
— . — — µsAWAITING TESTBENCH HARNESS
Engine profiler, mean and peak per frame
Scaling to 50+ active agentsLinear, inside frame budget
— . — — msAWAITING TESTBENCH HARNESS
1 / 10 / 50 agents, same scene
Memory per characterFixed pool, allocated at spawn
— — KBAWAITING TESTBENCH HARNESS
Module plus learned state, measured size
Learned state save sizeFits native SaveGame slot
— — BAWAITING TESTBENCH HARNESS
Serialized blob, versioned format
Network traffic0 bytes
BY CONSTRUCTION [0 BYTES]
By construction: the runtime opens no sockets
Allocations inside tick0
SPECIFIED TARGET
Allocation tracing under profiler. Target, not yet a result
Cross-platform determinismBit-identical actions, x86-64 and ARM64
IN PROGRESS
Record inputs, replay 100×, compare action hash

We don't publish synthetic benchmarks. Every value will be published raw, without smoothing, together with the testbench project.

SEC.06 / INTEGRATION

Native tooling integration. No standalone runtimes.

Every decision is written into the debugger your team already opens. Pause the fight, scrub back two seconds, read why the character did what it did.

ANTICIPATIONCOMMITMENT → RECOVERY

10:30:22.140 [PERCEPTION] PLAYER SPAM DETECTED: ROLL_LEFT (COUNT: 4)

10:30:22.142 [DESIRED] FIRE ACTION: SWEEP_LOW_COUNTER

10:30:22.143 [ENVELOPE] PASSED: REACTION_TIME 180ms >= FLOOR 150ms

10:30:22.144 [COMMITMENT] LOCKED: POINT_OF_NO_RETURN REACHED

Illustration of the log format.

UNREAL ENGINE 5Native C++. Trace streams into Visual Logger.
UNITYC#, DOTS-compatible. Scene View gizmos and Profiler markers.
DEPENDENCIESNo external virtual machines. No Python stack.
SEC.07 / LICENSING

Transparent licensing. Verifiable source code.

The core is open so anyone can check it. Studios pay for engine integration, tooling and the author in the pilot.

TIER AOPEN

Community & Open Core

Free · MIT-0

  • Base runtime algorithm
  • Minimal C / Rust reference implementation
  • Verification testbench
TIER BCOMMERCIAL

Production Engine Integration

Fixed fee per title, or optional 1% royalty

  • Unreal Engine 5 and Unity plugins
  • Designer Envelope editor
  • Visual Logger and Profiler hooks
TIER CPILOT

Design Partner Program

Fixed fee per pilot

  • For studios in pre-production or on a vertical slice
  • Integration with the author of the technology
  • One encounter calibrated, blind playtest report delivered
> Opens your email client with the request filled in. No client? Write to pilots@actorics.com.