Coming to Fab — the Unreal Engine marketplace. One-time license, no subscription, no credits.
Plugin · Unreal Engine 5.7 & 5.8

The assistant that
lives inside
your editor.

The easiest way to build a game faster — and your best assistant once you do. Sentari AI Assistant doesn't wrap the engine from the outside; it works inside it. It reads your scene and viewport, reasons about what it sees, then authors real assets, Blueprint graphs, materials, PCG worlds and Gameplay Ability System data through a toolset it has already verified against the engine.

265+verified tools
:8765MCP bridge
Offline-readylocal or cloud
tool dispatch · verified
scene_author bp_graph pcg_worlds gas / abilities vision (vlm) MCP bridge :8765 editor PIE
Capabilities

One assistant. The whole editor.

Each capability is a family of tools that Sentari has resolved against the engine's real API and runtime-tested. A few representative tool names are shown in each — the actual roster is 265+ and growing.

Scene authoring

Spawn, move, align, distribute and snap actors; assign meshes and materials; trace and validate placement. Recipes scatter natural, terrain-following foliage as efficient instanced meshes.

spawn_actorassign_materialscatter_on_landscapedistribute_actors

Blueprint graphs

Build whole graphs atomically — nodes, wires, pin defaults, compile and rollback as one unit. Pre-flight validates every name against reflection before a node is created.

build_bp_graphbuild_bp_dslpreflight_bp_graphadd_bp_component

Materials & shaders

Author master materials from a declarative node spec, instance them with parameter overrides, and audit exactly which params exist before you touch them.

build_material_graphcreate_material_instancelist_material_params

PCG worlds

Node-level PCG primitives — add/wire nodes, edit settings, read generated points. Turing-complete composition plus proven scatter recipes for landscape and spline, at World-Partition scale.

add_pcg_nodeadd_pcg_edgeread_pcg_nodescatter_along_spline

Gameplay Ability System

Read abilities, effects and attribute sets; inspect ExecCalc captures; then drive the live game — activate abilities by tag, fire cues, read cooldowns and live attributes.

read_gameplay_abilityread_attribute_setpie_activate_ability_by_tagpie_get_attribute

Vision & viewport

An optional vision model reads the editor viewport or full desktop — lighting, layout, on-screen errors — and answers questions grounded in what it actually sees. Capability-checked per model.

analyze_viewport_asyncget_vision_jobanalyze_full_screen_async

Generate 3D, audio & image

Bring your own keys and generate in-editor: text/image-to-3D meshes (Meshy, Tripo), voice, SFX and music (ElevenLabs), and images (FLUX via fal.ai) — then drop the result straight into your scene.

generate_3d_meshgenerate_voicegenerate_sfxgenerate_image

Runtime control (PIE)

Play the game, then command it — teleport actors, set properties, move AI on the NavMesh, inspect live state. Changes are transient, the asset stays clean.

pie_move_ai_topie_set_propertypie_teleport_actorpie_list_actors

+ Niagara VFX authoring & recolour · 800+ Epic editor actions · performance & asset audit · 12-language UI · in-panel CLI launcher for Claude Code & Codex.

Why Sentari

Detailed enough for real work. Easy on your wallet.

Deep, verified tooling doesn't have to be expensive or complicated. Sentari pairs node-level depth with a local-first, budget-aware design — so the easy stuff costs nothing and the hard stuff costs little.

Detailed, yet non-destructive

Every change is verified — compile-clean or PIE-tested — before Sentari reports success, and every action is undoable. Powerful enough for production, safe enough to trust blindly.

verify · undo · safe

Local models run natively

LM Studio and Ollama are built in, not bolted on. Native tool-calling, VRAM-aware keep-alive and per-model capability probing — your local GPU is a first-class citizen.

ollama · lm studio

Free model today, frontier tomorrow

Start free on an open-source Llama, Qwen or Gemma. Reach any frontier model — Claude, GLM, Gemini — through OpenRouter or a direct API key. Same panel, your choice of brain.

byom · openrouter

A real budget saver

Keep the high-volume grind on free local weights; spend cloud only on reasoning that earns it. One-time license, no subscription, no credits to burn. The money stays in your pocket.

no subscription

Offline by design

Run fully offline — your project never has to leave the machine. The same local-first architecture that makes it private is exactly what makes it affordable.

offline mode

The easy way to build a game

Ask in plain language; get real assets. From your first scattered forest to a balanced combat ability, Sentari is the fastest path from idea to thing-that-works-in-engine.

your best assistant
Token & budget saver

Run the routine locally. Spend cloud only where it counts.

Split the workload like a smart team does: free local models carry the volume, and your paid cloud model is reserved for the heavy lifting. You stay fast, and your bill stays small.

Lane 01 · Local · free

The daily grind, on free weights

