DOCUMENTATION / GETTING STARTED

Get AIRuntime running.

Start with a small example that reads a file without an AI account. Then connect your chosen AI service. This guide is for people who already use Unity; the C# section is optional unless you want to build your own integration.

External services: hosted inference requires your own account, credentials and any applicable usage payments under the provider's terms. No model weights or inference hosting are included. The offline example needs no account or network connection.

01 / Install the package

The validated target is Unity 2022.3.30f1 on Windows Editor. Other versions and player platforms are not yet verified.

In Window → Package Manager, install these dependencies by name:

The Editor assembly references Test Runner, so Test Framework is required even when you do not run the tests. Retain the built-in Unity modules for UnityWebRequest, IMGUI, UI, UIElements, physics, physics2d, audio, animation, image conversion, screen capture and JSON serialization.

Import the package, then wait for compilation. All shipped assets live under Assets/AIRuntime.

02 / Run without a model

1. Select Window → AIRuntime → Examples → Run Offline Tool Loop.
2. The Console should report AIRuntime offline example PASS with exactly one tool call.
3. For the scene version, open Assets/AIRuntime/Examples/OfflineToolLoop.unity, enter Play Mode and click Run offline demo.

The example creates a temporary workspace, writes test.txt, lets FakeProvider request a read, and verifies the structured result. The temporary workspace is removed afterwards. This proves the offline tool path; it is not live-inference evidence.

03 / Build from C#

The example implementation is in Runtime/Examples/OfflineToolLoop.cs. Its central calls look like this:

var runtime = new AIRuntime.Runtime.AIRuntime(workspace);
runtime.RegisterCapability(new ReadFileCapability());
runtime.UseProvider(new FakeProvider());

AgentRunResult result = await runtime.RunAsync(
    "Read test.txt", cancellationToken);

This excerpt assumes an existing workspace containing test.txt, the relevant namespace imports and a cancellation token. The complete shipped example handles setup, cleanup, timeout and result checking.

Your application owns the UI, lifetime, cancellation and deployment credentials. Register only the capabilities you need. Never embed a provider secret in source, scenes, Resources or a distributed client; use your own backend for secret-bearing hosted access.

04 / Explore the Editor tools

• Window → AIRuntime → Chat Console: choose a provider, endpoint and model. Enter your credentials where needed. Try a short message with tools disabled first.
• Window → AIRuntime → Kanban Agents: configure agent profiles for project work.
• Window → AIRuntime → Kanban: manage tasks and inspect outcomes.
• Window → AIRuntime → Agent Activity: inspect agent execution activity.

Use a backed-up or version-controlled test project. Agents with enabled write tools can modify scripts, scenes and assets. A completed task or automated review does not establish that a game works; inspect the result and run appropriate tests.

Adapters are included for OpenAI, OpenRouter, Nous Portal, NVIDIA Developer and local AI through Ollama. To use local AI, run a model with Ollama on your computer, then select Ollama in AIRuntime and configure its endpoint and model name. You supply the model and suitable hardware; model files are not bundled with AIRuntime. Accounts, hosting and model availability are separate. Not every model supports tool calls or the same request options. Package installation and removal are manual; the agent tools do not perform those operations.

Kanban: organize tasks

Open Window → AIRuntime → Kanban. Think of the board as a shared to-do list for you and your AI assistants. Each card represents a task, with a goal, an assigned assistant and a status.

The agent sidebar shows what each assistant is doing or waiting for. Open task details to inspect results and review information. Work can wait on another task or require attention after a provider error or failed check; the board helps make those situations visible.

Kanban Graph: see the connections

Open Window → AIRuntime → Kanban Graph. This is the node view of the same task board. Each circle is a task; its colour shows its status. Lines explain how tasks relate:

• Cyan: parent and child tasks.
• Orange: dependencies—work that needs another task first.
• Red: blockers.
• Purple: associated tasks.

Drag a circle to reposition it, drag empty space to pan, and scroll to zoom. Hover a task to highlight its connections, or double-click it to open details. Auto Layout arranges the network; Fit adjusts the view. Relationship toggles let you choose which connections to show.

Rearranging the graph does not change task dependencies, execution order or whether agents are running. It helps you understand the work rather than control execution by drawing a layout.

Multiple agents: share out the work

Configure multiple assistants in Window → AIRuntime → Kanban Agents. Give each agent a profile with its chosen model and permitted tools, then assign tasks on the board. For example, different assistants can handle implementation and review.

The Kanban board and Kanban Graph show the shared work, including dependencies and waiting tasks. Scheduling still respects task readiness, agent availability and Unity state; adding agents does not mean every task runs at once.

Fallback providers: choose your backups

Provider fallback is an ordered chain of configured providers for an agent. When a request encounters a supported failure, AIRuntime can try the next provider in the chain. Examples include timeouts, rate limits and an unavailable service.

Configure the endpoint, model and any required credentials for each backup. Model capabilities can differ, and hosted backups may incur their own usage costs. Invalid requests, cancellation and unclassified errors stop the default chain rather than switching providers.

Provider fallback changes which service handles a request. Kanban also supports separately configured agent fallback, where another agent can take over eligible implementation work.

Data, credentials & limitations

What can leave the project?

Hosted requests can contain prompts, conversation history, tool schemas and tool results. Enabled capabilities can read project files or scene/component data, which may become tool results sent to the selected provider. Provider retention and training practices depend on the service and your account terms.

Where are keys stored?

Agent configuration export can serialize the API key in plaintext JSON. The Chat Console defaults to Documents/AIRuntime/architect/agent.json, with a project-root fallback if Documents is unavailable. User-selected paths and other workflows can differ. Keep these files outside Assets and version control. A masked field is not encryption.

What about logs and history?

Debug output, Unity logs, board memory and conversation history can contain prompts, tool results and project data. The Ollama adapter warns about request/response body logging. Redact private data and credentials before sharing diagnostic material.

What has been validated?

The release candidate passed 1,033 offline EditMode tests, the offline tool-loop check and 34 Asset Store validator checks on Windows Editor with Unity 2022.3.30f1. This does not establish live-service reliability, visual acceptance, Asset Store approval or player-platform support. Player builds, IL2CPP, WebGL, mobile, macOS, Linux and newer Unity versions require separate testing.

Permission policies constrain registered capability execution. They are not an operating-system sandbox. Model output and generated code can be incorrect; retain backups and review changes.

This website

This website does not include application analytics, sign-in or external fonts. It is hosted by Cloudflare, which processes requests to serve and protect the site. Clicking the support address opens your email application; no support message is sent automatically.

Troubleshooting

• Missing Newtonsoft or TestRunner assembly: install the dependencies above and let Unity finish compiling.
• Authentication/model error: check the endpoint, model access and account. Repeated retries do not fix invalid credentials.
• Tool call fails: inspect capability registration, enabled tools, arguments and permission settings.
• Paused card or provider cooldown: inspect its failure details and configuration before resuming.
• Offline example fails: read the first Console error. This example should not contact a hosted service.

Made with AI, guided by a human

100% made by AI, with real human guidance. AIRuntime is an AI-made project directed by a real person. This credit applies to AIRuntime; Unity, its third-party dependencies and connected services have their own authors and licenses.

Support from Voltron

Email mjdust.defender@gmail.com with the Unity version, operating system, reproduction steps and redacted error output. Do not attach API keys or private project content.

Detailed architecture, scheduling, graph, fallback and memory references are included under Assets/AIRuntime/Documentation/Reference.