Layer2Rig Lab

Inspiration

I started Layer2Rig Lab because I wanted to turn layered character artwork into Live2D models more efficiently.

When Cubism 5.4 Alpha introduced a new developer-facing API, I became curious about how much of the repetitive rigging process an AI agent could handle. My original idea was close to automatic rigging, but the experiments quickly showed that giving an agent full control over a visual application was not a good idea.

The more useful question became: how can AI help with rigging while still keeping the artist in control?

Layer2Rig Lab, pronounced “Layer-to-Rig Lab,” is my attempt to answer that question.

What it does

Layer2Rig Lab is an AI-assisted workflow for turning layered character artwork into a proposed Live2D rig structure.

Instead of asking the AI to rig an entire character in one attempt, the workflow breaks the process into small and reviewable operations. The agent can:

• inspect and inventory artwork layers;
• create a semantic plan for the rig;
• perform a small structural edit in Cubism;
• read the model back to verify what actually changed;
• record evidence of the result;
• stop for human visual review before saving.

The human remains responsible for creative and sensitive decisions, including pivot placement, visual quality, licensing, and final saves.

This is not a one-click production rigger. It is a prototype for making repeatable rigging operations safer, easier to inspect, and faster to supervise.

How we built it

I combined a local Cubism bridge, a guarded Codex workflow, and machine-readable validation checks.

GPT-5.6 was used for visual and structural reasoning over layered artwork and rigging evidence. Codex coordinated the local Photoshop and Cubism workflow and handled the sequence of operations.

A major part of the system is the test-before-commit process. When the agent encounters an unfamiliar structural operation, it first performs the change inside a cancelable transaction. The workflow then reads the model back to confirm that the temporary change exists and can be removed cleanly.

Only after that test succeeds does the agent repeat the approved operation on a working copy. A human reviews the visible result, saves the model, and then runs another validation pass after the save.

During the hackathon, I validated several operations, including Head Z movement, nested Body Z movement, and independent left- and right-arm controls.

I did not have an original layered PSD ready during the build period, so I used Live2D’s official Mark-kun sample PSD and base model as a test case. I do not claim ownership of the character artwork, and the sample assets are not included in this project.

Challenges we ran into

The biggest challenge was not simply making the AI operate Cubism. It was stopping the AI from becoming too determined to complete the task in its own way.

In the early experiments, the agent sometimes formed its own plan, performed unnecessary UI actions, or continued working when it should have stopped and asked for approval. Once it entered a task-driven mode, it could focus so heavily on reaching the goal that it forgot the boundaries of the workflow.

This is especially risky in design and visual software. A technically valid change may still look wrong, and an accidental save or destructive UI action can be difficult to undo.

As a result, permission management became one of the central design problems. I had to define which actions the agent could perform automatically, which actions required read-back verification, and which actions must always remain under human control.

Another challenge was verification. It was not enough for the agent to report that an operation succeeded. The workflow needed to inspect the model again and provide evidence that the expected structure had actually changed.

Accomplishments that we're proud of

I am proud that I was able to turn a previously messy collection of experiments into a more structured and repeatable workflow.

The project now has a clearer sequence:

1. inspect the source;
2. propose a plan;
3. test a small operation;
4. read the result back;
5. cancel or approve the change;
6. perform human visual review;
7. save and validate again.

That structure makes the process easier to understand, debug, and supervise. It also has the potential to improve efficiency by automating repetitive structural work without removing the artist from the decision-making process.

I am also proud that the project does not hide its limitations. Rather than presenting the prototype as a fully automatic rigger, I focused on proving that small rigging operations could be made safer and more verifiable.

What we learned

The main thing I learned was how to stop an AI agent from becoming overly committed to finishing a task.

More seriously, I learned that reliable agent workflows need more than a good prompt. They need permissions, checkpoints, reversible actions, read-back validation, and clear stopping conditions.

For visual work, technical correctness is only part of the result. An operation can succeed according to the model structure and still fail visually. Human review therefore cannot be treated as a backup step; it has to be part of the workflow itself.

I also learned that automation becomes much more useful when the process is clearly defined. Breaking rigging into smaller operations made both the AI’s behavior and my own debugging process easier to manage.

What's next for Layer2Rig Lab

The next step is to make the workflow more precise and more fine-grained.

I want to improve layer interpretation, parameter planning, pivot suggestions, and the validation of visual results. I also want the system to handle more complex character structures while requiring fewer manual corrections.

The long-term goal is to move beyond a controlled sample model and reach the point where I can use Layer2Rig Lab on my own layered PSD files as part of a real rigging workflow.

It will still keep human review and approval, but I want the automated steps to become accurate and reliable enough to be genuinely useful for production work.

Built With

• codex
• cubism
• mcp
• python