Hi all,
I’m Erhan. Sentari AI Assistant for Unreal Engine is out now — six months of work, built by one developer. Sharing it here with the people it was built for.
What it is. A panel that docks in the editor and gives a language model supervised control of your project. You describe what you want, it inspects the level, proposes the changes, and — once you approve — authors them: Blueprint graphs, materials, Niagara systems, lighting, procedural scatter.
The panel docked beside the viewport. One sentence in, three procedural scatter layers out — around ninety thousand instances, all instanced so it stays cheap to render. The plugin ships no content of its own and isn’t tied to any asset pack: it scanned the project and built this from the nature assets that were already in it, so the same prompt against Megascans or your own library gives comparable or better results.
Bring whichever model you want, and switch without ceremony.
This is where most of the interface work went. You choose a provider and then a model from two separate searchable dropdowns — type a few characters, pick, carry on. Local runtimes like Ollama and LM Studio sit in the same list as the cloud providers and the aggregators, so moving a task from a frontier cloud model to something running on your own graphics card is two clicks, not a config file and a restart. Local models get first-class treatment rather than a checkbox: the list is populated live from what you actually have installed, and the panel adapts to each model’s real capabilities instead of assuming.
If you point it at a local model, no cloud call happens at all and nothing about your project leaves your machine. It uses your own provider keys.
Provider and model are two searchable lists — local runtimes sit alongside cloud providers.
Generating things was the easy half. Making the assistant honest about them was the hard half.
What kept eating time in real projects wasn’t generation — it was the assistant reporting success on something it hadn’t actually done. Saying a material parameter was set when the write had silently failed. Saying a Blueprint node was connected when the pin default never applied.
This happens most with smaller local models, but not only with them — even a strong cloud model will occasionally abandon the dedicated tool it should be using and start hand-writing scripts to brute-force the task instead — which is exactly when it stops being able to tell you honestly whether the task worked.
So most of those six months went into the layer underneath the generation:
- Writes are read back. After changing something it re-reads the asset and compares. If the value didn’t land, it says so instead of reporting success.
- It won’t claim what it can’t show. Viewport captures and play-in-editor runs are checked against what actually happened, not against what was intended.
- Nothing is authored without your approval, and there’s a read-only mode where it can inspect and explain your project but is structurally unable to write to it.
- When something fails, the failure goes back into the next attempt with the error in context, rather than repeating the same call.
The practical result is that it gets a high proportion of tasks finished even on modest local models — which is the outcome all that plumbing was for. It is not magic: if a model’s tool-calling or reasoning ability is weak to begin with, no amount of scaffolding above it will fix that.
This layer is worth calling out because anyone can put “verifies its own work” in a feature list. Building it is what most of the development time was spent on, and it’s the difference you feel on the third hour of a session rather than the first minute.
A door Blueprint authored from a prompt — components, variables and the tick logic, opened afterwards in the regular Blueprint editor. Nothing here is a screenshot of the panel; this is the asset it left behind, compiling clean.
“Make it brighter, like a midnight.” It reads the viewport, changes the scene, and reports back the actual before-and-after values it wrote — moonlight 0.35 to 2.0 lux, skylight 0.12 to 0.4, auto-exposure floor 0.3 to 0.5. That read-back is the part described above.
It works from the outside, too. Sentari runs its own MCP server on localhost, so an external agent can drive the editor through the same tools the panel uses. If you already work in Claude Code or Codex, the plugin detects them, registers itself with them for you, and launches them in a terminal inside the editor — so you can stay in one window instead of alternating between the editor and a separate console. Use the panel, use your own agent, or use both.
On Unreal Engine 5.8. Sentari brings 265 editor tools of its own, each written for a specific job rather than being a generic “run this script” wrapper. On 5.8 it also plugs into the engine’s toolset registry, which means Epic’s own built-in toolsets (Niagara, PCG, UMG, GAS and so on) become available to the model from inside the same panel. You switch them on group by group, because every enabled toolset adds its tool descriptions to the model’s context — enabling all of them at once eats a large slice of the context window for no benefit. Where Epic already provides a tool, Sentari uses it instead of shipping a duplicate.
Some things it doesn’t do yet, so nobody is surprised after installing:
- Landscape sculpting — it reads terrain and places things on it, but doesn’t raise or carve it yet. On the list.
- Sequencer has no dedicated authoring tools yet — it can inspect a level sequence, not build one. On the list.
- Windows only at the moment; a macOS port is realistic but isn’t done.
For anything not covered by a dedicated tool, a strong model can usually get there through the general Python scripting path — it just doesn’t get the read-back verification described above on that route.
Where it is. It’s a paid plugin for Unreal Engine 5.7 and 5.8, and there’s a free trial if you’d rather judge it yourself than take any of the above on trust:
- Trial and details: https://sentaridigital.com
- A full task from prompt to result: https://youtu.be/f4uwaBrbUyE
Hundreds of hands-on tests in the editor went into it, and it now completes the large majority of what people ask of it. Development is ongoing and updates land on a regular cadence.
Put it on your own project and see for yourself. Thoughts and suggestions about what it should do next are welcome — and technical questions in this thread get answered by the person who wrote the code.
Thanks for reading.
— Erhan Gökmen