@Amadev

Preview Artifacts, Bridge Recovery & Prefab Workflows

Added reproducible animation preview artifacts with stored records and comparison tools for repeatable QA.Improved Unity bridge recovery during reloads/recompiles, added retry hints and safer timeout handling.

Added real Unity E2E animation fixtures and reorganized the test suite.Finished the v0.1.3 release, refreshed the README/docs, and started v0.1.4 prefab workflows.

Added inspect_prefab_asset and inspect_prefab_overrides with native Unity services, support for nested/variant/model prefabs, structured override inspection, stable IDs, and Python/integration/EditMode test coverage.

Worked on a large animation/character workflow update for Visora.

Added dedicated agent workflows for animation authoring, camera/action sequences, rig retargeting, IK, gaze, motion polishing, contact handling and animation QA. Updated the MCP instructions and project docs so agents have a clear workflow for checking rigs, previewing animation, validating motion and handling Humanoid/Generic fallback cases.

Implemented new animation tooling around Two-Bone IK, viewport-based effector placement and character gaze. Added support for solving and baking IK/gaze into animation clips, including parameter validation and Unity capability checks.Added a bigger QA layer for animation. This includes temporal motion analysis, curve discontinuity diagnostics, self-intersection checks and comparison of animation previews. Also added contact baking for things like planted feet/hands and camera-subject action tooling for synchronizing character motion with camera impacts.

Added atomic animation transactions and improved rollback/backup handling so multiple animation edits can be applied together and reverted safely when something fails. Refactored the Unity-side animation services around shared sampling, curve writing and rollback helpers.

Spent a good amount of time hardening all of this against actual Unity edge cases: Edit Mode requirements, unsupported bridge capabilities, invalid parameters, unknown diagnostic values, quaternion discontinuities, tangent preservation and proper exception handling.

Added a Unity EditMode integration test suite covering IK, gaze, contact baking and atomic animation transactions, together with a runner script. Expanded the Python unit tests for the new animation tools and failure cases as well.Also reworked Visora’s visual output. Screenshots, animation previews and video frames now use multimodal MCP image blocks and file artifacts instead of dumping Base64 data into the response. Multi-frame previews can generate contact sheets, and full-resolution artifacts stay on disk.

After that I focused heavily on MCP context usage. Compact tool definitions reduced the tool catalog payload significantly, diagnostic tools now have limits/filtering for large skeletons and clips, tool results are compacted, duplicate structured output is removed, and several redundant tools/wrappers were merged or deleted. The tool catalog went from 55 tools down to 44.

Merged the two separate video capture tools into a single capture_video workflow and reduced the default screenshot resolution to 720p. Inline images are now automatically downscaled while keeping the full-resolution artifact available separately.

Finally tuned the default diagnostic dump sizes further so normal tool calls consume much less agent context and larger detailed dumps are requested only when they are actually needed.

Editing Animation Clips & Events

Hey everyone, continue working on it.

Up until now, the agent could only really watch animations—taking previews and checking poses. If a keyframe was off or a transition looked janky, you still had to go into Unity and fix it by hand. Now, the agent can actually edit AnimationClip assets directly. It can add, move, or delete keyframes, tweak curves, and set tangent modes like smooth, linear, or step holds.

Giving an AI write access to your animation files is honestly a bit scary—one bad curve and your character turns into a noodle. To keep things safe, Visora now takes an automatic backup of the clip before touching it, and hooks every edit into Unity’s native Undo system. If the agent makes a mess, you can roll it back with a tool call or just hit Ctrl + Z right in the editor.

We also added tools to create and remove animation events. This makes it way easier to sync things like hit-stops, camera shake, or footstep sounds to exact frames on the timeline instead of guessing with timers.

Visora v0.1.3 — Giving Agents Eyes on Unity Animations

So, we just fixed a massive problem. Once I hit merge, a huge weight lifted off my shoulders. It feels like the raw volume of code I write is getting smaller each time, but what actually lands has a massive, cascading impact on the entire system.Until now, whenever an AI agent needed to inspect an animation in Unity, it was basically flying blind. The old approach was either pulling raw curve data (which tells an agent nothing about clipping, silhouette, or visual feel) or recording full video dumps over the HTTP bridge. Video was heavy, expensive on tokens, slow to transfer, and worse: if the camera wasn’t manually lined up in the scene, the character would just walk right out of frame or get clipped halfway through. With Visora v0.1.3, we tackled this head-on by building preview_animation. It’s not just a snapshot tool — it’s a complete visual pipeline designed specifically for agent context budgets.

What Actually Changed Under the Hood

