Introducing Actions - Operate Inside the Game Engine

Today, we launched Actions, a significant expansion of Bezi’s Agent Mode and what it can do inside the Unity editor. Until now, Bezi has been an exceptional game development partner: writing scripts, debugging complex interactions, and answering questions about your project. But building games involves a lot more than writing and understanding code.

Now, Bezi can create GameObjects, edit prefabs, configure components, generate materials, automate content pipelines, and more. These capabilities are still powered by the deep project understanding and contextual intelligence Bezi has of your game.

We built Actions with accuracy and safety as core requirements. Every change is checkpointed and can be undone, so you can move fast without worrying about breaking your game.

What’s New

While existing tools like Cursor excel at coding related tasks, they stop at the script file for game development. Unity development happens across the Inspector, Hierarchy, and Project windows just as much as it does in your IDE. Bezi bridges that gap with Actions.

Editing Scenes and Prefabs

Beyond scripts, Bezi can now create GameObjects, reparent objects, rename them, instantiate prefabs, create primitives, and more. Actions works with multiple open scenes and can find and open the correct scenes and prefabs to edit. This extends Bezi's reach from script files to the full editor environment.

Creating and Updating Materials

Like custom MonoBehaviours and ScriptableObjects, Bezi understands your shaders and what properties are exposed by them. This makes creating material variants straightforward. Actions enables it to also edit most assets since any AssetImporter settings can be read and modified, and assets that can be created inside Unity (PhysicsMaterials, LightingSettings, etc.) can also be created using Actions.

Adding and Updating Custom MonoBehaviours and ScriptableObjects

Bezi can now understand and edit properties of any MonoBehaviour in your project. It can add and update custom MonoBehaviours on GameObjects, and the same capabilities extend to ScriptableObjects: create new instances or update existing ones. This is particularly useful for automating tedious content creation processes and technical art pipelines.

Context Gathering with Scenes and Prefabs

Bezi's context gathering capabilities were previously centered around currently open scenes. With Actions, Bezi can now use its agentic capabilities to open scenes and prefabs, inspect their structure, read component configurations, and understand asset references. This means Bezi can look into how any scene or prefab is laid out, what components are on each object, what properties are set on those components, and what assets are referenced.

Accuracy First: Three Layers of Protection

Unlike agents that make changes and hope for the best, Actions is designed to be safe and non-destructive. Every action goes through multiple validation checks before touching your project:

1. TypeScript Compilation: The generated code is type-checked before execution. Invalid code (like assigning a string to a number) is caught and corrected by the agent.

2. Unity-Side Validation: The Unity plugin verifies that all referenced asset paths and GameObject paths actually exist before execution.

3. Checkpointing: Before any file is modified, Bezi creates a backup. You can restore your project to the exact state before the action with one click—even for files not yet in version control.

You remain in control. Every change is reviewable, and every file modification is checkpointed. If Bezi makes a mistake, it's one click to undo. This level of safety and human oversight is what separates Bezi from experimental agent frameworks and makes it built for production workflows.

How It Works: A Unity-Aware TypeScript Sandbox

Under the hood, Bezi Actions is built on a secure TypeScript execution environment. When you ask Bezi to make changes, it generates TypeScript code that gets executed in that sandboxed environment, producing validated JSON actions that are then safely applied to your Unity project.

Why TypeScript? LLMs are extensively trained on TypeScript, making them highly reliable at generating correct code in this language. We've built a high-level TypeScript API that mirrors Unity's editor capabilities, dynamically generated to match your project's custom MonoBehaviours, ScriptableObjects, and shaders. This gives Bezi a clear, structured way to interact with Unity while maintaining safety and predictability.

The result is that Bezi can reliably cover the broad range of actions you perform daily in Unity, from creating UI layouts to setting up rigs, without the brittleness of free-form code execution.

How Devs and Studios Are Already Using Actions

Creating UI

Actions covers the full API surface area of the UGUI and TextMeshPro frameworks, making UI implementation significantly faster in a complete iteration loop:

• Attach a design mockup → Bezi analyzes it and creates the Canvas hierarchy

• UI components are added automatically → Buttons, Text, Images, Sliders, InputFields, Toggles, and more

• Layouts and anchors are configured → RectTransforms, Layout Groups, and Content Size Fitters set up correctly

• Iterate directly → Bezi can update the hierarchy when you need to adjust spacing or add new elements directly within a prefab

This workflow is particularly valuable for designers who can now implement and iterate on UI without pulling engineering resources. Developers use it to prototype interfaces quickly and hook up functionality, then spend their time on the logic rather than hierarchy setup. Teams report cutting UI implementation time from hours to minutes.

Building Rapid Prototypes

When Bezi writes code for a new mechanic, it can now immediately attach those scripts to GameObjects in your scene. The setup that used to require manual Inspector work now happens automatically:

• Script gets attached to the correct GameObject

• Component properties are configured with sensible defaults

• Related components (Rigidbody, Colliders, etc.) are added and configured

• Input mappings and references are established

You spend your time tuning values and refining gameplay feel rather than populating the Inspector. The bulk of the setup work is handled, so you can jump straight into playtesting.

General Workflow Automation

When combined with Pages, Actions can take game design documents from concept to implementation. Teams are using this to automate repetitive content creation across several different processes:

• Content Creation:

  • Document your item system in a Page with stats and properties and add a list of new weapons, enemies, or abilities

  • Bezi generates the corresponding ScriptableObjects, populates their properties, and organizes them in your project folder structure

• Art Pipeline Automation:

  • Technical artists document material specs and shader variants in Pages

  • Bezi creates material instances, configures shader properties, and sets up texture references, while generated material variants remain consistent across the project

• Data Entry Elimination:

  • Designers specify quest structures, dialogue trees, or level configurations in natural language

  • Bezi translates these into properly configured ScriptableObjects and prefabs to eliminate manual data entry across content pipelines

Actions is automatically included as a part of Bezi’s Agent Mode and is available to all Bezi users. Try it in your next prototype, debug session, or content creation workflow today.

To learn more about how to use Actions, check out the product documentation.