# Usage Analytics and Limits
Source: https://docs.bezi.com/account/analytics
View Member's usage metrics, track adoption patterns, and set credit limits in the Usage dashboard.
Per-Member usage data and limits are only available on Enterprise plans.
## What’s usage analytics and limits?
Enterprise account Admins can now view usage data and set usage limits per team member.
Members can view their credit usage and limits and request more credits in their [Accounts](https://app.bezi.com/account) dashboard.
![Admin Member Usage View]()
## Data Access by Role
| | Admin | Member |
| ----------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | --------------------------- |
| **Usage Overview**
Total Credit Pool and Credit Usage | Usage breakdown
per member | No per-member
details |
| **Member Credit Limits**
Custom Limits, Usage to date, Pending Requests | Table of all
Member data | Only their data |
| **Usage History**
Every prompt with the date, mode, model type, credit cost
Filters for time range, mode, and model type | Logs of all
Member data | Only their data |
## Admin Permissions
### Set Member credit limits
1. Confirm you are the account Admin
2. Open the [Account](https://app.bezi.com/account) page > select the organization
3. Open `Usage` > scroll to Credit Limits section
4. Turn on **Credit Limit per Seat**
5. Enter a default **Credit Limit** and click `Save`
6. To override the default spend limit for a member, locate their row in the **Team Member** **table** and add a **Custom Credit Limit** number
### Approve Member credit requests
**Members cannot prompt Bezi once they hit their credit limit**. To continue using Bezi, the Admin must open [Account](https://app.bezi.com/account) dashboard and either:
1. Increase the member’s credit limit (can adjust the Default or the Custom Credit Limit)
2. Approve the Member’s request for more credits
When a Member requests extra credits, Admins receive an email. In the Dashboard, Admins will see a **Pending request** next in the member’s **Team Member Credit Limits** row (for example, +2,000). Click `...` in their row to approve or deny the request.
If your organization's total credit pool is exhausted, approving a request won’t add more credits to the total pool. The Admin will need to contact the org’s Bezi account contact to purchase additional credits.
### Edit or remove a custom limit
Credit limit changes will take effect immediately.
1. Open the [Account](https://app.bezi.com/account) page > select the organization
2. Open `Usage`
3. Find their row in the **Member Credit Limits** table
4. Edit: Change the number in their **Custom Credit Limit** column
5. Remove: Click `...` at the end of their row > `Remove limit`
## **Member Permissions**
### Request more credits if you hit your limit
**You're blocked from prompting Bezi once you hit your credit limit.** Request more credits from the Admin to continue work:
1. Open your [Account](https://app.bezi.com/account) page > select the organization
2. Open `Usage` > scroll to Credit Limits section
3. Click the `...` button next to your row
4. Submit the credit request
5. Account Admins receive an email notifying them of the request - if urgent, ping the Admin directly to speed the approval process
# Billing
Source: https://docs.bezi.com/account/billing
### How do I access billing settings?
From Bezi, navigate to Account Settings > Subscription & Usage and clicking "Manage subscription". This opens a secure page for all billing and subscription tasks.
You can also access directly at: [**https://app.bezi.com/account**](https://app.bezi.com/account)
### How do billing cycles work?
Your billing cycle starts on the day you subscribe to a plan and renewals happen on that date, at the exact time, every month. At renewal the payment method on file is automatically charged by Stripe and, if payment goes through, your credit limit is refreshed.
### How do I start a subscription?
Open your [account dashboard](https://app.bezi.com/account) and select the plan. This will open a secure Stripe billing portal where you:
1. Select between monthly or yearly (20% discount) billing
2. Add payment method
3. Click `Subscribe`
### How do seats work for Teams accounts?
Teams accounts come with 3 seats included and each additional seat is an extra charge. All extra seats' credits contribute to the Team credit pool. Team admins manage seats through the account dashboard.
### What is Bezi Cash?
Bezi Cash is a balance attached to your Bezi account. When you have a Bezi charge, such as a subscription renewal or on-demand credit purchase, Bezi will deduct from your Bezi Cash balance before charging your card on file.
You receive Bezi Cash when you upgrade an active yearly subscription tier. This is how you receive an auto-refund on any remaining months you prepaid for.
### How do I update my active subscription?
You can upgrade, downgrade, or cancel paid Bezi subscriptions. All changes happen in the [account dashboard](https://app.bezi.com/account).
Upgrades are defined as moving up a subscription tier or from monthly to yearly billing.
**Upgrades go into effect immediately**. The active subscription is immediately cancelled and the new subscription is started. This will reset your monthly credits and the new billing cycle starts the day/time you upgrade.
1. Open your [account dashboard](https://app.bezi.com/account)
2. Select monthly or yearly (20% discount) billing
3. Select the plan you want to upgrade to
4. Review the payment popup thoroughly
5. Select `Pay Now` to execute the upgrade
If you’re currently on a yearly subscription, you’ll receive a refund in Bezi Cash for any pre-paid, unused months. It will go towards any future purchases through Bezi, such as a subscription renewal or on-demand credits.
If you’re on a monthly subscription, we recommend using all your credits prior to upgrading. Credits do not roll over and we cannot issue credit refunds.
Downgrades are defined as moving down a subscription tier. These **go into effect at the end of the billing cycle**.
Your active subscription billing cycle and credit limit will not change until then.
1. Open your [account dashboard](https://app.bezi.com/account)
2. Update the toggle for monthly or yearly (20% discount) billing
3. Select the plan you want to downgrade to
4. Review the payment popup thoroughly
5. Select `Confirm` to execute the downgrade
Cancellations **go into effect at the end of the billing cycle**. Your active subscription billing cycle and credit limit will not change until then.
1. Open [account dashboard](https://app.bezi.com/account) > Subscription & Usage tab
2. Select `Manage Subscription` to open your Stripe billing portal
3. Select ` Cancel`
### How do I update my billing information?
1. Open [account dashboard](https://app.bezi.com/account) > Subscription & Usage tab
2. Select `Manage Subscription` to open your Stripe billing portal
3. Update your billing information
### How does Bezi manage and protect my billing information?
We use Stripe to securely manage subscription billing information. Any changes will be made in your Stripe billing portal.
### Where can I access my invoices and receipts?
Your entire billing history, along with invoices and receipts, is available in your Stripe billing portal.
1. Open [account dashboard](https://app.bezi.com/account) > Subscription & Usage tab
2. Select `Manage Subscription` to open your Stripe billing portal
3. Navigate down to the **Invoice History** section
4. Select the invoices or receipts to download
### I have other billing questions not listed here
Email [**support@bezi.com**](mailto:support@bezi.com) and include the email associated with your Bezi account. Our team will respond ASAP!
# Plans and Credits
Source: https://docs.bezi.com/account/plans
## Plan options
See [**bezi.com/pricing**](https://www.bezi.com/pricing) for plan options and pricing.
| Plan | Price | Credits per month |
| ------------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Trial** | Free | 100 (one-time) |
| **Pro** | \$20/mo | 800 |
| **Advanced** | \$60/mo | 2,400 |
| **Ultimate** | \$180/mo | 7,200 credits |
| [**Team**](/account/team) | \$200/mo | 8,000 pooled, 3 seats included, unlimited workspaces, [Team Workspaces](/fundamentals/team-workspaces) and [Shared Pages](/context/pages), centralized billing and team management
(can add more seats, which will increase team's credit pool) |
| **Enterprise** | Custom | Custom credit and seat limits, [Team Workspaces](https://docs.bezi.com/fundamentals/team-workspaces), [Shared Pages](https://docs.bezi.com/context/pages), [Enterprise Admin Analytics](https://docs.bezi.com/account/analytics), Enterprise security and compliance, SSO, MSA/SLA, etc. |
## How credit usage is measured
This depends on the model used, task complexity and size - specifically, how many steps Bezi takes to complete the work.
1. Open [account dashboard](https://app.bezi.com/account) > **Usage** tab
2. Toggle on **Enable usage-based pricing**
3. Set your monthly spending limit
4. Click `Save`
5. Log out of Bezi completely and back-in before continuing your work
## View your usage
To see a per-prompt breakdown of credit usage, including which model was used and how many credits each prompt consumed:
1. Open [app.bezi.com/account](https://app.bezi.com/account)
2. Select the **Subscription & Usage** tab
## On-demand usage
If you hit your plan's credit limit before renewal, you can enable on-demand credits to keep working.
1. Open [app.bezi.com/account](https://app.bezi.com/account)
2. Select the **Subscriptions & Usage** tab
3. Toggle on **Enable on-demand usage**
4. Set your monthly spending limit
5. Click `Save`
Overage credits are priced at **\$0.05 per credit**. Charges are applied at regular intervals, not at the end of the month. If a payment fails, you won't be able to prompt Bezi until the payment succeeds.
## Credit reset at billing renewal
Credits reset to your plan's monthly limit at each billing renewal. Unused credits from the previous cycle do not roll over.
See [Billing](https://docs.bezi.com/account/billing) for information on upgrading, downgrading, and managing your subscription.
# Team Management
Source: https://docs.bezi.com/account/team
Teams are only available on Team and Enterprise plans.
A Team is an organization-level hub, created for groups with Team or Enterprise plans. A Team contains the following:
* **Team Roles (Admin or Member)**; Admin(s) can view, add, manage and monitor all Member licenses and usage in one place
* [**Team Workspaces**](https://docs.bezi.com/fundamentals/team-workspaces); A Team can hold endless Team Workspaces. Each Team Workspace is unique, with it's own subset of members and shared materials for a given purpose. Read more about a Team Workspace here
* **Credit pool**; A Team's monthly credits are shared across all Team Members so everyone has access to the credits they need as Unity work fluctuates. Adding extra team members will add more credits to the total pool
## Team Roles
* Can invite and remove Team members
* Can purchase and manage seats
* Can manage Team-level settings
* Can create Team Workspaces
* Can invite existing Team members to Workspaces
* Create and edit content within Team Workspaces they belong to
* Can create Team Workspaces
* Can invite existing Team members to Workspaces
* Create and edit content within Team Workspaces they belong to
## Creating a Team and adding members
To create a Team, follow these steps:
1. **For new users**: Visit [bezi.com/pricing](https://www.bezi.com/pricing) and select the Team plan
2. **For existing users**: Go to your [account dashboard](https://app.bezi.com/account) and click `Upgrade to Team`
1. Open **Account settings**
2. Navigate to the **Subscription** section
3. Confirm the account labeled`Team` is selected, or select it from the dropdown
1. Navigate to the **Subscription** section of **Account settings**
2. Click `Team Settings `
3. Go to **Team members** section
4. Enter email addresses and send the invites
If all purchased seats are full, invites will be blocked. The Team Admin must purchase more seats or free up existing ones before more invites can be sent.
1. Navigate to **Account settings** > **Subscription** section
2. Click `Team Settings `
3. Go to **Team members** section
4. Remove the desired Team members
When someone is removed from the Team, their access to all Workspaces is fully revoked. Any Shared Pages they created or added to will remain untouched.
# Usage Analytics and Limits
Source: https://docs.bezi.com/account/untitled-page
View Member's usage metrics, track adoption patterns, and set credit limits in the Usage dashboard.
Per-Member usage data and limits are only available on Enterprise plans.
## What’s usage analytics and limits?
Enterprise account Admins can now view usage data and set usage limits per team member.
Members can view their credit usage and limits and request more credits in their [Accounts](https://app.bezi.com/account) dashboard.
![Admin Member Usage View]()
## Data Access by Role
| | Admin | Member |
| ----------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | --------------------------- |
| **Usage Overview**
Total Credit Pool and Credit Usage | Usage breakdown
per member | No per-member
details |
| **Member Credit Limits**
Custom Limits, Usage to date, Pending Requests | Table of all
Member data | Only their data |
| **Usage History**
Every prompt with the date, mode, model type, credit cost
Filters for time range, mode, and model type | Logs of all
Member data | Only their data |
## Admin Permissions
### Set Member credit limits
1. Confirm you are the account Admin
2. Open the [Account](https://app.bezi.com/account) page > select the organization
3. Open `Usage` > scroll to Credit Limits section
4. Turn on **Credit Limit per Seat**
5. Enter a default **Credit Limit** and click `Save`
6. To override the default spend limit for a member, locate their row in the **Team Member** **table** and add a **Custom Credit Limit** number
### Approve Member credit requests
**Members cannot prompt Bezi once they hit their credit limit**. To continue using Bezi, the Admin must open [Account](https://app.bezi.com/account) dashboard and either:
1. Increase the member’s credit limit (can adjust the Default or the Custom Credit Limit)
2. Approve the Member’s request for more credits
When a Member requests extra credits, Admins receive an email. In the Dashboard, Admins will see a **Pending request** next in the member’s **Team Member Credit Limits** row (for example, +2,000). Click `...` in their row to approve or deny the request.
If your organization's total credit pool is exhausted, approving a request won’t add more credits to the total pool. The Admin will need to contact the org’s Bezi account contact to purchase additional credits.
### Edit or remove a custom limit
Credit limit changes will take effect immediately.
1. Open the [Account](https://app.bezi.com/account) page > select the organization
2. Open `Usage`
3. Find their row in the **Member Credit Limits** table
4. Edit: Change the number in their **Custom Credit Limit** column
5. Remove: Click `...` at the end of their row > `Remove limit`
## **Member Permissions**
### Request more credits if you hit your limit
**You're blocked from prompting Bezi once you hit your credit limit.** Request more credits from the Admin to continue work:
1. Open your [Account](https://app.bezi.com/account) page > select the organization
2. Open `Usage` > scroll to Credit Limits section
3. Click the `...` button next to your row
4. Submit the credit request
5. Account Admins receive an email notifying them of the request - if urgent, ping the Admin directly to speed the approval process
# ACP
Source: https://docs.bezi.com/acp
Agent Client Protocol (ACP) is a way to use Bezi's agent capabilities via an IDE.
## What is ACP? When do you use it?
ACP provides a communication channel between an IDE (Visual Studio, Rider, etc.) and agents like Bezi. If you want to work in your code editor UI and use the Bezi agent's rich context and superior typescript-based action execution method, this is an option.
## How it works
The Bezi ACP client connects your IDE to Bezi running on the same machine. When you send a prompt from the IDE:
* The **prompt, @-mentions, and attachments** are passed to Bezi
* Bezi does the actual execution work in Unity, working in whatever **workspace and project is open in the Bezi app**
* Results stream back into your IDE
* Start a **new chat session** in the IDE to begin a new thread in Bezi (follow standard best practice, one chat/thread per task, when using ACP)
## How to setup Bezi ACP in the IDE
> **Prerequisite**: The latest version of Node.js (version 22 or newer) must be installed and on your PATH. Install here: [https://nodejs.org/en/download](https://nodejs.org/en/download)
### 1. Activate the ACP server
* Open **Workspace Settings** > `App Settings`
* Toggle on the **ACP Server** (beta)
### 2. Configure Bezi
* Open the [Workspace](https://docs.bezi.com/fundamentals/workspaces) you want to work in
* Set the **Agent mode, model, and thinking effort** you want your prompts to use
* Activate any [Connections](https://docs.bezi.com/context/connections) or [MCPs](https://docs.bezi.com/context/mcp) you need Bezi to access
*Important: Keep the Bezi App open and running while you work!*
### 3. Configure your IDE
* Point your IDE’s ACP config at the Bezi bridge, which runs via `npx`
* **Do not** install anything globally: `npx -y @bezihq/acp@latest` fetches and runs the latest bridge automatically
## What's not supported (yet)
ACP covers most of Bezi, but a few App-only features aren't available in the IDE:
* **You cannot pin game objects** from the IDE
* **Rich previews of pages/plans**; diffs to your edited pages/plans will be rendered, but the final content and rich preview menus won’t
* **Accepting / rejecting checkpoints**; if you need to revert edits made in the current thread, **open that thread in Bezi** to revert to a previous point
## Troubleshooting
* **Editor can't connect / "waiting for Bezi"**: make sure the Bezi App is open/running and you've activated **ACP Server** in your **Bezi Settings** (Step 1)
* **Bezi can't see my project files**: Bezi works out of whichever Workspace is open in your app, not the IDE's project. Update the Workspace in Bezi to change what it has access to
* `npx `**errors**: confirm Node.js version 22+ is installed (`node --version`)
## Building custom experiences with Bezi ACP
The ACP standard can be used to drive the Bezi agent from more than just an IDE. You're free to try out other ACP-community-built apps, but try to build your own.
If you’re interested in building your own integration with Bezi ACP, we recommend you start by reading through the [ACP docs](https://agentclientprotocol.com/get-started/introduction).
# Connections
Source: https://docs.bezi.com/context/connections
These are the Workspace sources you give Bezi access to read from and write to. A**ll active Connections (other Unity projects, local folders) are available as read-only context for any thread in the same Workspace.** Connections are added and managed from Workspace settings.
Any Connections you add are private to you. Even if you're working in a Team Workspace, other members of the team cannot see or use the Connections you have added.
*Connection isolation is intentional. It ensures each team member can feed their Bezi agent the exact context needed for their work and won't be confused by a colleague's unrelated context.*
## Connection types
Enable Bezi to reference code or systems from a separate source to expedite work on the project or task at hand. All Connections are read-only context, unless they're the set as the thread's **target project**. Learn more about Target Project in [Threads](https://docs.bezi.com/fundamentals/threads).
### Unity projects
> Connect multiple Unity projects to a single workspace. In addition to linking your primary working environment, this is great for adding projects you want Bezi to reference for inspiration, copy systems from, etc..
### Local folders
> Connect any folders from your local filesystem. Great for non-Unity game migrations, asset pipelines, shared utility code, design docs, and any other context you want to give Bezi that lives outside of a Unity project.
## Managing Connections
Each Connection adds context for Bezi; monitor active Connections and disable ones that aren't relevant to a given task.
### Adding Connections
1. Open the **Workspace dropdown** (top of the left sidebar)
2. Select `Workspace Settings`
3. Navigate to **Your Connections**
4. Click `+` and select the Unity project or local folder
![Workspaces Connections]()
### Disabling or deleting Connections
Use the toggle to disable a Connection from Bezi. This will prevent it from being included in Bezi's context and being edited in Agent Mode. You can quickly disable and re-enable Connections in the left sidebar as you work.
To permanently remove a Connection from Bezi, open `Your Connections` and select `...` next to the Connection you wish to delete.
# Image Attachments
Source: https://docs.bezi.com/context/image-attachments
Image attachments are the best way to give Bezi references for visual work (UI mockup to implement) or more info on parts of Unity it has limited access to (e.g. ShaderGraph)
* **Implement UI or levels**: Give visual references that Bezi can copy
* **Fix Console, Unity Inspector, Unity’s Player Settings & Preferences errors**: Bezi has limited visibility into these in Unity, so screenshots are a fast way to give Bezi all the necessary info
## Using image attachments
If your prompt includes image attachments, include instructions fir:
1. What part of the image(s) Bezi should focus on
2. What information Bezi should gather or look for
3. What Bezi needs do with the information
You can attach **up to 3** images per prompt.
## How to upload
**There are two ways to attach an image:**
1. Drag/drop it into the prompt box
2. Click the attachment icon in the prompt box and select the file
**Upload specs**:
* Max file size: **5 MB** and **8000x8000 px**
* Supported image file formats: **JPEG**, **PNG**, **WebP**, and **GIF**
* GIFs are a collection of images, so Bezi can only analyze the first frame
# Project Context
Source: https://docs.bezi.com/context/index-project
Bezi is built to maintain a complete, real-time understanding of all connected Unity projects with zero set-up or maintenance.
Bezi's specialized project context (see below) and Unity comprehension are the foundation of it's plug-and-play accuracy. All changes made to a project are registered instantly by Bezi, so all work is done based on the most recent and complete project view.
## What Bezi knows about a connected project
**/Assets**
* Scripts (Monobehaviours, Scriptable Objects)
* Materials, Models, InputActions, Render Pipelines, etc.
* Scenes, Prefabs (in Edit AND Play Mode)
* Hierarchy
* Components, Variables
**/Packages**
* All Unity packages
* External packages and folders can be enabled on request
**Visual layouts**
* Bezi's Vision Tool takes screenshots of the scene to understand UI and visual behaviors.
* Please note: there is not a constant camera running in your scene, it can only take screenshots
**In-Bezi context**
* Rules
* Pages
* Pins
* History of the active thread
**Any searchable information on the web**
* Unity docs
* Stack Overflow, etc.
**Git diffs (available via MCP connection)**
* “What was in that last push?”
* Bezi knows the present state of a project, but cannot track and compare to past versions
**Node-based stuff (Animators, Shadergraphs, etc.)**
* Some understanding, but can’t create or modify it
* Parameters yes; layout, iffy
***
## How project indexing works
When you connect a new project, Bezi immediately indexes it. Bezi's context subagents will self-deployed across the target project, Connections, MCPs, and Pages, to retrieve and double-check context.
Bezi will automatically spin-up more subagents for more context-intensive tasks. This ensures accurate and credit-efficient context retrieval for all project types, including large, constantly evolving projects.
# MCP
Source: https://docs.bezi.com/context/mcp
Bezi can connect to external tools and services using the Model Context Protocol (MCP).
Game dev workflows are spread across a dozen tools; tickets in Jira, specs in Notion, mockups in Figma, code in GitHub, scenes in Blender, etc..
Connect an MCP to Bezi when you find yourself repeatedly copying data into Bezi from another tool or leaving Bezi to make changes in another tool.
## What you can do with MCP
With an MCP connection, you can ask Bezi to:
* **Jira**: Automatically pull in issue or feature request tickets to triage by severity and implement in Unity, then log update comments to close the loop on the ticket
* **GitHub**: Explain a diff, review a PR, or check what changed in a project since the last build
* **Blender:** Inspect scene structure, check poly counts, or flag naming convention issues in a model
* **Figma:** Reference UI mockups to build HUD elements to spec
* **Notion**: Query internal documentation hubs to keep work aligned to the most current designs
## Using Bezi with MCP
Always verify an MCP server before you connect it to Bezi.
Bezi’s interaction with an external product or service is dictated by the MCP permissions. Each MCP exposes different things. Check the MCP provider’s documentation to understand what’s possible.
* Read-only: Bezi can only pull information from the connector
* Read and Write: Bezi can pull data from the connector AND make changes in it
For example; Figma’s official connector is read-only, but Figma Bridge (an unofficial, community-built MCP) supports reading Figma file data and editing the Figma canvas
**Not supported: Bezi cannot run code in a Terminal or inject code into an external app or service.**
## MCP Connections and Context Limits
MCPs are comprised of tools. Each tool executes a specific task when the MCP is called.
When you connect an MCP to Bezi, its tools are added to Bezi’s context so all information and capabilities are accessible on demand.
**The limit is 100 MCP tools (active) at a single time.**
If you exceed this limit, prompting will be disabled until the number of active MCP tools drops below 100.
To view MCP tool counts and pause connections you’re not actively using:
* Open **Workspace Settings**
* Select the `MCPs` tab
* Toggle MCPs on (active) or off (paused)
If a single MCP has over 100 tools, you can deny specific tools in Allow List to bring it under the 100 active tools limit.
## Installing MCPs
Before you connect an MCP, always verify it and pause existing MCP connections you don’t need.
You can connect any MCP you want to Bezi. MCPs can be configured in two different ways:
### Prompt Bezi to install
1. Start a new thread
2. Ask Bezi to install the MCP (e.g. "install the Jira MCP" or paste a link to the MCP docs)
3. Bezi writes the entry into `mcp.json`
4. Bezi prompts you for credentials, and starts the server
5. The first time any of that MCP's tools fires, approve it in-thread (Always Allow / Always Ask / Always Deny)
### Edit `mcp.json` directly
1. Open **Workspace Settings**
2. Select the `MCPs` tab
3. Select **Open mcp.json**
4. Add the entry under `mcpServers` (see format example below)
5. Save the file
6. Resume prompting, Bezi will automatically detect and use the MCP
#### Format example
Each entry under `mcpServers` defines one MCP connection. The MCP provider’s documentation should include a setup snippet to copy/paste.
Example of what to look for
```json theme={null}
{
"mcpServers": {
"my-tool": {
"command": "npx",
"args": ["-y", "@my-org/my-mcp-server"],
"env": {
"API_TOKEN": "your-token-here"
}
}
}
}
```
## Manage and Troubleshoot MCP connections
MCP tools add context to Bezi; always pause MCPs you aren’t actively using and resume them when they’re needed for you work.
### Pause or resume connected MCPs
* Open **Workspace Settings**
* Select the `MCPs` tab
* View tool counts per MCP
* Toggle MCPs on (active) or off (paused)
* For MCPs with over 100 tools, open the Allow List and deny specific tools that you won’t need
### Debug a locally-connected MCP
* Toggle the MCP off and back on
* Restart Bezi
* Restart your machine
* Ask Bezi to inspect and patch `mcp.json` (paths, env vars, credential placement)
## MCP Security and Data Access
MCPs are third-party software. Bezi does not pre-vet MCP connections. Always verify an MCP before you connect it to Bezi.
MCPs access all the information in the tools and services they’re connected to. Connecting an insecure MCP to Bezi can risk exposing project data and IP externally.
### Data security best practices:
1. **Vet the MCP:** thoroughly review security standards for all MCPs, both official and unofficial
2. **Keep your** `mcp.json `**private:** It holds your credentials, never commit it to a repo
# Shared and Private Pages
Source: https://docs.bezi.com/context/pages
Pages are evergreen documentation, available to every thread in a Workspace. **Anything in a Page - coding standards, architecture decisions, design specs, system docs - is context for your Bezi agent's work anywhere in that Workspace.**
Pages can be created and modified by you or by Bezi can do it on your behalf. If you never want Bezi to create Pages, [create a Rule](https://docs.bezi.com/fundamentals/rules) explicitly stating this.
## Page documentation examples
When Bezi plans or implements an idea, pin @PageName so execution follows standards.
* UI creation standards
* Level creation guidelines
* Feature implementation requirements
Pin @PageName so Bezi knows to follow a pre-defined pattern.
* Core game mechanics (e.g., “Jumping uses stamina”)
* How specific systems work
Store meta-level game information and pin @PageName when you need a task to keep in mind the game's end-state.
* GDDs
* Instructions for Bezi to navigate your Connections: where to look for specific information types or references
## Shared Pages
Shared Pages are only available on Team and Enterprise plans.
Shared Pages are visible and editable by all members of a [Team Workspace](https://docs.bezi.com/fundamentals/team-workspaces). **They act as the team's single source of truth - vision, standards, rules, documented decisions - that every member's Bezi agent automatically references**. This keeps teams aligned and work consistent, even when people aren't in the same room.
If you're in a Team Workspace and need to create Pages for private use (not team-wide consumption) you can create **Private Pages**. These are visible only to the Page creator and their Bezi agent.
To update a Page from Private \<> Shared, select the Page and drag it to the other section.
### Real-time collaboration on Shared Pages
Shared Pages support real-time collaboration. If more than one person has a Shared Page open, you will see each other’s cursors and text will appear as it’s typed.
All edits merge automatically as you work, so there's nothing to manually save and no merge conflicts to resolve.
> Bezi agents can edit Shared Pages and will not show up in real-time. All edits Bezi makes to a Shared Page will appear once it’s done editing.
If your Team Workspace doesn't want Bezi to edit Shared Pages, each member needs to [create a Rule](https://docs.bezi.com/fundamentals/rules) explicitly stating this.
## Using Folders
Pages are organized into folders. To manage a folder or the Pages in it, hover over the Folder and click the`…`icon. You will see a menu of options to:
* Rename the folder
* Move Pages in/out of the folder
* Delete the folder
Deleting a folder will delete all Pages in it. Do not delete any folders until you’ve confirmed all Pages **you want to keep** are moved.
### Real-time collaboration on Shared Pages
Shared Pages support real-time collaboration. If more than one person has a Shared Page open, you will see each other’s cursors and text will appear as it’s typed.
All edits merge automatically as you work, so there's nothing to manually save and no merge conflicts to resolve.
> Bezi agents can edit Shared Pages and will not show up in real-time. All edits Bezi makes to a Shared Page will appear once it’s done editing.
If your Team Workspace doesn't want Bezi to edit Shared Pages, each member needs to [create a Rule](https://docs.bezi.com/fundamentals/rules) explicitly stating this.
### Real-time collaboration on Shared Pages
Shared Pages support real-time collaboration. If more than one person has a Shared Page open, you will see each other’s cursors and text will appear as it’s typed.
All edits merge automatically as you work, so there's nothing to manually save and no merge conflicts to resolve.
> Bezi agents can edit Shared Pages and will not show up in real-time. All edits Bezi makes to a Shared Page will appear once it’s done editing.
If your Team Workspace doesn't want Bezi to edit Shared Pages, each member needs to [create a Rule](https://docs.bezi.com/fundamentals/rules) explicitly stating this.
# @ Pins
Source: https://docs.bezi.com/context/pins
Pin relevant information (assets, scripts, Pages, etc) in prompts to focus Bezi in, so Bezi can generate the best response faster. If you *know* something is essential, pin it. This is extra important in large projects with thousands to millions of assets, scripts, etc.
## What can be pinned in a prompt?
Any context Bezi gathers can be referenced in a prompt. This includes:
* In-Unity context: any asset in your Scene or Project Folder, e.g. scripts, models, in-scene gameobjects, etc.
* In-Bezi context: Pages
## How to pin in a prompt
### Type @ while writing the prompt, then the name of what you want to pin
To in-line pin while writing your prompt, type @ then 3+ characters to trigger the search pop-up. The search popup will filter options based on the characters you type.
### Click the @ icon above the prompt input field
You can find and add pins by clicking on the`@`icon above the prompt input field. This will open up a popup menu to search in.
## Pills: context based pin suggestions
If you select something in your Unity project, Bezi will surface it as a **pill** (suggested pin) above the prompt input field. **You must click the pill to transform it into a pin**.
![Pill Not Tagged]()
![Pill Tags]()
## Disabling irrelevant pins
Always review your pins and disable irrelevant ones before submitting a prompt.
1. Review all the active pins above the prompt input field
2. Click the ones you wish to remove
3. Confirm the irrelevant pins are gone or returned to pill state (greyed out, dotted border)
# Workspace Rules
Source: https://docs.bezi.com/context/rules
Workspace Rules only apply to the Workspace they're set in, and to all threads and projects within that Workspace. If working in a Team Workspace, Rules are private to you and not shared or visible by other members.
## What are Workspace Rules?
Rules are persistent, custom instructions for Bezi to follow. They are added directly to the system prompt and given extra weight, so if your instructions conflict with our existing system prompt, your preferences are prioritized. Use rules to ensure Bezi’s ouput is consistent with your project structure, preferences, and workflows.
**Workspace Rules are universal principles for how Bezi works with a given Workspace**
1. Define workspace-specific structures and systems (unity version, render pipeline, default packages, etc.)
2. Define how Bezi should interact with certain systems or information types
3. Customize response formats, explanations, code style, etc.
## Using Rules
### Access Workspace Rules
1. Navigate to the desired Workspace
2. Click on `Your Rules`
3. Write custom rules for the Workspace, following the below guidance
### Shared Rules for Team Workspaces
If you're part of a [Team Workspace](https://docs.bezi.com/fundamentals/team-workspaces) and want to set the same Rules for everyone, add the Rules in a Shared Page and ask all members to ‘@mention’ the Page in the Workspace Rules.
### Project-specific Rules
If you want to set Rules that only apply to a specific Unity projects/local folders in a Workspace, create a Page for each Project containing rules and ‘@mention’ the Page in the Workspace Rules.
## Writing Workspace Rules that work
Workspace Rules has pre-written examples to illustrate rule-writing best practices. You need to edit them or write your own from scratch.
### Step 1: Decide if it's a Workspace Rule or Page
> **PAGE**: Documenting the GDD, how something is structured, standards for creating UI, etc.
> **RULE**: Define how Bezi should manage information sources (Connections, Pages, etc) and other "constants" that are relevant to most work done in that Workspace
### Step 2: Write Rules like instructions for a new team member
1. Write clear and concise rules, using natural language
2. Provide positive examples Bezi can follow
3. Do not give Bezi a lot of rules - it will miss things
### Step 3: Update Rules often, following best practices
1. **Write direct, clear instructions**: Only use decisive verbs and be very specific
1. GOOD: Follow code style rules defined in [**MyProjectStyle.md**](http://MyProjectStyle.md)
2. GOOD: NEVER use the Singleton design pattern
3. BAD: write good code
4. BAD: follow all SOLID principles
2. **Give real, positive examples to follow**: Add multiple examples of the formatting or behavior you want Bezi to follow, for positive pattern recognition
3. **Use strong language**: Use caps and decisive words (e.g. “*ALWAYS*,” “*IMPORTANT*,” “*CRITICAL*”)
4. **Enrich references**: Provide library name, version, official website, and a direct link to scripting examples
5. **Keep Rules list short**: Only list absolutely critical rules. The fewer rules, the better
6. **Reflect on and update Rules often**: Rules must evolve alongside the work. Don't ask Bezi to write them - you know what's most important
1. **Never use anti-examples** (e.g. "don't do X"), as Bezi may reference the example without taking into account the context it's used in
2. **Never write conditional rules, using "IF" or "SHOULD"** because rules must be constants and Bezi will not reliably follow these instructions
3. **Never include conflicting information** in your rules because Bezi will break one or both rules
4. **Never make Rules too long** because the more information Bezi has to adhere to, the more likely it is to miss something or to find conflicting instructions
5. **Never "set and forget" your rules** - this should be a living document that changes as your project and requirements evolve! Old rules need to be cleared out to make room for new ones
# Development
Source: https://docs.bezi.com/development
Preview changes locally to update your docs
**Prerequisite**: Please install Node.js (version 19 or higher) before proceeding.
Follow these steps to install and run Mintlify on your operating system:
**Step 1**: Install Mintlify:
```bash npm theme={null}
npm i -g mintlify
```
```bash yarn theme={null}
yarn global add mintlify
```
**Step 2**: Navigate to the docs directory (where the `mint.json` file is located) and execute the following command:
```bash theme={null}
mintlify dev
```
A local preview of your documentation will be available at `http://localhost:3000`.
### Custom Ports
By default, Mintlify uses port 3000. You can customize the port Mintlify runs on by using the `--port` flag. To run Mintlify on port 3333, for instance, use this command:
```bash theme={null}
mintlify dev --port 3333
```
If you attempt to run Mintlify on a port that's already in use, it will use the next available port:
```md theme={null}
Port 3000 is already in use. Trying 3001 instead.
```
## Mintlify Versions
Please note that each CLI release is associated with a specific version of Mintlify. If your local website doesn't align with the production version, please update the CLI:
```bash npm theme={null}
npm i -g mintlify@latest
```
```bash yarn theme={null}
yarn global upgrade mintlify
```
## Validating Links
The CLI can assist with validating reference links made in your documentation. To identify any broken links, use the following command:
```bash theme={null}
mintlify broken-links
```
## Deployment
Unlimited editors available under the [Pro
Plan](https://mintlify.com/pricing) and above.
If the deployment is successful, you should see the following:
![]()
## Code Formatting
We suggest using extensions on your IDE to recognize and format MDX. If you're a VSCode user, consider the [MDX VSCode extension](https://marketplace.visualstudio.com/items?itemName=unifiedjs.vscode-mdx) for syntax highlighting, and [Prettier](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode) for code formatting.
## Troubleshooting
This may be due to an outdated version of node. Try the following:
1. Remove the currently-installed version of mintlify: `npm remove -g mintlify`
2. Upgrade to Node v19 or higher.
3. Reinstall mintlify: `npm install -g mintlify`
Solution: Go to the root of your device and delete the \~/.mintlify folder. Afterwards, run `mintlify dev` again.
Curious about what changed in the CLI version? [Check out the CLI changelog.](https://www.npmjs.com/package/mintlify?activeTab=versions)
# Agent Mode
Source: https://docs.bezi.com/fundamentals/agent-mode
Agent Mode is Bezi's *actionable* setting. It directly implements changes in the Unity Editor. **Agent Mode is automatic implementation; [Ask Mode](https://docs.bezi.com/fundamentals/ask-mode) is manual.**
Bezi does not use an MCP to connect and implement in the Unity Editor. MCP's standardized method delivers unreliable results at scale and requires ongoing maintenance by the user.
Bezi's Unity Editor integration is designed for what AI excels at; writing TypeScript, the most common language within AI training data, and provides more accurate, reliable results.
***
## Using Agent Mode
Select the **mode dropdown** in the prompt textbox and select **Agent**. Agent Mode covers direct Editor implementation of:
1. **Actions**: creating, updating, and organizing scenes, GameObjects, prefabs, and assets
2. **Scripts:** creating and modifying scripts
Keep and undo Agent suggestions as you work. Letting suggestions pile up in an undecided state can lead to unintentionally keeping or erasing everything.
## Actions
Bezi can automatically create, update, and organize Unity editor objects on your behalf.
There are pre-built Actions (below) and [Custom Actions](/fundamentals/custom-actions) for everything not provided in Bezi.
When you prompt Bezi in Agent Mode, actions will be auto-deployed based on intent. Multiple actions will be chained to complete complex tasks. For more control, explicitly name the action(s) you want in your prompt, e.g. *"Use Actions to create a prefab from @\[gameObject]."*
#### GameObject **Modification and Scene Layout**
* Create, update, delete, and reparent GameObjects
* Print GameObjects, print GameObjects by path, print scene hierarchy
* Create scenes, primitives, tags
* Capture image of scene view and game view (at rest and runtime)
* Create, update and view Particle Systems
#### Assets & Prefabs
* Create or update assets
* Create prefabs, create prefabs from assets, instantiate prefabs
* Take prefab image (including uGUI)
* Create or update AnimatorController, materials, ScriptableObjects
* Update asset importers, print assets
* Create and update Input Systems
* Analyze Profiler performance data, implement optimizations
#### **Component Functionality & Dynamic Behavior**
* Add, update, or remove components
* Set RectTransform layout
* Generate animation clips, sequence cinematic content
* Setup advanced Mecanim BlendTrees
* Debug broken functionality, auto-iterate until desired behavior is achieved
## Preview Agent suggestions
Agent Mode auto-implements suggestions in Unity so it's easy to test them in the game before deciding to keep them.
1. Agent makes suggestions and auto-implements in Unity
2. Click back to Unity: test the suggestions in-action
3. Return to Bezi: keep or undo undecided suggestions
4. Continue working
### Agent suggestion states
Bezi agent suggestions can exist in three states. Once you decide to keep or undo a suggestion, you cannot revert the suggestion back to an undecided state.
Agent suggestions haven't been kept or rejected yet
When Agent suggestions are kept, the work Bezi's implemented will just remain as-is
* **Directly**: reviewed Agent suggestion(s) and selected `Keep` or `Keep All`
* **Indirectly**: accepted an Agent suggestion and all prior undecided suggestions were auto-kept
When Agent suggestions are undone, all the Bezi related work in Unity will be removed. New additions will be deleted and edits will be reverted.
* Select `Undo` or `Undo All` as soon as you decide you don't want a suggestion - undecided suggestions are at higher risk of being indirectly kept
* Rejecting an Agent suggestion in-thread will revert it to its previous undecided version
If you accidentally keep something you want undone, you use restore checkpoint or version history to revert back to a previous state.
## Restore Checkpoint
Restore Checkpoint reverts the project back to an earlier state, erasing all kept changes made after that point. **Restore Checkpoint does not revert suggestions to an undecided state.** It permanently erases all code additions and modifications Bezi.
To restore: hover on the Bezi response you want to revert to and select `Restore Checkpoint`
## Diffs
Diffs show exactly what Agent Mode suggestions are changing in each file:
* **Red highlights**: deletions
* **Green highlights**: additions
In chat, diffs are compressed for quick scanning. To view a diff in full context, open the script in **Canvas** (diffs will remain highlighted). Here you can compare and inspect Agent suggestions.
# Ask Mode
Source: https://docs.bezi.com/fundamentals/ask-mode
Ask Mode is Bezi’s *informational* setting. It serves as an Unity project's core knowledgebase, it can be prompted to provide information and cannot take action on your behalf.
Ask Mode cannot directly implement anything on your behalf in Unity, while Agent Mode can. Consider Ask Mode as **manual** implementation and [Agent Mode](https://docs.bezi.com/bezi/modes/agent-mode) as **automatic** implementation.
## How do I enter Ask Mode?
To enter Ask Mode, select the **mode dropdown** (below the prompt textbox) and select **Ask**. When you're in Ask Mode, it will look like this:
![Ask]()
## What can I do in Ask Mode?
In Ask Mode, Bezi can respond with information, tutorials, and code snippets (that must be implemented by you via copy/paste) to walk you through an implementation or explain a concept.
All Ask Mode responses are customized to whatever is in your Workspace at a given moment.
# Custom Actions
Source: https://docs.bezi.com/fundamentals/custom-actions
Execute any in-engine functionality not covered by Bezi’s built-in Actions, like working with specific plugins, menu item functions, or custom workflows defined in your project.
Custom Actions expose static C# methods as an extension of Bezi Actions. They run with the Unity Editor’s full execution permissions and can access your computer, filesystem, network, processes, and project data.
**Best practice is to setup version control prior to testing Custom Actions**. There is no built-in automatic checkpointing or recovery. Review all code that goes into a Custom Action and enable approval for risky operations.
## Auto-create Custom Actions
1. Enter Agent Mode
2. Prompt: describe the Action you want, it’s goal, and tell Bezi to create an Action. Be specific with inputs, outputs, side effects, read-only, and approval requirements
3. Bezi will use the dedicated skill to write the Custom Action to the codebase
4. Check the thread’s diff to review the Custom Action code
5. Use the Custom Action!
Create a read-only action that takes an assets folder path and returns the number of prefabs in it.
Convert DeleteGeneratedPrefabs in @PrefabTools.cs into a custom action that requires approval.
## Manually create a Custom Action
If you prefer to build Custom Actions in C#, add the `[BeziAction]` attribute to a static method in an Editor assembly, and provide the required parameters.
```csharp theme={null}
using Bezi;
public static class ProjectActions {
[BeziAction("Return the given message.", IsReadOnly = true)]
public static string Echo(string message) => message;
}
```
### BeziActionAttribute API
```csharp theme={null}
[BeziAction(
"Describe what the action does.",
IsReadOnly = true,
RequireApproval = "User-facing approval message."
)]
```
Methods with `[BeziAction]` can be synchronous or async, with any serializable inputs and outputs. Invalid inputs throw an exception and instructions for Bezi to recover from the error. You can customize the attribute with the following parameters:
| Parameter | Default | |
| :---------------- | :----------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Description` | **Required** | Explains to Bezi how to use the Action, as well as any additional instructions and examples. Bezi will also use this during the Actions discovery process. |
| `IsReadOnly` | `false` | Set true only when the method does not modify any data in Unity, the filesystem, the network, or any other data. This allows the Action to be used in read-only contexts such as Ask and Plan mode. |
| `RequireApproval` | `null` | Set a string to require user approval before Bezi executes the Action. Use it for destructive or sensitive Actions. The message will show up as an approval prompt in Bezi, along with the inputs and the Action name. |
## Best Practices
#### Structured return values
Return a serializable class, struct, or tuple when the Action needs to return more than one result.
```csharp theme={null}
[Serializable]
public struct SceneSummary {
public string name;
public int rootObjectCount;
}
[BeziAction("Return a summary of the active scene.", IsReadOnly = true)]
public static SceneSummary GetSceneSummary() {
var scene = SceneManager.GetActiveScene();
return new SceneSummary {
name = scene.name,
rootObjectCount = scene.rootCount,
};
}
```
### Validate inputs, throw useful exceptions, and use Undo patterns
Validate inputs and the current state of the project upfront as much as possible. Throw an exception with a useful message early in the Custom Action so Bezi knows what went wrong and how to proceed.
Since Bezi creates an undo group for each batch of Actions, you can use Unity's typical `Undo` patterns to hook into the undo group and allow the Custom Action to use the undo menu or shortcuts.
```csharp theme={null}
public static void RenameGameObject(GameObject target, string newName) {
if (target == null) {
throw new ArgumentNullException(nameof(target), "Target object was not found.");
}
if (string.IsNullOrWhiteSpace(newName)) {
throw new ArgumentException("The new name cannot be empty.", nameof(newName));
}
if (EditorApplication.isPlaying) {
throw new InvalidOperationException(
"RenameGameObject only works in Edit Mode. Exit Play Mode and try again.");
}
// Mutate after validations succeed, with Undo record
Undo.RecordObject(target, "Rename GameObject");
target.name = newName;
}
```
### Prefer returning data instead of logging
Logs written to the Unity console via `Debug.Log` methods are not directly available to Bezi without extra tool calls. Make sure to provide any useful information from the Custom Action as a return value.
```csharp theme={null}
[BeziAction("Return the current product name.", IsReadOnly = true)]
public static string GetProductName() {
Debug.Log(Application.productName);
return Application.productName;
}
```
## Troubleshooting
#### Bezi can't find the Custom Action
Wait for Unity to compile (as well as the `Generating type definitions...` background task), fix any Console errors, and confirm the method is public, static, non-generic, and part of an Editor assembly.
#### The Custom Action isn'tavailable in Ask or Plan Mode
Custom Actions must be marked `IsReadOnly = true` to run in Ask or Plan Mode. Use Agent Mode for Actions which require modifying state.
#### Bezi receives no useful output from the Custom Action
Return a serializable value, class, struct, or tuple to send output to Bezi. Logs are not automatically returned to Bezi.
# Model Selection
Source: https://docs.bezi.com/fundamentals/model-selection
You can pick the model Bezi uses to affects the depth, speed, and cost of a response.
How to decide: **heavier tasks need more reasoning power; simple tasks don't**. The right model for the right task gets you a good result faster, which will help credits go further.
## Model type options
Bezi offers a constantly-updating selection of models - from heavy, frontier models to lightweight, experimental ones - so you can pick the one that works best for you.
All models are organized into one of these categories:
Bezi offers a constantly-updating selection of models - from heavy, frontier models to lightweight, experimental ones - so you can pick the one that works best for you.
All models are organized into one of these categories:
Bezi offers a constantly-updating selection of models - from heavy, frontier models to lightweight, experimental ones - so you can pick the one that works best for you.
All models are organized into one of these categories:
1. **Featured Models**: our team has confirmed these are reliable and support all the functionality Bezi needs to perform any game development related workflow.
2. **Experimental Models**: riskier and generally less expensive. Some may not support image attachments or other features Bezi needs in order to execute tasks to satisfaction.
## When to use each model type
A good rule of thumb: **start with a featured model**. Test experimental models once you're familiar with Bezi's platform, AI behavior and quirks and have a new workflow you're comfortable in.
A good rule of thumb: **start with a featured model**. Test experimental models once you're familiar with Bezi's platform, AI behavior and quirks and have a new workflow you're comfortable in.
Bezi offers a constantly-updating selection of models - from heavy, frontier models to lightweight, experimental ones - so you can pick the one that works best for you.
All models are organized into one of these categories:
1. **Featured Models**: our team has confirmed these are reliable and support all the functionality Bezi needs to perform any game development related workflow.
2. **Experimental Models**: riskier and generally less expensive. Some may not support image attachments or other features Bezi needs in order to execute tasks to satisfaction.
## When to use each model type
A good rule of thumb: **start with a featured model**. Test experimental models once you're familiar with Bezi's platform, AI behavior and quirks and have a new workflow you're comfortable in.
Bezi offers a constantly-updating selection of models - from heavy, frontier models to lightweight, experimental ones - so you can pick the one that works best for you.
All models are organized into one of these categories:
Bezi offers a constantly-updating selection of models - from heavy, frontier models to lightweight, experimental ones - so you can pick the one that works best for you.
All models are organized into one of these categories:
1. **Featured Models**: our team has confirmed these are reliable and support all the functionality Bezi needs to perform any game development related workflow.
2. **Experimental Models**: riskier and generally less expensive. Some may not support image attachments or other features Bezi needs in order to execute tasks to satisfaction.
## When to use each model type
A good rule of thumb: **start with a featured model**. Test experimental models once you're familiar with Bezi's platform, AI behavior and quirks and have a new workflow you're comfortable in.
A good rule of thumb: **start with a featured model**. Test experimental models once you're familiar with Bezi's platform, AI behavior and quirks and have a new workflow you're comfortable in.
Bezi offers a constantly-updating selection of models - from heavy, frontier models to lightweight, experimental ones - so you can pick the one that works best for you.
All models are organized into one of these categories:
1. **Featured Models**: our team has confirmed these are reliable and support all the functionality Bezi needs to perform any game development related workflow.
2. **Experimental Models**: riskier and generally less expensive. Some may not support image attachments or other features Bezi needs in order to execute tasks to satisfaction.
## When to use each model type
A good rule of thumb: **start with a featured model**. Test experimental models once you're familiar with Bezi's platform, AI behavior and quirks and have a new workflow you're comfortable in.
A good rule of thumb: **start with a featured model**. Test experimental models once you're familiar with Bezi's platform, AI behavior and quirks and have a new workflow you're comfortable in.
These are more expensive but well worth the extra credits for time saved on complex tasks:
* Long, multi-step Agent Mode workflows
* Output that requires precision, like UI generation
* Tasks with many dependencies or subtle system interactions
* Deep debugging across scenes and systems where the root isn’t clear
Genuinely great for most daily work:
* Debugging and error fixing
* Writing or modifying scripts
* Building an editor tool
Best for getting a fast answer or iterating on lighter tasks:
* Quick lookups and explanations
* Simple one-line fixes you're confident about
* Tasks where you plan to review and refine the output anyway
## How to change the model selection
The model selector is inline in the prompt input. To select a different model type, open the dropdown and pick the new model before you submit a prompt.
## Tracking credit usage
To see a breakdown of credits consumed per prompt and model type, follow these steps:
1. Go to: [app.bezi.com/account](https://app.bezi.com/account)
2. Open the **Subscriptions & Usage** tab
See the [Plans & Credits](https://docs.bezi.com/account/plans) page for a full breakdown of how credit usage works.
# Plan Mode
Source: https://docs.bezi.com/fundamentals/plan-mode
Plan Mode creates clear, detailed prompt sequences to produce more consistent results in [Agent Mode](https://docs.bezi.com/fundamentals/agent-mode) - with less iteration. Use Plan Mode to scope a task completely, then set Bezi to execute on it while you work on something entirely different.
## What is Plan Mode?
Plan Mode helps you define **the approach and work needed to execute a task**, then Agent Mode **executes on it**.
> **Mental model**: Pages store context. Plans define execution. Agent Mode executes.
Use Plan Mode when working on medium-to-complex tasks that benefit from being broken into structured steps before building.
## What can Plan Mode help me do?
* Improve accuracy of complex tasks with multiple steps or dependencies
* Get more predictable or repeatable results
* Get more work done (giving Bezi approved steps to execute on independently)
* Clarify work and requirements before Bezi starts updating a project
**What to not use Plan Mode for:**
* Small, exploratory tasks with frequent iteration
* Document background information, guidelines, or multiple deliverables (use [Pages](/context/pages))
* To plan an entire game and press build
## How to use Plan Mode
Plans should be **clear, concise, and implementation-ready**. Ask follow-up questions to clarify requirements and prompt to edit the plan until you're pleased with the results.
When the plan is ready:
1. Click `Build`
2. A new Agent thread will be created, using the plan as the initial prompt
3. The plan will be auto-saved in the **Plans** section for future reference
Plans work best when they define **a single execution goal**. If a plan becomes **long**, turn it into **Page** and start a new plan that references it.
## How to enter Plan Mode
Select the **mode dropdown** (below the prompt textbox) and select **Plan**. When you’re in Plan Mode, it will look like this:
![Frame41081]( "Frame41081")
# Prompting Best practices
Source: https://docs.bezi.com/fundamentals/prompting
### Plan first, then implement
Asking Bezi to jump straight into implementation can produce the wrong outcomes and waste credits. Use [**Plan Mode**](/fundamentals/plan-mode) to find the best approach before execution.
### Specific prompts = better outcomes
Bezi cannot read minds; **specific prompts take fewer prompts to deliver accurate results**. Tag Pages, set constraints, and define what you consider "success".
1. Define the current state
2. Define what needs to be done
3. Define the desired end-state
4. Define how Bezi should measure successful completion of the task
5. Point Bezi to resources: tag Pages, pin related parts of the project, reference existing patterns ([in any projects](/context/connections)), share suggestions or ideas, etc.
Before submitting a prompt, read it in isolation. Is it very clear what the prompt refers to, what Bezi needs to do, and the resources and success criteria to use?
### Give Bezi rich data to inform decisions
Use @ to reference in-project context, pages, and external Connections
1. [**Add in-line pins**](https://docs.bezi.com/bezi/product/prompt-tagging) to define project references (assets, scripts, scenes, etc.)
2. Pin [Pages](https://docs.bezi.com/bezi/product/pages-folders) to give Bezi guidelines or documentation to follow
3. [**Attach images**](https://docs.bezi.com/bezi/product/attach-images) (UI mockups, screenshots, etc.) directly to the prompt
4. Set [Rules](https://docs.bezi.com/bezi/product/project-rules) to standardize how Bezi navigates and interacts with the Workspace
### Low context window = high performance
Performance degrades and prompts take more credits as the context window fills. Always check a thread's **context window tracker** (bottom right of the prompt field) before prompting.
Try these thread context modifications if the context window is full:
1. The thread's own prompt and response history; **start new threads every \~10 prompts**
2. All active [Workspace Connections](https://docs.bezi.com/context/connections) (Unity projects and local data sources); **disable Connections that are unrelated to a given task**
### If you get responses you don’t like, start a new thread
Bezi ingests the active thread's prompt and response history as context. If Bezi gives you a response you don't like and you prompt on top of it, Bezi may reference the wrong response as "relecant context" for its next attempt.
# Proofs
Source: https://docs.bezi.com/fundamentals/proofs
A Proof is an interactive tool or mini application; think about a balancing sheet, chart, or editor, that Bezi creates to assist in game development work. It’s a visual canvas you can interact with, iterate on, and use as rich context beyond chat for in-engine implementation.
Just as your work usually involves Bezi generating Plans or Pages, a Proof is another output and input type so you can quickly find out whether an idea works before you commit to building it in the engine.
Browse the [Proofs Gallery](https://bezi.com/proofs) to see what people have made, or start from one of the template Proofs in the app.
## When to use Proofs
Use Proofs for work that needs richer inputs than text. Their functionality; click buttons, filter data, drag elements, is up to you. Prompt Bezi to add whatever you need.
**Proof examples:**
* **Dialogue and narrative tools**: a branching dialogue editor you can click through instead of reading as an indented list
* **Data and balance tools**: a weapon balance matrix or economy simulator that translates into Unity data assets
* **Shaders and visual tools**: a shader previewer you can tune and see change live
* **Layout and UI tools**: a drag-and-drop UI layout builder you can hand-off once it's right
* **Reports and dashboards**: interactive charts, heatmaps, other visual data that's hard to describe in chat form
![Screenshot 2026 08 13 At 9 41 52 AM]()
## Creating and editing a Proof
Proofs are are lightweight, interactive tools and prototypes rendered in Bezi. They can be created with threads and automatically use Bezi’s context base to inform what’s built.
1. Prompt Bezi what you want. For example, "Create a new Proof for charting @\[data] as a bar graph" or "make a Proof for a simple dialogue tree editor."
2. Bezi generates the Proof; each Proof becomes it’s own page in the section
3. Click on the Proof to review; if good as-is, begin to work
4. Prompt Bezi to edit the Proof output (manual code-editing surface coming later)
## Pushing your changes into Unity from Proofs
Bezi can move your Proof into a Unity project. This works through AI translation, not a live connection: ask Bezi to bring your Proof into the project, Bezi interprets it and auto-creates these changes in-engine.
What carries over depends on the Proof’s contents:
* **Content**: a layout or dialogue tree would translate into matching Unity objects or assets
* **Data or configuration**: a weapon balance sheet, would translates into Unity data assets, like the weapon and enemy ScriptableObjects that use those values
**Pushing the Proof to Unity is a one-time action. Unity will not stay linked to the Proof or reflect changes made after it’s pushed.** A direct, two-way connection between Proofs and the engine is planned for a future release.
Two-way connection workarounds:
1. Ask Bezi to `get Data` or `set Data` on each proof. We use the `getProofDataand` `setProofData` tools. Bezi will add this functionality to the Proof and the in-memory data can be used to translate to Unity without modifying the Proof code or recreating it
2. You can ask Bezi to implement `persistence` of the proof data so it’s saved between reloads
## Sharing a Proof
Neither sharing option supports real-time updates of Proofs. Once a Proof is exported or published as a public link, the shared version cannot be changed. You will need to republish it or reexport to include any changes.
* **Export/Import**: Export a Proof as a .zip and import one someone else shared with you.
* **Publish as public link**: Generate a public link to share a Proof with anyone. **Use the ‘Publish updates’ button.**
# Skills
Source: https://docs.bezi.com/fundamentals/skills
Skills extend what Bezi can do and standardize repeated workflows.
Create a skill when you keep pasting the same instructions, checklist, or multi-step procedure into a prompt, or when a Page has evolved into a checklist instead of information to reference.
# What are skills
A skill packages a repetitive, multi-step workflow into a single command. Bezi runs the skill the same way every time, delivering a more reliable, predictable output with less effort.
A skill is a folder that contains instructions, and scripts or reference files it needs. The instructions are executed a defined sequence of steps whenever the skill is invoked. A single skill can include any combination of the following:
1. Multi-step procedure to run in a fixed order
2. Call an MCP tool to pull in external information
3. Scripts or reference files for extra context
You can use default skills or create custom skills. Bezi skills follow the same [**Agent Skills**](https://agentskills.io/) open standard as other common AI tools.
## **What skills are available**
Skills work best when tailored to *your* workflow. You can create any custom skill you need or edit Bezi default skills.
* **Implement UGUI \[default]** - Build UI using UGUI from a screenshot or Figma file.
* **UGUI to UI Toolkit** **\[default]** - Convert UGUI canvas-based screens to UI Toolkit.
* **Create documentation \[default]** - Scan the project and automatically generate a GDD as organized pages.
* **Set up a scene** — Drop in your default lighting, camera rig, and environment so every new scene starts the same way.
* **Set up an object pool** — Generate a reusable pool for a prefab (bullets, enemies, pickups) instead of instantiating at runtime.
* **Run a pre-build checklist** — Walk through your standard QA checks before you ship a build.
* **Pull data into a report** — Query an external tool (analytics, issue tracker, docs) and format the results how you want.
* **Generate a changelog or release note** — Turn recent commits or merged work into a formatted summary your team can read.
* **Onboard a new project** — Configure a fresh project with your standard settings, dependencies, and structure.
## **What is the difference between Skills, Pages, and Rules?**
* **Skills**: A list of steps Bezi executes in a specific order for a given task (a repeatable, multi-step workflow)
* [**Pages**](https://docs.bezi.com/context/pages): Reference materials for Bezi, like facts, decisions, architecture/design docs, etc
* [**Rules**](https://docs.bezi.com/context/rules): Standards Bezi applies to all work in a Workspace (code style, project structure, constants)
## **Using Skills**
![Screenshot 2026 06 25 At 6 45 45 PM]()
### **Install a default skill**
Installing a default skill automatically creates a copy of it on your machine.
1. Open **Workspace Settings**
2. Select the `Skills` tab
3. Click the `Discover` toggle to explore skills options
4. Identify the desired skill and select `Install`
If a default skill requires an MCP you don't have, Bezi will tell you and set up the configuration during install. If a skill includes an MCP, it will inherit the MCP’s allow-list permissions. Adjust the permissions directly in [MCP settings](https://docs.bezi.com/context/mcp#installing-mcps) as needed.
### **Create a custom skill**
There are two ways to create a custom skill. It will automatically be installed and a copy will be created on your machine.
1. **Chat**: Describe the workflow steps and asks Bezi to create a skill for it. Bezi will automatically create instructions and any scripts or reference files needed to run
2. **Workspace Settings**: In the `Skills` section, click the `+ Create with Bezi` button
### **Run a skill**
Bezi can only run installed skills
1. **Automatically:** Bezi knows every skill you have installed and uses that information to invoke the right skill for a request, even if it’s not named
2. **Use a ‘/command’:** Invoke a specific skill using the slash command and skill name
### **Edit a skill**
You can only edit installed skills. To edit, write a prompt with the skill name and desired changes. Bezi will proposes the edits as a diff: review it and select `Keep` or `Undo` (same way you review changes in Agent Mode).
### **View and uninstall skills**
Default skills show a name and a one-line description; your own skills show their name.
1. Open **Workspace Settings**
2. Select the `Skills` tab to see everything you have installed
3. Select the `>` icon next to the desired skill and click `Uninstall`
Uninstalling a skill is non-reversible. If you uninstall a custom skill, it will be deleted from Bezi.
## **Current Limitations**
* **No on/off toggles.** A skill is either installed or not. To deactivate a skill, you must uninstall it.
* **Skills are local to you.** Skills cannot be auto-shared in Team Workspaces yet. Send a colleague the skill file to give share it.
* **Skills run JavaScript only.** Skills can’t run file system, network, or shell access yet. If you’re importing a skill from another AI tool, confirm it doesn’t rely on shell commands before running.
# Team Workspaces
Source: https://docs.bezi.com/fundamentals/team-workspaces
Team Workspaces are only available on Team and Enterprise plans.
Team Workspaces enable multiple people to build a shared a source of truth and collaborate in a shared environment, directly within Bezi. **Members of a Team Workspace can create and access [Shared Pages](https://docs.bezi.com/context/pages), the team's single source of truth for vision, standards, rules, documented decisions.** Every member's Bezi agent automatically references Shared Pages to keeps teams aligned and work consistent.
Information that's usually specific to an individual's workflows is not shareable within a Team Workspace. **Threads, Connections, Rules, and Private Pages are private for each member**.
## Team Workspace structure
Team Workspaces live in a [Team](https://docs.bezi.com/account/team), the centralized place for managing licenses, roles, billing, usage and Workspaces.
Each Team Workspace is different; it has a unique purpose and subset of members and Shared Pages. Every Team Workspace contains the following:
* **Workspace Members list**; Each Member has equal ability to invite and remove people from the Workspace. Only Team Members can be Workspace Members
* **Members**; Each Member can view, edit, and create Shared Pages. Each member also has private data for their Bezi agent: Threads, Connections list, Rules and Private Pages
* [**Shared Pages**](https://docs.bezi.com/context/pages); All Shared Pages in a Team Workspace, such as one defining UI Standards, can be viewed and modified by all Members (and their Bezi agents) in that Workspace
### Shared and private materials
Because shared materials change the context of every Workspace member's Bezi agent, information that's typically specific to an individual's workflows is kept private.
If you want to share a private material with all members (e.g. standardized rules or must-have Connections), ask Bezi to document it as a Page and share it.
| Content | Visibility |
| :------------------------------------------------------- | :--------------------------------- |
| [Shared Pages](https://docs.bezi.com/context/pages) | All Workspace members |
| [Private Pages](https://docs.bezi.com/context/pages) | You only |
| [Threads](https://docs.bezi.com/fundamentals/threads) | You only |
| [Connections](https://docs.bezi.com/context/connections) | You only |
| [Workspace Rules](https://docs.bezi.com/context/rules) | You only (applies to your threads) |
## Creating a Team Workspace
Being in the Team doesn't automatically put someone in a Team Workspace. Make sure you invite people to collaborate with you.
**Account settings** > **Subscription dropdown** > select desired Team account
![Screenshot 2026 04 13 At 3 15 21 PM]()
If you aren't part of a Team org yet, follow [these instructions](https://docs.bezi.com/account/team) to create one.
1. Open the **Workspace dropdown**, located at the top of the left sidebar
2. Click `New Workspace`
1. Open **Workspace dropdown** > `Workspace Settings`
2. Select Workspace members
3. Invite people to join the Team Workspace (must already be in the Team)
An individual must have a seat in the Team before they can be added to any Team Workspaces. Follow these steps to add someone to the Team.
1. Open **Workspace dropdown** > `Workspace Settings`
2. Hover over the member's name
3. Select `...` > `Remove from Workspace`
## Updating an existing Workspace to a Team Workspace
You can move a personal Workspace into a Team in Workspace Settings. This will preserve all data in the Workspace including connections, Pages, Plans, and threads. **Once it’s moved into a Team, it cannot be converted back into personal Workspace for security reasons**.
# Threads
Source: https://docs.bezi.com/fundamentals/threads
Threads are how you interact with your Bezi agent. They belong to a Workspace, write to the target project and pull context from multiple places. Using threads correctly is very important.
![Image]()
## How Threads gather and manage context
1. The thread's own prompt and response history (it cannot access other thread's histories)
2. All active [Workspace Connections](https://docs.bezi.com/context/connections); Unity projects and local data sources you've connected. Target project context will have more emphasis placed on it.
3. [Pages](https://docs.bezi.com/context/pages), both private and shared (if you're in a team workspace)
Monitor the **thread's context window tracker** (bottom right of the prompt field). Lower context windows = better results and fewer credits used per prompt.
If the context window is high, disable unnecessary Connections or start a new thread.
## How Threads interact with the Workspace
Threads are stored at the Workspace level, not the project level. **This means that the Threads list shows every thread you've created, across every project in a given Workspace.**
When you switch Workspaces, the Threads list will only show threads that belong to the new Workspace.
## How Threads interact with Unity projects
For every new thread, you assign **target project**. This tells the Bezi agent which Unity it will make edits and use for primary context. Click the **Project selector** to select a target project from your Connections.
Do not change a thread's target project once you've prompted in that thread. This leads to unexpected behavior and changes.
![Target Project]()
## Threads navigation
Everything Threads-related lives in the right sidebar, i.e. the ‘**Threads window**’. This is where you create new threads, access old threads, and manage all threads associated with a Workspace.
Open the **Threads** dropdown in the right sidebar to see a list of your past threads in the current Workspace. Each entry shows the thread name and its target project so you can quickly identify what you were working on.
From this menu you can:
* Open a past thread to continue where you left off
* See which target project each thread is associated with
* Delete threads you no longer need
If you can't find a specific thread, confirm that you're looking in the right Workspace.
![Workspaces Threads (1)]()
# Workspaces
Source: https://docs.bezi.com/fundamentals/workspaces
Workspaces is the organizational layer for a project. It's a single place to gather everything relevant to the project: other projects, external data sources, shared documentation, and team members.
This hub for a project's entire body of work helps individuals execute their work more effectively, while keeping teams in-sync throughout the game's development pipeline.
## What a Workspace contains
Everything below belongs to the Workspace. Meaning that you can work on multiple projects in a single Workspace, and all the information below will remain available.
### Connections
Multiple Unity Projects and external local folders can live in a Workspace. *In a Team Workspace, your Connections are private and not visible or accessible by others in the Team.*
> [Connections documentation](https://docs.bezi.com/context/connections)
### Shared and Private Pages
Pages can hold documentation, specs, coding standards, and architecture references. They provide context across everything and everyone in a Workspace. Private Pages mean they're only visible and act as context for you.
Shared Pages are visible to all team members in the Workspace and are automatically incorporated in everyone's context (only available on Team and Enterprise plans).
> [Pages documentation](https://docs.bezi.com/context/pages)
### Plans
Plans are private to you. To share a great Plan with someone in your Team Workspace, convert it to a Page and promote it to a Shared Page.
> [Plan Mode documentation](https://docs.bezi.com/fundamentals/plan-mode)
### Rules
Rules are private to you and apply to all threads and Connections in a Workspace. For Team Workspaces that want standardized Rules, define them in a Shared Page for everyone to copy.
> [Rules documentation](https://docs.bezi.com/fundamentals/rules)
### Threads
At the start of each thread you'll declare a Target Project to inform Bezi where to focus. Create a new thread if for each target project and for separate tasks within each.
> [Threads documentation](https://docs.bezi.com/fundamentals/threads)
## Workspace structure
Workspaces either belong to a personal account or a Team.
![Mac Book Pro 16 1]()
## Managing Workspaces
### Create a new Workspace
1. Open the **Workspace dropdown**, located at the top of the left sidebar
2. Click `New Workspace`
3. To tailor or manage it, open **Workspace dropdown** > `Workspace Settings`
### Switch between Workspaces
1. Open the **Workspace dropdown**, located at the top of the left sidebar
2. Select the other Workspace you want to open from the list
![WS Prod Docs 1]()
# Changelog
Source: https://docs.bezi.com/get-started/changelog
**App:** v1.36.0
**Plugin**: v0.115.12
## NEW: models & automated self-checking loops!
**New**
* Agent mode works in Play Mode: execute fully automated edit-play-verify-iterate loops with Bezi
* New models: GPT-6 Astra & Claude Fable 5.1
**Usability improvements**
* You can submit prompts with no project connected
* New Actions: control the play and pause state of the editor, the open and closed scenes, and the current selection
* All text-based file extensions are supported
* Bezi can ask follow up questions in all modes, not just Plan mode
* Bezi can use tools that do not require Unity connection without running the engine
* Bezi can now read and modify Project Settings directly, including custom SettingsProvider objects
**Usability improvements**
* Resolved high compilation times and CPU usage when Unity recompiles with the Bezi Plugin
* Improved reliability of checkpoint undo
**Bug fixes**
* Fix Bezi occasionally getting confused about missing actions if a thread is started mid-recompilation
* Fixed resume plan after follow-up questions are answered
* Fixed a bug where after any page is deleted, Bezi would navigate to Home
* Prevent Bezi from getting stuck or using stale rules when switching into plan mode
* Restored directory search in `@` mentions
* Now shows full file paths in `@` mention tooltips and keep tooltips in the viewport
## NEW: Custom Actions
* [**Custom Actions**](https://docs.bezi.com/fundamentals/custom-actions): build Custom Actions to provide Bezi with specialized C# functionality (beyond what’s covered by Bezi Actions)
* Build Custom Actions automatically using Bezi or manually with C#
* **Bezi works with Package Manager**: install packages, manage registries, export and import packages
**Usability improvements**
* Bezi can now read text files attached to a thread
* Attaching a ZIP to a thread will now extract and attach its contents
* Removed the 10 calls per workflow limit on MCPs
* Proofs can send prompts to the current thread
* Pages can be duplicated
* Pages can be transferred between workspaces
**Bug fixes**
* Fixed the Unity Profiler action sometimes returning blank data
* Fixed some situations that prevented Bezi from running Actions
## NEW: Proofs
**Proofs:** Create visual inputs (lightweight, interactive tools or prototypes) in Bezi
* Great for tasks that require more rich context than text alone
* Quickly test/iterate on an idea before committing to build in-engine
* Inspiration gallery: [https://www.bezi.com/proofs](https://www.bezi.com/proofs)
**Usability improvements**
* Improved skill naming and visibility
* Separated plan credits from on-demand usage credits for more granular tracking
* Added more languages to syntax highlighting in code editors and proofs
* Improved subscription upgrade and auto-reimbursement flows for annual plans
* Team members now see the Team account dashboard by default
**Bug fixes**
* Fixed slow tool recovery and tool calls, code-generation length-limit failures, and empty agent responses
* Fixed editing behavior in name fields and page-creation text wrapping
* Fixed checkpoint-restores automatically accepting pending changes
* Fixed inaccessible shared pages being referenced by Bezi
**Usability improvements**
* Skills can be exported/imported via App Settings
* Added a “copy” button for Page content
* Improved embedded media in Pages; upload reliability, save behavior, file tracking
* Clarified subscription cancellation verbiage
* Improved Actions execution when Unity is in the background
* Improved the empty state when searching skills with no matches
* Reduced cost and latency of retrieving action definitions by \~17%
**Bug fixes**
* Improved Pages reliability: fixed pinned pages renaming to “Untitled,” incorrect page -history in Settings, and better breadcrumb behavior in nested folders
* Removed the “Plans” option from Make Page settings
* Fixed the Team plan upgrade prompt appearing incorrectly
* Fixed several Actions reliability and compilation issues
## NEW: Bezi Actions & Image Embeds!
* **Pages now support image embeds!** (great for UI - see image)
* **Bezi Actions overhaul** to reduce cost and improve performance across all models
* **[Bezi Actions](https://docs.bezi.com/fundamentals/agent-mode#actions): 6 new capabilities**
1. Generate animation clips, sequence cinematic content
2. Setup advanced Mecanim BlendTrees
3. Debug broken functionality and auto-iterate until desired behavior is met (Test Runner)
4. Create and update Input Systems
5. Create, update and view Particle Systems
6. Analyze Profiler performance data, implement optimizations
* **Removed workspace limits for all plan levels**
**Usability improvements**
* Better support of Feel and TDE packages
* Unity Hub projects now auto-discovered in Add Unity project
* Page blocks can be reorganized with drag-and-drop
* Added support for block selection
* Added support for search @mentions in pages, plans and project rules
**Bug fixes**
* UI fix where model change popover was cut off in thread
* Will now ignore blank/invalid values in isolated view screenshot requests
* Fixed a workflow crash with a GPT model’s thinking configuration
* Fixed mismatches mention icon text color
* Fixed misalignment between mentions
![Image (5)]()
**Usability improvements**
* Improved ability for Actions to handle larger tasks at lower cost
* Added confirmation step to prevent trial cancellation
* Improved wording of error popup when org limit is reached
* Compressing images prior to upload
**Bug fixes**
* Fixed several issues when Bezi would lose connection or terminate workflow after a failed tool call to Unity
* Fixed a bug where compilation requests hung on disconnected targets
* Fixed connection status error causing blocked input
* Detect and escape unbalanced parentheses in grep queries
* Restores view setup after screenshot action failure
* Fixed a bug where Bezi UI stopped updating during parallel LLM generation
* Remove duplicate error sections in action execution batches
* Fixed excessive scroll bars appearing
* Fixed subscription inactive warning shows for annual plans near usage cap
* Fixed a bug where deleted assets may be returned by editor APIs to list assets
* Fixed a bug where duplicate customer payment profiles caused sign-in issues
* Fixed display of credit numbers in web app for lower tier plans
* Fixed UI issue showing incorrect diff values for added lines
* Show invited org after accepting an invite
* Redirect used invite links to the web app for logged-in users
* Fixed usage bar doesn't reach the end when limit is exceeded
* Removed on-demand usage for free trial
**NEW**
* Nested subfolders supported for Pages!
* Enterprise account Admins can view and limit member credit usage
* New UGUI Default Skill: quickly implement UI using UGUI from a screenshot or Figma file
**Usability improvements**
* You can now independently accept/reject changes in parallel threads
* Ability to pin folders
* Improved rendering of pinned resources, @ mentions, and skill commands
* Improved Oversized Markdown Handling
* Added a progress bar animation for app loads and workspace switches
* Renders Unity Shaders several frames forward, so the screenshot is representative
**Bug fixes**
* Fixed subagent errors on GPT models
* Several fixes and performance improvements to Bezi Actions
* Fixed global state of domain recompilation when working in multiple Unity projects in parallel
* Fixed Bezi disconnecting from Unity in Multiplayer Play Mode
* Fixed Unity logs warning for invalid quaternion rotation
**NEW**
* **NEW GPT MODELS:** Luna, Sol, Terra
* New featured MCP connections: Blender, Miro, Perforce, Trello
**Usability improvements**
* Improved grep search performance
* Real-time Collaborative Pages improvements
* Improved handling for session expired state
* Performance improvements to loading collaborative pages
* Added back the missing reset to default button in Your Rules tab
* Fixed memory leak in collaborative pages
* Fixed display issue for users without names on collab pages
* Fixed drag-drop of workspace nodes in the collaborative pages
* Updated the message for accepting changes from another project in current project
* Enforced Bezi Trial policy in the application and updated in-app messaging for it
**Bug fixes**
* Fixed a bug where Bezi would trigger Unity blocking popup during restore
* Fixed a bug where Bezi would trigger save popup for prefabs
* Fixed the bug where entering Play Mode would throw Bezi type load errors
* Fixed the Unity 6.5 SceneView rotation warning in 2D mode
* Fixed SearchAssetsByQuery due to InstanceID deprication
* Fixed the SaveScene error in Unity plugin in Ask mode
* Fixed a bug where Bezi reverted unsaved changes in additively loaded scenes
* Fixed the occasional error screen when loading the app
* Fixed a type validation error for Actions
* Fixed the crash when inputting \[@...] into prompt
* Fixed a bug where Workspace switcher menu overflows narrow left panel
* Updated the redirect to Home when page not found after login
* Fixed a bug where the app would enter refresh loop on logout
* Removed console warning for unsupported HSL color format on macOS
* Fixed dimensions error when submitting prompts with image attachments
* Fixed a bug where chat area suddenly scrolls down and leaves empty screen
* Fixed the trailing @ remains after deleting skill name in thread
* Fixed occasional subagent error on compaction for deepseek-v4-flash
* Disabled prompting when the target project is disabled
* Fixed avatar image loading and unassigned seat visuals for Team plans
## Now Introducing: Skills & Direct Model Selection
**NEW: Skills!!**
* Extend what Bezi can do and standardize repeated workflows
* Let Bezi automate complex tasks by packaging repetitive, multi-step workflows into a single command. Use default Bezi skills or create custom skills for a workflow
* Default Skills options include: `UGUI > UI Toolkit Conversion` or `Create Documentation`
* Learn more: [https://docs.bezi.com/fundamentals/skills](https://docs.bezi.com/fundamentals/skills)
**NEW: Model selection and more options**
* You can now select a specific model from the menu (see image)
* Added GLM 5.2 model: performant and cheap, great for daily work
* Added Claude Sonnet 5 model: next-gen sonnet offering
* Safer defaults for model capabilities, e.g. disabled image output for models that don’t support it
* Updated model descriptions and compaction/model-provider tuning
**Usability improvements**
* Updated Bezi’s Home interface for better management of workspaces, projects and skills
* New detailed view of token usage and plan usage in Home
* Improved MCP tool serialization
**Bug fixes**
* Fixed private pages that failed to load when collaboration is turned on
* Reduced failed sync requests and validated collaboration-server behavior
* Reduced token-usage spikes in websocket-related flows
* Fixed several save-flow and scene-state blockers, including screenshot-triggered scene creation, missing-script save popups, unsaved-scene handling, and action failures despite healthy Unity connection state
* Fixed Notion MCP setup hallucinations and MCP-cap limit behavior
* Removed outdated Pages word-count UI
* Fixed Unity save-scene prompts when taking screenshots
* Fixed sync polling so it stops on automatic logout after 401 responses
* Fixed the explored dropdown jumping while tools are being called
* Fixed a bug that made Shared pages load very slowly
## Now Introducing: Opus 4.8 and real-time collaborative pages!
**New: real-time collaborative pages**
* Shared Pages (available in Teams) now support real-time collaboration. When more than one person has a Shared Page open, you see each other's cursors and see text appear as it's typed.
* The person editing a paragraph is visible to everyone viewing the page. Everyone's edits merge automatically as you go, so there's nothing to manually save and no merge conflicts to resolve.
* Real-time collaboration covers people’s manual edits. Edits Bezi makes to a Shared Page on your behalf will appear once it's done editing.
**AI updates**
* Frontier now uses Opus 4.8
* Context window is expanded 2x
* Improved speed and accuracy of thread compaction
**Subscriptions updates**
* Outstanding payments are now invoiced before a new subscription can be created
**Usability improvements**
* Improved compilation of Bezi Actions when submitting consecutive messages in a thread
* Added progressive generation of Actions to improve speed
* Included Plans in page list searches
* Enabled aborting Action batches
* Several improvements to recompilation triggers - after deleting scripts and DLLs
* Grouped Actions by modules in Unity
**Bug fixes**
* Fixed occasional file watcher errors
* Fixed Actions checkpointing not working with subagents
* Fixed a UI bug where header overlayed scrollbar in Pages
* Fixed a bug where listing folders recursively would return incomplete lists
* Fixed a bug that broke moving pages via right
* Undo All does not remove created material now
* Fixed an occasional crash in Bezi
* Removed some Unity console messages on first install
* Fixed a bug where Bezi failed to recompile on assembly reference edits
* Forces Unity recompilation after script changes and deletes
![Real Time Collab]()
## Now Introducing: Skills & Direct Model Selection
**NEW: Skills!!**
* Extend what Bezi can do and standardize repeated workflows
* Let Bezi automate complex tasks by packaging repetitive, multi-step workflows into a single command. Use default Bezi skills or create custom skills for a workflow
* Default Skills options include: `UGUI > UI Toolkit Conversion` or `Create Documentation`
* Learn more: [https://docs.bezi.com/fundamentals/skills](https://docs.bezi.com/fundamentals/skills)
**NEW: Model selection and more options**
* You can now select a specific model from the menu (see image)
* Added GLM 5.2 model: performant and cheap, great for daily work
* Added Claude Sonnet 5 model: next-gen sonnet offering
* Safer defaults for model capabilities, e.g. disabled image output for models that don’t support it
* Updated model descriptions and compaction/model-provider tuning
**Usability improvements**
* Updated Bezi’s Home interface for better management of workspaces, projects and skills
* New detailed view of token usage and plan usage in Home
* Improved MCP tool serialization
**Bug fixes**
* Fixed private pages that failed to load when collaboration is turned on
* Reduced failed sync requests and validated collaboration-server behavior
* Reduced token-usage spikes in websocket-related flows
* Fixed several save-flow and scene-state blockers, including screenshot-triggered scene creation, missing-script save popups, unsaved-scene handling, and action failures despite healthy Unity connection state
* Fixed Notion MCP setup hallucinations and MCP-cap limit behavior
* Removed outdated Pages word-count UI
* Fixed Unity save-scene prompts when taking screenshots
* Fixed sync polling so it stops on automatic logout after 401 responses
* Fixed the explored dropdown jumping while tools are being called
* Fixed a bug that made Shared pages load very slowly
![Release July 1]()
## Now Introducing: Opus 4.8 and real-time collaborative pages!
**New: real-time collaborative pages**
* Shared Pages (available in Teams) now support real-time collaboration. When more than one person has a Shared Page open, you see each other's cursors and see text appear as it's typed.
* The person editing a paragraph is visible to everyone viewing the page. Everyone's edits merge automatically as you go, so there's nothing to manually save and no merge conflicts to resolve.
* Real-time collaboration covers people’s manual edits. Edits Bezi makes to a Shared Page on your behalf will appear once it's done editing.
**AI updates**
* Frontier now uses Opus 4.8
* Context window is expanded 2x
* Improved speed and accuracy of thread compaction
**Subscriptions updates**
* Outstanding payments are now invoiced before a new subscription can be created
**Usability improvements**
* Improved compilation of Bezi Actions when submitting consecutive messages in a thread
* Added progressive generation of Actions to improve speed
* Included Plans in page list searches
* Enabled aborting Action batches
* Several improvements to recompilation triggers - after deleting scripts and DLLs
* Grouped Actions by modules in Unity
**Bug fixes**
* Fixed occasional file watcher errors
* Fixed Actions checkpointing not working with subagents
* Fixed a UI bug where header overlayed scrollbar in Pages
* Fixed a bug where listing folders recursively would return incomplete lists
* Fixed a bug that broke moving pages via right
* Undo All does not remove created material now
* Fixed an occasional crash in Bezi
* Removed some Unity console messages on first install
* Fixed a bug where Bezi failed to recompile on assembly reference edits
* Forces Unity recompilation after script changes and deletes
![Real Time Collab]()
## Now Introducing: Opus 4.8 and real-time collaborative pages!
**New: real-time collaborative pages**
* Shared Pages (available in Teams) now support real-time collaboration. When more than one person has a Shared Page open, you see each other's cursors and see text appear as it's typed.
* The person editing a paragraph is visible to everyone viewing the page. Everyone's edits merge automatically as you go, so there's nothing to manually save and no merge conflicts to resolve.
* Real-time collaboration covers people’s manual edits. Edits Bezi makes to a Shared Page on your behalf will appear once it's done editing.
**AI updates**
* Frontier now uses Opus 4.8
* Context window is expanded 2x
* Improved speed and accuracy of thread compaction
**Subscriptions updates**
* Outstanding payments are now invoiced before a new subscription can be created
**Usability improvements**
* Improved compilation of Bezi Actions when submitting consecutive messages in a thread
* Added progressive generation of Actions to improve speed
* Included Plans in page list searches
* Enabled aborting Action batches
* Several improvements to recompilation triggers - after deleting scripts and DLLs
* Grouped Actions by modules in Unity
**Bug fixes**
* Fixed occasional file watcher errors
* Fixed Actions checkpointing not working with subagents
* Fixed a UI bug where header overlayed scrollbar in Pages
* Fixed a bug where listing folders recursively would return incomplete lists
* Fixed a bug that broke moving pages via right
* Undo All does not remove created material now
* Fixed an occasional crash in Bezi
* Removed some Unity console messages on first install
* Fixed a bug where Bezi failed to recompile on assembly reference edits
* Forces Unity recompilation after script changes and deletes
![Real Time Collab]()
## Now Introducing: Opus 4.8 and real-time collaborative pages!
**New: real-time collaborative pages**
* Shared Pages (available in Teams) now support real-time collaboration. When more than one person has a Shared Page open, you see each other's cursors and see text appear as it's typed.
* The person editing a paragraph is visible to everyone viewing the page. Everyone's edits merge automatically as you go, so there's nothing to manually save and no merge conflicts to resolve.
* Real-time collaboration covers people’s manual edits. Edits Bezi makes to a Shared Page on your behalf will appear once it's done editing.
**AI updates**
* Frontier now uses Opus 4.8
* Context window is expanded 2x
* Improved speed and accuracy of thread compaction
**Subscriptions updates**
* Outstanding payments are now invoiced before a new subscription can be created
**Usability improvements**
* Improved compilation of Bezi Actions when submitting consecutive messages in a thread
* Added progressive generation of Actions to improve speed
* Included Plans in page list searches
* Enabled aborting Action batches
* Several improvements to recompilation triggers - after deleting scripts and DLLs
* Grouped Actions by modules in Unity
**Bug fixes**
* Fixed occasional file watcher errors
* Fixed Actions checkpointing not working with subagents
* Fixed a UI bug where header overlayed scrollbar in Pages
* Fixed a bug where listing folders recursively would return incomplete lists
* Fixed a bug that broke moving pages via right
* Undo All does not remove created material now
* Fixed an occasional crash in Bezi
* Removed some Unity console messages on first install
* Fixed a bug where Bezi failed to recompile on assembly reference edits
* Forces Unity recompilation after script changes and deletes
![Real Time Collab]()
## Now Introducing: Skills & Direct Model Selection
**NEW: Skills!!**
* Extend what Bezi can do and standardize repeated workflows
* Let Bezi automate complex tasks by packaging repetitive, multi-step workflows into a single command. Use default Bezi skills or create custom skills for a workflow
* Default Skills options include: `UGUI > UI Toolkit Conversion` or `Create Documentation`
* Learn more: [https://docs.bezi.com/fundamentals/skills](https://docs.bezi.com/fundamentals/skills)
**NEW: Model selection and more options**
* You can now select a specific model from the menu (see image)
* Added GLM 5.2 model: performant and cheap, great for daily work
* Added Claude Sonnet 5 model: next-gen sonnet offering
* Safer defaults for model capabilities, e.g. disabled image output for models that don’t support it
* Updated model descriptions and compaction/model-provider tuning
**Usability improvements**
* Updated Bezi’s Home interface for better management of workspaces, projects and skills
* New detailed view of token usage and plan usage in Home
* Improved MCP tool serialization
**Bug fixes**
* Fixed private pages that failed to load when collaboration is turned on
* Reduced failed sync requests and validated collaboration-server behavior
* Reduced token-usage spikes in websocket-related flows
* Fixed several save-flow and scene-state blockers, including screenshot-triggered scene creation, missing-script save popups, unsaved-scene handling, and action failures despite healthy Unity connection state
* Fixed Notion MCP setup hallucinations and MCP-cap limit behavior
* Removed outdated Pages word-count UI
* Fixed Unity save-scene prompts when taking screenshots
* Fixed sync polling so it stops on automatic logout after 401 responses
* Fixed the explored dropdown jumping while tools are being called
* Fixed a bug that made Shared pages load very slowly
![Release July 1]()
## Now Introducing: Opus 4.8 and real-time collaborative pages!
**New: real-time collaborative pages**
* Shared Pages (available in Teams) now support real-time collaboration. When more than one person has a Shared Page open, you see each other's cursors and see text appear as it's typed.
* The person editing a paragraph is visible to everyone viewing the page. Everyone's edits merge automatically as you go, so there's nothing to manually save and no merge conflicts to resolve.
* Real-time collaboration covers people’s manual edits. Edits Bezi makes to a Shared Page on your behalf will appear once it's done editing.
**AI updates**
* Frontier now uses Opus 4.8
* Context window is expanded 2x
* Improved speed and accuracy of thread compaction
**Subscriptions updates**
* Outstanding payments are now invoiced before a new subscription can be created
**Usability improvements**
* Improved compilation of Bezi Actions when submitting consecutive messages in a thread
* Added progressive generation of Actions to improve speed
* Included Plans in page list searches
* Enabled aborting Action batches
* Several improvements to recompilation triggers - after deleting scripts and DLLs
* Grouped Actions by modules in Unity
**Bug fixes**
* Fixed occasional file watcher errors
* Fixed Actions checkpointing not working with subagents
* Fixed a UI bug where header overlayed scrollbar in Pages
* Fixed a bug where listing folders recursively would return incomplete lists
* Fixed a bug that broke moving pages via right
* Undo All does not remove created material now
* Fixed an occasional crash in Bezi
* Removed some Unity console messages on first install
* Fixed a bug where Bezi failed to recompile on assembly reference edits
* Forces Unity recompilation after script changes and deletes
![Real Time Collab]()
## Now Introducing: Opus 4.8 and real-time collaborative pages!
**New: real-time collaborative pages**
* Shared Pages (available in Teams) now support real-time collaboration. When more than one person has a Shared Page open, you see each other's cursors and see text appear as it's typed.
* The person editing a paragraph is visible to everyone viewing the page. Everyone's edits merge automatically as you go, so there's nothing to manually save and no merge conflicts to resolve.
* Real-time collaboration covers people’s manual edits. Edits Bezi makes to a Shared Page on your behalf will appear once it's done editing.
**AI updates**
* Frontier now uses Opus 4.8
* Context window is expanded 2x
* Improved speed and accuracy of thread compaction
**Subscriptions updates**
* Outstanding payments are now invoiced before a new subscription can be created
**Usability improvements**
* Improved compilation of Bezi Actions when submitting consecutive messages in a thread
* Added progressive generation of Actions to improve speed
* Included Plans in page list searches
* Enabled aborting Action batches
* Several improvements to recompilation triggers - after deleting scripts and DLLs
* Grouped Actions by modules in Unity
**Bug fixes**
* Fixed occasional file watcher errors
* Fixed Actions checkpointing not working with subagents
* Fixed a UI bug where header overlayed scrollbar in Pages
* Fixed a bug where listing folders recursively would return incomplete lists
* Fixed a bug that broke moving pages via right
* Undo All does not remove created material now
* Fixed an occasional crash in Bezi
* Removed some Unity console messages on first install
* Fixed a bug where Bezi failed to recompile on assembly reference edits
* Forces Unity recompilation after script changes and deletes
![Real Time Collab]()
## Now Introducing: Opus 4.8 and real-time collaborative pages!
**New: real-time collaborative pages**
* Shared Pages (available in Teams) now support real-time collaboration. When more than one person has a Shared Page open, you see each other's cursors and see text appear as it's typed.
* The person editing a paragraph is visible to everyone viewing the page. Everyone's edits merge automatically as you go, so there's nothing to manually save and no merge conflicts to resolve.
* Real-time collaboration covers people’s manual edits. Edits Bezi makes to a Shared Page on your behalf will appear once it's done editing.
**AI updates**
* Frontier now uses Opus 4.8
* Context window is expanded 2x
* Improved speed and accuracy of thread compaction
**Subscriptions updates**
* Outstanding payments are now invoiced before a new subscription can be created
**Usability improvements**
* Improved compilation of Bezi Actions when submitting consecutive messages in a thread
* Added progressive generation of Actions to improve speed
* Included Plans in page list searches
* Enabled aborting Action batches
* Several improvements to recompilation triggers - after deleting scripts and DLLs
* Grouped Actions by modules in Unity
**Bug fixes**
* Fixed occasional file watcher errors
* Fixed Actions checkpointing not working with subagents
* Fixed a UI bug where header overlayed scrollbar in Pages
* Fixed a bug where listing folders recursively would return incomplete lists
* Fixed a bug that broke moving pages via right
* Undo All does not remove created material now
* Fixed an occasional crash in Bezi
* Removed some Unity console messages on first install
* Fixed a bug where Bezi failed to recompile on assembly reference edits
* Forces Unity recompilation after script changes and deletes
![Real Time Collab]()
## Now Introducing: Skills & Direct Model Selection
**NEW: Skills!!**
* Extend what Bezi can do and standardize repeated workflows
* Let Bezi automate complex tasks by packaging repetitive, multi-step workflows into a single command. Use default Bezi skills or create custom skills for a workflow
* Default Skills options include: `UGUI > UI Toolkit Conversion` or `Create Documentation`
* Learn more: [https://docs.bezi.com/fundamentals/skills](https://docs.bezi.com/fundamentals/skills)
**NEW: Model selection and more options**
* You can now select a specific model from the menu (see image)
* Added GLM 5.2 model: performant and cheap, great for daily work
* Added Claude Sonnet 5 model: next-gen sonnet offering
* Safer defaults for model capabilities, e.g. disabled image output for models that don’t support it
* Updated model descriptions and compaction/model-provider tuning
**Usability improvements**
* Updated Bezi’s Home interface for better management of workspaces, projects and skills
* New detailed view of token usage and plan usage in Home
* Improved MCP tool serialization
**Bug fixes**
* Fixed private pages that failed to load when collaboration is turned on
* Reduced failed sync requests and validated collaboration-server behavior
* Reduced token-usage spikes in websocket-related flows
* Fixed several save-flow and scene-state blockers, including screenshot-triggered scene creation, missing-script save popups, unsaved-scene handling, and action failures despite healthy Unity connection state
* Fixed Notion MCP setup hallucinations and MCP-cap limit behavior
* Removed outdated Pages word-count UI
* Fixed Unity save-scene prompts when taking screenshots
* Fixed sync polling so it stops on automatic logout after 401 responses
* Fixed the explored dropdown jumping while tools are being called
* Fixed a bug that made Shared pages load very slowly
![Release July 1]()
## Now Introducing: Opus 4.8 and real-time collaborative pages!
**New: real-time collaborative pages**
* Shared Pages (available in Teams) now support real-time collaboration. When more than one person has a Shared Page open, you see each other's cursors and see text appear as it's typed.
* The person editing a paragraph is visible to everyone viewing the page. Everyone's edits merge automatically as you go, so there's nothing to manually save and no merge conflicts to resolve.
* Real-time collaboration covers people’s manual edits. Edits Bezi makes to a Shared Page on your behalf will appear once it's done editing.
**AI updates**
* Frontier now uses Opus 4.8
* Context window is expanded 2x
* Improved speed and accuracy of thread compaction
**Subscriptions updates**
* Outstanding payments are now invoiced before a new subscription can be created
**Usability improvements**
* Improved compilation of Bezi Actions when submitting consecutive messages in a thread
* Added progressive generation of Actions to improve speed
* Included Plans in page list searches
* Enabled aborting Action batches
* Several improvements to recompilation triggers - after deleting scripts and DLLs
* Grouped Actions by modules in Unity
**Bug fixes**
* Fixed occasional file watcher errors
* Fixed Actions checkpointing not working with subagents
* Fixed a UI bug where header overlayed scrollbar in Pages
* Fixed a bug where listing folders recursively would return incomplete lists
* Fixed a bug that broke moving pages via right
* Undo All does not remove created material now
* Fixed an occasional crash in Bezi
* Removed some Unity console messages on first install
* Fixed a bug where Bezi failed to recompile on assembly reference edits
* Forces Unity recompilation after script changes and deletes
![Real Time Collab]()
## Now Introducing: Opus 4.8 and real-time collaborative pages!
**New: real-time collaborative pages**
* Shared Pages (available in Teams) now support real-time collaboration. When more than one person has a Shared Page open, you see each other's cursors and see text appear as it's typed.
* The person editing a paragraph is visible to everyone viewing the page. Everyone's edits merge automatically as you go, so there's nothing to manually save and no merge conflicts to resolve.
* Real-time collaboration covers people’s manual edits. Edits Bezi makes to a Shared Page on your behalf will appear once it's done editing.
**AI updates**
* Frontier now uses Opus 4.8
* Context window is expanded 2x
* Improved speed and accuracy of thread compaction
**Subscriptions updates**
* Outstanding payments are now invoiced before a new subscription can be created
**Usability improvements**
* Improved compilation of Bezi Actions when submitting consecutive messages in a thread
* Added progressive generation of Actions to improve speed
* Included Plans in page list searches
* Enabled aborting Action batches
* Several improvements to recompilation triggers - after deleting scripts and DLLs
* Grouped Actions by modules in Unity
**Bug fixes**
* Fixed occasional file watcher errors
* Fixed Actions checkpointing not working with subagents
* Fixed a UI bug where header overlayed scrollbar in Pages
* Fixed a bug where listing folders recursively would return incomplete lists
* Fixed a bug that broke moving pages via right
* Undo All does not remove created material now
* Fixed an occasional crash in Bezi
* Removed some Unity console messages on first install
* Fixed a bug where Bezi failed to recompile on assembly reference edits
* Forces Unity recompilation after script changes and deletes
![Real Time Collab]()
## Now Introducing: Opus 4.8 and real-time collaborative pages!
**New: real-time collaborative pages**
* Shared Pages (available in Teams) now support real-time collaboration. When more than one person has a Shared Page open, you see each other's cursors and see text appear as it's typed.
* The person editing a paragraph is visible to everyone viewing the page. Everyone's edits merge automatically as you go, so there's nothing to manually save and no merge conflicts to resolve.
* Real-time collaboration covers people’s manual edits. Edits Bezi makes to a Shared Page on your behalf will appear once it's done editing.
**AI updates**
* Frontier now uses Opus 4.8
* Context window is expanded 2x
* Improved speed and accuracy of thread compaction
**Subscriptions updates**
* Outstanding payments are now invoiced before a new subscription can be created
**Usability improvements**
* Improved compilation of Bezi Actions when submitting consecutive messages in a thread
* Added progressive generation of Actions to improve speed
* Included Plans in page list searches
* Enabled aborting Action batches
* Several improvements to recompilation triggers - after deleting scripts and DLLs
* Grouped Actions by modules in Unity
**Bug fixes**
* Fixed occasional file watcher errors
* Fixed Actions checkpointing not working with subagents
* Fixed a UI bug where header overlayed scrollbar in Pages
* Fixed a bug where listing folders recursively would return incomplete lists
* Fixed a bug that broke moving pages via right
* Undo All does not remove created material now
* Fixed an occasional crash in Bezi
* Removed some Unity console messages on first install
* Fixed a bug where Bezi failed to recompile on assembly reference edits
* Forces Unity recompilation after script changes and deletes
![Real Time Collab]()
**New**
* Added support for adding scenes to the build list
* Added support for referencing sub-assets
* Added a button to copy message response
**Usability improvements**
* Improved app load time from 12s to 4s average
* Improved compaction, thinking-effort, and max-token handling
* Pending changes in one project no longer block sending messages to another target project
* Selecting “Make Plan” now stays in plan mode vs executing in agent mode
* Safer handling of multiple messages in one thread
* Reduced scroll jitter in threads
* Minor UI updates
**Bug fixes**
* Fixed action compilation failures
* Fixed animator controller action changes not being applied
* Fixed failed actions restoring previous scene changes incorrectly
* Fixed prefab instances not being detected in scene understanding
* Fixed scene changes being reverted after app updates
* Fixed cases causing pages and plans failing to load
* Fixed invalid generated TypeScript appearing before a successful result
* Fixed a bug where the Submit button self-disabled after repeat edit-and-submit cycles
* Fixed Unity plugin auto-update to 0.9.0 breaking projects
* Fixed desktop app crash edge-case due to actions compilation
* Fixed issues with the cancel-subscription button for users with pending updates
* Fixed a Figma MCP rate-limit issue
* Fixed the Jira MCP discovery helper link (wasn’t clickable)
* Fixed malformed attachment URLs causing AI image download errors
## Now introducing: Opus 4.8 and real-time collaborative pages!
**New: real-time collaborative pages**
* Shared Pages (available in Teams) now support real-time collaboration. When more than one person has a Shared Page open, you see each other's cursors and see text appear as it's typed.
* The person editing a paragraph is visible to everyone viewing the page. Everyone's edits merge automatically as you go, so there's nothing to manually save and no merge conflicts to resolve.
* Real-time collaboration covers people’s manual edits. Edits Bezi makes to a Shared Page on your behalf will appear once it's done editing.
**AI updates**
* Frontier now uses Opus 4.8
* Context window is expanded 2x
* Improved speed and accuracy of thread compaction
**Subscriptions updates**
* Outstanding payments are now invoiced before a new subscription can be created
**Usability improvements**
* Improved compilation of Bezi Actions when submitting consecutive messages in a thread
* Added progressive generation of Actions to improve speed
* Included Plans in page list searches
* Enabled aborting Action batches
* Several improvements to recompilation triggers - after deleting scripts and DLLs
* Grouped Actions by modules in Unity
**Bug fixes**
* Fixed occasional file watcher errors
* Fixed Actions checkpointing not working with subagents
* Fixed a UI bug where header overlayed scrollbar in Pages
* Fixed a bug where listing folders recursively would return incomplete lists
* Fixed a bug that broke moving pages via right
* Undo All does not remove created material now
* Fixed an occasional crash in Bezi
* Removed some Unity console messages on first install
* Fixed a bug where Bezi failed to recompile on assembly reference edits
* Forces Unity recompilation after script changes and deletes
![Real Time Collab]()
**New**
* Added support for adding scenes to the build list
* Added support for referencing sub-assets
* Added a button to copy message response
**Usability improvements**
* Improved app load time from 12s to 4s average
* Improved compaction, thinking-effort, and max-token handling
* Pending changes in one project no longer block sending messages to another target project
* Selecting “Make Plan” now stays in plan mode vs executing in agent mode
* Safer handling of multiple messages in one thread
* Reduced scroll jitter in threads
* Minor UI updates
**Bug fixes**
* Fixed action compilation failures
* Fixed animator controller action changes not being applied
* Fixed failed actions restoring previous scene changes incorrectly
* Fixed prefab instances not being detected in scene understanding
* Fixed scene changes being reverted after app updates
* Fixed cases causing pages and plans failing to load
* Fixed invalid generated TypeScript appearing before a successful result
* Fixed a bug where the Submit button self-disabled after repeat edit-and-submit cycles
* Fixed Unity plugin auto-update to 0.9.0 breaking projects
* Fixed desktop app crash edge-case due to actions compilation
* Fixed issues with the cancel-subscription button for users with pending updates
* Fixed a Figma MCP rate-limit issue
* Fixed the Jira MCP discovery helper link (wasn’t clickable)
* Fixed malformed attachment URLs causing AI image download errors
## Now introducing: Opus 4.8 and real-time collaborative pages!
**New: real-time collaborative pages**
* Shared Pages (available in Teams) now support real-time collaboration. When more than one person has a Shared Page open, you see each other's cursors and see text appear as it's typed.
* The person editing a paragraph is visible to everyone viewing the page. Everyone's edits merge automatically as you go, so there's nothing to manually save and no merge conflicts to resolve.
* Real-time collaboration covers people’s manual edits. Edits Bezi makes to a Shared Page on your behalf will appear once it's done editing.
**AI updates**
* Frontier now uses Opus 4.8
* Context window is expanded 2x
* Improved speed and accuracy of thread compaction
**Subscriptions updates**
* Outstanding payments are now invoiced before a new subscription can be created
**Usability improvements**
* Improved compilation of Bezi Actions when submitting consecutive messages in a thread
* Added progressive generation of Actions to improve speed
* Included Plans in page list searches
* Enabled aborting Action batches
* Several improvements to recompilation triggers - after deleting scripts and DLLs
* Grouped Actions by modules in Unity
**Bug fixes**
* Fixed occasional file watcher errors
* Fixed Actions checkpointing not working with subagents
* Fixed a UI bug where header overlayed scrollbar in Pages
* Fixed a bug where listing folders recursively would return incomplete lists
* Fixed a bug that broke moving pages via right
* Undo All does not remove created material now
* Fixed an occasional crash in Bezi
* Removed some Unity console messages on first install
* Fixed a bug where Bezi failed to recompile on assembly reference edits
* Forces Unity recompilation after script changes and deletes
**New**
* Added support for adding scenes to the build list
* Added support for referencing sub-assets
* Added a button to copy message response
**Usability improvements**
* Improved app load time from 12s to 4s average
* Improved compaction, thinking-effort, and max-token handling
* Pending changes in one project no longer block sending messages to another target project
* Selecting “Make Plan” now stays in plan mode vs executing in agent mode
* Safer handling of multiple messages in one thread
* Reduced scroll jitter in threads
* Minor UI updates
**Bug fixes**
* Fixed action compilation failures
* Fixed animator controller action changes not being applied
* Fixed failed actions restoring previous scene changes incorrectly
* Fixed prefab instances not being detected in scene understanding
* Fixed scene changes being reverted after app updates
* Fixed cases causing pages and plans failing to load
* Fixed invalid generated TypeScript appearing before a successful result
* Fixed a bug where the Submit button self-disabled after repeat edit-and-submit cycles
* Fixed Unity plugin auto-update to 0.9.0 breaking projects
* Fixed desktop app crash edge-case due to actions compilation
* Fixed issues with the cancel-subscription button for users with pending updates
* Fixed a Figma MCP rate-limit issue
* Fixed the Jira MCP discovery helper link (wasn’t clickable)
* Fixed malformed attachment URLs causing AI image download errors
**New**
* Added support for adding scenes to the build list
* Added support for referencing sub-assets
* Added a button to copy message response
**Usability improvements**
* Improved app load time from 12s to 4s average
* Improved compaction, thinking-effort, and max-token handling
* Pending changes in one project no longer block sending messages to another target project
* Selecting “Make Plan” now stays in plan mode vs executing in agent mode
* Safer handling of multiple messages in one thread
* Reduced scroll jitter in threads
* Minor UI updates
**Bug fixes**
* Fixed action compilation failures
* Fixed animator controller action changes not being applied
* Fixed failed actions restoring previous scene changes incorrectly
* Fixed prefab instances not being detected in scene understanding
* Fixed scene changes being reverted after app updates
* Fixed cases causing pages and plans failing to load
* Fixed invalid generated TypeScript appearing before a successful result
* Fixed a bug where the Submit button self-disabled after repeat edit-and-submit cycles
* Fixed Unity plugin auto-update to 0.9.0 breaking projects
* Fixed desktop app crash edge-case due to actions compilation
* Fixed issues with the cancel-subscription button for users with pending updates
* Fixed a Figma MCP rate-limit issue
* Fixed the Jira MCP discovery helper link (wasn’t clickable)
* Fixed malformed attachment URLs causing AI image download errors
**New**
* Animation Timeline support in Bezi Actions
* Create and edit keyframes for any GameObject properties, such as position/rotation/scale, script values, etc.
* Sprite animations via image sequences or sprite sheet sub-assets
* Featured MCP registry to make it easier to discover and connect to supported MCPs
**Usability improvements**
* Several updates to the image capture tool to improve Bezi’s ability to inspect prefabs and assets
* More stable MCP connection settings, includes persistent enabled toggles and improved syncing when `mcp.json` is edited manually
* Updated logic for mode, model and thinking effort selection between threads
* Mode is now derived from the most recently used mode in that thread
* Model and thinking effort is consistent across the app
**Bug fixes**
* Several Actions updates to reduce errors, especially those causing its confusion about availability and capabilities
* Filesystem and action workflows now behave more reliably with VFS paths and required action properties
* Fixed a bug where deleting a page could result in a crash
## Now introducing: Thinking Effort
* Specify the amount of thinking that each model should use for solving tasks
* Select from None, Low, Medium, High
* Higher thinking effort will solve harder problems, but will cost more tokens
**Usability improvements**
* We have updated the Bezi Actions system to handle larger tasks faster, more reliably, and at lower cost
* Threads panel is now resizable
**Bug fixes**
* Fixed a bug where recompilation was not called before calling the console errors tool
* Editor-tool generation no longer captures Game View screenshots when it shouldn’t
* Fixed a bug where "Project not found" errors would show up after a project was disconnected and relinked
## Now introducing: MCP Connectors
*Connect external tools to Bezi to add more context and execute multi-tool workflows from Bezi*
[MCP Connectors](https://docs.bezi.com/context/mcp)
* Add and manage any MCP-compatible tool or service via chat or Workspace Settings
* Bezi can read from and write to connected tools directly in a session
* MCP provider documentation will define what permissions and actions are available to Bezi
* Example connections include; Jira, Blender, GitHub, Figma, but options are infinite!
**New**
* Checkout-aware actions to reduce prefab and scene merge conflicts
* Applicable to check-out based VCS, like Unity VCS and Perforce
* Available on Team plan only
**Usability improvements**
* Bezi can now search files inside Unity Packages folders
* Greatly improved reliability of Bezi to Unity connection
* Improved how Bezi handles long-running threads so you’re less likely to lose progress when a run hits its limit
**Bug fixes**
* Fixed cases where paid plans were shown incorrectly, including some Pro accounts being prompted to upgrade and some upgrades from Pro to Advanced not going through
* Fixed a bug where subscription details weren’t shown for some users
* Fixed the dll collision that would make Bezi plugin conflict with some other Unity plugins
* Fixed a naming collision that could stop action generation in some Unity projects
* Fixed an action-type error that could break certain Unity update actions
* Reduced heavy disk usage some people experienced with large Unity projects, which could slow work down or even crash Unity
* Fixed a bug where approving multiple tool actions at once could cancel the thread instead of resuming it
* Fixed several failure modes that could interrupt runs unexpectedly, including subagent timeouts, malformed Unicode content, and some Basic model request errors
* Fixed an assortment of UI bugs
**Usability improvements**
* Increased the timeout limit for get console errors tool to prevent tool errors in large projects
* Getting console errors is now properly distinguishes between connected parallel Unity projects
**Bug fixes**
* Fixed a bug where, after tool approvals, the thread occasionally becomes unusable
* Fixed a bug so that switching from a team account to a personal account would not cause an error in certain cases
* Fixed a bug so that relinking a project on a different computer would properly connect
* Fixed several bugs with upgrading and downgrading subscriptions
**Usability improvements**
* Added profiler tools to inspect selected ranges
* Removes missing scripts before saving prefabs to not block saving
**Bug fixes**
* Fixed a bug that caused subagents silently to silently timeout and fail the workflow
* Fixed a bug where compaction of threads produced an error
* Fixed a bug where read console tool could be erroneously called on Folders and would timeout
* Fixed a bug that blocked re-adding removed connections
* Fixed a bug where relinking non-selected projects would fail
**Usability improvements**
* Launched an Ultimate plan for individuals that need more credits or workspaces, but don't need a Team w/ multiple seats
* Bezi can now move and delete files with permission from the user
* Bezi can create directories with permission from the user
* Improved how search tools use relative paths to reduce usage finding results
**Bug fixes**
* Fixed a bug where file diffs would show full file rather than specific changes
## Now introducing: Workspaces
*multi-source, team hubs with shared artifacts, parallel working threads, subagents and more!*
[**Workspaces**](https://docs.bezi.com/fundamentals/workspaces):
* One hub to contain all relevant Unity projects, local folders, pages, threads, and rules for the work
[**Connections**](https://docs.bezi.com/context/connections): *Unity projects & local folders*
* **Unity projects:** Bezi retains knowledge of all conventions, systems, and architecture across connected projects. Streamline porting, referencing examples, and working across a multi-project studio pipeline
* **Local folders**: Add local folders (server-side code, other games, build tooling, asset pipelines) for Bezi to reference and update during work
* **Manage Connections**: Toggle them on/off to keep Bezi focused and prevent context overload
[**Team Workspaces**](https://docs.bezi.com/fundamentals/team-workspaces)
* Members of a Team Workspace can create and access a single source of truth for vision, standards, rules, documented decisions in a project
* Admins can view, add, manage and monitor all Member licenses and usage from a single Team settings panel
* Workspace membership is managed per Team Workspace
* You can convert a personal Workspace into a Team Workspace to preserve all its data (Connections, Pages, Plans, and threads)
[**Shared Pages**](https://docs.bezi.com/context/pages):
* Shared Pages are how your whole team gets consistent, grounded outputs - the same coding standards, the same architecture decisions, the same documented schemas - without repeating work
* Every member's Bezi agent automatically references Shared Pages to keeps teams aligned and work consistent
* In Team Workspaces, Pages can be Shared (visible to everyone) or Private (visible only to you)
* Shared Pages are visible and editable by all members
**Run multiple threads in parallel**
* You can run multiple threads in parallel for separate projects - great for parallelizing work on different parts of a game
* If a thread has pending Agent Mode changes for a project, you can't run Agent Mode in a second thread for the same project until the changes are decided
***
**Subagents**: *Save your time and money by reducing work on the main model*
* Subagents are deployed automatically by Bezi to break up larger tasks and manage the less complex work, reducing the work the main agent does
* You can see what tasks Subagents are assigned to and what they are currently working on
[**Workspace Threads**](https://docs.bezi.com/fundamentals/threads):
* You set one target project per thread to tell Bezi which project to actively work on
* All Threads for a Workspace live in the dedicated Threads panel on the right
[**How to prompt**](https://docs.bezi.com/fundamentals/prompting):
* Use # to mention Projects/Local Folders in prompts
[**Workspace Rules**](https://docs.bezi.com/context/rules):
* Rules now function at the Workspace level (apply to all work and Connections in a Workspace)
* Rules are private to each person in a Team Workspace, so each dev can tailor Bezi to your workflow without affecting your teammates
* Still persistent instructions for how Bezi behaves - preferred code style, naming conventions, architectural constraints
**Efficiency improvements**
* Asset Sync has been replaced by subagents to power our Project Search tool
* Searching files by name or contents is more token efficient and faster
* Executing actions is now more token efficient
* Substantially decreased Bezi’s chance to spiral when it works on long, complex tasks
## Now introducing: Vision Tool
**Vision Tool**: *Auto-capture images to enable more accurate implementations*
* Bezi now automatically takes images of a project's Game View, Scene View, UI, and assets to analyze changes visually
* Game View and Scene View images work in edit mode and play mode
* asset images only work in edit mode
* Supported asset types: *Scenes, GameObjects, Prefabs (including uGUI), Materials, Textures, Sprites, UI Toolkit, Particles, and Animators*
* Bezi decides when to activate the Vision Tool, which camera angles to use, and which objects to focus on
\--------------
**Usability improvements**
* Huge improvements to how Bezi loads and handles large code files, improving output and minimizing credit usage
* Team seat add-ons now add 2000 credits/seat
* Transform Page text into a Plan: select the text > open the selection menu
* Pages can now render tables
**Bug fixes**
* Resolved a bug that blocked the Play Mode pop-up from showing when Unity was in Play Mode
**Usability improvements**
* Added optimizations to the read console tool to use fewer tokens
* Removed retry functionality from errors to prevent unintended loss of data
* Added performance improvements to view hierarchy and view GameObject tools for larger scenes
**Bug fixes**
* Fixed a bug where occasionally duplicate subscriptions would be created for the same user resulting in account information discrepancy
* Fixed a bug where creating a new message would sometimes result in an unrecoverable error
## Now introducing: Model Selection, Auto-Continue, New Credit System
**Model Selections:** *Choose the right AI for a task. Available on all plans.*
* **Frontier** (Claude Opus 4.6) for complex multi-step challenges, UI and debugging
* **Core** (Claude Sonnet 4.6) for everyday development work - the default
* **Basic** (Gemini Flash) for fast, lightweight tasks
**Auto-Continue**
* Bezi will execute multi-step tasks completely, without interruption
* No more prompt to "continue" when Bezi hits the 20 tool-call limit
**New Credit System**
* No changes to the subscription price
* Credit consumption per prompt is determined by the model it uses
* Increased the credit limit per plan (see pricing page)
**On-Demand Credits & Spend Limits:** *Use Bezi past the monthly credit limit*
* On-demand credits are cheaper: \$0.05/credit (reduced from \$0.20/credit)
* Enable on-demand usage in your account dashboard
**Usage Dashboard**
* The Usage tab in your account dashboard shows full credit history: consumption per prompt, breakdowns by model, mode, and date
**Usability improvements**
* Bezi now proactively summarizes, caches, and clears expired tools mid-workflow to keep the context window clearer for long tasks
* Enabled Bezi actions for Animation controllers
* Improved Bezi's speed and ability to retrieve subscription information in the account dashboard and app
* Enabled yearly subscriptions to add on-demand credits
**Bug fixes**
* Fixed multiple bugs related to Bezi's file reading and list directory tools failing on invalid paths
* Fixed bug that was blocking Bezi from reading packages linked from outside of the Unity folder
**Usability improvements:**
* Plans include more implementation specifics so you can tweak and get more predictable results when executed
* Enable submission of custom, free-form responses in Plan Mode
* Plans can be moved to pages folders
* Main reasoning model updated to Sonnet 4.6
* Bezi's reasoning (what it's doing when it says "thinking...") now shown in the thread so you can see what it's doing
* Made Bezi compatible with certain JSONConverter packages, like `Newtonsoft.Json-for-Unity.Converters`
**Bug fixes**:
* Networking updates to limit timeout errors (usually related to to slow network, slow LLM reasoning, or long domain reloads)
* Copy/paste formatting between pages, threads, and prompts preserves rich text
* Bezi will not focus Unity (bring it into the foreground) to avoid interrupting other work
## Now introducing: Plan Mode
Plan Mode is a new space for structuring prompts to execute complex tasks more accurately in Agent Mode
* Get more done by enabling Bezi to execute tasks independently (min intervention needed once a plan's set)
* Define what to build and how to approach it before execution
* Best for medium-to-complex tasks with multiple steps or evolving requirements
**How to use it**
* **Plans define execution. Pages store context. Agent Mode builds.**
* Break work into clear, implementation-ready steps
* Click Build to start a new Agent Mode thread from your plan
**When to use it**
* Medium-to-complex tasks with multiple steps or evolving requirements
* Work that needs repeatable, accurate results
**When NOT to use it**
* Small or exploratory tasks where in-time iteration is better
* To document background information, multiple separate deliverables, etc. (use a Page instead)
* Planning entire games and press build
**Other improvements**
* Faster initial response times
* Better error recovery when Bezi needs to use tool calls (so it can more reliably correct itself)
**Usability improvements:**
* Improved Bezi's ability to accomplish longer or more complex tasks while keeping responses fast, specifically for users that sent/received a message in the last 5 min
* Reduced the context usage needed to review Unity packages, enabling you to use threads for a bit longer before filling the context window
**Bug fixes:**
* Fixed a bug where users would sometimes be unable to delete pages
* Fixed a bug where serializing certain recursive Unity types would cause stack overflow errors
* Fixed a bug with resizing the sidebar
* Small UI tweaks to color
**Hotfixes from yesterday's release:**
The updater isn't auto-surfacing so, to get the latest release, fresh install the app from [www.bezi.com](https://www.bezi.com/).
**Bug fixes**:
* Fixed a bug where auto-updates were not delivered starting from version 1.19.0
* Fixes a bug where sidebar threads and pages would jump
* Fixed a bug where older messages would not render @ mentions correctly
* Fixed a bug where some requests would fail when selection in Unity changes
* Fixed a bug where some messages with large images would fail to process
* Fixed a bug in Unity plugin where certain objects would be undefined
* Fixed several visual bugs with prompt container and asset drawer
**Usability improvements:**
* Bezi desktop icon shows visual alert when a response is done generating
* Prompts are colored to indicate which mode (Agent or Ask) was used
* Prompt character limit (2000 characters) and a count for prompt length
* Multiple consecutive code edits are now grouped in an Agent response
**Bug fixes:**
* Fixed serialization for popular plugins (Odin, etc.) so they can be used with Actions
* Added support for SerializeReference fields for Actions
* Redesigned of the prompt container UI for clarity
* Updated console errors tool to prevent overflow errors
* Other small fixes and improvements
**Usability improvements:**
* If you prompt to execute Actions when Unity's in Play Mode, you'll see the option to exit Play Mode or continue in Ask Mode to prevent unexpected behavior
* Updated output formatting when Bezi searches a project so it's easier to read and understand what Bezi's looking at
**Bug fixes:**
* \[Actions] fixed bug related to creating materials without shader names
* \[Actions] fixed bug that blocked Bezi from creating standard material sometimes
* \[Actions] fixed bug that blocked Actions if Hot Reload plugin is present
* \[Actions] fixed bug that blocked Actions if Amplify shaders are present
* \[Actions] fixed bug that blocked Actions if a specific Terrain shader is present
* \[Actions] fixed bug that blocked Actions from inspecting Enums for ECS-related assets
* NRE when deleting a selected object in Unity
* Fixed bug re: not inspecting GameObject marked as DontDestroyOnLoad
* Fixes for obsolete warnings in custom script
* Fixed a bug in Windows where Bezi would not properly be closed before updating
* Several other minor bug fixes related to generating and executing Actions
**Usability improvements:**
* Bezi Actions can create prefab variants from existing prefabs and assets
* Bezi Actions can use null values when modifying reference properties
* Increased the range of user-defined types and properties that Bezi can understand and modify
**Bug fixes:**
* Fixed some extraneous errors printed to Unity console
* Improved recovery when Bezi encounters certain errors
**Now introducing**: Actions is in GA!!
* Big launch to kick off 2026: Actions is now available and activated by default for everyone
* Bezi can perform the following in-engine actions:
* Create, modify, and delete GameObjects
* Add, modify, and delete components on GameObjects
* Create and modify ScriptableObjects
* Create and modify materials and shaders
* Create and modify prefabs, both loaded and available in the Assets
* Create and modify scenes, both loaded and available in the Assets
* Learn more: [https://docs.bezi.com/fundamentals/agent-mode-actions](https://docs.bezi.com/fundamentals/agent-mode-actions)
**Usability improvements:**
* New UI to show how much context's used per thread and when thread compacting will happen. This will indicate when a thread's size is impacting response quality and you need to start a new thread!
**Bug fixes:**
* Several bug fixes for Actions and serialization in Unity
**Actions - NEW:**
* Bezi can auto-create prefabs and scenes
* Bezi can auto-remove components and delete GameObjects
* Actions work on all scenes and prefabs, closed and opened
* Fixed bugs that prevented actions from working with specific scenes
* Fixed bugs for more reliable actions undo
**Bug fixes and improvements:**
* App updates should now have administrator permissions to install into protected folders
* Fixed several bugs related to "Something went wrong" errors and improve reliability
* UI polish for app scrollbars
* Prompt boxes are auto-focused when switching between threads
**Actions - NEW:**
* Bezi can auto-create scriptable objects in Unity
* Bezi can auto-create materials in Unity
**Pages - NEW:**
* Pages can now mention other pages for better GDD design
* @ mention a page while typing to reference
* Click a page mention to navigate to it
* Bezi can create page links via prompt responses
**Usability improvements:**
* Improved communication of "something went wrong" error
* Improved response auto-scrolling:
* New messages now scroll to the top on submit
* Responses now auto-scroll through tool results and code snippets
* Scrolling back to the bottom auto-enables auto-scroll
* Page character limit increased to 50,000
* Page can render checkboxes for better planning
**General health:**
* Bezi will create less documentation and be more conservative about documentation details
* Fixed several serialization bugs to enable more types of actions
* Fixed Restore bug where non-consecutive edits could be skipped
* Improved inline diff editor UX by properly focusing first diff
* Updated Canvas to support diff navigation across file tabs
* Fixed the UI bug that allowed Team members to delete the team
* Improved email invite process for unassigned seats
**Usability improvements:**
* Actions improvements for paid users who opted into the pre-release testing
* Selecting the actions feature flag would not deselect it between sessions.
* Fixed several errors when performing actions:
* Actions can now reparent game objects
* Actions can now create new tags
* Actions don't error out when dealing with null components
**General health:**
* Fixed a bug where selecting the current version of the page from a thread would override its version.
* Fixed a bug where selecting a page version from a thread would load it twice
* Minor cleanup of the page history UI
* Fixed a bug where teams could not be deleted
* Fixed a bug where users could not leave a team
**Usability improvements:**
* You can now prompt Bezi in Agent Mode to create and edit Pages
* Introduced version history for Pages to navigate and revert changes
* Bezi Agent Mode can also create folders when necessary
**General health:**
* Fixed a search tool bug causing increased `Errors` errors in large projects
* Fixed a Team plan bug that limited the Page count
**Now introducing:**
* Added a Team Plan for studios using Bezi! Includes 3 seats, 5k credits in a shared pool, and team management capabilities. Learn more: [https://www.bezi.com/pricing](https://www.bezi.com/pricing)
* Bezi can now view and edit local Unity packages installed in a project
**Usability improvements:**
* Bezi can more effectively find assets via GUID for faster and more complete project searching
* Pages version history to allow you to restore a Page's content back to a previous point
* Enable Bezi to work when Unity's in Play Mode or paused and to properly handle recompilation and minimization during responses
**General health:**
* Improved contrast in the thread and prompt input with new background colors
* Resolved bugs with file system access when Bezi looks at Unity package contents
* Improved Bezi's likelihood to refactor and enhance existing code (vs create new code)
* Reduced Bezi's likelihood to generate extensive documentation unless prompted to do so
* More agent improvements for speed and accuracy
**Usability improvements:**
* New: View threads and pages side by side
* A substantial UI update paving the way for future features
* Threads and pages can be switched independently
* New: Sidebar drag and drop for pages
* Update: Tag selection and pinning!!
* If you have something selected in Unity, it will now show as **a suggested pill** that you can click on to include it as prompt context (before it was auto-included)
* If a Page and floating thread are open simultaneously, the Page will show as **a suggested pill** that you can click on to include it as prompt context
* Update: Bezi asks clarifying questions more frequently
**General health:**
* Improved agent mode's viewing of large files
* Account Settings UI now opens in a popup to not disrupt the pages and threads workflows
* Optimized context for @ mentioned assets and pages
* Optimized context for viewing and searching GameObjects
* Bezi logs file size is now limited in MB size
* Improvements to object serialization and pagination in Unity scenes
* Search results should not overflow context
**Usability improvements:**
* Improved Bezi's project handling
* All new projects must be added via "Add Project"
* No more reliance on Unity Hub for managing projects!
* If location of a project on your computer changes - path, name, or a different computer altogether - you can relink and continue using it
* Pages automatically searched as context!
* Bezi can now find relevant information in Pages via semantic search from prompts. No longer dependent on a Page being tagged in-prompt to search it
* Images can be dragged / dropped into prompts
**General health:**
* Formally added Claude 4.5 Sonnet. Thorough testing confirmed it's a reliable foundation and will improve the end experience.
* From our tests, Claude 4.5 is a lot more aware of Unity 6 APIs and should drive improvements in those responses
* This can also address some of the GCP challenges, which prioritizes resources for Claude 4.5
* Unity plugin bug fixes
* Fix: Parsing selected prefabs and prefabs added to the scenes correctly.
* Fix: Reduce the Bezi app's conflict with other installed plugins. This may require a Unity restart after plugin install if there's an existing one.
***When you use Bezi to help with game development, memory is crucial. You want it to remember the core premise of your game, a great implementation plan from another thread, or a mechanic’s original state to track changes.***
*There is so much crucial information that, unless stated, is totally unknown to Bezi and Unity, or easily gets lost in the context an AI system works through.*
[***We built Pages so you have the power to inject and reinforce these key details without repeating yourself or copy/pasting. Save longer-form project information in Pages and tag them in threads/prompts when a given task builds on them.***](https://docs.bezi.com/bezi/product/pages-folders)
**Now introducing...**
* **Pages (in beta)**: Store important, larger-format game information that can be tagged in threads/prompts to get more consistent and precise output
* Save implementation plans and for Bezi to execute on in Agent Mode
* Store your GDD to reference when work needs to be tailored to your game’s concept, roadmap, etc.
* Pages must be referenced in prompts with @ mention
* Pages is in beta - please share all your feedback and requests!
* Read the docs: [https://docs.bezi.com/bezi/product/pages-folders](https://docs.bezi.com/bezi/product/pages-folders)
* Page examples: Yahor to post / Sarah to add
* **BEZI WORKS IN PLAY MODE NOW**! You can submit prompts in Play Mode & get answers to your runtime questions
* No docs, just start prompting!
**Usability improvements:**
* Fixed a challenging bug that users have surfaced multiple times, causing not all rejected changes would be practically rejected in the files
* Improved Bezi's ability to correctly identify and inspect active scenes, when unloaded scenes are present
* Improved Bezi's ability to inspect components and gather more precise details
**General health:**
* Fixed the issue that blocked Enhanced Code Intelligence (ECI) from initializing on Mac
* Fixed the conflict Bezi was having with some other apps (e.g. Intel GPU monitor, etc.)
**Usability improvements:**
* Bezi can now correctly display hierarchies of additively loaded scenes
* Bezi can now find objects in much larger hierarchies
**General health:**
* Fixed a bug that was contributing to Bezi losing it's connection with Unity after an update
* **PLEASE NOTE**: this fix will help in future updates - meaning this still may happen in today's update. If it does, you can resolve it by restarting your machine to clean up all Bezi processes and ports
* Minor visual updates to templates UI
**Usability improvements:**
* Messages are no longer cancelled by a domain reload or Play Mode. Bezi will continue the response after the domain reload is complete
* Improved Bezi's ability to auto-detect when images are attached to a prompt
* Made significant improvements to ECIs startup time on Windows
* Added Bezi application suggestions (based on where people see most value) in Home
**General health:**
* Fixed a bug where monthly credits weren't auto-resetting in select yearly Pro subscriptions
**Now introducing...**
* **ATTACH IMAGES TO PROMPTS**! You can now add images/screenshots to a prompt to supplement the information Bezi factors into its response.
* Read the docs: [https://docs.bezi.com/bezi/product/attach-images](https://docs.bezi.com/bezi/product/attach-images)
**Usability improvements:**
* Improved performance of the GameObject inspecting tools to address feedback about Bezi freezing when looking for components in the scene/on GameObjects
* Added best practices for writing Project Rules to the rules page
**General health:**
* Fixed the bug where Bezi would throw errors when reading console logs
* Added more enforcement to prevent the looping behavior when Bezi is trying to correct console errors
* Bug fix for Restore Checkpoint not showing up for new prompts
* Bug fix for occasionally not showing an updated plans new prompt limit in the UI if it's changed mid-cycle
> We want your feedback! We're committed to making Bezi as lightweight as possible and to not impact game developer's workflows or testing performance.
After this update, do you notice any performance difference in your project's compile times, time to enter play mode, or general performance inside of Unity? If you do, can you share the before + after?
**Usability improvements:**
* Bezi \<> Unity connection: improve reliability of the connection and shows clearer warning if a response cant be submitted / continue because Unity has become disconnected (usually due to a domain reload or being in Play Mode)
* Agent Mode - Restore Checkpoint: now easier to restore checkpoints to any point in a thread, changes made in Agent Mode will be correctly restored, UI will accurately reflect which messages have been reverted, files created during the time can be removed, and more
* Enhanced Code Intelligence (ECI): reducing the "Inactive" status many of you have reported by improving ECI's project auto-connect (Bezi now generates a .NET solution file for your Unity project using robust, built-in Unity methods)
* Long threads performance: faster rendering for threads with lots of code edits
**General health:**
* Project sync performance: increased Bezi's servers abilities to adapt to traffic changes and efficiently index project assets
* More bug fixes and polish!
**Bug fix:**
* A bug in one of the libraries we use caused a "grey screen crash" situation. This hotfix resolves it.
**Usability improvements:**
* Improved the load and response time for longer threads!
**General health:**
* Improved our server's ability to handle for asset indexing traffic to proactively prevent slowdowns. More identifiable speed improvements will come in the next few weeks!
**Other fun:**
* We've updated Bezi's branding! Keep an eye out for the new Bezi bud showing up in the app, docs, discord, and more :)
**Usability improvements:**
* Added [credit overages options ](https://docs.bezi.com/bezi/account-settings/plans-usage#usage-based-overages)for paid plans: if you’re on a paid plan (pro, advanced, or business) and have reached your credit limit, you can buy extra credits to continue working in bezi for the rest of the current subscription period
* Added a Continue button and information when responses reach their tool call limits
* Updated Agent/Ask Mode toggle to improve visibility
**General health:**
* Fixed several bugs that made Bezi return errors or stop streaming responses/show retry buttons that wouldn’t successfully retry
* Fixed a bug where Project Rules list items aren’t clickable on Windows
* Added ability to deactivate Enhanced Code Intelligence for when it uses too much memory w/ larger projects
**Now introducing...**
* Project Rules! Define project-wide rules for Bezi to follow. Set the code syntax, how to navigate your project's files, game design patterns, and other project-specific context, instructions, etc. you want Bezi to follow
* Read the docs: [https://docs.bezi.com/bezi/product/project-rules](https://docs.bezi.com/bezi/product/project-rules)
* Enhanced Code Intelligence: Turn this on to enable Bezi to find errors and warnings in your codebase on its own! Bezi hooks into the OmniSharp language server to catch errors in the code it writes or help you fix existing errors in your own code
* Read the docs: [https://docs.bezi.com/bezi/product/enhanced-code-intelligence](https://docs.bezi.com/bezi/product/enhanced-code-intelligence)
**Usability improvements:**
* *Restructured our database to enable a lot of long-term improvements.*
* One in this release is better in-thread memory! Bezi has better ability to recall past messages and context gathering steps, resulting in better accuracy in short and medium length threads
* Long threads are still not the recommended way to use Bezi. We suggest starting new threads as you change tasks
* Bezi can search your project with multiple methods simultaneously, to gather the context needed to generate a response faster
**General health:**
* New sidebar design: Where you access past threads and the Project Rules page
* More informative messages re: which files, classes, or GameObjects Bezi's searching for
* Tons more bug fixes and polish!
**Between release bug fix**:
Addressed an issue where, upon opening Bezi, select users would only see a grey screen and couldnt use the app.
**Usability improvements**:
* 5x performance increase for the tool used to search keywords in files
* Improvements to file search to minimize hallucinations
**General health**:
*Agent Mode updates and bug fixes:*
* Keeping / Undoing changes won't override previous decisions
* Keeping / Undoing changes only shows updates to pending changes
* Restoring Checkpoints will correctly restore all relevant file changes, not just the latest ones
* Bezi can read any asset file's contents (still not allowed to modify any asset files in case of hallucination)
* Improved speed of Keeping / Undoing changes
* Diffs in the Asset Drawer now show only pending and kept changes, omitting any undone changes
*UI updates to Canvas and Agent Mode:*
* Sliders now stay within bounds
* Canvas search with cmd/ctrl+F scrolls to the search results items
**New tool**:
* Added the Grep Tool, which can find specific keywords within files (i.e. function names and lines / files where the functions are used)
**Time-sensitive bug fix:** *If you select the* `Restore Checkpoint`*button in Bezi now, it will revert all changes made by Bezi after that point*
* Addressed an issue where multiple edits made to the same file by Agent Mode wouldn't fully restore with a checkpoint
**Subscription tiers and management:**
* New tiers for higher credit limits: [bezi.com/pricing](https://www.bezi.com/pricing) New subscription setting hub to easily manage subscription and billing: [https://app.bezi.com/account](https://app.bezi.com/account)
* See updated product docs on managing subscriptions and billing here: [https://docs.bezi.com/bezi/account-settings/subscription-billing](https://docs.bezi.com/bezi/account-settings/subscription-billing)
**Usability improvements:**
* Added the ability to pause the Bezi plugin in Unity!
*Today's release includes fixes for some critical issues that severely degraded user experience. If you noticed inconsistencies in Bezi's referencing existing files or recreating things that were already in the project, please update your app/plugin and give it another go!*
**New functionality:**
* Added a new search tool to improve Bezi's ability to find specific scripts by path
* Added fuzzy search for @ mentions
* Allows searching with misspellings
* Improved lookup speed
**Usability improvements:**
* Fixed inconsistencies with Bezi's locating relevant files (based on description, etc)
* Fixed prompts disappearing when entering play mode
* Fixed prompts editing in the middle of the sentence in the Edit view
* Fixed very long files failing to fully generate
* Fixed partial responses completely failing when an internal error occurs
**General health:**
* Updated restore logic for Agent Mode to allow restoring to the top of the thread
* Increased the number of tools AI can use to 20 per prompt
[**Introducing, Agent Mode in beta!**](https://docs.bezi.com/bezi/modes/agent-mode)
* Bezi can now create and modify code, directly in your Unity project
* View code diffs in the response or in the full context of the script with Canvas
* All proposed code changes are viewable / testable in Unity before deciding to Keep or Undo them, but must be Kept by you to save
* Rejecting proposed code changes removes only Bezi-generated code from it's memory
* New asset drawer to track all files that Agent Mode has edited and Keep / Undo all changes at once
**Usability improvements:**
* App UI updates
* changed the padding and spacing of the input container
* updated color of the ‘send’ button
* updated colors for the file reference tags to have better hierarchy
**General health:**
* Huge performance improvements to eliminate Bezi freezing when syncing very large projects
This release is a little light because the team is working on Agent Mode, the ability for Bezi to implement approved changes on your behalf. Agent Mode will only apply to code - i.e. Bezi will be able edit and apply code changes, which you can decide to Keep or Undo - to start. It will be released in beta shortly, as we'd like everyone's feedback but it should be treated with caution to start (as with all new functionality).
**Usability improvements:**
* Updated Unity 6 docs in Bezi context, to help Bezi deliver quality responses for all supported versions
* Method to increase credit limits if you run out of Pro credits before the month is up (Bezi team does this)
* New method to "Reload" system if you see a "failed to iterate over archive" error when installing Unity Plugin on a Mac
**General health:**
* Switched core model to Claude 4
* Improvements to system prompt language
**Introducing, Canvas!**
Canvas allows you to view a Bezi response and the code file side-by-side in the Bezi app. It also provides a bigger window for reviewing a code file (opposed to having to scroll through a small window)
**Usability improvements:**
* Fixes to some very long responses abruptly ending
* Bezi preserves unsubmitted prompts if Unity disconnects
* Asset sync panel shows more real-time updates on asset's sync status
* Increased search speed for assets and game objects in @ mention
**General health:**
* Fixes to Unity package recognition issues
* Unity Plugin is available for download from [docs.bezi.com](http://docs.bezi.com) if you're unable to install via the Bezi app
**Usability improvements:**
* Updated Bezi's memory and output to prevent longer scripts getting cutoff
* Faster search for assets and gameobjects within Bezi
* Bezi can respond in the language it's prompted in
* Long text wrapping (console errors, exception messages, etc.) improvements
* Spaces in a search query work as expected now!
* Added progress bar in the Asset Sync panel so it's easy to see what % of your project has been indexed
**General health:**
* Bezi can work with Photon networking library now!
* WebSocket connection error fixes that occasionally impacted Unity performance when Bezi was not running
* New flow to help install Bezi's Unity plugin with protected directories (*prev. users saw a "Failed to install plugin" popup with no way to fix*)
**Bezi access and usage-based trial/subscriptions:**
* Ability to sign-up directly from our website! No more waitlist!
* Credits system for trial (100) and subscription (500 /mo)
* Updated Account Settings to track credit usage
**Usability improvements:**
* Asset sync performance improvements
* Ability to log out from the Bezi app
**General health:**
* A lot of quality-of-life improvements and polish in the Bezi app
* Header spacing for long thread titles
* Fitting and scrollable mention containers
* Major updates to our product documentation
**Usability improvements:**
* Update Bezi's Unity plugin to resolve time-out issues that were externally showing as websocket errors
**General health:**
* Quality of life improvements to asset search in the Bezi app
**Usability improvements:**
* Fixed several issues with Bezi plugin in Unity impacting performance when the Bezi app isn't running
* Fixed material serialization issues impacting Unity performance when Bezi app is running
* UI updates to search results in prompts and mentions with @ tagging
* Collapsed option for large code blocks
* Asset search results in gathered context will select assets and gameobjects in Unity on click
**Usability improvements:**
* Prompt suggestions for best uses of bezi
* Ability to pin assets in your Unity project in prompts
* Updated the "new thread" page with clearer setup instructions
**General health:**
* Several bug fixes for context gathering and response errors
**Usability improvements:**
* New Thread prompt suggestion improvements
* Fixed assets sync issues on Windows machines
* Improved assets sync speed for all machines
**Usability improvements:**
* Help button in the bottom bar that links to product documentation
* Context-drive prompt suggestion improvements
* Smoother rendering of responses
* UI polish for prompt mentions
**General health:**
* Addressed issues around some responses not fully saving
* Addressed search result link issues
* More fast-follow polish and bug fixes from last week's release!
**Core capabilities:**
* Major improvements to Bezi's ability to understand your Unity project and use that context in responses
* We've disabled Bezi's ability to attach scripts and generate Unity actions on your behalf. These capabilities will come back once they meet our accuracy and reliability standards!
**Usability improvements:**
* Asset sync UI has been refreshed to better display progress and any errors it encounters
* Better warnings when you are prompting during play mode or if the Bezi Unity package is out of date
* New experience for creating new threads, complete with starter prompts to help you start seeing value from Bezi
* Smoother text streaming
* Context on what information Bezi is gathering to generate a response
**General health:**
* Many more bug fixes and improvements!
**Bezi product update - moving into beta!**
Excited to share that Bezi is moving into beta! The beta phase is focused on deep context of your Unity project. Using this context, Bezi can be queried to identify and propose fixes for console errors, answer questions about project contents and packages, and even teach you how to implement unfamiliar mechanics.
During our alpha, we learned a lot from testers (you!) about what’s needed in order to reduce the noise and repeatable work in game development. This helped us prioritize the right things to build in our beta - and it all starts with strong context of your project.
Heading into our beta (which starts today!) we invested a lot of effort into making sure Bezi has this complete context of your project. This context is the first step and we will add more capabilities powered by the context.
We’ve learned that, above all, game dev tools need to be accurate and reliable in order to make the workflow more efficient. We hold Bezi to a high standard for both and will only ship new capabilities that meet this bar. During alpha it was clear there were issues with the script attaching and action creation capabilities. As a result, **script attaching and action creation will be temporarily disabled in Bezi**. They'll be re-implemented as soon as they are reliable and accurate enough to support game development!
No release this week! The team is heads-down on stability and bug fixes for the new agentic workflow - release will resume next Thursday.
**Asset Sync package support:**
* Bezi's now able to sync and reference Unity project packages and use them to inform responses! *For example, if you have a TextMeshPro package installed in your Unity project, Bezi can write scripts that reference it*
**Usability improvements:**
* You can manually add a Unity project you want to connect in Bezi! Select the "Add project" button at the bottom of the Project Picker dropdown
* Code rendering is faster
* Improved speed of AI responses
**General health:**
* Various bug fixes
No release this week, the team is heads-down on a big stability push. Weekly releases will resume next Thursday
**Asset sync speed:**
* projects up to 20GB sync 4x faster
**New features:**
* You can use Bezi to create and assign tags in Unity's tag system
* You can create 2D and 3D physical materials
* You can search/add a Unity project you want to connect with via Bezi's Unity Project Selector (see "Add project" in dropdown), no need to rely on Unity Hub!
**General health:**
* Various bug fixes and improvements to response accuracy
*Bezi's Unity plugin is now installed locally per Unity project. Please uninstall the existing Unity plugin, then follow app instructions to install the new plugin*
**Improvements to Unity asset sync flow in Bezi:**
* Improved stability - bug fixes to address accidental errors, more file types are able to sync
* Faster synching
* Improved error reporting - Bezi will give you more specifics about what isn't syncing
**UI updates:**
* Improved look and feel of Bezi's interface
* Typography updates for better readability
**New features:**
* Pinning selections from Unity for better prompt context setting
* Prompt response feedback buttons (thumbs up/down to improve prompt response)
**General health:**
* Unity plugin is now installed locally per Unity project
* Mac app installation improvements
* Various bug fixes
* Improvements to asset sync and error reporting
* Bezi can generate and apply materials
* Bezi can update a variety of Unity built in components
* Stability improvements to the mac app
* UI updates: actions accept states are now ordered, but non-blocking
# Quickstart
Source: https://docs.bezi.com/get-started/quickstart
A brief guide to get you set-up and building with Bezi in under an hour. If you have questions or run into anything unusual, check the [Troubleshooting FAQ](https://docs.bezi.com/get-started/troubleshooting) - or get some good ol' fashioned human support on our [**Discord**](https://discord.com/invite/UKWB46HTT9).
## Install and set-up Bezi
1. Visit [bezi.com](http://bezi.com) > select `Download` > choose your operating system
2. Run the installer
3. Launch the Bezi app
Add the app to your dock for ease of access.
1. Open Bezi > select `Log In / Sign Up` > sign-in with email or Google
2. When set-up is complete, you'll see a webpage that says "Launch Bezi App"
3. Click `Launch app` to return to Bezi
4. Start your free trial (100 credits, no expiration)
## Connect Bezi with Unity
You'll start in an empty [Workspace](/fundamentals/workspaces)
1. Click `Connect Unity project`
2. Select the Unity Project from your file system and click `Open`
1. Open the project
2. Confirm the project's in a folder with write permissions
3. Return to Bezi
Click the`Install plugin` button, located in the **Your Connections** dialog
If you can't install the plugin from Bezi, download it directly from our [Changelog](https://docs.bezi.com/bezi/product/changelog).
After you click `Install` in Bezi, return to the Unity project. Unity will ask for consent to install the plugin. Once granted, the Unity Package Manager popup will appear.
Check Unity's menu for a green dot next to the **Bezi icon** and Bezi's menu for green dot next to the **Unity icon**. Both must be green for Bezi to work.
If either is red, follow [these steps to fix a broken connection](https://docs.bezi.com/bezi/troubleshooting#how-do-i-reinstate-a-lost-connection-between-unity-and-bezi%3F).
Both the target Unity project and Bezi must be open to use them together. We recommend a split screen to see both simultaneously.
* [Add relevant data sources](https://docs.bezi.com/context/connections): connect Bezi to other Unity projects and external files
* [Create your documentation and instructions](https://docs.bezi.com/context/pages): give Bezi evergreen context with Pages
* [Set mandatory Rules](https://docs.bezi.com/context/rules) for Bezi to follow
1. [How to prompt](https://docs.bezi.com/fundamentals/prompting)
2. [How to use threads](https://docs.bezi.com/fundamentals/threads)
3. [Model Selection](https://docs.bezi.com/fundamentals/model-selection)
4. [Agent Mode](https://docs.bezi.com/fundamentals/agent-mode) vs [Plan Mode](https://docs.bezi.com/fundamentals/plan-mode)
# Security
Source: https://docs.bezi.com/get-started/security
We’re proud to serve everyone - from AAA studios to indies - and maintain an exceptionally security standard for each level. Our [Security Program](https://www.bezi.com/security) reviews the measures currently in practice.
**Custom, advanced security programs are available for Enterprise customers.** For security-related questions, email [security@bezi.com](mailto:security@bezi.com).
### What project data does Bezi ingest?
Bezi indexes each Unity project Connection. Project data refers to the scripts and assets in the Unity project.
We only index the project data required to provide project-accurate responses.
### Is my project data used to train any of the LLM provider’s models?
Never. When an AI request is made, LLM providers will see project data needed to help generate a response or output to your prompt, but our licenses with these providers ensure that your data will not be used to train their models.
### How is project data stored by Bezi, for how long?
For optimal application performance, scripts and select assets are cached securely on our AWS infrastructure, which is covered by our SOC 2 Type 2 certification, for up to 7 days.
### How is my project data handled and secured during transit and in cache?
We use secure protocols for project data transfer. All project data is encrypted in flight and at rest on our AWS storage infrastructure.
### What personal data does Bezi collect and how is it stored?
See our [Privacy Policy](https://www.bezi.com/privacy-policy) for complete information on what personal data is collected and how it is protected by Bezi.
### Who owns the project data created by Bezi?
You own all scripts and actions generated by Bezi.
# Troubleshooting
Source: https://docs.bezi.com/get-started/troubleshooting
Below are frequent asked questions. If you have an issue that isn't answered, or feels like a bug, please report it so we can make it better.
### Where to ask questions and report bugs
1. Post in our [Discord server](https://discord.com/invite/UKWB46HTT9)
2. Email [support@bezi.com](mailto:support@bezi.com)
## App Setup and Bezi \<> Unity Connection
### What versions of Unity does Bezi support?
* **Unity 6**
* **Unity 2023**
* **Unity 2022**
* **Unity 2021**
### I see a *“Failed to install Unity Plugin”* popup when I try connecting Bezi with my Unity project.
Occasionally this error shows if a Unity set-up isn’t conducive with the Bezi plugin. Please try these things (in order) to see if either resolve. If neither work, reach out to [support@bezi.com](mailto:support@bezi.com) for assistance.
1. Follow the Bezi flow to install the Unity plugin with administrator privileges
2. Download the Unity plugin directly from our [Changelog](https://docs.bezi.com/bezi/product/changelog)
### I can no longer find my project in Bezi after installing a package, and when I add the project manually I get a pop up that says “Error adding project”.
This error occurs when installing some template games for the Unity Asset Store. Doing so may overwrite the **productGUID** with an **invalid GUID** (00000000000000000000000000000000). Bezi requires a valid GUID to work, so this immediately breaks the connection to the project.
To fix the issue, you need to fix the project. We recommend trying these solutions, in order:
1. (If you have version control) Revert changes to ProjectSettings.asset and its .meta file
2. Close and reopen the Unity Project to regenerate the GUID
3. Delete the Library Folder to force-regenerate the GUID
Bezi tracks history using the GUID, so changing/regenerating the productGUID may lose your previous threads. In the future, we recommend **unchecking ProjectSettings.asset** in the Import pop-up, or copying the productGUID prior to install and replacing it after.
### I see a *"Consent Request"* popup from Unity
The popup is completely safe to accept and will only modify the scripts that make Bezi; none of your personal files will be affected.
We use some APIs in Bezi that can be auto-updated by Unity, but these may change between versions. This popup just updates them to use the latest for whatever version of Unity you’re working in.
### How do I know if Bezi is connected to my Unity project?
The connection indicators in your Unity project and Bezi app will both be green if they’re connected. If either are red, the connection is broken and the apps cannot communicate.
> If you've installed the plugin but Bezi and Unity aren't successfully connecting, see the question below about troubleshooting a failed or lost connection.
![Successfulconnection]()
### How do I manually update or reinstall Bezi's plugin in Unity?
When a new version of Bezi is released, you'll receive an in-app prompt to update the app and plugin. Follow the instructions to do so before you start or resume working.
If Unity’s Package Manager doesn’t automatically update the plugin, follow these steps:
1. Close Bezi: right-click on the desktop app > `Quit`
2. Open the Unity project you’ve connected with Bezi
3. Open Unity Package Manager: Window menu > `Package Manager`
4. Delete the Bezi plugin: open “Bezi Sidekick” in the Package Manager > `Remove`
5. Reopen the Bezi app
6. Download the most recent plugin version from our [**Changelog**](https://docs.bezi.com/bezi/product/changelog)
7. Click on the Unity project > see the Package Manager popup
8. The Unity plugin should now be updated!
### How do I reinstate a lost connection between Unity and Bezi?
Try these common fixes. If none work, manually update the Unity plugin to restart the connection.
1. Check that you have reliable internet connection
2. Confirm both the Unity project and the Bezi app are open and connected
3. Confirm the **Project selector** dropdown shows the correct Unity project name
4. Confirm you're running a Unity version that Bezi supports
5. Close Bezi & Unity entirely
6. Restart your machine
## Bezi App
### How do I manually update or reinstall the Bezi app?
1. Close Bezi: right-click on the desktop app > `Quit`
2. Open the Applications folder > drag Bezi.app to Trash
3. Restart your computer
4. Download the latester version of the app from [https://www.bezi.com](https://www.bezi.com)
5. Install and launch the app
1. Close Bezi: right-click on the desktop app > `Quit`
2. Uninstall Bezi: `Settings` > `Apps` > `Installed Apps` > Remove Bezi from the list
3. Restart your computer
4. Download the latester version of the app from [https://www.bezi.com](https://www.bezi.com)
5. Right-click the installer > choose `Run as administrator`
6. Launch Bezi
### I opened Bezi and got stuck on the splash screen. How do I get past it?
This can happen if the app is out of date and auto-update wasn’t able to execute. Follow these steps to manually update the app:
1. Open [**https://bezi.com/auth-app**](https://bezi.com/auth-app)
2. Select the `Launch app` button
3. Follow the prompts to update the app to the newest version
If that doesn’t work, email [**support@bezi.com**](mailto:support@bezi.com) and we can send you the latest version of the app to manually install.
## Other Common Errors, Bugs & FAQ
### My project seems to take longer to compile code and move slower after installing Bezi.
This should never happen. If you encounter it, please email [**support@bezi.com**](mailto:support@bezi.com) with a description of the problem and any screenshots of the console, profiler logs, etc..
### Why don't I see a project in the Project selector?
The **Project selector** lists all your private [Connections](/context/connections) for that Workspace. If you want a project or data source in the selector, add it as a new Connection and refresh the app.
# Welcome
Source: https://docs.bezi.com/get-started/welcome
Bezi is a game development assistant. Its custom engine integration enables complete, real-time project context (scripts, scenes, prefabs, assets, packages and more), and is used to help plan work and then implement the work in-engine.
Bezi's hub connects to and centralizes the Unity projects, data sources, files, and other shared or individual artifacts. It provides a source of truth for teams and the individuals on them, to keep output consistent and eliminate the redundant, menial work.
Together, Bezi's assistant and platform help you get work done - build features, fix bugs, implement UI - keeping it aligned to your team's standards and compounding each person's work.
## What you can do
Bezi handles the tedious work and set-up for UI. Give it a screenshot or Figma file and assets, and it will implement and verify its visual output.
See [create UI](https://docs.bezi.com/use-cases/create-ui) for more details.
See [create UI](https://docs.bezi.com/use-cases/create-ui) for more details.
Ask Bezi to find, install, update, or remove Unity packages from the registry, Git, or local files. It can also import package samples, and move assets between connected projects with their dependencies and GUIDs intact using package exporting.
Describe the animation you want, and Bezi builds it. Create new Animator Controllers, states, parameters, layers, and wire up Mecanim BlendTrees and transition logic so characters blend smoothly between movement states.
For cinematics and scripted sequences, Bezi builds Timeline tracks and clips directly, and connects both systems into your existing gameplay scripts so the right parameter changes at the right moment.
Bezi writes EditMode and PlayMode tests for your code, runs them inside the Unity Test Runner, and reads back real pass/fail results with error messages and stack traces.
Ask it to get a suite passing and Bezi will iterate on its own: run tests, fix what's broken, rerun to confirm - continuing until everything's green, while you work on something else.
Describe the scope to Bezi; complete code refactor, asset re-organization and implementations, etc.. It will plan the approach, break it into chunks, implement it for you, and keep your architecture intact.
Ragdoll setup, batch asset changes, level layouts, and more. Bezi will build procedural workflows and tools to handle your most tedious tasks.
Share your spec or just what you want in plain language. Bezi will help you flesh out the idea, plan the implementation, and execute it directly in Unity - tailored to work with the existing architecture and best practices.
See [Rapid Prototyping](https://docs.bezi.com/use-cases/prototype-iterate) for more details.
Describe the symptom or paste an error. Bezi will parse through all your sources to diagnose issues across scenes and systems and implement a fix.
Store GDDs, feature specs, and coding standards in [Shared Pages](https://docs.bezi.com/context/pages). Every team member and every Bezi agent response draws from the same source.
Introduce new hires to a project that already knows itself and can teach them how to build in it. They learn as they work and have instant access to all important docs in the Team Workspace.
## How it works
Bezi runs as a Unity Editor plugin. Requests go through a custom TypeScript execution layer; **Bezi does not use an MCP connection to execute changes in Unity**. Changes are correctly sequenced, validated against your live project state, and applied step by step. See [Bezi Actions](https://docs.bezi.com/fundamentals/agent-mode-actions) for the full picture.
## Security
We invest heavily in IP security. **Your source code, assets, and game data are never used to train AI models**. Review our [Security](https://docs.bezi.com/get-started/security) program or email [security@bezi.com](mailto:security@bezi.com) with questions.
# Canvas
Source: https://docs.bezi.com/more/canvas
## What's Canvas?
Canvas is another way to view certain parts of a Bezi response (at present, code and text documents) alongside the chat view. This allows you to review scripts in full, side-by-side with their explanations and/or implementation instructions.
Canvas is especially powerful in Agent Mode because it allows you to see diffs and suggested changes in the context of the full script.
## How do I access Canvas?
Canvas is available in **Ask Mode** and **Agent Mode** and is accessed differently in both. To close in either situation, just select the `X` in the top bar.
**Ask Mode:** select the expand button at the top of a script
**Agent Mode**: select the script title (very short, non-agentic code snippets cannot be opened)
## Diffs
When working in Agent Mode, Canvas is great for seeing changes in the context of the entire script and keep or undo them from there.
## Tabs
**The tabs feature is still in development**, particularly for Ask Mode. For example, you may encounter tabs with “Untitled” names. Please consider the current version a work-in-progress!
Canvas uses **tabs** to navigate between scripts returned in a response. When you open a script from one response, all the tabs will update to show only the scripts returned in that response, *at the state that they were for that query*.
For example, if you’ve been iterating on Script A and you want to compare the present version to a previous iteration, you can navigate to the previous message and view the script as it was returned there. This history navigation helps you to make compare versions and, as needed, informed decisions about reversion.
# Edit Past Prompts
Source: https://docs.bezi.com/more/edit-prompts
Modify prompts after the fact to include new information or redirect Bezi's focus
Dynamic prompt editing is designed to let you alter prompts after they're made, as you observe how Bezi responds to a prompt or realize critical information was left out.
**Please note:** Editing a past prompt in a thread will regenerate the edited prompt and erase any responses under it.
To edit a past prompt, hover over the prompt and click the icon that appears in the upper right corner. This will activate edit mode for the existing prompt so you can edit, then resubmit it.
![Edit Prompt Pn]()
# Enhanced Code Intelligence
Source: https://docs.bezi.com/more/enhanced-code-intelligence
Access Bezi's enhanced code editing capabilities
## What is enhanced code intelligence?
Enhanced code intelligence provides advanced code editing capabilities for your Unity project, inside Bezi. This currently includes improved refactoring and compilation error assistance.
This guide covers the prerequisites and setup required to enable enhanced code intelligence.
## Prerequisites
To enable enhanced code intelligence, your project must meet two core requirements:
### 1) .NET SDK installation
You must have the .NET SDK installed globally on your system. This lets Bezi develop a deeper understanding of the code.
**Default installation locations:**
* macOS (Intel): `/usr/local/share/dotnet/x64/dotnet`
* macOS (Apple Silicon): `/usr/local/share/dotnet`
* Windows: `C:\Program Files\dotnet`
**Setup steps:**
1. Download and install the appropriate .NET SDK for your Unity version from [the .NET website](https://dotnet.microsoft.com/en-us/download)
* For Unity-specific .NET requirements, see [Unity's .NET Profile Support documentation](https://docs.unity3d.com/2022.3/Documentation/Manual/dotnetProfileSupport.html)
2. Close out of, then relaunch the Bezi app
3. Navigate to the bottom right. If .NET was the only issue, the enhanced code intelligence UI should be set to active.
### 2) Project naming convention
Your Unity project name must match its corresponding `.sln` file:
* The `.sln` file must be located at the project root (adjacent to the **Assets** folder)
* The filename must exactly match your project name
**Example:**
```
My-Unity-Project/
├── Assets/
├── Library/
├── ProjectSettings/
└── My-Unity-Project.sln ← Must match project name
```
### How to generate the .sln file
1. In Unity, go to `Unity` > `Preferences` > `External Tools`
2. Temporarily set the **External Script Editor** to Visual Studio Code (or any supported editor)
If you use Cursor and no other IDE, Unity will not recognize it as a supported editor and will not create the .sln file. In that case, **install a supported IDE** to create the .sln then set the **External Script Editor** back to Cursor.
3. Check all the boxes for:
* Embedded packages
* Local packages
* Registry packages
* Built-in packages
4. Select `Regenerate project files`
5. Confirm the generated `My-Unity-Project.sln` file exists
6. Restart Bezi app
## Status indicators
The enhanced code intelligence service will display different states to indicate its current status
All prerequisites are met and the service is running correctly:
* **What it means:** Enhanced features are fully operational
* **Features available:** Improved refactoring and self-healing
* **Action required:** None - you're good to go!
In the initial setup phase:
* **What it means:** The service is analyzing your project structure
* **Duration:** This may take a few minutes depending on project size
* **Note:** You can still submit prompts during initialization, though some features may be limited
Prerequisites are not met:
* **What it means:** One or more required components are missing
* **Common causes:**
* `.sln` file doesn't match project name
* .NET SDK not installed or not found in PATH
* **Action required:** Review the prerequisites above and ensure both requirements are met
An unexpected error has occured:
* **What it means:** The service encountered an error during initialization
* **Action required:** Check your project setup, then contact support via our [Discord server](https://discord.com/invite/UKWB46HTT9)
## Troubleshooting
### Solution file not found
1. Check that your `.sln` file exists at the project root
2. Verify the filename matches your project name exactly (case-sensitive)
3. If missing, open your project in Unity to regenerate the solution file
### Unsupported script editor (Cursor, etc.)
1. Install a supported script editor
2. Temporarily set that as the **External Script Editor**
3. Follow instructions (above) to regenerate the solution file
4. Set the **External Script Editor** back to Cursor
### .NET SDK issues
1. Confirm installation: `dotnet --version`
2. Ensure the SDK version is compatible with your Unity version
3. Restart Bezi after installing the SDK
4. Check that the SDK is properly added to your system PATH
### Service won't initialize
1. Verify both prerequisites are met
2. Try closing and reopening your project
3. Check for any error messages in the status indicator
4. If issues persist, reach out on [Discord](https://discord.com/invite/UKWB46HTT9) with your project details
If you have any unanswered questions or need additional support, visit our [Discord server](https://discord.com/invite/UKWB46HTT9)
# Prompt Guide
Source: https://docs.bezi.com/more/prompt-guide
How to prompt Bezi to get the best results.
These are tips and tricks for getting the best results from Bezi. Don't forget to switch between [Agent Mode](https://docs.bezi.com/bezi/modes/agent-mode) and [Ask Mode](https://docs.bezi.com/bezi/modes/ask-mode), depending on what type of response you want!
> **Pro tip**: Before you start prompting, create [Project Rules](https://docs.bezi.com/bezi/product/project-rules) to ensure specific context, instructions, or requirements are factored into every Bezi response.
If you have tried-and-true methods of your own, share them with fellow game devs in our [Discord server](https://discord.com/invite/UKWB46HTT9)!
## Things to do
### Identify the goal and describe results
Two ways to interpret this: first, on the prompt-to-prompt scale. Try to word your questions in terms of the endpoint you want to reach.
![Describe Pn]()
Second, on the project-wide scale. Use a Page to document key game information, such as your project's goal, a detailed description of your idea, design pillars, and more. Pin the Page(s) in any prompts/threads where such context will improve Bezi's suggestions and responses.
### Specify a role/persona
State the perspective and the level of expertise you want from Bezi. For example, “*Act as an expert*” vs. “*Explain X to a student*”, or “*I’m a level designer, trying do Y*.”
![Role Pn]()
### Be specific
Add as much relevant information as you can/have. Think about **what keys to map to**, **what object you’ll attach them to**, **desired console**, **relevant pins**, etc. The clearer you are, the more likely it is that the result will match the idea.
![Specifics Pn]()
### Pin as much as possible!
If you know something is essential context, [pin it](https://docs.bezi.com/bezi/product/prompt-tagging) to ensure Bezi includes it from the start. This will help Bezi reach the best answer ASAP. Type **@** to search pins while in-line prompting, or select important information in Unity and click the pill(s) that appear above Bezi's prompt input field.
![Tag Pn]()
### Edit and iterate
Simple informational asks can be combined into one prompt, but for asks that need larger outputs from Bezi, break down your idea into multiple prompts and build it up from the foundation to get the best results.
If a response doesn’t touch on what you need, **edit** the original message to set yourself back on the right path. If that still goes off track, the best way to get reset is to **start a new thread** and iterate from there.
![Iterate Pn]()
***
## Things to avoid
### Fluff and anti-prompts
Don’t be overly wordy or polite, and don’t use words you wouldn’t want to see in Bezi's response. If you **need** to instruct Bezi to ignore something, use strong language like “***never***”.
Clear, organized prompts lead to better responses, so keep asks readable and concise.
![Avoid The Fluff Pn]()
### Overpacked prompts
Too many processing steps can lead to disorganized, cluttered responses. For (a bad) example: “*first search for A, then search for B, then write C, then combine A and B, then finally make D*.”
Keep prompts thread-specific and, if you need to pivot, do so with a new prompt or thread.
![Too Much Pn]()
### Repetition
Don’t prompt the same question multiple times. Results are dependent on gathered context, so if you’re not getting the response that you need from a prompt, repeating it is unlikely to get you a better result. Instead, **edit** the prompt to add more context or information or start a new thread with the rephrased prompt for a clean slate.
![Repetition Pn]()
### Old or irrelevant pins for new prompts
Bezi doesn't reset pins when you start a new prompt, so check that all pins are still revant to your prompt before posting. Bezi prioritizes what's pinned, so unrelated pins can take a thread down the wrong path.
![Irrelevant Pins Pn]()
# Quickstart
Source: https://docs.bezi.com/quickstart
Start building awesome documentation in under 5 minutes
## Setup your development
Learn how to update your docs locally and deploy them to the public.
### Edit and preview
During the onboarding process, we created a repository on your Github with
your docs content. You can find this repository on our
[dashboard](https://dashboard.mintlify.com). To clone the repository
locally, follow these
[instructions](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository)
in your terminal.
Previewing helps you make sure your changes look as intended. We built a
command line interface to render these changes locally. 1. Install the
[Mintlify CLI](https://www.npmjs.com/package/mintlify) to preview the
documentation changes locally with this command: `npm i -g mintlify`
2\. Run the following command at the root of your documentation (where
`mint.json` is): `mintlify dev`
### Deploy your changes
Our Github app automatically deploys your changes to your docs site, so you
don't need to manage deployments yourself. You can find the link to install on
your [dashboard](https://dashboard.mintlify.com). Once the bot has been
successfully installed, there should be a check mark next to the commit hash
of the repo.
[Commit and push your changes to
Git](https://docs.github.com/en/get-started/using-git/pushing-commits-to-a-remote-repository#about-git-push)
for your changes to update in your docs site. If you push and don't see that
the Github app successfully deployed your changes, you can also manually
update your docs through our [dashboard](https://dashboard.mintlify.com).
## Update your docs
Add content directly in your files with MDX syntax and React components. You can use any of our components, or even build your own.
Add flair to your docs with personalized branding.
Implement your OpenAPI spec and enable API user interaction.
Draw insights from user interactions with your documentation.
Keep your docs on your own website's subdomain.
# Create UI
Source: https://docs.bezi.com/use-cases/create-ui
Bezi creates UI using [Actions](https://docs.bezi.com/fundamentals/agent-mode-actions) to spawn gameObjects, set up functionality, and create prefabs. It uses its native Vision tool to automatically check its work against references, to ensure speed and quality.
Bezi isn't trained to create pixel-perfect hierarchy canvas, visual assets, or polish yet. We’re working towards this, but the complexity and nuance of UI and the variance in any LLM-based response makes it impossible for any LLM-based tool to promise it could build UI 100% to-spec right now.
With the right prompting, you can reach relatively complete and polished UI, depending on the task
* **Layout & Functionality:** 90% completion using Actions. The remaining 10% depends on manual customizations or polish.
* **Visual Assets & Polish**: Bezi isn't trained to generate human-level polish. It makes it easier to configure assets (e.g. swap out sprites, fonts, text, etc. and to link it to game functionality) but the polish is in your hands.
## Steps to generate UI
The more detail and specificity in a prompt, the better Bezi’s output will be.
1. **Tell Bezi you want to create UI**
2. Create your UI Standards Page, ref the below [framework and example](https://docs.bezi.com/use-cases/create-ui#precursor-for-creating-ui-with-bezi)
3. Define what UI you want to create (level-selection menu, leaderboard screen, health bar, etc.)
4. Find visual example(s) of UI layout you want Bezi to generate
5. Define any customizations and functionality *specific* to this UI that shouldn't live in your UI Standards Page
6. Pin any existing assets you want to use, e.g. textures, icons, etc.
7. \[[**Agent Mode**](https://docs.bezi.com/bezi/modes/agent-mode)] Draft a prompt with all the information in Steps 1-6. [**Pin**](https://docs.bezi.com/context/pins) the UI Standards Page created in Step 2 (type `@`, then Page name) and attach images from Step 4
* **Prefab example prompt**: “*Create UI to do \[Step 3]. Make it look like the attached image (\[Step 4]), especially \[specific parts of the image Bezi should focus on], and do \[Step 5]. Follow the guidelines written in @\[UI Standards Page]. Use the assets in @\[Step 6].”*
8. Submit your prompt!
9. Bezi will create the UI prefab and functionality directly in the Unity Editor
10. Bezi will take images of the UI and iterate on look and feel until it gets close to the specs
11. Manually polish the UI to get it to 100%
## UI Standards Pages for generating consistent UI
**Before doing UI-related work with Bezi, document the UI standards / guidelines in a** [Page](https://docs.bezi.com/context/pages). Pin the UI Page(s) whenever you're doing relevant work in Bezi to ensure it has enough information to provide quality output.
### What to include in a UI Page
1. UI specs / parameters
2. Template (if you have one)
3. Dev best practices to follow for UI setup, prefabs, organization, exposed inputs, etc.
4. List all UI requirements that must be met
### UI Page examples; copy and customize!
## UI Guidelines + Specs
### Components/Objects
* ALWAYS use textmeshproUGUI not Text
* ONLY use layout groups when the number of child objects is likely to change
* Use the slider component for progress bars
* Search the current scene for a canvas object to place the new UI
### Prefabs
* ALWAYS create a prefab for groups of objects that are repeated. Add them to the "Prefab/GeneratedUI" folder
* ALWAYS use prefabs for objects that can be considered to be a separated section of the UI
* ALWAYS re-use a created prefab for repeated objects
* Store all generated UI prefabs in /Assets/Prefabs/GeneratedUI/ folder
### Anchoring & Positioning
* ALWAYS anchor UI elements relative to their intended screen position:
* Top-left elements → anchor to top-left
* Center elements → anchor to center
* Bottom elements → anchor to bottom
* Use stretch anchors for elements that should scale with screen size (backgrounds, panels)
* NEVER position UI with absolute world coordinates - always use anchored positions
* Set appropriate pivot points based on scaling/rotation needs (0.5, 0.5 for center scaling)
* Use sizeDelta for pixel-perfect dimensions when anchors are together
* Keep Z position at 0 for all UI elements unless intentionally layering
### Best Practices
* Use consistent spacing between UI elements (multiples of 8 or 10)
* Name button callbacks clearly: OnButtonNameClicked() pattern
* Keep UI scripts single-responsibility - separate concerns (display vs. logic)
* Use serialized fields for references instead of FindObjectOfType
* Add \[Header] attributes to organize Inspector properties
* Cache frequently accessed components in Awake() or Start()
## Essential UI Toolkit Guide for Unity 6.1
### Panel Settings Asset
The foundation of runtime UI controlling rendering and input handling.
**Create:** Right-click → Create → UI Toolkit → Panel Settings
**Configure:**
* Reference Resolution (e.g., 1920x1080)
* Scale Mode (Constant Pixel Size, Constant Physical Size, Scale With Screen Size)
* Screen Match Mode for aspect ratio handling
* Sort Order for layering multiple UIs
### UXML Documents
Define UI structure and hierarchy, similar to HTML.
**Create:** Right-click → Create → UI Toolkit → UI Document
**Edit:** Double-click to open in UI Builder or edit as text
### USS StyleSheets
Control visual appearance and styling, similar to CSS.
**Create:** Right-click → Create → UI Toolkit → StyleSheet
\`\`\`xml
\
\
\
\`\`\`
### UI Document Component
Bridge between scene and UXML files.
**Create:** GameObject → UI Toolkit → UI Document
**Configure:**
* Panel Settings: Assign Panel Settings asset
* Source Asset: Assign UXML document
* Sort Order: Set rendering order
## Asset Requirements
### Fonts
* Formats: TrueType (.ttf), OpenType (.otf)
* Applied via USS `-unity-font` property or inline styles
* Import by dragging into Assets folder
### Sprites and Textures
* Formats: PNG, JPG, TGA, PSD, SVG (with Vector Graphics package)
* Recommended sizes: Power-of-two (256x256, 512x512, 1024x1024)
* Icon sizes: 16x16, 24x24, 32x32, 64x64 pixels
* Use sprite atlases for batching
* 9-slice support for scalable elements
## Core Workflow
1. Create Panel Settings → Configure rendering
2. Create UXML Document → Define structure
3. Create USS StyleSheet → Define styles
4. Link USS to UXML → Apply visual appearance
5. Create UI Document in Scene → Display at runtime
6. Use UI Builder → Visual design and iteration
7. Test in Play Mode → Verify functionality
## Built-in UI Elements
### Input Controls
* `Button` - Clickable actions
* `TextField` - Single-line text input
* `Toggle` - Boolean checkbox
* `Slider`, `SliderInt` - Numeric input with drag handle
* `MinMaxSlider` - Dual-handle range selector
* `DropdownField` - Selection from list
* `EnumField` - Dropdown for enums
### Numeric Fields
* `IntegerField`, `LongField` - Integer inputs
* `FloatField`, `DoubleField` - Floating-point inputs
* `Vector2Field`, `Vector3Field`, `Vector4Field` - Vector inputs
* `BoundsField`, `BoundsIntField` - 3D bounds
### Display Elements
* `Label` - Non-interactive text
* `Image` - Textures, sprites, vector images
* `HelpBox` - Informational messages
### Containers
* `VisualElement` - Base container for grouping
* `Box` - Container with border styling
* `GroupBox` - Container with header
* `Foldout` - Collapsible container
* `ScrollView` - Scrollable content
* `ListView` - Virtualized list for collections
* `TreeView` - Hierarchical tree structure
* `MultiColumnListView`, `MultiColumnTreeView` - Tabular data displays
### Editor-Specific
* `ObjectField` - Unity Object references
* `ColorField` - Color picker
* `CurveField` - Animation curve editor
* `GradientField` - Gradient editor
## Best Practices
### Web-Inspired Architecture
Separate concerns into three layers:
* **UXML** - Structure (like HTML)
* **USS** - Style (like CSS)
* **C#** - Behavior and logic
### UI Builder Workflow
* Primary tool for visual authoring
* Drag-and-drop interface for rapid prototyping
* Extract inline styles to reusable USS classes
* Preview different screen sizes in viewport
* Use UI Debugger (Window → UI Toolkit → Debugger) for troubleshooting
### Flexbox Layout
Based on CSS Flexbox model:
* Flex Direction: Row or column flow
* Justify Content: Main axis alignment (start, center, end, space-between)
* Align Items: Cross axis alignment (stretch, start, center, end)
* Flex Grow/Shrink: How elements expand or contract
* Use percentage-based sizes for responsive design
### Retained Mode Architecture
* UI structure persists in memory as visual tree
* Elements created once, updated only when data changes
* Framework handles rendering optimization
* Better performance than immediate mode
### Data Binding Pattern
* Automatically synchronize UI with data sources
* Two-way binding (UI updates data, data updates UI)
* Reduces boilerplate synchronization code
* Similar to modern web frameworks
### Design Patterns
* **MVP (Model-View-Presenter):** Separate data, presentation, and logic
* **State Pattern:** Manage UI screens and navigation flows
* **Custom Controls:** Extend VisualElement for reusable components
## Styling
### USS Structure
Style rules contain selectors and declaration blocks:
* **Type Selectors:** Target by C# class name (e.g., `Button`)
* **Name Selectors:** Target by unique name (e.g., `#playButton`)
* **Class Selectors:** Target by USS class (e.g., `.primary-button`)
* **Complex Selectors:** Descendant `selector1 selector2`), child `selector1 > selector2`)
* **Pseudo-classes:** State-based `:hover`, `:active`, `:focus`, `:disabled`, `:checked`)
### Style Application Methods
1. **USS Files:** Define reusable styles (recommended)
2. **Inline Styles:** Direct properties on elements (prototyping only)
3. **UI Builder:** Visual style modification
4. **C# Scripts:** Programmatic styling at runtime
### Theme Style Sheets (TSS)
Specialized USS files for complete visual themes:
* Use `@import` to compose multiple stylesheets
* Switch themes at runtime for dark/light modes
* Support platform-specific or localization-based themes
* Assign to Panel Settings as default theme
### Managing Styles at Runtime
* Add class: `element.AddToClassList("className")`
* Remove class: `element.RemoveFromClassList("className")`
* Toggle class: `element.ToggleInClassList("className")`
* Direct property: `element.style.backgroundColor = Color.red;`
## Interactivity
### **Event System**
UI Toolkit uses event-driven architecture:
* Default event system created automatically in Play mode
* Supports Input Manager (legacy) and Input System (new) packages
* Configure in Project Settings → Player → Active Input Handling
### **Event Types**
* Pointer Events: Mouse/touch `PointerDownEvent`, `PointerUpEvent`, `PointerMoveEvent`)
* Click Events: Click interactions `ClickEvent`)
* Change Events: Value changes `ChangeEvent`)
* Keyboard Events: Key presses `KeyDownEvent`, `KeyUpEvent`)
* Navigation Events: UI navigation `NavigationMoveEvent`, `NavigationSubmitEvent`)
* Focus Events: Focus changes `FocusInEvent`, `FocusOutEvent`)
### **Event Propagation**
Events flow through three phases:
1. **Trickle-Down**: Root to target
2. **Target**: At the target element
3. **Bubble-Up**: Target back to root
### **Callback Registration**
All interactive behavior implemented through callbacks in C# (not Inspector-based):
\`\`\`csharp
button.RegisterCallback\(OnButtonClicked);
void OnButtonClicked(ClickEvent evt)
\`\`\`
### **Focus and Navigation**
* Mark elements `focusable = true` for keyboard focus
* Tab key navigates between focusable elements
* Arrow keys for UI navigation
* `:focus` pseudo-class for visual feedback
### **Manipulators**
Reusable behavior components:
* `Clickable` - Click detection
* `ContextualMenuManipulator` - Right-click menus
* Custom manipulators for drag-drop, gestures, long-press
## App UI Package ([com.unity.dt.app](http://com.unity.dt.app)-ui)
Experimental framework extending UI Toolkit with enterprise-level components.
**Install:** Package Manager → Add package by name → `com.unity.dt.app-ui`
### **Key Components**
**Panel**: Root element providing context and overlay layering.
**Overlay Components:**
* `Popover` - Content next to target element with arrow
* `Modal` - Blocking dialog centered on screen
* `Tray` - Bottom-anchored popup (mobile-style)
* `Toast` - Auto-dismiss notification at screen edge
* `Tooltip` - Hover information popup
**MenuBuilder:** Fluent API for hierarchical menus with submenus and separators.
**Pressable:** Manipulator for press and long-press gestures.
### **Architecture Support**
* **MVVM**: Model-View-ViewModel pattern
* **Observables**: Data binding infrastructure
* **Dependency Injection**: Constructor injection with lifetimes
* **Navigation**: Stack-based page navigation
* **Context Management**: Hierarchical context propagation
### **Resources**
* Icon library with Phosphor Icons integration
* Typography system
* Pre-built theme TSS files (dark/light, various sizes)
## Performance Optimization
### **Draw Call Batching**
* UI Toolkit auto-batches compatible elements
* Same material/texture batch together
* Monitor in Unity Profiler
### **Dynamic Atlasing**
* Automatically combines textures at runtime
* Configure in Project Settings
* Reduces draw calls for multiple images
### **Hierarchy Optimization**
* Flatten visual tree where possible
* Minimize nesting depth
* Remove unnecessary containers
### **Memory Management**
* Unregister callbacks when elements destroyed
* Pool and reuse elements for lists
* Release unused asset references
## Quick Tips
* Use UI Builder for visual authoring, code for behavior only
* Prefer USS classes over inline styles for maintainability
* Design at reference resolution, use scaling modes for adaptation
* Test multiple resolutions and aspect ratios thoroughly
* Profile with Unity Profiler for performance bottlenecks
* Use data binding to reduce manual UI updates and synchronization
* Implement MVP pattern for complex UIs and better separation of concerns
* Create reusable custom controls to avoid duplication
* Use flexbox for responsive layouts that adapt to screen sizes
* Debug with UI Debugger tool for style and hierarchy inspection
# Debugging
Source: https://docs.bezi.com/use-cases/debug
Use Bezi's in-depth project (scripts, assets, scenes, packages, etc.) and Unity knowledge to find, interpret, and fix bugs faster than manual or code-only investigation.
The more information about a bug that you give Bezi, the faster it will find and fix the issue. Pin important information and attach images to your prompt as much as possible!
Never submit vague prompts like "*fix errors*" or "*not working*". Bezi won't know what you're talking about, nothing will get fixed, and you'll waste a valuable prompt!
## What types of bugs can Bezi help with?
1. Console errors
2. Behavioral issues
3. Optimization
## Steps to fix console errors
1. **Tell Bezi to implement a fix for a console error**
2. Attach a screenshot of the console error or copy/paste it in the prompt field
3. \[[**Agent Mode**](https://docs.bezi.com/fundamentals/ask-mode)] Submit one prompt with all the information in Steps 1-2
4. Test the fix and iterate as needed with Bezi
## Steps to fix behavioral and optimization issues
*These issues aren't standardized like console errors and require a bit more information to fix*
1. **Tell Bezi you want an explanation and possible solutions for a bug or lag**
2. Explain the current state of whatever is operating incorrectly
3. Define the expected or ideal state
4. Take screenshots of the bug (required for all visual issues)
5. Identify important information (assets, pages, scripts, game objects, etc.)
6. \[[**Ask Mode**](https://docs.bezi.com/fundamentals/ask-mode)] Draft a prompt with all the information in Steps 1-5,
1. add the information from Step 5 as [**in-line pins**](https://docs.bezi.com/context/pins) (type `@`, then the name to pin)
2. [**attach images**](https://docs.bezi.com/context/image-attachments) from Step 4 to the prompt
7. Submit the prompt
8. If there are multiple possible solutions, Bezi will provide options. Iterate with Bezi on those that seem right until you’re happy with the proposed solution
9. \[[**Agent Mode**](https://docs.bezi.com/fundamentals/ask-mode)] Tell Bezi to implement the fix you liked
10. Test the fix and iterate as needed with Bezi
## What do I do if Bezi's fix doesn't work?
If Bezi isn't able to fix it on the first try, it's likely missing a key piece of information.
**DO**: Review the information you've given Bezi, try to figure out what context it's missing and [edit the last prompt](https://docs.bezi.com/more/edit-prompts) to include that information.
**DO NOT**: Prompt "*still broken*", "*not working*", or anything vague like that. It won't help and risks sending Bezi down a rabbit hole!
# Document and Explain Projects
Source: https://docs.bezi.com/use-cases/documentation
Onboard to a new project and get custom documentation in a heartbeat.
Bezi understands the contents of a project, the objects in a scene, and the properties on the assets, so it’s well-equipped to parse through it all and deliver the exact information you need.
Ask Bezi to navigate the depths of your project to find the little details that take endless time to recover. And breathe easy knowing project documentation is covered, without spending time on it.
Currently, Bezi’s context **does not** dive into node graphs, state machines, or visual scripting. Bezi is aware they exist, but cannot see or explain how objects like animators and shader graphs are set up.
To use Bezi to track and document how a feature, system or project evolves over time, follow these steps:
1. Prompt Bezi to write detailed documentation for the scope in question
2. Copy and paste the in-thread documentation into a [Page](https://docs.bezi.com/bezi/product/pages-folders)
3. Title the Page according to the scope and date
4. Ask Bezi to generate documentation on how the current version is different from the original, pinning the Page you created so Bezi knows to use it as the "origional" datapoint
1. *"Write me detailed documentation on the current version of @\[scope] and how it is different from the origional @\[Page-name]"*
5. Voila! Bezi's written your detailed documentation and changelog
## Prompt examples
1. Get onboarded to a new or unfamilar project
* **Prompt Example**: *“Tell me about this project”*
* **Prompt Example**: *“How does the multiplayer system in this game work?”*
* **Prompt Example**: *"What are the controls for this game? List what mechanics there are, and explain how to use each to test."*
2. Identify all relevant properties / types
* **Prompt Example**: *“Find all objects set to Static”*
* **Prompt Example**: *“Do I have multiple cameras tagged MainCam?”*
* **Prompt Example**: *“List all food prefabs”*
3. Quickly find all dependencies
* **Prompt Example**: *“What tile palettes were used to build this level?”*
* **Prompt Example**: *“Return all scripts that instantiate Prey prefabs”*
* **Prompt Example**: *“Which animation clips does my character movement system actually use?”*
* **Prompt Example**: *“What script controls the pickup/drop behavior?”*
4. Find low-hanging fruit for optimization
* **Prompt Example**: *“List all 4K textures”*
* **Prompt Example**: *“What models do I actually use across my scenes?”*
* **Prompt Example**: *“Which models are too high poly to run on mobile?”*
# Auto-Create Unity Tools
Source: https://docs.bezi.com/use-cases/old-custom-tools
Create custom Unity tools in minutes, without writing any code.
Easily scale and automate repetitive Unity workflows and outputs, like creating levels and implementing asset.
Anyone can create tools with Bezi, wielding the power to unblock workflows when programmers are busy or pre-built tools don't meet your exact requirement.
## How to create custom tools
See the [Agent Mode docs](https://docs.bezi.com/bezi/modes/agent-mode) to learn more.
In as much detail as possible, explain: the process you want to automate, any key inputs or variables Bezi should include, and the ideal outcome - what form the tool should take and what the output of using it should look like. See example prompts below.
Pin specific project assets or scripts in your prompt ([type @, then the name](https://docs.bezi.com/bezi/product/reference-assets-in-prompts)) to ensure Bezi factors them into the tool.
Make sure your prompt clearly instructs Bezi to use this information to build a custom tool.
Bezi will create all required scripts for the tool. It will also give you step-by-step explanations for how to use the tool. In some cases, this might include attaching some scripts in-scene.
Once set-up, test the tool and prompt Bezi in the same thread to make any required changes.
If the tool has an editor window, make sure you pin it in Bezi so the interface stays up-to-date with any changes. If your thread is getting too long, make a new thread, pin all relevant scripts, and resume iteration.
## Example prompts
**Object configurations:**
* *“Make a setup script to add all necessary components (@AnimalController.cs, Rigidbody, Collider) to an animal on play. Include a dropdown for all animal types in @Animals folder, and add the selected animal-type script.”*
* *“Create a ragdoll generator that I can attach to an object to setup configurable joints on it and all of its children.”*
**Custom editors:**
* *“Create a canvas tool, where I can lay out and generate new levels. I want to be able to add tiles, with each tile corresponding to a different prefab; place them on the grid; and press a button that generates that layout in-scene.”*
* *“Create a custom editor with buttons to draw, shuffle, and discard cards for testing in play mode"*
* *“Add a custom editor to control the values of my shader”*
**Scene visualizations:**
* “*Add debug visualization of the locations where the enemies will spawn in the next wave”*
* *“Add a debug visualization of the spherical hotspots which trigger the next event”*
# Learn Unity
Source: https://docs.bezi.com/use-cases/old-learning
Ask Bezi to explain a concept or how to do something and save hours searching through Stack Overflow, Reddit, and uncommented code.
When struggling to understand the nuances of Unity development - like how to build a new mechanic or work with an unfamiliar plugin - it can take ages to find an explaination that addresses your specific scenario.
Bezi combines its deep knowledge of your project with Unity docs, ReadMes, and other web resources to give detailed explanations that are always custom to your work at hand.
## Example prompts
**Unity Information:**
* *“What’s the difference between a MeshRenderer and a SkinnedMeshRenderer?”*
* *“What are the main differences between Unity 6 and Unity 2022?”*
* *“Teach me about the core tabs of the Lighting window. Specifically, what are Adaptive Probe Volumes?”*
**Custom Instructions**:
* *“How do you use set up custom tile palettes to use with a TileMap?”*
* *“Tutorial for making an inventory system for a desktop exploration game”*
* *“How do you use the Profiler?”*
**Packages**:
* *“Explain the key features of the PortalsForVR package”*
* *"What are the best packages for stylized water (provide Pros, Cons, and recommendations)?”*
* *“How can I set up my project for Passthrough with MetaXR?”*
# Rapid Prototyping
Source: https://docs.bezi.com/use-cases/prototype-iterate
Move from early idea to playable prototype in less time; test all the ideas to find the best version without sacrificing the deadline.
## How to prototype or iterate on features with Bezi
Enter [Plan Mode](/fundamentals/plan-mode)
Explain in detail what you want to build; the ideal result, any key variables you’ll want to play with, and the controller scheme.
[Pin](/context/pins) the pages, assets, and context (in any connections) that you want Bezi to focus on. This is important; Bezi can quickly replicate a mechanic in a different project if you pin it!
Ask Bezi to write you an implementation plan for this feature.
The goal is to have a comprehensive implementation plan, with minimal room for Bezi to make assumptions.
If you want to use this implementation plan again, convert it into a [Page](https://docs.bezi.com/bezi/product/pages-folders) to store and reference in the future. If you want to share it with a teammate, make it a Shared Page for easy distribution!
Move to [**Agent Mode**](https://docs.bezi.com/bezi/modes/agent-mode) and direct Bezi to implement the final plan.
When the agent is done working, click into Unity to test it in action.
Continue moving between Bezi and Unity, iterating on the mechanic and seeing the changes in action instantly.
## Prompt examples
1. Generate foundational systems
* **Prompt Example**: *“Make a first person character controller with mouse-based camera movement”*
* **Prompt Example**: *“Mock up object pooling for the obstacles and set up the basic obstacle ‘spawning’ and movement system (right to left)”*
2. Experiment with new whitebox mechanics
* **Prompt Example**: *“Prototype a ghost possession mechanic that lets the player take and relinquish control of other characters when in range and spacebar is pressed”*
* **Prompt Example**: *“I want a camera system that moves to a fixed CameraLocation when they enter a collider tagged FixedCam, then lerps back to third person when out”*
3. Iterate on existing systems and designs
* **Prompt Example**: “*Add crouch and jump behavior to the player movement script*”
* **Prompt Example**: “*Instead of using a Raycast to detect treasure, can we change that to use the hunter collider?*”
* **Prompt Example**: “*Incorporate the isFalling, isFlying, and isMoving animation bools from @Character.controller into CharacterController.cs*”
# Tutorial Video Assets
Source: https://docs.bezi.com/use-cases/tutorials
Our product education YouTube channel provides tutorials for using Bezi - great if you want to level-up your practice or learn how to streamline a new workflow.
## [Mobile Game UI Tutorial](https://www.youtube.com/watch?v=2Y6nkgk90Ho)
# Create Unity Tools
Source: https://docs.bezi.com/use-cases/unity-tools
When you can generate tools in minutes instead of building them manually **or distracting teammates** , you're free to use them for all sorts of manual and repetitive tasks—**from small one-offs to huge, once-painful processes** .
## How can I use Bezi to automatically create tools?
1. Define what you want the tool to do
2. Prompt Bezi with the right details (Steps 1-5, [**below**](https://docs.bezi.com/use-cases/unity-tools#steps-to-create-a-custom-tool)) and tell it to create a tool
3. Bezi will generate a tool to meet your exact purpose and specs!
If you have guidelines or standards that Bezi-generated tools should follow, document them in a [**Page**](https://docs.bezi.com/context/pages) and [pin the page](https://docs.bezi.com/context/pins) whenever you ask Bezi to create a tool.
## Steps to create a custom tool
The instruction and detail in your prompt dictates the tool's level of completion and polish...
1. **Tell Bezi you want it to create a Unity tool**
2. Define the process or workflow you want to automate
3. Define what the tool’s output should be, in as much detail as possible
4. Define any tool structure requirements: the form it should take, UI preferences, etc.
5. Identify key project references and assets for the tool (assets, pages, scripts, etc.)
6. \[[**Agent Mode**](https://docs.bezi.com/bezi/modes/agent-mode)] Draft a prompt with all the information in Steps 1-5, add anything from Step 5 as [in-line pins](https://docs.bezi.com/context/pins) (type `@`, then the name to pin)
7. Submit the prompt
8. Bezi creates the tool in Unity and writes documentation on how to use it
* Bezi creates all tool scripts in Unity
* If tool set-up requires attaching scripts in-scene, Bezi will give instructions for this step
9. Start using your tool!
## Steps to edit a Bezi-created tool
**If you generally like the tool but want to make a few minor edits...**
1. \[**Agent Mode**] Write another prompt with a detailed explanation of the edits
* Include current state vs desired state
* [Attach images](https://docs.bezi.com/context/image-attachments) for any visual edits
2. Submit the prompt and test the updated tool
3. Continue to iterate. If any future iterations causes a reversion/problem, edit that prompt to include missing details or specifications
4. Select Keep All on the response when you're happy with the results.
**If you want something very different than what was created...**
1. Click the edit button on the original prompt
2. Accept the pop-up to revert changes (this undoes any changes made after the edited prompt)
3. Identify what information is missing or needs editing in the original tool prompt to get what you want
4. Edit the prompt to account for that missing/incorrect info and submit!
## Prompt examples
1. Automate a repetitive process/pipeline
* **Prompt Example**: *Make a setup tool that will configure a given animal FBX as a prefab with the necessary components (@AnimalController.cs, Rigidbody, Collider). In the tool UI, include a dropdown for all animal types in @Animals folder, and add the selected animal-type’s script. Follow the rules in @UI-Guidelines-Page*.
2. Automate UI creation
* **Prompt Example**: *Make a tool that will create the pictured UI for the Achievements screen. Create it as a prefab, use TextMeshPro, and include the ability to assign each sprite. Follow the scaling guidelines in @UI-Guidelines-Page*.
3. Automate very manual, 1-off setup process
* **Prompt Example**: *Create a partial ragdoll generator tool that I can attach to an object to setup configurable joints on it and all of its children*.
4. Create a more intuitive interface for a visual/artistic workflow
* **Prompt Example**: *Create a canvas tool to help me lay out and generate new levels. I want to be able to add tiles, with each tile corresponding to a different prefab; place them on the grid; and press a button that generates that layout in-scene*.
# Tutorial Video Assets
Source: https://docs.bezi.com/use-cases/untitled-page
Our product education YouTube channel provides tutorials for using Bezi - great if you want to level-up your practice or learn how to streamline a new workflow.
## Crystal Magic UI Tutorial
# Delete Plant
Source: https://docs.bezi.com/x-api-reference/endpoint/delete
DELETE /plants/{id}
Deletes a single plant based on the ID supplied
# Get Plants
Source: https://docs.bezi.com/x-api-reference/endpoint/get
GET /plants
Returns all plants from the system that the user has access to