Back to roadmap
What the agent can actually do
Discover the live project tool surface for Blueprints, materials, actors and world, widgets, Niagara, levels, assets and more.
The live tool catalog is the authoritative map of capabilities for a project. Tool counts and availability depend on enabled plugins. Supported tool calls can use the hidden backend, while rendering, Slate and simulation operations still require their appropriate context. Transaction and save behavior depend on the selected tool.
Three sources, one catalogue
- Engine-reflected toolsets. Any UFUNCTION marked AICallable on a UToolsetDefinition is harvested by Unreal's ToolsetRegistry and surfaced through the AllToolsets plugin. This is the bulk of the catalogue and it grows with the engine.
- Native ClaudusBridge toolsets. More than a dozen hand-written C++ toolsets for the things reflection does not reach. They are UToolsetDefinitions too, so they flow through exactly the same registry and adapter path as the engine's.
- Your own ToolLibrary Blueprints. Subclass UClaudusBridgeToolLibrary, add a public function with a doxygen tooltip, and it auto-registers as a tool with a generated schema. For new C++ work the recommended path is authoring a UToolsetDefinition directly.
The engine domains
- Actors and world: spawn, transform, attach, select, delete, query the level, read back transforms and components.
- Blueprints: create classes from a parent, add variables, functions, components and events, set defaults, compile and save.
- Materials: create materials and instances, add and connect expression nodes, expose parameters, set overrides.
- UMG and widgets: create Widget Blueprints, build and nest the widget tree, set slot layout and properties, compile.
- Niagara: create and configure systems and emitters.
- Sequencer: create level sequences, add tracks and keys, drive cinematics.
- Assets: import, find, duplicate, organise and inspect Content Browser assets.
- Levels: open, stream, save and organise maps.
- Textures: create and edit textures and render targets.
The toolsets ClaudusBridge writes itself
- MaterialGraph, 15 tools. Read a fully resolved graph with DescribeMaterialGraph, then author it: ConfigureCustomNode for Custom HLSL, ConfigureParameterNode, ConfigureFunctionIO, ConnectMaterialExpressions, ConnectMaterialProperty, CreateNamedReroute, SetExpressionPositions, DeleteMaterialExpression.
- MaterialInstance, 5 tools, and MaterialAudit, 4 tools. Reparent instances, set parameters and static switches, copy overrides, and audit which materials under a path actually use a given parameter.
- Niagara script graphs, 13 tools, and NiagaraSystem, 9 tools. Author module and function script graphs including Custom HLSL and includes; manage user parameters, data interface bindings, and non-blocking compile state with GetNiagaraCompileStateFast, RequestNiagaraCompile and WaitNiagaraCompile.
- Orchestration provides a job queue, agent sessions, enforced package locks and GetEditorBusyState. Scheduling tracks long-running work; synchronous engine calls can still occupy the game thread.
- Multi-User discovers Concert sessions, manages participation and exposes presence controls. Distinct editor participants need separate project roots; the same-root helper refuses an existing project writer.
- Simulation tools inspect pawns, movement and physics in an appropriate world or play context. A hidden tool backend does not replace a configured gameplay or PIE session.
- Asset, 8 tools, and Level, 6 tools. FindAssets, GetAssetInfo, MakeUniqueAssetName, DuplicateAsset, dependencies; SaveCurrentLevel, SaveAllDirtyPackages, PersistSessionChanges, OpenLevel, CreateFolder.
- BlueprintComponent, 3 tools, and BlueprintToCpp, 4 tools. Live component edits on a Blueprint's construction script, and analysis plus C++ struct and actor scaffolding with reparenting.
- Image tools save, export and display images in supported contexts. Reflection describes classes and objects, reads and changes supported properties, invokes reflected functions, creates objects and explicitly saves packages through Unreal.
- Chess, 13 tools. A self-contained 3D board with autonomous play and agent camera control, shipped as a showcase of how far a native toolset can go.
How the agent picks a tool
Tool-search mode exposes list_toolsets, describe_toolset and call_tool for progressive discovery; timeline tools may also be present. Eager registration remains optional. Use toolset_name, tool_name and arguments from the actual schema when dispatching a tool.
Against the 5.7 generation
| Feature | Before | Oceanology Pro |
|---|---|---|
| How tools are produced | Hand-written C++ wrappers, one per capability | Generated from reflection, with hand-written natives only where reflection cannot reach |
| Catalogue size | 567 or more tools in 50 or more categories | Live tool catalog determined by the project and enabled plugins |
| What the client sees | The full tool list registered up front | list_toolsets, describe_toolset and call_tool, with eager mode optional |
| Undo safety | Snapshot and transaction tools the agent had to remember to call | Tool-specific transactions with explicit persistence and post-edit verification |
| Parallel agents | Coordination bus and watcher sub-agent | Job queue, enforced ownership, persistent sessions and observable backend activity |
| Tools | Discover with toolsets and describe |
|---|---|
| Toolsets | Depends on enabled project and engine plugins |
| Native C++ toolsets | More than a dozen, shipped in the plugin |
| MaterialGraph tools | 15 |
| Niagara script-graph tools | 13 |
| NiagaraSystem tools | 9 |
| Orchestration tools | 12 |
| Multi-User tools | 11 |
| Simulation tools | 8 |
| Agent coordination | Persistent identity, sessions, policy and package leases |