Modern software looks and feels sterile. Almost every app optimizes for consumer familiarity, relying on the same standard buttons, card layouts, and predictable patterns. It works, but software loses art, personality, and individualism along the way.

Celstate exists to fix that. Growing up on video games and anime, I loved interfaces that felt alive, reactive, and expressive. I want the software my AI agents build to feel the same way.

Personification is a major vector for aliveness. Character personas give software a soul: Duolingo's Duo the owl drives gamification and attachment, Headspace uses warm animated figures to guide meditation, Waze adds interactive driver moods, and Carrot Weather infuses weather checking with an AI mascot personality.

The challenge is scale. Duolingo runs a 12-person motion studio with formal animator-to-engineer handoffs. Most builders cannot afford a dedicated motion studio per asset, and requiring a human animator for every character breaks the economics.

Since AI coding agents are generalists, my product premise is simple: give the generalist agent a tool that produces specialist output. I wanted an agent to call a service and get back a bespoke, animated character ready to drop into a host app.

My test target: a friendly earth spirit that floats around a mobile UI with a dance cadence while fireflies circle it. The bar: convincingly alive, above stock clip art, with zero human animators in the loop for asset generation.

The first pipeline attempt was embarrassing:

“What I see rendered looks like paper cut-outs of arms, legs, torso, and a head poorly glued to a stick. Like something a 1st grade student would do for a project. It's kind of creepy. The fireflies are ok-ish.”

EMRE // ADVISOR BRIEF CHECKPOINT 2026-07-31

The engineering behind it was clean. My agents generated a text-to-3D chibi spirit, split the mesh into six regions, rendered each part with native alpha from a locked camera, computed joint positions, and animated them with CSS transforms. Per-part registration error was under 0.03 percent and payload was 118 kilobytes. Every automated metric said it passed.

In reality, it looked like a creepy paper cutout. Only the parametric CSS fireflies looked decent.

This is how I took that pipeline from paper cutouts to a character persona I would actually ship: by running human taste gates while agents executed the work. Every image in this article is a real research artifact stamped with its gate.

A chibi forest spirit with a green leaf canopy, bark arms and a red chest gem, rendered as a soft 3D toy-like model on a white background.
SOURCE // TEXT-TO-3D // 2026-07 The earth spirit as a text-to-3D service built it. Cute head, no linework, no light ramp — and every motion attempt inherited this flatness.
The cutout head from the first flat rig attempt. HEAD
The left arm cutout from the first flat rig attempt. ARM // LEFT
The right arm cutout from the first flat rig attempt. ARM // RIGHT
The torso cutout from the first flat rig attempt. TORSO
The left leg cutout from the first flat rig attempt. LEG // LEFT
The right leg cutout from the first flat rig attempt. LEG // RIGHT
ATTEMPT_1 // FLAT RIG PARTS // 2026-07 Attempt 1 cut the render into six independent regions and animated them with CSS transforms. The registration was perfect; the result was paper cut-outs glued to a stick.

Killing the dead ends first

Before building further, I ran four research agents across substrate options: programmatic 2D rigging, alpha video, production pipelines, and a ground-truth audit of my codebase. Their job was to separate vendor claims from verified reality.

Every dead end failed for a structural reason.

Alpha video failed on generation and delivery. Transparent video generators lack image conditioning, meaning the same character cannot be generated twice, and no RGBA model loops seamlessly. Delivery is even worse: Android's standard player ignores alpha transparency, while iOS requires a format encodeable only on macOS, which a Linux-hosted service physically cannot output.

Frame sequences were far too heavy. A four-second 512px APNG loop hit 169 megabytes, and animated WebP ran 16 to 22 times heavier than stacked video.

Image-model frame sequences lacked temporal consistency. Static character sheets looked perfect, but fell apart at 24 frames per second due to sub-pixel silhouette drift.

Device 3D runtimes required managing four separate runtime stacks across target platforms, each with distinct transparent compositing bugs in un-controllable host apps.

3D auto-rigging failed because vendor tools explicitly reject non-humanoid assets. A floating earth spirit fits no humanoid template, and preset motion libraries only cover walking, running, and waving.

The 2D rigging formats each had major traps. Spine requires every downstream customer to buy an editor seat. DragonBones is abandoned. Live2D is a closed binary. Lottie lacks bones and mesh deformation, a limitation format authors confirmed keyframes cannot fix.

I had previously let my agents pick Lottie simply because a generator already existed in my repo, a classic case of choosing a tool just because it was already in front of me.

The key pivot: auto-rigging an arbitrary generated image is unsolved, but only if you ingest arbitrary images. By generating the character as a rig upfront, fixing the skeleton and part hierarchy before drawing, bone binding becomes deterministic because joints are known before pixels exist.

