(This model is for Anima-V1.0, the "preview2" is the version of this model not Anima) ⚠️ To use this model, you will need custom nodes and workflow. Find them inside "anima_control_tools.zip". Having an issue? Ask in comments (and they may already cover your problem, take a look at them!) <h2 id="what's-new-in-preview-2">What’s new in Preview-2 </h2>The main thing is resolution. Preview-1 only ever saw 512. This one trained at 512, 768 and 1024, so it actually holds up at the bigger sizes now, and the bodies are a lot less broken up there — way fewer of those melted or split-in-half moments. 1024 is honestly where it looks best.It also learned from a lot more art this time, roughly double the images Preview-1 had, which shows up as cleaner anatomy and steadier poses across the board. And it’s better at every resolution I support now, not just the new big ones — the higher you go, the bigger the jump.There’s also a little ComfyUI node that gives you one more thing to try when a pose almost works but not quite. Usually you’d just keep rerolling the seed. This lets you also change how the skeleton itself is drawn: thicker lines, a colored puppet version, a heatmap, or with the hands or face dropped. The plain thin one is still what you want most of the time, since that’s the only kind it actually trained on, but every so often a different render gets a stubborn pose to land when the seed won’t. It pulls the pose off a reference photo for you too, so you’re not drawing skeletons by hand.For the technically curious: it’s still a rank-16 control-LoRA sitting on the frozen Anima model with a zero-init skeleton embedder, so at strength 0 you get the base model back exactly, untouched. The real changes are the bigger corpus (about double Preview-1’s ~3,900 examples) and training across all three resolutions for 8 epochs instead of 512-only. On held-out poses the pose-accuracy score went up at every size, with the biggest gains at 768 and 1024.<img src="https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/c5530d9d-087d-4968-a005-019a9cb0dc74/original=true/c5530d9d-087d-4968-a005-019a9cb0dc74.jpeg" /><h2 id="what's-still-off-honestly">What’s still off, honestly </h2><ul><li>It doesn’t always follow the skeleton. Even a clean, correct one. I’ve had a clear walking pose come out as someone just standing there.</li><li>Part of why: a thin stick figure on a black background isn’t really how anime gets drawn, so the model only half-reads it. And the ugly stuff (fused hands, general mush) shows up right where the skeleton is busiest.</li><li>Anything dynamic — running, jumping, sitting — is still the shakiest.</li><li>On short or lazy prompts the style drifts toward one samey default. Give it a proper prompt and it comes back. </li></ul><h2 id="what-i'm-working-on-right-now">What I’m working on right now</h2> Preview-3 is about that “doesn’t follow the skeleton” problem, which turned out to be more interesting than just “train it harder.” The thin-lines-on-black signal seems kind of foreign to the model, so before I sink a couple days into a real training run, I ran a small bake-off on the pose signal itself: take the same poses, draw them a few different ways — the current thin lines, a thicker high-contrast one, a colored body-part “puppet,” and a depth/mannequin look — then measure which one Anima actually follows, and how much quality it costs. That’s how I’ll decide what the skeleton should even look like. The smaller fixes ride along with it: a lower default strength, dropping the noisy hand points, and more varied captions so the look stops flattening.The other half is the detector. The one I’m using was made for photos, not anime, so on art it hands me messy skeletons, and a messy skeleton wrecks everything after it. So Preview-3 is probably going to wait until I build a pose detector meant for anime, a sort of “DWPose for anime,” which I’m starting on right after this. Preview-3 is then the actual retrain: clean detector, whichever render won the bake-off, and a lot more dynamic poses in the data. No date on it. It hangs on that detector working. <h3 id="then-1.0">Then 1.0</h3>If Preview-3 lands clean, that’s the one that drops the “preview” label, and it’ll train on a good deal more data again, not just the same pile pushed further. Also available on Hugging Face: https://huggingface.co/Claquasse/Anima-Control-Pose⚠️ The main file here is the adapter weights (adapter_model.safetensors). The ComfyUI custom node, both workflows, and the skeleton script are attached as anima_control_tools.zip, with pose_control_demo.json also attached on its own for drag-and-drop. You have an INSTALL.txt file inside of the archive to guide you. Everything is mirrored in the Hugging Face repo above.<h1 id="anima-control-pose-(preview-1)">Anima Control — Pose (Preview-1)</h1>⚠️ Preview-1 — experimental. This is an early, lightly-trained release of pose control for Anima v1.0. Because it is a preview, it will often generate bad images: deformed or split bodies, wrong or extra limbs, and similar artifacts. It simply has not had enough training and refining yet. Treat it as a proof of concept, not a finished tool. It is not production-ready for now. Non-commercial use only (inherits the Anima base model license). Behavior and weights may change.A native pose control adapter for the Anima v1.0 image model: condition generation on a skeleton pose map so the subject follows a target pose.<h2 id="abstract">Abstract</h2>Anima Control adds spatial conditioning to the frozen Anima v1.0 diffusion transformer without retraining the base model. Preview-1 ships the first component, pose, as a channel-concat control-LoRA. A small, zero-initialized embedder injects a VAE-encoded skeleton at the model input, and a low-rank adapter on the transformer blocks lets the frozen network act on that signal. Because the embedder starts at zero, an untrained or zero-strength adapter is an exact no-op: the output is identical to the base model. Control is optional and off by default.<h2 id="highlights">Highlights</h2><ul><li>Pose conditioning for Anima v1.0: drive the subject's pose from a skeleton map.</li><li>Zero-init no-op: at <code>strength = 0</code> the output is exactly the base model.</li><li>Small trainable footprint: only the control embedder and a rank-16 adapter train; the base stays frozen.</li><li>Part of a shared control platform: the same harness is meant to host other control types (see roadmap below).</li></ul><h2 id="method">Method</h2>The adapter has one fusion point at the model input and trains two small parts.Conditioning. The base VAE encodes the skeleton pose map into a control latent, the same latent space as the noisy image, so the control stays spatially aligned with the generation.Fusion (<code>ControlEmbedder</code> + <code>ControlInitialLayer</code>). A zero-initialized <code>ControlEmbedder</code> (a patch projection on the control latent) produces control tokens that are added to the frozen base patch-embed output inside an overridden <code>ControlInitialLayer</code>. This is the only place the forward pass changes. Zero-initialization means training starts as an exact no-op (output == base) and the control contribution grows only as it earns loss.Trainable parameters. The <code>ControlEmbedder</code> plus a rank-16 low-rank adapter on the transformer <code>Block</code>s. The base transformer, text encoder, and VAE are frozen.Objective. The base model's native flow-matching objective, unchanged.<pre><code>skeleton ─▶ VAE ─▶ control latent ─┐
 ▼ (+ zero-init ControlEmbedder)