Trajectory-Aware Auto-Framing (C# Engine Side) Instead of relying on whatever camera happens to be in the scene, Visora now spins up a transient preview camera. Before snapping a single frame, it samples the clip across its timeline, collects every active skinned and mesh renderer, and computes a union bounding sphere for the entire motion trajectory.
It places the camera at an ideal 45° vantage point, automatically calculates the optimal distance based on camera FOV, and dynamically compensates for vertical vs. horizontal aspect ratios so tall or wide aspect ratios don’t clip the character’s head or limbs.

Smart Keyframe Selection (Python Side) Agents can’t look at 120 raw frames — that would incinerate context windows and latency. We built an intelligent keyframe extractor (preview_keyframes.py) that analyzes the clip curves to find where actual motion happens: curve extrema, zero-crossings, sudden velocity changes, and animation event timestamps. It pins the start and end poses, then fits the most informative frames within a strict frame budget (e.g. 4 to 8 images).

Zero-Side-Effect Scene Safety One of the hardest parts of building agent tooling for Unity is engine hygiene. The preview system samples the animation, renders offscreen to a custom RenderTexture, encodes directly to PNG byte buffers, and cleans up after itself. No dummy cameras left in the hierarchy, no dirty scene flags, and character poses are strictly restored to their pre-sampling state.

Hardened CI & The Unity Package Gate We also tightened our pre-commit and CI gates. We introduced scripts/check_unity_package.py, compiling the C# package directly against real Unity assemblies with Microsoft.Unity.Analyzers in headless Linux containers. If there’s an obsolete API, a loose memory allocation, or a CA analyzer warning, the build fails before it ever touches a project.

It feels great to have this merged and rock-solid. With animation visual inspection out of the way, I’m heading straight to the next item on the Roadmap: Typed Clip, Event, and Camera Authoring!

Visora devlog — v0.1.1 & v0.1.2

Shipped two releases back to back.

Visora now has a proper open-source foundation: an Apache-2.0 license, full contributor and security docs, a hardened Docker image, and a complete CI pipeline that tests every change and publishes releases automatically.

v0.1.1 was about infrastructure — agents can now search the web for 3D models, environments and rigs and import them straight into a live Unity project, plus all the CI/CD and Docker groundwork.

v0.1.2 was about packaging and community — licensing, PyPI metadata, issue templates, contributor guides, and release integrity checks. You can now just pip install visora.

And here’s the first real demo. A 2-second shot: a Rover-style character from Wuthering Waves throws a flying kick straight into the camera in a desert wasteland. The environment, the rig, the animation and the capture were all built by an AI agent driving a live Unity Editor through Visora — nothing hand-placed.

The whole thing was made by Claude Sonnet 5, using about 20% of the 5-hour limit on the $20 plan. So a mid-tier model, for a fraction of a cheap subscription, can already take a scene from empty to finished shot on its own.

Right now it’s 2 seconds — deliberately small, to set the floor. The goal is for Visora to grow into something where AI can build full, directed animation sequences: minute-long shots, multiple characters, real rigging, proper timelines. “Make me a cutscene” turning into an actual cutscene. This dropkick is just the starting line.

Production CI/CD and MCP 2.0 are now complete for Visora.

The project now has a parallel GitHub Actions pipeline covering formatting, Ruff linting, strict mypy checks, unit and integration tests, lockfile validation, Unity package validation, distribution builds, and an enforced 80% coverage threshold.

The workflows use uv caching, cancel outdated runs automatically, and skip runs for documentation-only changes. All GitHub Actions are pinned by commit SHA.

A release pipeline now validates version tags, runs the full verification suite, builds the package, publishes it to PyPI, and creates a GitHub Release.

Dependabot was added to update GitHub Actions and Python dependencies weekly. Funding configuration was added as well.

Visora was migrated from MCP 1.x to MCP 2.1.1, replacing FastMCP with MCPServer and updating the related tests and documentation.

The updated Dependabot pull request passed every CI check and was merged. The Production CI/CD roadmap item is now marked as completed.

Visora devlog — asset pipeline & Unity native bridge (18 commits)

Asset pipeline: from broken to trustworthy

Built out the 3D-asset workflow (search → download → import → verify) and then spent most of the effort hardening it against silent failures:

Added asset search/download/Unity-import tools (1a0bcd3, bf6a7d9), then refactored out dead backward-compat aliases (dda6c17).

Fixed real bugs found by actually running it: ambientCG downloads being wrongly rejected and Sketchfab results silently hidden (99d3f15), a wrong ambientCG download URL for 3D models (1d6e2ce), a crash on comma-separated port lists plus missing env-var docs (117e6e3), and .bin/.mtl companion files being incorrectly stripped out of glTF/OBJ archives (5cb1afa).

Discovered Sketchfab’s own search API ignores the query text entirely (verified live) — added web_search_assets, a SearXNG-primary/DuckDuckGo-fallback real web search to find a specific named model and extract its Sketchfab UID (4489725).

Biggest find: download_and_import_asset was reporting success=true even when Unity couldn’t actually parse the file (glTF with no importer installed → empty placeholder asset). Fixed to detect and reject that case explicitly instead of lying about success (8c4241b).

Native Unity bridge: first real compile & runtime test
com.visora.editor had apparently never been compiled in a real Unity Editor before. Opening it in Unity 6.6 surfaced a chain of genuine bugs, fixed one at a time: A broken float field that Unity’s JSON deserializer can’t handle, flattened to float on both C# and Python sides (08f502e, 4d05468).

Unity 6.6 API removals: GetInstanceID() → GetEntityId() (c8c8905), then GetEntityId()’s own obsolete int-conversion operator → GetRawData() (027e39c).

Two HTTP handlers (/api/editor/state, /api/visora/info) and a log-callback subscription were calling Unity APIs off the main thread, causing runtime errors — dispatched onto the main thread (d27e03f, 5e3069b).

Dynamic C# snippet compilation was missing a reference to UnityEditor.CoreModule, breaking any snippet touching EditorApplication/EditorSceneManager (a8689a9).

Agent guidance
Shipped documentation aimed at other agents driving Visora, not just humans: an always-on MCP instructions block plus a copyable Claude Code skill (visora-asset-workflow) covering Sketchfab’s broken search, supported import formats, and how to actually verify an import worked (4e8cd5c).

Housekeeping
Committed the 29 .meta files Unity generated on first real import of the package — standard Unity convention, and further confirmation the package had never been opened in a real editor before this round of testing (b9e4f01).

Net effect: the asset import pipeline no longer lies about success, Sketchfab search actually works for named models, and the native Unity bridge compiles and runs cleanly on Unity 6.6 — all verified end-to-end (ambientCG apple + a Sketchfab character model imported, inspected, and visually confirmed in-scene).

Building Visora: Teaching AI agents to actually see and fix Unity scenes (v0.1.0 update)

Quick update on what I’ve been hacking on for Visora since adding the project banner.

The problem I ran into: If you try to let an AI agent (like Claude or Cursor) work inside Unity, it’s usually a disaster. Current bridges just let the model run raw C# strings and read console logs.The agent is completely blind. It doesn’t know if a 3D character spawned behind the camera, if an animation is flying off into infinity, or if a model looks like a spiky mess because bone weights are broken. Even worse, agents love to edit things during Play Mode or hit save while Unity is recompiling, completely wrecking the scene files.I got tired of babysitting that, so I built Visora — a Python MCP server and a companion Unity package that gives agents actual eyes, rigging smarts, and guardrails so they don’t break your project.

V0.1.0 —

Here is what I’ve coded and got working over the last few days:

1. Gave the agent actual vision. The agent can now render screenshots from any camera in the scene, check if a character is cut off by the screen edges or clipping planes (project_world_points and diagnose_camera_framing), compare before/after images, and even record short MP4/WebP video clips to inspect physics and animations over time.

2. Made it understand rigs and animations. Instead of guessing why an animation looks wrong:
   It inspects AnimationClip curves directly and catches unwanted position or scale drift.
   It can sample any character’s pose at a specific second, inspect the transforms, and immediately restore the original pose so nothing stays messed up.
   Added a skeleton mapper with fuzzy bone search that understands both standard Humanoid rigs and messy Japanese MMD bone chains (like 全ての親, センター, 下半身, D-bones).

3. Skinned mesh diagnostics Added tools to inspect SkinnedMeshRenderers. It detects inverted or zero-sized bounding boxes, missing root bones, and broken bone weights. It also tells you whether a glitch is just a missing material/texture or an actual broken mesh deformation.

4. Made scene edits safe (undo & transaction rollback). Every script the agent runs now happens inside an isolated Undo group. If the C# code crashes or throws an exception, Visora automatically rolls back the entire scene to before the run. It also blocks saving during Play Mode so your scene never gets corrupted.

5. Native Unity package + 24 typed tools Built a native Unity Editor package (com.visora.editor) using HttpListener hooked directly into Unity’s main editor update loop. On the Python side, I implemented 24 clean MCP tools with strict Pydantic schemas, auto-discovery for ports 8080-8085, and async queue polling for long tasks.

Tagged and released v0.1.0 on GitHub with complete setup guides, agent recipes, and test coverage.

What I’m building next for v0.1.1:

Auto 3D model web search & download: I want the agent to search the web, find 3D models, textures, and environments, and download/import them directly into the Unity project so it can build and animate entire scenes on its own.

Clean GitHub Actions CI/CD: Automatic linting, typing, and test runners on every commit.

Docker support: A lightweight Dockerfile to easily run the MCP server anywhere in a headless container.

You can check out the code and the v0.1.0 release here: https://github.com/AmaLS367/Visora