High-volume, low-risk work runs on a local Llama, Qwen or Gemma — zero per-prompt cost, fully offline.

  • Scatter & place actors
  • Rename, organise, audit assets
  • Wire nodes, set pin defaults
  • Read attributes & scene state
Sentari routes
the task
Lane 02 · Cloud · on demand

The hard parts, when you need them

Complex reasoning, vision and long planning go to a frontier model — invoked only when the local lane can't carry it.

  • Design a system from scratch
  • Read the viewport (VLM)
  • Debug a tricky graph
  • Long multi-step builds
One panel, two modes

Compact when you're focused. Extended when you mean business.

The same dockable panel shrinks to a slim chat rail that tucks beside your viewport, then expands into a full bench — chat, tool calls, 3D preview and logs — the moment you need the whole workspace. Switch on demand; your layout persists.

sentari · compact
compact · chat rail
sentari · extended
chat · tool calls
input
3D preview
logs
extended · full bench
Guarantees

Safe enough to hand it the keys.

Letting an AI touch a real project takes more than a good demo. Three things hold true of every action Sentari takes — not as policy you have to trust, but as behaviour you can check.

01 · Your machine

Your model, your data

Work entirely offline on a local model, or bring your own cloud key. No account, no telemetry, no middleman. Your project and your prompts go exactly where you send them and nowhere else.

  • Offline mode, local-first
  • Bring your own key
  • No telemetry, no account
02 · Every change

Verified before it's claimed

A change is reported as done only after it compiles or passes a check, and it lands on the editor's undo stack like any other edit. An honest “that did not apply” is the plugin working, not failing.

  • Verify, then claim
  • Undoable like any edit
  • Approvals on by default
03 · Your call

Scoped to what you allow

Give it a free hand where you trust it and a hard boundary where you don't — per tool family, per asset folder. Guests you connect can be held to read-only. You draw the lines.

  • Per-folder allow / deny
  • Tool groups on or off
  • Read-only for guests
A real request

Ask in plain language. Get real assets.

Sentari plans with the model, then calls verified tools that write into your project. Here's what a scatter request looks like end to end.

sentari — scatter a forest on the hillside
› you  "scatter oak trees across the south hill, denser near the river"

› sentari plans
  1. read landscape bounds  →  south hill region detected
  2. scatter_on_landscape   →  template: SM_Oak, density tuned by slope
  3. instanced + random yaw →  non-grid, terrain-following, 2 draw calls
  4. generate + verify      →  625 instances spawned, pivots on surface

✓ done instances: 625 · actors: 0 · seed: 1234
   undo available · non-destructive · assets written to current level
Vision

Give it a photo. Get a lit scene.

The most underestimated thing Sentari does. Attach a reference image, describe the outcome you want, and it calls the real lighting tools in the same turn it looks at your picture — no values read off the photo by hand, no plugin-specific syntax to learn.

“Set the atmosphere and lighting like in the picture I gave you.”

The Sentari panel with a sunset reference photo attached; the local model lists the exact lighting changes it made, with the result filling the viewport
One turn

The reference photo rides along with the message. The reply — from a local Qwen in LM Studio, not a cloud model — reports exactly what it changed: sun to a −5° horizon angle at 2700 K and 5 lux, orange height fog at density 0.06, a warm skylight at 2.5× for bounce, and a post-process pass with bloom 1.5, saturation 1.3, contrast 1.2 and −0.3 exposure compensation to keep the sun bright without blowing it out. The viewport behind it is already the result.

The resulting scene from the player's point of view: a warm low sun, orange haze and long shadows
The result

The same scene from the player's point of view. Nothing here was hand-tuned — every value came from the model reading the photograph, and every one of them is an ordinary editor change you can undo.

Watch

See it work.

The captures above are real, straight from the editor. The clips below come from the same sessions — the remaining tiles fill in as the reel is cut.

Driving GAS at runtime: activate, cue, cooldown
video placeholder · 1:24
—:—
Text-to-mesh: generate a prop and drop it in
video placeholder · 0:58
—:—
Recolouring a Niagara VFX system in one prompt
video placeholder · 0:47
—:—
Compact to extended: resizing the workspace
video placeholder · 0:36
—:—
Running Claude Code inside the panel
video placeholder · 1:32
—:—
Get started

From zero to authored in minutes.

Step 01

Get it on Fab

Add Sentari_AI_Assistant from Fab to your project and enable it. UE 5.7 & 5.8.

Step 02

Point at a model

Local (Ollama / LM Studio) or cloud, or any model via OpenRouter. The bridge listens on :8765.

Step 03

Open the panel

The dockable panel connects automatically — compact or extended. Start talking to your scene.

Step 04

Author & verify

Every action is verified and undoable — compile-clean or PIE-tested — before Sentari reports success.

Coming to Fab

Put Sentari in your pipeline.

One-time license on Fab — no subscription, no credits. Drop your email to be notified at launch, or tell us what you're building and we'll show you what the assistant can do for it.

Notify me at launch ← Back to studio