noisy latent ─▶ patch-embed ─▶ [ControlInitialLayer] ─▶ Block×N (+ rank-16 LoRA) ─▶ output
</code></pre><h2 id="training">Training</h2>Data. 3,914 (image, skeleton, caption) triples. Images are generated by Anima from a broad prompt distribution; skeletons are rendered from each image's detected keypoints (DWPose, COCO-WholeBody, black background); captions are quality-prefixed tag lists.Configuration.SettingValueResolution512, aspect-ratio bucketed (AR 0.5–2.0, 7 buckets)Adapter rank16Learning rate1e-4Epochs10Control dropout0.1Precisionbf16Optimizeradamw (optimi)Final training loss: ≈ 0.13 (denoising MSE, mean over the final 400 optimizer steps); stable across all 10 epochs.<h2 id="results">Results</h2>Preliminary — measured on 10 held-out full-body poses (fresh generations not seen in training). Pose agreement is scored by re-detecting keypoints on each generated output and comparing to the target skeleton (PCK@0.1 = fraction of keypoints within 10% of the pose bounding-box diagonal).<img src="https://huggingface.co/Claquasse/Anima-Control-Pose/resolve/main/samples/grid.png" alt="Base vs pose control on held-out poses" />Each row: the input reference, the DWPose skeleton extracted from it, base Anima at the same prompt and seed, then the pose-controlled output. Base ignores the skeleton; control follows it.<ul><li>Control roughly triples body-pose agreement (0.20 → 0.59); several held-out poses (standing, waving, hands-on-hips) reach near-perfect adherence.</li><li>With control off (strength 0.0) the output matches base Anima whatever the skeleton: the adapter is a clean no-op when disabled.</li><li>Strength sweep (0.0 / 0.5 / 1.0): raising strength moves the subject from the base pose toward the target skeleton; 0.5 is a partial blend, 1.0 follows the skeleton.</li><li>Limitations: adherence is strongest on upright / static poses; highly dynamic poses (running, jumping) are followed only partially at this preview's scale and resolution.</li></ul><h2 id="usage-(comfyui)">Usage (ComfyUI)</h2>Preview-1 runs as a small ComfyUI custom node, Anima Control Apply (<code>AnimaControlApply</code>, category <code>AnimaControl</code>).<h3 id="install">Install</h3><ol><li>Download the adapter (<code>adapter_model.safetensors</code>, the file attached to this CivitAI model) into <code>ComfyUI/models/loras/</code>.</li><li>From the <a target="_blank" rel="ugc" href="https://huggingface.co/Claquasse/Anima-Control-Pose/tree/main/comfyui">Hugging Face repo</a>, copy the <code>comfyui/anima_control_lora/</code> folder into <code>ComfyUI/custom_nodes/</code>, then restart ComfyUI. That folder is the whole node: <code>__init__.py</code> and its one helper, <code>control_embedder.py</code>.</li><li>Load <code>pose_control.json</code> (also in the HF repo) from the ComfyUI workflow menu, or build the graph by hand (below).</li></ol>One file does two jobs. <code>adapter_model.safetensors</code> holds both a low-rank adapter (<code>lora.*</code> keys) and the control embedder (<code>control_embedder.*</code> keys). <code>LoraLoaderModelOnly</code> reads the first set, Anima Control Apply reads the second. A bare filename in <code>control_embedder_path</code> is resolved against <code>models/loras/</code>, so both nodes just point at <code>adapter_model.safetensors</code>.Two workflows are in the HF repo:<ul><li><code>pose_control_demo.json</code> — the easiest way to test everything. Drop in any reference image; it runs DWPose to extract the skeleton, then generates the same prompt twice, once on base Anima and once with pose control, so you can compare side by side. The DWPose step needs the <code>comfyui_controlnet_aux</code> nodes.</li><li><code>pose_control.json</code> — the core control graph, where you supply a skeleton image yourself.</li></ul><h3 id="prepare-a-skeleton">Prepare a skeleton</h3>The control input is a skeleton pose map: DWPose keypoints (COCO-WholeBody) drawn on a black background. You can make one two ways:<ul><li>A DWPose preprocessor node (for example, from <code>comfyui_controlnet_aux</code>) run on a reference image inside ComfyUI.</li><li>The bundled <code>scripts/render_skeletons.py</code> (in the HF repo), which needs <code>pip install rtmlib opencv-python</code>:<pre><code>python scripts/render_skeletons.py --imgs &lt;ref_dir&gt; --out &lt;skeleton_dir&gt;</code></pre></li></ul><h3 id="graph">Graph</h3><ol><li>Load base Anima with your usual model loader.</li><li><code>LoraLoaderModelOnly</code>: set <code>lora_name</code> to <code>adapter_model.safetensors</code>.</li><li><code>VAEEncode</code>: encode the skeleton image to a <code>LATENT</code> (this is the <code>control_latent</code>).</li><li>Anima Control Apply: inputs are <code>model</code>, <code>control_latent</code>, <code>control_embedder_path</code> (<code>adapter_model.safetensors</code>), and <code>strength</code>. It returns a patched <code>MODEL</code>.</li><li>Sample from the patched model as usual.</li></ol>Strength. <code>0.0</code> is the base model with no control; <code>1.0</code> follows the skeleton. The range is 0 to 2. Higher values track the pose more closely but can cost some image quality.<h2 id="limitations">Limitations</h2><ul><li>Preview quality. Lightly trained; pose adherence may be inconsistent and is still under evaluation.</li><li>512×512 only. The adapter is trained at 512, and the control latent has to line up spatially with the generation latent, so the skeleton input and the output are both fixed at 512×512. Other resolutions are not supported yet: off-512 the latents do not match and the pose is not tracked. Fine detail (hands, faces) is also limited at this resolution.</li><li>Single input injection. Control is asserted once, at the input; at low strength the model may under-follow the pose. Raising strength helps but can reduce image quality.</li><li>Pose only. Other control types are roadmap, not in this release.</li><li>Non-commercial. Inherits the Anima base model license.</li></ul><h2 id="the-platform-and-its-v1-components">The platform &amp; its v1 components</h2>Pose is the first component on a shared control harness for Anima. The harness owns the frozen base, the adapter machinery, and the data/caching path; each control type plugs in by supplying a conditioning encoder and a fusion point. Planned v1 components:<ul><li>Pose v1: this preview, hardened for higher fidelity and reliable adherence.</li><li>IP-Adapter v1: image-prompt conditioning, to drive style and content from a reference image.</li><li>Identity v1: face-identity conditioning, to keep a subject's identity across generations.</li></ul>A pose detector trained specifically for Anima is also on the table. The skeletons here come from DWPose, a general detector built for photographs, so it is noisy on anime art. An Anima-native detector would give cleaner skeletons for both the training data and inference, which should directly improve how closely generations follow the target pose.<h2 id="license">License</h2>These weights are a derivative of the Anima base model (<code>circlestone-labs/Anima</code>) and inherit its terms: the CircleStone Labs Non-Commercial License, and — because Anima is itself a derivative of Cosmos-Predict2 — the <a target="_blank" rel="ugc" href="https://www.nvidia.com/en-us/agreements/enterprise-software/nvidia-open-model-license/">NVIDIA Open Model License</a>.The model weights are for non-commercial use only. Generated images (outputs) are not restricted by these terms and may be used commercially. See the base model card for the full text.<h2 id="support">Support</h2>Building these models means mining and labeling hundreds of thousands of images and renting GPUs to train on them, which takes real time and money. If they are useful to you and you want to chip in, it is appreciated and never expected: <a target="_blank" rel="ugc" href="https://ko-fi.com/claquasse">https://ko-fi.com/claquasse</a><h2 id="citation">Citation</h2><pre><code>@misc{anima_control_pose_preview1,
 title = {Anima Control --- Pose (Preview-1)},
 author = {Claquasse},
 year = {2026},
 note = {Preview-1 pose control adapter for Anima v1.0},
 howpublished = {\url{https://huggingface.co/Claquasse/Anima-Control-Pose}}
}
</code></pre>Built on Anima (CircleStone Labs), the Cosmos-Predict2 transformer architecture, and the diffusion-pipe training framework.

Anima-Control-Pose

What’s new in Preview-2The main thing is resolution. Preview-1 only ever saw 512. This one trained at 512, 768 and 1024, so it actually holds up at the bigger sizes now, and the bodies are a lot less broken up there — way fewer of those melted or split-in-half moments. 1024 is honestly where it looks best.It also learned from a lot more art this time, roughly double the images Preview-1 had, which shows up as cleaner anatomy and steadier poses across the board. And it’s better at every resolution I support now, not just the new big ones — the higher you go, the bigger the jump.There’s also a little ComfyUI node that gives you one more thing to try when a pose almost works but not quite. Usually you’d just keep rerolling the seed. This lets you also change how the skeleton itself is drawn: thicker lines, a colored puppet version, a heatmap, or with the hands or face dropped. The plain thin one is still what you want most of the time, since that’s the only kind it actually trained on, but every so often a different render gets a stubborn pose to land when the seed won’t. It pulls the pose off a reference photo for you too, so you’re not drawing skeletons by hand.For the technically curious: it’s still a rank-16 control-LoRA sitting on the frozen Anima model with a zero-init skeleton embedder, so at strength 0 you get the base model back exactly, untouched. The real changes are the bigger corpus (about double Preview-1’s ~3,900 examples) and training across all three resolutions for 8 epochs instead of 512-only. On held-out poses the pose-accuracy score went up at every size, with the biggest gains at 768 and 1024.What’s still off, honestly<ul><li>It doesn’t always follow the skeleton. Even a clean, correct one.</li><li>Part of why: a thin stick figure on a black background isn’t really how anime gets drawn, so the model only half-reads it. And the ugly stuff (fused hands, general mush) shows up right where the skeleton is busiest.</li><li>Anything dynamic — running, jumping, sitting — is still the shakiest.</li><li>On short or lazy prompts the style drifts toward one samey default. Give it a proper prompt and it comes back.</li></ul>What I’m working on right nowPreview-3 is about that “doesn’t follow the skeleton” problem, which turned out to be more interesting than just “train it harder.” The thin-lines-on-black signal seems kind of foreign to the model, so before I sink a couple days into a real training run, I ran a small bake-off on the pose signal itself: take the same poses, draw them a few different ways — the current thin lines, a thicker high-contrast one, a colored body-part “puppet,” and a depth/mannequin look — then measure which one Anima actually follows, and how much quality it costs. That’s how I’ll decide what the skeleton should even look like. The smaller fixes ride along with it: a lower default strength, dropping the noisy hand points, and more varied captions so the look stops flattening.The other half is the detector. The one I’m using was made for photos, not anime, so on art it hands me messy skeletons, and a messy skeleton wrecks everything after it. So Preview-3 is probably going to wait until I build a pose detector meant for anime, a sort of “DWPose for anime,” which I’m starting on right after this. Preview-3 is then the actual retrain: clean detector, whichever render won the bake-off, and a lot more dynamic poses in the data. No date on it. It hangs on that detector working.Then 1.0If Preview-3 lands clean, that’s the one that drops the “preview” label, and it’ll train on a good deal more data again, not just the same pile pushed further.

Files with SHA256: c10fa11628e9b1bf16dfe095ac5c6dc4ddd9ae77d7fe023d0a1857f7e29c516f