The floor test

Could a model author a charming character as a rig from scratch? My first experiment tested the simplest setup: seven candidates, one brief, three text models typing bezier coordinates blind without image models or visual feedback. Each candidate output structured SVG with nine rig parts, declared pivots, and closed paths. I applied one motion rig identically across all seven.

Every candidate came back structurally rig-ready with valid parts, declared pivots, and allowed primitives. Structural compliance was free by construction. The scarce resource was charm: only two cleared the bar, and one model family output floating, detached limbs.

You can see all seven candidates below, moving under the exact same rig:

CLAUDE OPUS 5 // DRAW 1 Best of the seven
GEMINI 3.5 FLASH // DRAW 1 Not it
GEMINI 3.5 FLASH // DRAW 2 Not it
GEMINI 3.5 FLASH // DRAW 3 Acceptable
GEMINI 2.5 PRO // DRAW 1 Detached limbs
GEMINI 2.5 PRO // DRAW 2 Detached limbs
GEMINI 2.5 PRO // DRAW 3 Detached limbs
EXPERIMENT_1 // VECTOR CANDIDATES // 2026-07-31 Seven candidates, one brief, one authored motion rig applied identically to all of them. Every one was structurally rig-ready on the first try. Charm was the scarce resource — two of seven cleared it.

Vector generation proved to be the floor, competent clip art. Rig readiness came free by construction, but visual craft had to come from elsewhere.

A second experiment tested Blender: render a 3D character, then rig it in 2D. Registration was exact to 3 pixels in 65,536 with soft native alpha edges. The mechanical pipeline worked, but the art direction still fell short.

How to ask for help you can't audit

When agents execute, judging output is easy, but auditing technical reasoning is hard. I wrote an advisor brief structured to surface blind spots:

  1. Facts and observations isolated from interpretation.
  2. Interpretation explicitly labeled as hypothesis so the advisor could reason from raw evidence.
  3. Every un-attempted path listed, distinguishing ruled-out options from un-tried ones.
  4. A section titled "where this analysis has already been wrong", listing five specific mistakes: applying a button-press rule to ambient characters, choosing Lottie because it was in the repo, misreading format programmability, splitting a mesh through a character's face, and animating flat images expecting depth.

Exposing mistakes upfront made the brief actionable. The advisor's recommendation: stop trying to build the full pipeline at once and run falsifiable gates. I established three checkpoints requiring human taste: Gate 1 (can any toolchain make one still worth shipping?), Gate 2 (does it read as alive when animated?), and Gate 3 (can it produce the same character twice?). If Gate 1 failed, I stopped before building motion.

Gate 1: the art ceiling

I tested two parallel paths for Gate 1.

Lane A used my existing image generator tuned for painterly illustration. The brief specified craft qualities (crisp ink linework of varying weight, cel-shaded forms with two or three light steps) and explicit negatives (not 3D, clay, plastic, or a toy figurine).

Lane B used Blender with cel quantization, a fresnel rim light, tapered Freestyle linework, adjusted lighting, a rest pose, and a three-quarter camera.

Lane A produced twelve draws in one pass; all twelve were usable:

Ink-lined cel-shaded forest spirit mid-leap with fireflies. A1 // LEAP
The same leaping spirit without fireflies. A1 // NO FLIES
The spirit in a resting pose with a weight shift. A1 // IDLE
A heavier-ink print-styled take on the spirit. A1 // LINE HEAVY
The 3D character redrawn as a flat illustration. A2 // RESTYLE
The restyle holding closer to the source pose. A2 // KEEP POSE
GATE_1 // LANE_A // 2026-07-31 Lane A, one pass, no retries: twelve of twelve draws came back usable. Six of the twelve above — crisp varied-weight ink, cel shading, designed poses. This was the still Emre would ship.

Lane B reached its ceiling after ten iterations:

The 3D mesh with three-step cel quantisation, in its default A-pose. B1 // TOON
The toon-shaded mesh with Freestyle linework added. B2 // FREESTYLE
The best non-photorealistic render achieved — rebalanced lighting, desaturated texture, Freestyle lines. B4 // CEILING
GATE_1 // LANE_B // 2026-07-31 Lane B after roughly ten shader, lighting and camera iterations. Clearly better than the default material. Clearly behind Lane A — the ceiling was set by the generated mesh, not by the shading effort.

Lane B improved on raw 3D, but lagged behind Lane A:

Posing the seven-bone rig shears the left arm into a flat brown plank. B3 // RUBBER MAN
Hard posterization of the generated texture dissolves into scribble. B5 // SCRIBBLE
GATE_1 // LANE_B // 2026-07-31 Two failures worth keeping. Left: posing the seven-bone rig shears the arm into a plank — a verdict on this mesh, not on skeletal deformation. Right: posterization needs clean colour regions; the generated texture has none.

