# anitya Engine: AI-Native Foundation

Unity and Unreal are powerful, but they weren't designed for visual creators nor for AI agents. They were built for human developers who understand implicit state, can debug crashes, and tolerate opaque workflows. This architecture breaks down completely when you try to let AI agents create autonomously.

Here's why:

**Opaque State Management:** Traditional engines maintain state in ways only humans familiar with the codebase can navigate. An AI agent can't query "what objects are in the scene?" or "what behaviors are attached to this asset?" without parsing complex data structures or reading source code. There's no machine-readable representation of scene logic.

**Black Box Execution:** When you submit code to Unity/Unreal, it either works or it crashes. There's no intermediate feedback. An AI agent generates a script, crosses its fingers, hits "run," and hopes for the best. If something breaks, there's no clear path to debugging. Just try again with different code.

**Undefined API Surface:** These engines expose thousands of functions with complex interdependencies. Some combinations cause crashes. Others have performance implications that aren't documented. An AI agent has no way to know which operations are safe, which are expensive, and which will bring the whole system down.

**Local Installation Requirements:** Unity/Unreal require local installation with specific versions, dependencies, and configurations. This means every AI agent needs its own development environment, a massive overhead that prevents agents from spinning up on-demand in cloud environments.

**The result:** AI can generate 3D assets, but it can't orchestrate full 3D experience creation. Creators are stuck manually integrating AI outputs, debugging errors, and stitching together workflows that should be automated.

## The anitya Solution: AI-Native Architecture

We are rebuilding the stack from first principles around a single question: What would a 3D engine look like if AI agents were first-class users, not an afterthought?

### **1. Browser-Native Deployment**

The entire anitya platform runs in a web browser. No downloads, no installations, no version conflicts. A creator opens a URL and starts building immediately.

**Technical implementation:** We built on Godot Engine and compiled it to WebAssembly (Wasm). Because Godot is open-source, we have complete access to its C++ core, allowing us to optimize specifically for browser performance. The engine runs natively in the browser without sacrificing power: full physics, lighting, scripting, everything.

**Why this matters for AI:** A browser-native engine is a standardized, sandboxed, cloud-deployable environment. An AI agent doesn't need local setup. It just spawns a browser instance, loads the engine, and starts creating. The environment is reproducible: every agent works in an identical sandbox, eliminating "works on my machine" problems.

This is the foundation. Everything else builds on the fact that our engine is accessible via URL, not locked behind installation barriers.

### **2. Transparent State via Behavior Graphs**

Every interactive behavior in an anitya scene is represented as a node in a behavior graph. Want a button to trigger an animation? That's a node. Want proximity to play a sound? Another node. The graph defines the scene's logic in a structured, machine-readable format that's always visible and queryable.

**For human creators:** This provides an intuitive drag-and-drop workflow. No code required. Just connect nodes to create complex interactions.

**For AI agents:** This provides a clear, machine-readable representation of scene logic. An agent can query the behavior graph to understand:

* What objects exist in the scene
* What behaviors are attached to each object
* What parameters each behavior accepts
* What events trigger which actions
* How objects interact with each other

The agent doesn't need to parse code or reverse-engineer state. It queries the graph, gets a structured response, and acts accordingly.

**Example query:**

```javascript
// AI agent asks: "What happens when user clicks object_A?"
const behaviors = scene.getBehaviors('object_A');

// Returns: [{type: 'on_click', action: 'play_animation', target: 'object_B'}]
```

This eliminates guesswork. The agent has perfect visibility into scene logic, enabling autonomous decision-making without human intervention.

### **3. Real-Time Feedback Loops**

Every action in anitya (whether initiated by a human or an AI agent) results in an immediate visual update in the 3D viewport. This creates a tight feedback loop that allows both humans and agents to validate their work instantly.

**Traditional workflow:**

1. Write code
2. Submit to engine
3. Wait for compilation
4. Hope it works
5. If broken, guess what went wrong and try again

**anitya workflow:**

1. Call API function
2. See result immediately in viewport
3. Validate visually
4. Adjust next action based on observable evidence

This is transformative for AI agents. Instead of generating entire scripts and hoping for the best, the agent can work iteratively:

* Place object, verify position looks correct
* Attach behavior, test trigger, adjust parameters
* Add lighting, check shadows, fine-tune intensity

The agent has "eyes" to see what it's building. This enables a level of precision impossible in traditional engines where agents work blindly.

### **4. Bounded API Surface**

We don't expose the raw engine API to AI agents. Instead, we provide a **Bounded API Surface**: a curated set of high-level, semantic functions that are safe, powerful, and deterministic.

**Why this matters:**

**Security:** The agent can't manipulate memory addresses, alter rendering pipeline, or access system resources. All operations are sandboxed and validated.

**Performance:** Every API function is optimized. The agent can't accidentally write O(n²) logic or trigger expensive operations unknowingly.

**Reliability:** Functions are deterministic. Same inputs always produce same outputs. No hidden state, no side effects.

**Developer Experience:** The API is learnable. An AI agent (or human developer) can understand the entire surface in minutes, not months.

This acts as a security "moat" while maintaining full creative power. Agents can build anything. They just can't break anything.

### **5. MCP Compatibility**

The Model Context Protocol (MCP) is an emerging open standard for AI-to-tool communication, developed by Anthropic. It defines how AI agents can interact with external tools in a standardized way.

**The problem MCP solves:** Every AI agent currently uses custom integrations for every tool. Claude has one API for file systems, a different one for databases, another for calendars. This doesn't scale.

**MCP's solution:** A universal protocol for tool interaction. One standard interface for all tools.

**anitya's implementation:** We are implementing MCP natively, making anitya the first no-code 3D engine that AI agents can interact with through a standardized protocol.

**What this enables:**

**Autonomous Workflows:** Instead of a creator prompting an agent ("create a lighting setup"), the agent autonomously understands context, makes decisions, and executes multi-step operations.

**Agent Marketplace:** Third-party developers can build specialized agents (lighting, physics, character rigging) that work with anitya out of the box. No custom integration needed.

**Future-Proof:** As MCP becomes adopted across the AI ecosystem, anitya automatically benefits. Any MCP-compatible agent can interact with anitya.

**Example workflow:**

```markdown
Creator: "Set up this scene for a dramatic presentation"
Agent (autonomous execution):
1. Query scene, understand objects and layout
2. Analyze lighting, determine mood requirements
3. Place key lights, validate shadows in real-time
4. Add camera paths, ensure all objects visible
5. Fine-tune timing, optimize for pacing
6. Present result, creator approves or adjusts

Total time: 45 seconds
Traditional workflow: 2-3 hours
```

This is the shift from generative AI (create on command) to agentic AI (understand goals and execute autonomously). And it's only possible because the engine was designed for it from the start.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://anitya.gitbook.io/lightpaper/welcome/anitya-engine-ai-native-foundation.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.