Connect All Your Tools - GitHub, Blender, Figma - to Bezi with MCPs

Integrating with the Unity engine and your codebase is one thing. But game development spreads across a dozen tools: your UI mockups live in Figma, your tickets live in Jira, your version history lives in GitHub, your 3D assets live in Blender. Until now, that context stayed outside of Bezi's reach.

Starting today, Bezi supports MCPs (Model Context Protocol, the open standard for connecting AI tools to external services).

Connect the tools you already use, and your design files, issue trackers, repositories, and documentation become extensions that Bezi reads from, acts on, and writes back to.

MCP context layers on top of Bezi's continuously indexed understanding of your entire Unity project. When Bezi reads a Jira ticket through MCP, it already knows how your project is structured, how your systems interact, and what conventions your team follows. It can move straight from reading the ticket to implementation.

Bezi works with any configurable MCP server. Here are three that show what becomes possible.

GitHub: Your project's full history, as super-powered context

Connect the GitHub MCP and your repository structure, commit history, open issues, pull requests, CI/CD status, and code search are all accessible within your Bezi threads.

When you ask Bezi to help debug a regression, it can cross-reference recent commits and PRs to identify what changed and when. When you are implementing a new system, Bezi can look at how similar systems were built in your repo's history and follow the same patterns. When a teammate opens a PR that touches a system you are working on, Bezi can surface the relevant changes without you needing to leave your workflow.

With GitHub connected, Bezi's context extends beyond what is inside your Unity project right now to the full arc of how your project has evolved, who changed what, and why.

Figma: Go from mockup to game UI

Figma's MCP gives structural insight into UI mockups and translates those designs directly to the Unity Project. The direct access to every frame takes the manual inspection, painstaking rebuilding, and guesswork out of the process: UI translation becomes a conversation.

Reference a Figma frame in your Bezi thread, and Bezi reads the structured design context directly: layout hierarchy, component properties, variables, spacing, typography, and styling information. Instead of interpreting a screenshot, the Figma MCP provides Bezi with the actual design data that defines how the mockup is constructed.

The loop from mockup to implemented game UI shrinks from hours of manual Inspector work to a single conversation.

Blender: Bring your 3D pipeline into Bezi

Connect the Blender MCP and Bezi gains access to your 3D authoring environment. Blender's MCP server exposes scene structure, object hierarchies, material configurations, and mesh data, giving Bezi visibility into how your assets are built before they reach Unity.

When you are setting up a character prefab and need to understand how the source mesh is structured, what materials are assigned, or how the bone hierarchy is organized, Bezi can reference the Blender scene directly rather than relying on your description. When a technical artist documents asset pipeline conventions in a Page, Bezi can cross-reference those conventions against the actual Blender scene to verify compliance before import. And because the Blender MCP supports write operations, Bezi can also create and modify objects directly in your Blender scene.

Beyond these three

GitHub, Figma, and Jira are starting points. The MCP ecosystem includes servers for Linear, Notion, Slack, Sentry, PostgreSQL, Perforce, and dozens more, with new ones appearing regularly. If your team has built a custom internal tool with an MCP server, that works too. Any MCP server that follows the protocol standard can connect to Bezi and contribute to the context Bezi builds around your project.

How to connect an MCP

There are two ways to set up an MCP in Bezi.

1. Ask Bezi to do it. Tell Bezi which MCP you want to connect, and it will configure the mcp.json file for you. If you say "install the GitHub MCP," Bezi adds the entry, sets up the server command, and tells you which credentials to add to the config file. Bezi never collects or stores your access tokens. The MCP comes online and you are ready to go.

2. Edit mcp.json directly. From your workspace settings, open the mcp.json file and add an entry for the server you want to connect:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token-here"
      }
    }
  }
}

Each MCP server has its own config structure and credential requirements. Reference the provider's documentation for setup details, or ask Bezi to handle the configuration for you.

You control what Bezi can access

Every MCP tool call goes through a permission system. The first time a new tool is triggered, Bezi prompts you in-thread with three options: Always Allow (auto-approve future calls to this tool), Ask for Permission (prompt you every time), or Never Allow (ignore this tool going forward).

Permissions are set per tool, not per MCP server. You can always-allow one Github tool while never-allow-ing others, and keep some as ask-for-permission forever. The full allow list is viewable and editable from workspace settings at any time, so you are never locked into a decision you made in the middle of a thread.

What's next

MCP support is available today for all Bezi users. The setup experience will continue to improve as we add dedicated connection flows for the most popular providers.

We are also working on support for the Agent Client Protocol (ACP), the open standard built by JetBrains and Zed for connecting coding agents to IDEs. ACP will let developers use Bezi directly from their preferred code editor.