Posing Blender's seven-bone rig sheared arms into flat planks, while posterizing baked textures dissolved into noise because generated textures lack clean color regions.

“If it's asking if I would ship any of the Lane B generations, the answer is no. All the Lane A generations are fantastic.”

EMRE // GATE 1 VERDICT CHECKPOINT 2026-07-31

The gap was not effort; it was what each tool natively emits. However, Lane A traded off determinism: 3D re-renders identically, while Lane A's image draws drifted slightly between runs.

Why Blender underperformed

I challenged my agents on why Blender demos show AAA results while my renders fell flat. The answer: Blender automation excels at scene assembly from curated asset libraries. Agents compose human-authored assets; they do not model stylized organic characters from scratch. Practitioners note that AI character modeling in Blender is tedious, full rigging is impractical, and manual retopology takes two to four hours per asset.

Requiring hours of human 3D cleanup per asset breaks my human-free generation constraint.

My rule going forward is that Blender supplies rendering craft, like lighting, shading, and compositing, rather than modeling craft. If Blender comes back into the pipeline, it will be to render geometry I already trust, not to generate character art.

Gate 2: the motion ceiling

Gate 1 gave art worth shipping. Gate 2 tested motion: does it read as alive or as a paper puppet? The first cutout attempt felt like a puppet because it lacked joint overlap, mesh deformation, and a rest pose. For Gate 2, I added overlapping joints, skinned-mesh deformation, a rest pose, and secondary motion on hair and forearms.

A proper rest pose was a hard requirement. Gate 1 stills were mid-leap poses, great as static art, but impossible to decompose without inventing missing background geometry. Gate 2's brief demanded clear separation between limbs and torso without resorting to a stiff A-pose.

The ink-lined spirit standing with arms clear of the torso and background visible between the legs.
GATE_2 // REST POSE // 2026-07-31 The rest pose is a rig requirement, not an aesthetic one: background must be visible between every limb and the body, or no part can be lifted out cleanly. Four draws, all four riggable.

Part decomposition failed when asking the model to erase everything except one part (erasing an arm deleted the torso; erasing the torso deleted the face).

The fix: ask the model to draw parts laid out separately on a single sheet. One generation produced head, hair, arms, and legs separated with clean ink outlines, matching palette and line weight automatically.

The broader lesson: erasure is really segmentation in disguise. Always ask generative models to draw, never to erase.

A deconstruction sheet with the head, hair canopy, arms, legs and torso drawn apart on a transparent canvas, nothing touching.
GATE_2 // DECONSTRUCTION SHEET // 2026-07-31 Asked to erase everything but one part, the model failed six times out of seven. Asked to draw the parts apart, it succeeded on the first try — and every part matches the others because they were drawn as a set.

Deterministic code separated the parts using a magenta key background and connected components:

The leaf hair canopy cut as its own part. HAIR
The far arm cut as its own part. ARM // FAR
The near arm cut as its own part. ARM // NEAR
The torso cut as its own part. TORSO
The far leg cut as its own part. LEG // FAR
The near leg cut as its own part. LEG // NEAR
The head cut as its own part. HEAD
GATE_2 // CUT PARTS // 2026-07-31 Seven parts, keyed and cut by deterministic code — no model involved at this step. Each part is closed past its seam so joints can overlap instead of butting together.

Assembling the composite rest pose exposed subtle alignment flaws, like inward-pointing feet, that were invisible in isolated parts:

The assembled first-pass character: bark-textured arms and legs, feet and knees pointing inward.
GATE_2 // REST COMPOSITE // V1 // 2026-07-31 The rest-pose composite is the review artifact, not the sheet. Every part looked correct on its own; assembled, the inward-pointing feet and knees were obvious — and had not been caught.

I built a skinned-mesh renderer where parts bend along grid meshes in a hip-to-torso-to-head hierarchy:

GATE_2 // RIGID CONTROL // 2026-07-31
The floor of layered 2D: the same seven parts on the same rig with the same timing, moved as rigid pieces. This is what attempt 1 was. The control is honest — if the two look the same, the deformation earns nothing.
GATE_2 // MESH DEFORMATION // 2026-07-31
The same motion with mesh deformation on: each part bends along its axis instead of swinging rigidly, and hair, hem and forearms lag behind what they hang off.

Deformation was better, but my review caught a core flaw:

“When I said the spirit "dances," I didn't mean waves its arms up and down. I meant just like the fireflies. Imagine a phone screen: I want the spirit slowly dancing and twirling left to right, up to down, bouncing from one side to another like a happy little dance.”

