Unreal Engine Plugin

The Tonetta plugin for Unreal Engine 5.8+ puts the whole Tonetta workflow inside the editor and turns the results into assets: USoundWave for audio, and — since plugin 2.3 — skeletal or static meshes with textures, a material instance, a physics asset, and animation clips for 3D models. It talks to tonetta.io over HTTPS with your API key — nothing else to run.

• •Unreal Engine 5.8 or newer. The plugin builds on the engine's ToolsetRegistry plugin, which ships with 5.8 and is enabled automatically.
• •A C++-capable project (the plugin compiles from source), Git, and Visual Studio / Xcode as for any UE C++ project.
• •A Tonetta account and an API key for the editor — plus, only if your game fetches live endpoints at runtime, a second read-only key (see below). Generation spends credits.

1. 1Clone the plugin into your project's Plugins folder:

   cd /path/to/YourProject/Plugins
   git clone https://github.com/kevinpbuckley/tonetta.git Tonetta

2. 2Build the editor target as usual — right-click the .uproject → Generate Visual Studio project files, then build YourProjectEditor. (Projects using VibeUE can run its BuildAndLaunchGame.ps1 instead.)
3. 3Open the editor, go to Edit ▸ Plugins ▸ Audio ▸ Tonetta, enable it, and restart when asked.
4. 4Later, update with git pull inside Plugins/Tonetta and rebuild.

The editor needs a full-scope development key. A shipped game normally needs no key at all — imported USoundWave assets play like any other sound and nothing talks to Tonetta at runtime. The only exception is a game that fetches live endpoints while running: that gets a separate, read-only shipping key, because Config/DefaultGame.ini is packaged inside your game and anything in it can be read out of a shipped build.

A live_endpoints:read shipping key can fetch cached live-endpoint audio but can never create, delete, or spend credits, so a leaked key costs you nothing. The Public TTS API treats it as cache-only: cached audio is served, generation is never triggered. Warm every live endpoint once from the editor or the dashboard before you ship.

1. 1Go to Dashboard ▸ API Keys and create a development key with the scopes you want in the editor.
2. 2Only if your game uses live endpoints at runtime: create a second, shipping key with only live_endpoints:read.
3. 3Paste each into its slot in Project Settings (next section). Leaving a scope out later shows up as a missing_scope error in the panel — add it to the key here, no plugin change needed.

Two sections under Project Settings ▸ Plugins (the panel's Settings button opens the first):

The same values as ini files, if you prefer editing text:

; Config/DefaultEditor.ini — never packaged
[/Script/Tonetta.TonettaEditorSettings]
DevelopmentApiKey="tk_dev_..."

; Config/DefaultGame.ini — ships with the game
[/Script/Tonetta.TonettaSettings]
ApiBaseUrl="https://tonetta.io"
ShippingApiKey="tk_readonly_..."

Open Tools ▸ Tonetta. The header reads Connected as <key name> plus which key is in use, or an error that says what to fix.

1. 1New Project — a project is the workspace voices, characters, and content belong to. A fresh organization has none; create one and it becomes the selected project.
2. 2Voices — describe a voice in Voice Studio, Design Voice, listen to the previews, save the one you like (spends credits); or link an external provider voice (ElevenLabs, OpenAI, Google, Resemble) into the project for free.
3. 3Characters — bind a voice plus persona/tone instructions; Listen auditions it.
4. 4Lines — pick a character, write a line (or a prompt like "warn the player about low oxygen"), optionally Rewrite for free with Character Enhancement and Expression markup, then Generate. Import puts the active version at <Import Root>/Lines/<name> as a USoundWave.
5. 5SFX — describe a sound, set the duration, Generate, Import to <Import Root>/SFX.
6. 6Music — describe a track, pick a model, set the length, Generate, Import to <Import Root>/Music. Billed per generation, not per second, so ask for the length the game needs.
7. 7Models — describe a hard-surface asset, pick which language model builds it, and Generate. The prompt is the whole specification: the agent decides the asset's name, its rig — static, or one of the rig contracts in force for your organization and project — its style and its weathering from what you wrote. The job runs on Tonetta's servers for a few minutes; the screen lists active jobs with their stage, round, and latest preview render, and a Cancel. When it finishes, Import puts everything under <Import Root>/Models/<Name>/: SK_<Name> (or SM_ for static presets) with its skeleton, the textures, MI_<Name> on the master material, a physics asset, and A_<Name>_<Clip> per clip.

Generated TTS, SFX and music are MP3, ElevenLabs TTS is WAV; the importer sniffs the real format from the bytes, so mislabeled legacy entries still play and import.

• •Imported assets are the normal path: generate and import in the editor, reference the USoundWave from Blueprints or C++ like any other sound. Nothing talks to Tonetta at runtime and the shipped build needs no API key.
• •Live endpoints go through UTonettaSubsystem (GameInstance subsystem): ProcessTonettaRequest returns the cached line or your fallback sound immediately and refreshes the cache in the background. Blueprint access via UTonettaBlueprintLibrary. The cache lives in Saved/TonettaCache/.
• •This is the one case a shipped build needs a key: packaged builds authenticate with the read-only shipping key, so the server serves cached audio only. Fetch each endpoint once from PIE or the dashboard preview before shipping; an endpoint with no cached audio returns 403 and the subsystem plays the fallback.

FTonettaRequest Request;
Request.LiveEndpointId = TEXT("my-endpoint-id");
Request.DefaultSound = FallbackSound;
Request.DefaultText = FText::FromString(TEXT("Fallback text"));

FTonettaResponse Response =
    GetGameInstance()->GetSubsystem<UTonettaSubsystem>()->ProcessTonettaRequest(Request);
// Response.Sound / Response.Text are ready immediately (cache or fallback).

Three different links exist; the plugin itself needs only the first.

Tonetta.GenerateAgentConfig ClaudeCode

import unreal, json
svc = unreal.TonettaService
def call(fn, *args):
    r = json.loads(fn(*args))
    assert r.get("success"), r.get("errors")
    return r["result"]

print(call(svc.verify_access)["scopes"])
project_id = (call(svc.list_projects) or [call(svc.create_project, "My Game")])[0]["id"]
d = call(svc.design_voice, "A gravelly old sea captain, weathered and warm")
v = call(svc.save_internal_voice, "Sea Captain", d["requestId"], d["previews"][0]["url"], "A gravelly old sea captain")
c = call(svc.create_character, "Captain Marlow", project_id, v["id"], "Weary but kind. Dry humor.")
rw = call(svc.enhance_text, c["id"], "Dive! Dive! All hands to stations!")
line = call(svc.generate_speech, c["id"], rw["textToSpeech"], "dive-order", "", rw["textToScreen"])
print(call(svc.import_content, line["savedContent"]["id"])["assetPath"])   # /Game/Tonetta/Lines/dive-order

# 3D model: submit, wait (long-polls in 240 s slices), import
job = call(svc.generate_model, "twin-engine attack submarine, angular hull, forward laser cannons",
           project_id, "glm-5.3-flash")          # the prompt is the whole specification
while True:
    j = call(svc.wait_for_model_job, job["jobId"], 240)
    if j["done"]: break
assert j["status"] == "SUCCEEDED", j.get("error")
imported = call(svc.import_model, j["contentId"], "", "", True, True)
print(imported["assetPath"], imported["materialPath"], imported["animationPaths"])   # /Game/Tonetta/Models/Harrower/SK_Harrower …