# Directing AI Agents Like a Small Animation Studio: An AI Agent Workflow With People at the Gates

URL: https://www.synapticlabs.ai/blogs/ai-agent-workflow-animation-studio
Author: Professor Synapse
Published: 2026-11-03

Source: Synaptic Labs, https://www.synapticlabs.ai/blogs/ai-agent-workflow-animation-studio

---

> "Let the agents build side by side. Keep the final say in one place." _Professor Synapse_

On 27 September 2026, twelve new moves for Professor Synapse went into our video studio in a single change. He learned to throw the rock-on sign, drum his fingers, ponder with his thumb and finger on his chin, sing opera, do push-ups and dance. He learned to hold up a clipboard, curl a dumbbell, listen to music in headphones, warm up by a Bunsen burner, jump onto a crate, and get struck by lightning.

AI agents wrote the code for all of it. A person decided what was good enough to keep.

This is the fourth post in our series on building the Professor. [Post 1](https://www.synapticlabs.ai/blogs/brand-mascot-logo-to-living-character) covered why we turned our logo into a character, [post 2](https://www.synapticlabs.ai/blogs/3d-character-animation-library) how his library of moves works, and [post 3](https://www.synapticlabs.ai/blogs/animation-principles-before-and-after) the craft lessons from this same batch. This one is about how the work got done: how we split it between several AI agents, where Joseph Rosenbaum, our founder, stayed in charge, and what we changed after something went wrong. If you're thinking about putting AI agents to work in your own organization, the lessons carry over.

## Why an animation studio is the right picture

A small animation studio has a director and a few departments. One team animates the characters, one builds the props, one handles effects like smoke and lightning. They work at the same time on the same film, but never on the same drawing. The director reviews the day's work, says yes, no or change this, and the pieces come together in one final edit.

We ran the batch the same way. Joseph was the director. A lead AI agent planned the work and handed out the jobs, and three builder agents took one department each:

- **Gestures:** six moves (rock on, tapping fingers, pondering, push-ups, singing and dancing).
- **Props:** a new system for things he holds, wears or stands on, plus five moves that use it (the clipboard, the dumbbell, the headphones, the Bunsen burner and the crate).
- **Effects:** the lightning strike, with its storm cloud, bolt, flash and sooty aftermath.

These were AI coding agents (Claude Code, in our case). Each one wrote code, ran it, rendered the Professor and looked at the results. None of them decided what shipped.

## The setup: separate lanes so no agent trips over another

The first rule of managing AI agents in parallel is the same as for people: don't have two of them editing the same page at once.

Each builder agent worked in its own copy of the project, on its own branch. The gestures agent could change hand poses all day without disturbing the props agent's clipboard. If one agent broke something, only its own copy broke.

Some files are shared by everything, such as the central settings file, the list of moves and the move library's tests and documentation. Each agent's changes to them were combined once, near the end, when the branches were joined. That meant one careful join instead of a dozen small collisions along the way.

> **Under the hood:** each copy is a git worktree, a second working folder attached to the same code repository. Worktrees let several branches sit side by side on one machine, so each agent gets its own folder and its own branch, and in this multi agent workflow no two agents ever write in the same folder.

## An AI agent workflow diagram of how we work

![AI agent workflow diagram: twelve moves split across gestures, props and effects agents on separate branches. They self-review, a person reviews; flagged moves are revised, approved ones merged once.](https://cms.synapticlabs.ai/api/media/file/b439ceba1d0e11ba30bcf3145cd882d4b6f616bc896632201bc5dac992de266e.png?v=b439ceba1d0e11ba)

The shape matters more than the tools. Work fans out to agents that can work independently, comes back through one gate, and joins once. The last step, writing the lessons down, is the one most teams skip.

## The review loop: human in the loop AI in practice

"Human in the loop" can mean a person clicking approve on something they barely looked at. We wanted a loop where the human's time went into judgement and the machine's time went into everything else.

**The agents check their own work first.** Before Joseph saw anything, each agent rendered its moves, pulled key frames out of each clip and laid them out on a contact sheet: one row per move, frames left to right, and the beat named under each frame. Then it studied the sheet and fixed whatever broke the house style rules. The effects agent went through eleven versions of the lightning strike this way. One early bolt, drawn with rounded joins, looked like a bent pipe; sharp corners and a tapering point made it read as lightning. Automated checks ran too, and the rule now is that nobody asks Joseph to review while a check is failing.

**Joseph reviews one sheet per round.** He answers per move and names frames when something is off. In round one he approved six of the twelve moves as they were: rock on, push-ups, the dance, the Bunsen burner warm-up, the jump onto the crate and the lightning strike. He sent six back with a note each. The tapping hand looked like a hand hanging off the flask. The pondering fist needed to be a thumb and finger on the chin. The singing hand covered the face. The hand on the clipboard didn't look like it was gripping it. The dumbbell curl was only a turn of the wrist. And stars appeared where musical notes belonged.

**Only flagged moves get revised, and only for what he said.** The six approved moves were frozen: nobody touched their files, their settings or their renders again. The round-two sheet showed only the revised rows.

![Contact sheet of Professor Synapse with props: holding a purple prompt-checklist clipboard, curling a dumbbell, and wearing headphones with music-note bubbles, in wide and vertical frames](https://cms.synapticlabs.ai/api/media/file/bb9fcd2e0efaa2d60dfbde43759023375e1feed6c4a12047ab50f251db7b2699.png?v=bb9fcd2e0efaa2d6)

A round-two review sheet: only the three props moves Joseph flagged, now with fingers wrapped round the clipboard, a curl on the arc of an imagined arm, and music-note bubbles. Each row shows the landscape demo first, then the vertical spots used in shorts.

**Everything merges once.** The three branches were joined into one during round two, and the last props fixes were made on the joined code. When all twelve were approved, the full test suite ran again on the combined code, and it went into the main project as one change: twelve moves, the props system and the lightning effect, with 1,420 tests passing and no new failures.

Post 3 goes through those six notes as craft lessons. What matters here is the pattern: small approvals, given often, on something the reviewer can see. A contact sheet puts a whole move on one image, so a review round is one sheet and one set of answers.

## Skills that learn: writing the lessons down

Each builder agent kept a lessons log as it worked: what broke, what fixed it, what to try first next time. At the end of the batch, the method lived in three scratch files and three agents' working context, and an agent's context ends with its session.

So Joseph asked for a proper "create new animation" guide. The professor-rig skill, the written procedures our agents follow whenever they work on the Professor, gained four things:

1. **The guide itself.** It runs from brief to merge: write down the beats, the shape that must read at a glance and the closest existing move; split the batch into groups with a separate copy each; review your own frames; show Joseph; revise only what he flagged; merge once; log the lessons.
2. **A craft reference.** The rules the review notes add up to, grouped under readability, hands and grips, faces, body and weight, props, effects, timing, layout and known pitfalls. Every rule says why it exists and how to check it.
3. **Worked examples.** Six moves from the batch, each with its brief, its beats frame by frame, and what review changed.
4. **A checker.** A short script that flags a move missing any part: the move file, its registration, its test, its demo entry, its line in the documentation and its row in the timing table. On the merged batch it found all 62 moves complete.

The next day the guide got its first real use: a new gesture in which the Professor pushes a plug into a socket, with a spark on the click. The agent's notes open with the guide's brief: the beats in order, the silhouette that has to read (two fists meeting in front of him, cables trailing out), and the closest existing moves to borrow from (the dumbbell grip, the clipboard and the lightning's electric strokes). It shipped as its own change and brought the library to 63 moves.

It passed review the first time. Joseph's whole note was "Plug animation looks good."

A skill is an agent's version of a team handbook, and it pays off the way a good checklist does for people. The next agent starts from what the last one learned instead of rediscovering it.

## What went wrong: the clean-up that deleted shared tools

Not everything went smoothly, and the mistake taught us the most.

Every copy of the project, including temporary ones made to run checks, needed the same large toolbox of software libraries. Instead of giving each copy its own, each was linked to the main project's toolbox with a shortcut. That is common practice and saves a lot of disk space.

When a temporary copy was no longer needed, an agent deleted it with a forced clean-up command. The command followed the shortcut into the main project and deleted part of the shared toolbox there: the folder the video tools start from. From then on, every render command in the main project failed.

The agents noticed within minutes, because renders stopped working. The agents worked around it by starting the video tool directly, and one rebuild command restored the missing folder.

The fix that matters is written into the guide: remove the shortcut first, then delete the copy, and never force the delete while the shortcut is there. The craft reference lists it under pitfalls, and the clean-up step says it outright. When the other copies were cleaned up later, they were removed that way and the main toolbox was untouched.

> **Under the hood:** the shortcut was a Windows directory junction to the main project's `node_modules` folder. `git worktree remove --force` followed the junction and deleted `node_modules/.bin`, so every `npx` command failed. `npm rebuild --ignore-scripts` put it back.

For leaders, the lesson is about process. Clean-up steps are where damage hides, because nobody reviews them. The build got two review rounds and a stack of automated checks; the delete step got none. And when something breaks, fix it, then write the fix into the procedure, where the next person or agent will read it.

## Managing AI agents: what leaders can take from this

You don't need to animate anything to use this pattern. It applies to any work you split between AI agents, or between agents and people.

**Keep human judgement at the gates.** Agents can build, test and check their own work. The call on whether it's good enough, and whether it sounds like you, stays with a person. Put that person where work is accepted, not at every keystroke.

**Give small approvals, often.** Twelve verdicts on one sheet beat one big yes at the end. A verdict per item also makes revision cheap: fix what was flagged and leave the rest alone.

**Freeze what's approved.** Once something passes review, it's done. The reviewer never has to check the same work twice.

**Give each agent its own lane.** Split the work so that no two agents edit the same thing, and join the shared pieces once, carefully, at the end.

**Write the lessons down where the next agent will read them.** An agent starts every session fresh. A lesson that isn't in its instructions is lost.

## Is this AI agent workflow right for your team?

It fits work that splits cleanly into independent pieces, where quality is judged by looking, and where the same kind of work comes around again: a batch of animations, a set of email templates, a run of social graphics, a series of reports.

It isn't free. Someone has to review, and that someone needs taste and the authority to say no. The shared pieces still need one careful merge. And writing the lessons down takes time on the day you'd rather move on.

If the work is a one-off, one agent and a good review is simpler. If it repeats, the guide and the checker are what make the second batch faster than the first.

This is how we approach any AI project: map the work, train the team, build what fits. Parallel agents belong in the build-what-fits column when the map shows work that splits and repeats.

Next in the series: putting the Professor to work, from a voice memo to a finished short.

**Want a character like the Professor for your organization, or animated explainers built this way? Let's talk. [Book an AI Opportunities Discussion](https://www.synapticlabs.ai/book-a-call).**

## Frequently Asked Questions

### What is AI agent workflow automation?

An AI agent workflow is a process in which AI agents carry out the steps of a task, such as writing code, drafting content or checking results, inside a structure a person designed. The agents handle the repeatable steps, and people stay responsible for the decisions that need judgement, such as approving what ships.

### What are the best practices for designing AI agent workflows?

Split the work into pieces that don't touch each other, give each agent its own lane, and have agents check their own output before a person sees it. Put human review at the points where work is accepted, revise only what the reviewer flags, and write each lesson into the agents' instructions so the next run starts smarter.

### How do you create an AI agent workflow for a small team?

Start with one task your team repeats often and write its steps down. Run it with one agent and one human review point until the results are dependable, then add agents in parallel only for parts that can be done independently.

### What makes a workflow a strong candidate for agentic AI?

Good candidates repeat, split into independent pieces, and can be judged quickly by looking at the result. Work where a mistake is cheap to catch before it ships is a better start than work where one error reaches a client or funder straight away.

### What does human in the loop AI mean?

Human in the loop means a person reviews and approves an AI system's output at set points before it is used. In our animation work, Joseph saw every move on a contact sheet, and nothing reached the main project until he had approved it.

### Can several AI agents work at the same time without breaking each other's work?

Yes, if each agent works in its own copy of the project and shared files are combined once at the end. Be careful with clean-up: remove any links to shared resources before deleting a copy, or the delete can reach the shared original.