EMRE // GATE 2 FEEDBACK CHECKPOINT 2026-08-01

Motion budget had been spent on limb swing instead of travel motion. "Floats around a mobile UI" was the load-bearing requirement.

Pass two

I shifted motion budget into root travel: diagonal drift, leaning into turns, squashing on descents. Limb swing was cut by 80 percent. Bark limbs were rewritten into soft skin with moss accents, and facial micro-motion (blinks, idle tilts) was added.

First pass: bark limbs that do not share a material language with the painted face. V1 // "SUPER CREEPY WOOD"
Second pass: soft limbs in the face’s own skin, moss at the joints, feet pointing forward. V2 // "TRULY SHIPPABLE"
GATE_2 // SECOND PASS // 2026-08-01 One round of feedback, one regeneration. Each part of v1 was individually well drawn and the character still failed — material coherence is judged across the whole figure, not part by part.

I ran into a prompt bug during the rebuild. The torso prompt still had "bark chest" left over from the old brief, which made regenerated torsos look like tree trunks while the rest of the body was soft skin. When you update a character brief, every sub-prompt referencing it has to be updated at the same time.

The second-pass deconstruction sheet on transparency: soft child limbs with moss at elbows and knees, one faint woodgrain marking per limb.
GATE_2 // DECONSTRUCTION SHEET // V2 // 2026-08-01 The v2 sheet. The brief’s material block changed once and every per-part drawing changed with it — limbs became soft child skin with moss at the joints, bark explicitly negated.

Pass two art was shippable, but travel motion still felt constrained.

Pass three: the dance itself

Two problems remained. First, 2D rigs cannot rotate in 3D. The fix: draw four facings as a matched set, swapping sprites when edge-on while maintaining mesh deformation.

Front, three-quarter, profile and back views of the spirit drawn as one matching set, with the hair canopy above.
GATE_2 // THIRD PASS // 2026-08-01 A flat rig cannot turn — so the turns are drawn. Four facings, drawn as a matching set, swapped where the character is edge-on and the swap is invisible. The oldest trick in games.

Second, fixed sine waves feel artificial. I replaced periodic motion with a move scheduler: a library of sways, hops, and twirls with randomized duration, direction, and easing, preventing repeated moves.

GATE_2 // THE DANCE // 2026-08-01
The third pass. The motion budget moved out of the limbs and into a wandering travel path; a move scheduler — not a sum of sines — drives sways, hops and twirls through all eight facings.

We hit a subtle bug during assembly: updating the animation logic dropped three helper functions, causing the page to fail silently on every frame. I fixed it by checking the compiled bundle for expected symbols.

“This is the first time we've gotten close enough to where I feel like our vision is possible.”

EMRE // GATE 2 VERDICT CHECKPOINT 2026-08-01

What this research actually taught me

A few core principles came out of this work that I will carry into future pipelines.

First, target specifications carry real structural requirements. A phrase like "floats around a mobile UI" dictated where the motion budget had to go, even though we initially treated it like atmosphere.

Second, generative models draw far better than they erase. Asking a model to draw separated parts gave me consistent assets on the first try, while asking it to erase background elements failed repeatedly.

Third, micro-motion is mandatory. If a body is moving while the face is frozen, the character looks uncanny. Simple blinks and idle head tilts belong in the first version.

Fourth, material coherence matters more than individual part quality. Soft painted faces and rough bark limbs do not mix, no matter how well drawn each piece is.

Fifth, always review assembled composites. Alignment issues like inward-pointing feet only show up when the full figure is placed together in its rest pose.

Sixth, true aliveness needs dynamic scheduling rather than fixed sine waves. Fixed periodic loops eventually feel mechanical, while randomized movement primitives feel organic.

Finally, document your research checkpoints. Keeping structured logs of every experiment turned feedback into fast re-runs instead of full rebuilds.

Where this stands

The character art itself is ready to ship. I settled on layered 2D with mesh deformation for the motion, and the move scheduler handles the ambient animation. I still need to hand-tune the pivot points, figure out how to keep characters consistent across multiple assets, and clean up the delivery formats.

The key takeaway for building with agents is simple: use research to rule out dead ends, write briefs that expose assumptions, run cheap human taste gates, and script pipelines so feedback triggers re-runs. My agents handled reading, generation, rendering, and code. My job was taste and judgment.

That division of labor is Celstate's core bet: agents as the execution layer, human taste as the gate, and a paper trail between them. I started with paper cutouts glued to a stick. Now a forest spirit twirling across a phone screen with fireflies circling it, and the path to alive software interfaces is clear.

“The art is truly shippable. Shippable as a floor, as long as it's not the ceiling.”

EMRE // GATE 2 CLOSING VERDICT CHECKPOINT 2026-08-01