Agentic Development in Unreal Engine with JetBrains Rider | Alexander Dzerakh | GameDev Day 2026
In a Nutshell
JetBrains Rider Kit connects AI agents directly to Unreal Engine by linking Rider's code intelligence with the live Unreal editor state. Agents can now understand and modify C++ code, blueprints, assets, and runtime behavior in one workflow instead of working from static repository files alone. This enables agents to perform real tasks like creating gameplay abilities, setting breakpoints, debugging standalone games, and validating fixes without developers switching contexts.
These notes were generated by AI and may contain inaccuracies.
Alex is the product manager for Rider at JetBrains. The goal is to make Rider the ultimate development environment for game developers. Rider supports Unreal, Unity, Godot, or custom C++ engines. Users can work with C++, C#, GDScript, shaders, and build scripts, then ship to desktop, mobile, consoles, or XR devices. Rider supports the entire game development loop: writing code, building, debugging, profiling, running tests, and deploying to target platforms. Rider understands the environment around the code, including assets, engine concepts, project structure, and runtime behavior.
Rider delivers three key benefits: understanding the whole project including source files, assets, engine concepts, project structure, and runtime behavior; connecting the development workflow so developers can move between code, engine, debugging, profiling, build systems, and target platforms while carrying context across the entire workflow; and iterating faster by finding problems earlier, understanding root causes faster, making changes, and validating with less friction.
AI is becoming another layer across the entire workflow rather than a separate tool. JetBrains takes an open approach where developers do not have to choose between their trusted development environment and preferred AI agent. The concept is "your agent with Rider intelligence."
The approach consists of three pieces: the agent itself, which works through ACP (Rider Agent Client Protocol) allowing connection to different agents based on task needs; Rider tools through MCP, giving agents access to code intelligence, navigation, inspections, debugging, and project understanding; and for game development, engine-specific knowledge and tools including Unreal-specific skills, Rider skills for code refactoring and debugging, and agent hooks for code quality checks.
An Unreal project is not just a C++ repository. Game behavior spreads across C++ code, blueprints, assets, config files, actual Unreal editor state, and build targets. Additional context exists in logs and runtime behavior that cannot be seen in an IDE. Generic coding agents may excel at reading and generating C++ but only see repository files, missing the complete picture. This leads to changing C++ without understanding blueprint side, giving build advice without knowing actual Unreal state, missing important runtime logs, or making incorrect assumptions about project configuration.
Rider Kit is an AI chat directly inside the Unreal editor. Rider installs a plugin into Unreal editor that connects the editor back to Rider. The goal is not to build another AI agent or reinvent the model. Users connect their agent of choice via ACP (such as Claude or Cursor), and Rider Kit enriches that agent with the development environment. One side provides Rider's understanding of codebase, symbols, usages, inspections, navigation, debugging, and project model. The other side provides the Unreal editor with viewport, blueprints, assets, logs, and current editor state. Rider Kit connects these environments and gives the agent access to both sides of the context.
Three broad workflow categories exist: understanding, where agents answer questions about the Unreal project and trace gameplay logic across C++, blueprints, assets, and project structure; implementation, where agents make changes using both project knowledge and Unreal editor context rather than treating tasks as isolated code generation; and investigation, where agents reproduce issues, inspect runtime state, use Rider's debugger, find causes, make fixes, and validate them.
Three examples demonstrate how the agent reasons about an Unreal project beyond reading C++ files. First, the agent finds all blueprints derived from two parent types, using Rider's project knowledge to provide the actual blueprint hierarchy and asset locations. Second, the agent creates a new blueprint, then answers a broader question about what references an existing base blueprint has, understanding how assets use it and what could break if changed. The agent calls MCP tools from Rider, looks beyond simple reference search at what the blueprint contains, follows dependencies, and checks how other assets consume it. The result provides relationships and potential impact of changes across all blueprints. Third, the agent explains how a pistol asset connects to its weapon instance, crossing the blueprint boundary to follow the asset relationship into C++ code that consumes it at runtime.
The agent creates a new dash gameplay ability in C++ using Unreal's gameplay ability system. The task requires exposing a force property, creating a blueprint based on it, and adding the ability to the player. The agent uses Rider to understand existing project structure, finds the right classes and files, creates the C++ implementation, starts the Unreal build through Rider, which understands live coding and applies changes without restarting the editor. The agent creates the blueprint, configures the property, and wires the ability into the player's default abilities. The agent notices that nothing triggers the dash yet and explicitly states the next step would be to bind it to an input action. The demonstration shows one connected workflow: understanding existing architecture, changing C++, placing files properly, building through Unreal tooling, creating the blueprint side, configuring the player, and understanding what remains missing.
The agent receives a human-level instruction to set a breakpoint on the weapon pickup attached to the game, simulate the player moving forward, and observe what happens. The agent uses Rider search and project understanding to determine what weapon pickup means in the project, finds relevant code in shooter pickups.cpp, identifies the pickup path, sets the breakpoint, and attaches Rider's native debugger to the running Unreal editor process. Rider Kit uses Unreal-side input simulation to reproduce the scenario. The agent starts play in editor, moves the player forward, lets the character reach the pickup, and the breakpoint hits. The agent reads the debugger state and reports relevant runtime variables back in the chat.
A real game issue is presented: picking up another weapon, clicking switch weapon, seeing debug log printed but nothing happening. The agent receives the problem description in plain language and is asked to run standalone game, attach debugger, and determine what is happening. The agent uses Rider to find code responsible for weapon switching, sets a breakpoint, launches the game in standalone mode, attaches Rider's debugger to the new game process. The user controls the character to reproduce the issue. The breakpoint hits, the agent inspects runtime state, continues investigation through debugger stepping through the stack, and finds the root cause: an inverted condition in the weapon selection loop. The agent proposes a fix, applies it when instructed, builds through Rider using live coding via UBT, and returns to play in editor for validation.
Rider Kit is not publicly available yet but private preview opens shortly. Developers interested in trying it can scan the QR code shown in the presentation to sign up. The product is maintained by JetBrains.
The agent uses the real project model, real assets, and real index from the project at any given moment. If changes are made and the agent is asked to check something, it uses the actual current state.
Rider Kit shortens the development loop. Users can validate something in Unreal editor, then spawn a task for an agent directly in Unreal editor without leaving it. Users can choose to continue in Rider or stay in the editor.
The agent handles organization and moving assets as well as Rider does because the agent uses Rider tooling under the hood via MCP. When files are refactored or reorganized in the IDE, the updated state is reflected for the agent. The agent knows about any file reorganization at any given moment.
Keep JetBrains in your library
Save the videos and channels worth coming back to, and find them again in one place.
