Research date: Friday 13 November 2026 · Confidence labels used throughout: verified live = read in the research browser on that date; index = read via web-index search/fetch on that date. Primary sources — papers, vendor docs and terms — are prioritized; vendor-blog and aggregator figures are flagged where they are the only source.
No generative image vendor can promise exactly 8 arms — or any exact limb or object count. None claims to in its documentation, and none contractually guarantees anatomical correctness. On controlled counting benchmarks, SDXL and DALL·E 3 get the exact object count right roughly one time in three.
The only way to promise exactly 8 is to stop asking a generative model to count. Build the character as a puppet rig — an SVG vector puppet, a Spine or Live2D 2D rig, or a Blender 3D armature — with exactly eight arm parts. The count becomes a property of the file, countable before rendering, and no render can invent a ninth arm.
We also ran the test ourselves, on our own mascot: twenty poses at 35% yield (~40% once the production rules were applied), then a paid LoRA training run that scored 0/10 on the same briefs — with exhibits.
How often models get the count right
Exact-count accuracy, in percent. 100% is the only number that counts as a promise — the dashed line. Everything ever published lands below it.
Exact object-count accuracy by model / method
Sources: CountGen / Make It Count, CVPR 2025 (T2I-CompBench-Count and CoCoCount, human rating)[1]; AIBL layout-attention results (Ngo et al., arXiv preprint, NeurIPS 2026, 58–65% range shown to its top)[39]; noise-prior conditioning, Zhao et al. 2025[2]; CountLoop, arXiv:2508.16644 (“as much as 98%” on high-instance object benchmarks — a loop-until-pass headline, not single-shot accuracy, and not limbs)[8]. None of these is a shipped vendor guarantee, and none is validated for limbs attached to a character.
Two more findings frame the chart. Scaling does not fix it: a 2025 Microsoft Research Asia / Peking University study found counting does not improve when scaling from 2B to 12B parameters and 1K to 500K training samples.[2] And 8 is already a hard number: benchmark performance is documented to degrade beyond five objects, with even state-of-the-art models, as shipped, struggling to exceed 50% accuracy on single-digit prompts — for ordinary objects, before adding the harder problem that arms must also be attached correctly to one body.[2]
Why the models can’t count
The failure is architectural, data-driven and encoding-driven. It is not a prompting bug, and “try a bigger model” is empirically not a fix.
1. There is no known counting step in the architecture
Counting requires keeping “a sense of separate identity for every instance… and then carry[ing] out a global computation implicitly during generation. It is still unknown if such representations exist” in diffusion models. The CountGen authors add that models “struggle with controlling spatial layout just from text” and that a correct count “requires obeying a global and complex spatial relation” — while denoising is a local, iterative refinement process with no slot, register, or tally for instances.[1]
The numerosity study states the mechanism plainly: models “lack effective mechanisms to bind textual numerals to spatial instance slots,” and in practice they “primarily optimize with respect to the noise prior, rather than the text instructions, making object count a weak signal easily overridden by stochastic noise patterns” — different noise seeds carry their own preferred counts.[2]
2. Training data teaches “a hand is present,” not “five fingers”
The AbHuman / HumanRefiner authors attribute limb anomalies to training that “typically focuses on aligning overall characteristics, like the human having hands and legs, while less attention is paid to detailed characteristics such as the number of fingers or hands,” leaving models with “limited control over the fine-grained generation of detailed body parts.”[4] Hands compound this: small in frame, frequently occluded, folded or cropped in web photos, highly articulated, and self-similar — so the training distribution rarely presents a clean, labeled, countable hand. In short: the model sees pixels, never bones. There is no skeleton in the model to check the output against.
3. The numeral is a soft signal, not an instruction
Prompts are encoded into embeddings where a numeral is a token associated with scenes that tended to contain about that many things — not an integer executed by a counting routine. The numerosity paper explicitly links the image failure to the LLM “strawberry test” lineage of tokenization / architecture counting failures. Autoregressive / transformer image models change the sampler, not this fact: the same paper lists FLUX, Ideogram V2, GPT-4o image, Nano Banana and Qwen-Image together as struggling “to produce the correct number of objects specified in text prompts” on GeckoNum.[2]
4. The human-figure evidence is worse than the object evidence
- Distortion-5K (2025): “Nearly 50% of generated images contain distortions” — proliferated limbs, missing fingers, deformed / fused parts — across four popular text-to-image models on a 500-prompt benchmark.[3]
- AbHuman / HumanRefiner (2024): a failure benchmark built from 56K synthesized human images with 147K annotated anomalies in 18 categories — even SOTA generators (SDXL, Midjourney, DALL·E 3 named) produce limb abnormalities routinely enough to build it.[4]
- HumanBench (WACV 2026): 36K images across Midjourney, Stable Diffusion, FLUX and three more models — “persistent failures, including disfigurements, species leakage, and counting errors”; two heads, missing legs, misplaced limbs; prompt–image consistency “declines monotonically” with prompt complexity.[6]
- Kamali et al. (CHI 2025): a human detection study of 450 diffusion images and 149 real images with 50,444 participants and 749,828 observations, establishing a 5-class artifact taxonomy (anatomical, stylistic, functional, physics-violation, sociocultural). The paper itself (arXiv:2502.11989v1, verified against the primary source on 13 Nov 2026) reports anatomical implausibilities at 51.4%, functional implausibilities at 58.7%, and stylistic implausibilities at 39.0% of annotated images.[5]
- NumBench (2026 preprint — treat with caution, very recent): 640,000 prompts, counts 1–100, 5 commercial + 2 open systems: “performance declines sharply with requested count; all evaluated methods are weak above 50 objects.”[40]
How widespread the problem is
Counting fingers became the public shorthand for “that’s AI” — the first check taught in spotting-AI coverage — precisely because extra and fused digits were the most legible, repeatable error. The CHI 2025 study was motivated by exactly this public circulation.[5]
- Hands and fingers (the canonical case): six or seven fingers, fused fingers, proliferated or missing hands — quantified at ~50% distortion rates in controlled human-generation benchmarks, not just anecdotes.[3][4]
- Whole limbs and heads: HumanBench’s title is itself a catalog — “Two Heads, No Legs, But Mostly Human.” HumanRefiner likewise opens with SDXL’s “incorrect limb counts, twisted hands, and incorrect limb position.”[6][4]
- Horses’ legs: a widely shared equestrian-community post dissects an AI horse-anatomy diagram with extra legs, three hips, backward joints and an invented anatomical label, run as a recurring “What’s Wrong Wednesday” feature; a separate photographer’s AI-transformed horse image drew community criticism for distorted, extra legs and unnatural musculature / gait.[21][22] Production help docs agree anatomical inaccuracy “can be an issue when generating people or animals.”[19]
- Furniture, bicycles, everyday objects: artifact-repair guides catalog a chair with five legs, an oval bicycle wheel, cups at torso scale, floating / intersecting objects — the same “presence without correct quantity / geometry” failure in inanimate subjects, fixed only by masking and regenerating the whole object.[20]
- Children’s books (a named production blocker): a 24-page book requires the same character 24 times; creator guides describe page-1 perfection followed by a different face structure (p.3), different hair (p.8), different proportions (p.15) — and publish a pre-flight checklist whose first item is “Finger count: Are there exactly 5 fingers per hand? (AI loves extra fingers).”[17] A companion guide calls character consistency “the single most common frustration in this space,” attributing it to models having no memory between generations.[18]
- Comics, brand mascots, illustrators: the same two blockers recur — identity drift panel-to-panel, and limb / finger errors that survive into print, where they cannot be patched by re-rolling a feed. That is why the workarounds in the techniques section exist as a cottage industry, and why community negative prompts are litanies of the failure: “extra limbs, bad anatomy, malformed hands, extra fingers, fused fingers.”
Ground News framing
No Ground News story page specifically about extra fingers / AI hands was found in this run (a site:ground.news search returned no results, 13 Nov 2026 — see open questions). What Ground News is, methodologically, is documented by the Columbia Journalism Review: it aggregates 40,000+ outlets and presents each story as a bias distribution (left / center / right percentages) with factuality ratings, under the tagline “See every side of every news story.”[23] Used correctly for this topic, that framing supports one claim and no more: spotting-AI / extra-fingers coverage is not a partisan or single-outlet narrative — it runs as consumer how-to, fact-checking, tech and culture coverage across the spectrum, consistent with a technical failure any outlet’s audience can reproduce in minutes.
First-party evidence: we ran the test ourselves
Everything above rests on published benchmarks. On 13 November 2026 we also ran the experiment directly, on our own mascot — Huxley, a red octopus whose design was locked in a character sheet on 8 November 2026 (glossy bright red, darker red spots, gold-amber eyes, silver over-ear headphones, spiral-curl arm tips). Producer: Freddie Avalos (editor); counts and QA by Muse. Total cash cost of the training test below: $2.35.[FP]
Methods — the trace rule
An image passes only if it shows exactly 8 arms and every visible arm segment can be traced continuously to an emergence from the body or to a tip. A segment ending against another arm, a prop, or a frame edge counts as a failure — a “chopped arm” — never as depth. Counts were performed by Muse (Huxley — the editor’s Muse assistant, and the octopus who is the test subject); the editor’s count governs any dispute.
Three production rules were adopted mid-test, on the editor’s direction. The clipboard floats: Huxley’s clipboard is a hologram panel that hovers beside him, touched by zero arms; a prop gets at most one arm, never two — arms spent holding props appear to fall out of the model’s loose arm budget and get backfilled elsewhere. Flat-row language: every later brief specified “one single flat row like a paper cutout, NO arms behind the body, NO back row, wide triangular gaps between the legs, body held HIGH” — with that language, the hidden back-row extras disappeared entirely and failures moved to the front row, where they are visible at a glance.
Exercise 1 — ten poses, reference-image generation
Storybook illustration style; the locked sheet’s full-body front view supplied as a reference image; one character per image; briefs specified the pose plus an explicit arm map.
| Pose | Result | Detail |
|---|---|---|
| 01 · Wave | Fail | ~11 arms — extra back row |
| 02 · Counting (clipboard) | Fail | ~11–12 arms |
| 03 · Shrug | Pass · 8 | Clean |
| 04 · Presenting | Fail | 7 arms (merge) + thumb-like tip |
| 05 · Dancing | Pass · 8 | Clean |
| 06 · Thinking | Fail | 9 arms + a nub |
| 07 · Conducting | Pass · 8 | Clean |
| 08 · Celebrating | Fail | 10 arms — six upper arms |
| 09 · Meditating | Fail | 10 arms — named gesture added on top of a full set |
| 10 · Wave (retest) | Count-pass · 8, flagged | Thumb-like nubs on both raised arms |
Exercise 2 — ten fresh poses, all rules applied
Same method, with the hologram rule, the one-arm-per-prop rule, and flat-row language in every brief.
| Pose | Result | Detail |
|---|---|---|
| 11 · Bowing | Fail | 10 arms — both rows doubled symmetrically |
| 12 · Sleeping | Pass · 8 | Clean — see Exhibit 1a |
| 13 · Reading (hologram) | Fail | 9 arms |
| 14 · Idea | Pass · 8 | Clean |
| 15 · Surprised | Pass · 8 | Clean |
| 16 · Gliding | Fail | 10 arms |
| 17 · Welcoming | Fail | 10 arms — middle row duplicated both sides |
| 18 · Curious | Pass · 8 | Clean |
| 19 · Proud | Fail | 10 arms — named gesture added to a full set |
| 20 · Laughing | Fail | 10 arms — brief said “only four upper arms in total”; the model drew six |
Patterns across all twenty poses: the generator treats the prompt’s arm list as decoration added to its own default octopus template, not as a budget. Named gestures are added on top; symmetric wide poses duplicate a row; exuberant poses multiply the wide arms; raised “wave” arms grow thumb-like nubs. Passes cluster on calm, symmetric, single-gesture poses close to the model’s natural template. A generate-and-select workflow is viable for one-off art at ~40% — it is not a per-panel guarantee for a comic.
Disclosure — why the baseline failures are tallied, not shown. On the editor’s instruction, every failed image from both exercises was permanently deleted on 13 November 2026. The tallies above were recorded in the project log before deletion and are the surviving record. A consequence: all surviving baseline images are passes, so baseline failures cannot be exhibited. The LoRA failures below can, because they were not struck.[FP]
The LoRA test — does training the model fix it?
Hypothesis: fine-tuning a model on the character’s own locked artwork would teach it the count. Method: fal.ai flux-lora-fast-training (FLUX.1 [dev]), 21 training images — 14 views from the locked character sheet plus the 7 verified storybook passes (the thumb-flagged image was deliberately excluded) — trigger word HUXLEYOCTO, 1,000 steps (the trainer default), $2.00. Generations via fal-ai/flux-lora at ~$0.035 per image ($0.35 for ten), using the same ten briefs as Exercise 2.
| Pose | Baseline (Ex. 2) | With LoRA | Note |
|---|---|---|---|
| 11 · Bowing | Fail · 10 | Fail · 10 | Same duplication |
| 12 · Sleeping | Pass · 8 | Fail · 10 | Training made a passing pose fail — Exhibits 1a / 1b |
| 13 · Reading | Fail · 9 | Fail · 7 — count + rule fail | Holds a solid clipboard in a finger-like grip — Exhibit 3 |
| 14 · Idea | Pass · 8 | Fail · 6 | Legs merged into two giant curls |
| 15 · Surprised | Pass · 8 | Fail · 6 | Merges |
| 16 · Gliding | Fail · 10 | Fail · 9 | Includes a chopped, flat-ended arm segment — Exhibit 2 |
| 17 · Welcoming | Fail · 10 | Fail · 8 | Count exact, but one arm exits the frame — fails the trace rule — Exhibit 4 |
| 18 · Curious | Pass · 8 | Fail · 6–7 | Merges in three-quarter view |
| 19 · Proud | Fail · 10 | Count-pass · 8, flagged | Pose intent lost; arms crowd the frame edges |
| 20 · Laughing | Fail · 10 | Fail · 6 | Wide arms merged away |
Exact counts with the LoRA: 2/10 — Welcoming and Proud. Under the trace rule only Proud stands as a pass, flagged for lost pose intent; Welcoming’s eighth arm exits the frame. None of Exercise 2’s four clean passes survived training: Sleeping, Idea, Surprised and Curious all failed with the LoRA. Both of the LoRA’s exact-count results had themselves failed untrained.
- What training did do: identity. All ten images are unmistakably the same character — headphones, spots, eyes — with no reference image supplied at generation time. The LoRA is a genuine identity lock. It is not a counting mechanism.
- Behavior and style followed the training data and the base model, not the brief. No training image contained a clipboard, so when the brief mentioned one, the model drew the generic behavior — the character holding a solid clipboard (Exhibit 3) — overriding the production’s floating-hologram rule. And FLUX’s glossy 3D-render house style dominated the output despite the storybook passes in the training set.
- The failure direction flipped. The untrained generator over-counts (adds rows and gestures). FLUX + LoRA under-counts by merging more often than it over-counts (five under-count rows against three over-count rows) — three failures at exactly 6 arms and one at 6–7 — plus one chopped arm segment ending flat in open water (Exhibit 2).
Bottom line from our own bench: training is an identity tool, not a counting tool — the same conclusion the literature reaches, verified here at first hand for $2.35.
Exhibits
Exhibit 1 is the honest pair: the same “Sleeping” brief, before and after training. The baseline failures from Exercises 1–2 were struck and deleted (see the disclosure above), so they are tallied in the tables, not shown; the LoRA images below were not struck. Exhibit 5, after the grid, is a different kind of exhibit: not one of our generations, but another model’s confident claim about this exact problem — included so it can be audited against the tables above.
Exhibit 5 — the confident version, tested
The same day, the editor asked ChatGPT the question this section tests: “Can this just come down to a matter of training the renderer on rendering eight-armed octopuses in various poses? Is that what it really is?” ChatGPT’s accompanying text hedged correctly — it distinguished teaching the process to respect the character’s anatomy from training an entirely new model, recommended building the reference library first and fine-tuning only if that proved unreliable, and stated plainly: “even a trained model isn’t guaranteed to count appendages correctly in every complicated pose. We’d still need visual verification.” The infographic it produced dropped that hedge. It is reproduced below as an exhibit of the claim — not as a finding of this report.[E5]
Audited against our own test — same day, same character, same sequence
The workflow the graphic recommends is the exact sequence this production ran on 13 November 2026:
- Reference conditioning with the locked character sheet and explicit arm maps: 7 clean passes in 20 poses (35% overall; ~40% per roll once the rules were applied) — an improvement, not reliability.
- An approved pose library: the 7 verified passes — Shrug, Dancing, Conducting, Sleeping, Idea, Surprised, Curious.
- LoRA fine-tuning on 21 images (14 locked sheet views + those 7 verified passes), $2.00 training, the same ten briefs re-run for ~$0.35: 0/10 clean passes, 2/10 count-correct — both flagged. All four poses that had passed untrained failed trained. Identity lock succeeded; counting did not.
Verdict: no disagreement on the workflow order — references first, library, train last is sensible, and matches this production’s practice. The disagreement is the promise. The graphic’s “reliably… exactly eight arms every time” is the claim the $2.35 test above disproves: training teaches what Huxley looks like — appearance is learnable. It does not install a counter, so the arm count stays a dice roll. Training is an identity tool, not a counting tool. The graphic’s own artwork disproves it too — per the editor’s trace check in the caption above, 0 of its 9 images of Huxley verify at exactly 8.
Limits and confounds — read before citing
- Two variables changed at once. The exercises used one hosted generator; the LoRA test used FLUX.1 [dev] via fal.ai — the only hosted trainable route available. This is a comparison of pipelines, not a same-model LoRA on/off ablation, which was not run.
- Training size. 1,000 steps is the trainer’s default. Black Forest Labs guidance suggests 1,500–3,000 steps for character work (a $3–6 run at fal’s linear pricing). Untested here; the mechanism — a LoRA encodes appearance, not a countable constraint — gives no reason to expect a count guarantee at higher steps.
- One seed per brief per condition. Yields are point observations, not rates with confidence intervals. The direction of the result — no improvement; baseline passes became failures — is the finding, not the exact percentages.
- Counts are the production’s own QA, performed under the trace rule above, not an independent benchmark.
What we did with the result
Because of this test, Huxley’s comic character is being built as a deterministic vector puppet — eight arms by construction, arms as separate shapes in the file. Generated art is used for scenes and one-offs only, behind the trace-rule check. That is the architecture recommended later in this report, adopted here first: generative for concepts and backgrounds, rig for the character who has to be right every time.
The one thing that can promise it
A puppet rig carries the count in its structure. Below is the idea in miniature: an SVG puppet whose arms are eight named groups in the file. The button does what an agent does before every render — it counts the arm groups in the source and asserts the total.
arm groups in file: — (press the button to run the pre-render check)
Posing moves arms; it cannot create or delete them. If the rig file contains exactly 8 arm bones / parts, every pose, frame and render contains exactly 8 arms — and the agent can prove it by enumerating the arm nodes before rendering: 8 <g id="arm-*"> groups in SVG, 8 arm objects in Blender’s bpy.data, 8 slots in Spine JSON.
The same logic covers deterministic compositing, with one caveat: approve one arm asset once, then place exactly eight copies as separate layers / groups in Photoshop, Illustrator or SVG and flatten. The count is by construction — but the agent must still render and visually verify all eight are distinct, not fully occluded behind the body or each other. Structure is guaranteed; legibility still needs the QA render.
Every tool, judged
Criterion for “agent-drivable”: a documented API, headless / local automation, MCP, or SDK an agent can call without driving a consumer UI with a mouse — and without violating the vendor’s terms. Vendor count / anatomy guarantees across all of them: none found.
Showing 18 of 18 tools.
ComfyUI (local / cloud)
Agent-drivable Cannot promise 8
- API / automation
- Official HTTP/WS API: POST /prompt, /history, /upload/mask (verified live)
- Best control method for counts / anatomy
- ControlNet 8-arm skeleton + character LoRA + IP-Adapter + inpaint loop + counter-verifier
- Can it promise exactly 8 arms?
- Only if the workflow’s final step is deterministic compositing / rig render — as a generator, no.
OpenAI GPT Image (Images / Responses API)
Agent-drivable Cannot promise 8
- API / automation
- REST Images API + Responses image tool; gpt-image-1 in API Apr 2025 — pin current model ID
- Best control method for counts / anatomy
- Prompt + reference-image editing + masks; generate-and-verify
- Can it promise exactly 8 arms?
- No — Terms disclaim accuracy.
Google Imagen / Gemini Image API
Agent-drivable Cannot promise 8
- API / automation
- Gen AI SDK generate_images (Imagen) / generate_content (Gemini Flash Image) — verify live model ID
- Best control method for counts / anatomy
- Prompt + reference / edit (Gemini line); no ControlNet / LoRA
- Can it promise exactly 8 arms?
- No — Counting is a named Imagen 4 limitation.
Stability API / SD3.5
Agent-drivable Cannot promise 8
- API / automation
- REST Platform API; weights also self-hostable
- Best control method for counts / anatomy
- Via ComfyUI / A1111 stack (ControlNet / LoRA); hosted edit / control services
- Can it promise exactly 8 arms?
- No — Terms disclaim accuracy.
Replicate
Agent-drivable Cannot promise 8
- API / automation
- Prediction API, replicate.run; hosts FLUX / SD / ControlNet / LoRA models
- Best control method for counts / anatomy
- Whichever hosted pipeline you select (ControlNet / LoRA models available)
- Can it promise exactly 8 arms?
- No
fal.ai
Agent-drivable Cannot promise 8
- API / automation
- @fal-ai/client, FAL_KEY, subscribe / queue, seed; hosts FLUX / SD + adapters
- Best control method for counts / anatomy
- Hosted ControlNet / IP-Adapter / LoRA endpoints where offered
- Can it promise exactly 8 arms?
- No
Automatic1111
Agent-drivable Cannot promise 8
- API / automation
- --api + --nowebui headless REST (local)
- Best control method for counts / anatomy
- ControlNet extension + ADetailer + regional prompting + LoRA
- Can it promise exactly 8 arms?
- No — Maintenance-era — most new workflow development has moved to ComfyUI / Forge; verify extension compatibility per checkpoint.
InvokeAI
Agent-drivable Cannot promise 8
- API / automation
- Queue / workflow API; graph editor (local)
- Best control method for counts / anatomy
- Workflow ControlNet / IP-Adapter / LoRA + canvas inpaint
- Can it promise exactly 8 arms?
- No — Legitimate agent target; smaller ecosystem than ComfyUI.
Adobe Firefly API
Agent-drivable Cannot promise 8
- API / automation
- REST Firefly Services; Custom Models API
- Best control method for counts / anatomy
- Structure Reference (outline / depth, strength) + Custom Model (character) + Fill / inpaint
- Can it promise exactly 8 arms?
- No
Ideogram API
Agent-drivable Cannot promise 8
- API / automation
- API keys / credits, v2 endpoints; character reference
- Best control method for counts / anatomy
- Character reference + layout / typography controls
- Can it promise exactly 8 arms?
- No — Strength is typography / layout, not counting.
Recraft API
Agent-drivable Promises 8 — conditional
- API / automation
- REST external.api.recraft.ai/v1; native SVG vector models
- Best control method for counts / anatomy
- Vector output → agent edits / counts SVG groups; styles / reference for consistency
- Can it promise exactly 8 arms?
- As an edited vector file — not as generated; the agent must audit / set arm groups to exactly 8.
Leonardo API
Agent-drivable Cannot promise 8
- API / automation
- REST v2 cloud.leonardo.ai/api/rest/v2
- Best control method for counts / anatomy
- Elements / custom-model training + reference
- Can it promise exactly 8 arms?
- No
Runway API
Agent-drivable Cannot promise 8
- API / automation
- Dev API + SDKs, async tasks, text_to_image
- Best control method for counts / anatomy
- Reference images; video character features
- Can it promise exactly 8 arms?
- No — Video-first; no pose / ControlNet discipline for stills.
Midjourney
Not agent-drivable Cannot promise 8
- API / automation
- No official public API; terms ban automated tools
- Best control method for counts / anatomy
- (Human-only: omni / character reference, Vary Region)
- Can it promise exactly 8 arms?
- No — and an agent may not drive it — The only official statement is a 16 July 2025 note that the company is “starting to investigate opening up an Enterprise API” — investigating, not launched.
Photoshop / Illustrator (scripted compositing)
Agent-drivable Promises 8
- API / automation
- ExtendScript / UXP / Actions; Illustrator scripting; SVG as plain XML (scripting / batch; not a cloud API)
- Best control method for counts / anatomy
- Place exactly 8 approved arm layers / groups; enumerate before flatten
- Can it promise exactly 8 arms?
- Yes — by construction — Verify all 8 are visible in the final render.
Blender (3D rig)
Agent-drivable Promises 8
- API / automation
- Headless blender -b … -P script.py, bpy API
- Best control method for counts / anatomy
- Build an armature with exactly 8 arm chains; assert count in bpy.data pre-render
- Can it promise exactly 8 arms?
- Yes — unconditional
Spine / Live2D (2D rigs)
Agent-drivable Promises 8
- API / automation
- Cubism / Spine runtimes & SDKs drive a fixed bone / parameter rig in code (editor is GUI)
- Best control method for counts / anatomy
- Rig layered art to exactly 8 arm bones / slots; pose by parameters
- Can it promise exactly 8 arms?
- Yes — unconditional — Once the rig is built & audited.
SVG puppet (hand-built / Recraft-derived)
Agent-drivable Promises 8
- API / automation
- SVG is text: the agent writes / parses XML directly, renders via browser / rasterizer
- Best control method for counts / anatomy
- Author exactly 8 <g id="arm-N"> groups; unit-test count(arm groups)==8 before every render
- Can it promise exactly 8 arms?
- Yes — unconditional, cheapest to audit
Notes on the decisive cases: ComfyUI is the best-in-class generative stack for control — its server docs were verified live on 13 Nov 2026: submitting a workflow is POST /prompt, which “validates the prompt and adds it to an execution queue, returning either a prompt_id… or error,” with /history/{prompt_id}, /queue, /ws, /upload/image and /upload/mask — a complete agent loop, and the only stack here that natively composes ControlNet + IP-Adapter + LoRA + inpainting + seed in one graph.[9] Midjourney is the opposite pole: no official public API, and its terms prohibit automated access — every third-party “Midjourney API” is an unofficial wrapper automating accounts in breach of those terms, with ban risk.[12][13] Recraft matters beyond drivability: its vector models return editable SVG, which is inspectable and editable by the agent as data — the bridge to the deterministic promise.[11]
Model IDs churn Hosted model IDs retire fast — in this research run, gpt-image-1 was already listed in OpenAI docs as shut down 23 Oct 2026, and secondary guides reported Imagen 4 Vertex / Gemini endpoints as discontinued in mid-2026 with migration to Gemini Flash Image models. The API patterns are stable; the model ID is not. Pin a current model ID at build time, never hard-code one.
Techniques, ranked: nudge → repair → guarantee
The dividing line is absolute: anything that ends in a diffusion / transformer sampling step can fail the count; anything whose final render is a deterministic function of a counted scene description cannot.
Prompting & negative prompts
“Exactly 8 arms”, “no extra limbs” — a soft embedding nudge, and the weakest lever. The benchmarks above are measured with the count in the prompt.
Seed + generate-and-select
Reproducibility ≠ correctness: the same seed and prompt reproduce the same wrong count reliably. Selection helps only if a correct sample happens to occur and a checker catches it. Expected tries at p≈0.3 is ~3–4 per keeper; at p≈0.05 (hard pose / count) ~20 — with no upper bound.
Reference conditioning — IP-Adapter, character reference
Materially improves who the character is across images (Ideogram / Midjourney character reference, Firefly Custom Models). It conditions appearance, not cardinality — the reference’s arms are not transferred as a counted skeleton.
Character LoRA / fine-tune
The best generative route to a recognizable, repeatable character. A LoRA trained on an 8-armed character raises the prior for 8 arms — and can still render 7 or 9 on a novel pose, because sampling remains stochastic. First-party check: our own FLUX LoRA, trained on the character’s locked sheet and verified passes for $2.00, scored 0/10 clean on briefs the untrained generator passed 4/10 — identity locked, count did not (evidence and exhibits).
Region prompting / layout-to-image
An LLM or user supplies one box per instance; attention is confined per box. CountGen’s review: predefined layout “helps ensure” count, but LLM-layout baselines alone scored poorly in its tests (Reason-Out-Your-Layout 15–26%). Two-stage LLM-layout systems report object recall rising 57.2% → 99.9%[42] for the layout stage in a narrow table-setting domain — layout recall, not final-pixel limb accuracy. The renderer can still merge, duplicate or drop a boxed instance.
ControlNet pose / skeleton / depth / canny — the strongest generative control
Inject a spatial condition — e.g. an OpenPose skeleton drawn with exactly 8 arms — into every denoising step.[7] The peer-reviewed anchor is HumanRefiner’s pose-reversible refinement: 2.9× limb quality vs SDXL, 1.4× vs DALL·E 3 — large relative gains from a low base.[4] Why still no promise: ControlNet is a conditioning strength, not a constraint solver — the model may ignore, fuse or add a limb. And an 8-arm skeleton is far outside OpenPose’s human training distribution (2 arms), so expect the model to “correct” toward 2 arms or tangle arms unless the checkpoint / LoRA also knows the species. Custom skeleton + character LoRA + ControlNet is the best generative attempt — and it still requires verification per frame.
Inpainting / masking
The standard production repair: “inpaint the hand, not the picture.” Each inpaint is itself a new sampling roll for that region — no promise per operation. It becomes a guarantee only as part of a verified pipeline: inpaint → count-check → inpaint until the checker passes, then stop touching the image.
Generate-and-verify loop (agent + detector / VLM counter)
CountLoop formalizes this for objects — LLM layout planner + critic feedback loop — reporting “counting accuracy of as much as 98%” on its high-instance benchmarks.[8] The agent may truthfully say “this delivered file was machine-counted at 8” — never “this tool generates 8.” A QA claim about checked files, not a capability claim about the model.
Deterministic compositing (Photoshop / Illustrator / SVG layers)
Count = number of arm layers / groups in the source file, enumerable programmatically before export. Recraft’s native SVG route helps: generated vector art arrives as editable paths / groups the agent can split, duplicate ×8, name arm-1…arm-8, and audit.[11] Caveat: render and visually verify all 8 are distinct in the final frame.
Vector / 3D puppet rigs (SVG puppet, Spine, Live2D, Blender)
The character is a rig: a fixed hierarchy of parts / bones. Blender is fully agent-drivable headless — blender -b file.blend -P script.py via the bpy API — and Blender Studio rigs document the model: an armature with IK/FK limb chains the animator poses, never regenerates.[24][25] This is the answer to the title question. Generative AI may still be used upstream (concept art, textures, background plates), but the character asset that carries the promise must live in the rig.
Why generate-and-select is not a promise, in one line: a promise is a statement about all outputs; sampling gives a statement about a distribution — and for 8 arms the distribution’s mass at exactly-8 is unknown per pose, possibly near zero for out-of-distribution anatomy, so no finite re-roll budget converts it into a guarantee. Verification converts it into a checked deliverable; construction converts it into a guarantee.
What vendors promise vs. what their terms say
Vendor terms, services agreements and API docs were searched for “guarantee / warrant / accuracy / exact” language around counts and anatomy. Result: no generative vendor was found that contractually promises exact object counts, correct limb counts, or anatomical correctness. None. The contracts promise the opposite.
“Given the probabilistic nature of machine learning, use of our Services may, in some situations, result in Output that does not accurately reflect real people, places, or facts… Output may not always be accurate… You must evaluate Output for accuracy and appropriateness for your use case, including using human review as appropriate, before using or sharing Output.”
— OpenAI, Terms of Use (index — the live page presented a bot check in the research window and was not bypassed)[14]
Customer is “solely responsible for all use of the Outputs and for evaluating the accuracy and appropriateness of Output”; services are provided “AS IS” and OpenAI “MAKES NO REPRESENTATION, WARRANTY OR GUARANTEE THAT SERVICES WILL MEET CUSTOMER’S REQUIREMENTS OR EXPECTATIONS, THAT CUSTOMER CONTENT WILL BE ACCURATE, THAT DEFECTS WILL BE CORRECTED…” The only warranty is that the services conform “in all material respects with the Documentation” — and the documentation makes no count claim.
— OpenAI, Services Agreement, eff. 1 Jan 2026 (index)[26]
“OUR SERVICES ARE PROVIDED ‘AS IS’… WE… EXPRESSLY DISCLAIM ALL WARRANTIES OF FITNESS FOR A PARTICULAR PURPOSE, TITLE, MERCHANTABILITY, ACCURACY, SATISFACTORY QUALITY… YOUR USE OF OUR SERVICES AND INPUTS / OUTPUTS IS SOLELY AT YOUR OWN RISK.”
— Stability AI, Terms of Service, §11 (index)[15]
The marketing gap
Release language is qualitative and comparative — Midjourney V7’s official summary, as quoted in reference coverage, claims bodies, hands and objects have “significantly better coherence”; FLUX built its launch reputation on hands; Ideogram 3.0 on typography + “improved hands.” None publishes a number, and a dedicated cross-vendor check (Aug 2026, secondary source) concluded: “Checked against each vendor’s own documentation… None of the five publish a hand-specific accuracy figure; treat any percentage you see quoted elsewhere as unverified marketing, not a benchmark.”[16][27] Adobe’s indemnification / commercial-safety positioning for Firefly, where offered on enterprise tiers, concerns IP / legal risk of outputs, not their anatomical correctness — do not conflate the two in procurement.
Procurement implication: if a contract, SOW or product page says “exactly 8 arms,” that promise can only be underwritten by the pipeline owner — the agent / workflow builder, via construction + verification — never passed through to a model vendor. Any reseller claiming a generative model “guarantees” counts is claiming more than the model’s own maker does in its terms.
Emerging fixes, 2024–2026: real improvement, no 100%
Hand and limb quality in simple, standard poses has improved from “reliably wrong” (pre-V5, ~2022–23) to “usually right” (2025–26 flagships, ~74–90% in small independent tests). Exact counts of specified, attached, out-of-distribution parts have not crossed into reliability, let alone guarantee.
- Midjourney V5 → V6 / V6.1 → V7 (Mar 2023 → Apr 2025, default Jun 2025): V5 was the first version to render five-fingered hands with reasonable consistency; V7’s official line is bodies / hands / objects with “significantly better coherence on all details.” Reviewer estimates put standard-pose hand success ~40% (V3) → ~85–90% (V7) — reviewer-aggregated, not vendor-published. Complex grips, interlaced fingers, multiple hands and unusual angles still fail — and there is no API.[27]
- FLUX.1 / 1.1 / Kontext / FLUX.2 (Black Forest Labs, Aug 2024 →): launch reputation specifically on anatomy; an independent small test in this run’s sources found 86% acceptable hand anatomy (50 prompts) vs Midjourney V6.1’s 74%. Fused fingers on complex perspectives persist in the same tests; no vendor accuracy figure published.[16]
- GPT Image line (gpt-image-1, Mar / Apr 2025 → later GPT Image models): a step-change in instruction-following, text-in-image and multi-object binding vs DALL·E 3 — but community / press hands-on of later versions still records basic failures (e.g. a four-fingered hand in GPT Image 1.5 testing, Dec 2025 — desk reviews, this run’s sources), and the numerosity literature groups GPT-4o image with FLUX / Ideogram as still failing exact counts on GeckoNum.[2]
- Google Imagen 3 → 4 / Gemini Flash Image (“Nano Banana”) (2024 → 2025): Imagen 4 brought finer detail, 2K and better spelling — but counting is a named limitation of the flagship, in the vendor’s own words: Google DeepMind’s Imagen 4 Model Card (20 May 2025, verified against the primary source on 13 Nov 2026) lists numerical reasoning — rendering an exact number of objects — as “challenging for all models.”[41]
- Ideogram 2 → 3 / character features (2025): typography-first gains (~85–90%+ text accuracy in reviewer testing), Style Reference, Character Reference from a single reference image. Crowd / multi-person scenes still “deform faces and fingers” (Nov 2026 desk reviews, this run’s sources); its strength is text / layout, not cardinality.
- SD3.5 (Stability, Oct 2024): better typography and complex-prompt understanding, and open weights that enable the full ComfyUI control stack. Stability publishes no benchmark numbers for SD3.5 in its documentation, and its terms disclaim accuracy.[28]
- Counting-aware research: CountGen 29% → 48% / 26% → 54% (roughly coin-flip, objects not limbs); noise-prior conditioning 20.0% → 85.3% and 74.8% → 86.3% (best controlled result in this run is still ~1 failure in 7, on simplified benchmarks); AIBL (arXiv preprint, NeurIPS 2026) 58–65%[39]; CountLoop “as much as 98%” — a benchmark headline for objects in a research system, not a per-image guarantee, not limbs, not a product. Its architecture is, however, the template for the verified pipeline below.
Trajectory verdict: every documented curve asymptotes below 100%, and the vendors’ own limitation lists and terms say so.
Recommended production architecture
For an 8-armed character series — the setup this report was researched for.
Concept phase — generative, no promises
ComfyUI + ControlNet + character LoRA to explore look and poses — or any API model in the tool list above for boards. Nothing here is promised to anyone.
Asset phase — the promise
Build the approved character once as an SVG / Spine / Blender rig with
arm-1…arm-8. Add a CI-style check:assert arm_count == 8on the rig file.Per-episode phase — agent-driven
The agent poses and renders the rig headlessly. Backgrounds and props may be generative; the character may not be regenerated.
If a raster generative look is non-negotiable
ComfyUI 8-arm ControlNet + LoRA + IP-Adapter + inpaint + detector / VLM count verification on every delivered frame — and describe the deliverable honestly as “every delivered image was verified to show exactly 8 arms”: a QA claim about checked files, not a capability claim about the model.
Could not verify / open questions
Stated plainly, so nothing in this report rests on more than the evidence carries.
- Open Ground News: no Ground News story page on AI hands / extra fingers was retrievable in this run (site search returned no results). This report uses CJR’s description of Ground News’s method for framing only, with no story-specific bias split claimed. A follow-up with a live Ground News story URL could add the exact left / center / right distribution.
- Kamali et al. percentages — resolved 13 Nov 2026: verified against the primary source (arXiv:2502.11989v1): anatomical 51.4%, functional 58.7%, stylistic 39.0%. An earlier version cited a wrong arXiv ID (2406.08651) via a secondary explainer; corrected.
- Imagen 4 model card — resolved 13 Nov 2026: verified against Google DeepMind’s Imagen 4 Model Card (20 May 2025), which lists exact-number rendering as “challenging for all models.” An “exactly eight rubber ducks” anecdote carried by secondary guides does not appear in the card and has been removed from this report.
- ControlNet improvement percentages — cut 13 Nov 2026: practitioner figures for ControlNet hand / pose success trace to no controlled study and appear nowhere in the peer-reviewed ControlNet paper; they have been removed, keeping only the direction of the claim and the peer-reviewed HumanRefiner anchor (2.9× / 1.4× relative limb-quality improvement).
- Children’s-book consistency figure — cut 13 Nov 2026: a percentage of KDP authors carried in an earlier draft traces only to a vendor blog; no primary survey exists. The qualitative consistency complaint is retained without the figure.
- Open Live vendor verification: ComfyUI docs were verified live; OpenAI’s site presented a Cloudflare bot check (“Just a moment…”) in the research window and was not bypassed — OpenAI terms are cited from the web index, flagged as index. Model IDs / pricing for hosted APIs churn monthly; re-pin model IDs at build time.
- Open MCP: several platforms (Replicate, fal, Runway, Ideogram in enterprise coverage) now expose MCP servers in addition to REST APIs. MCP changes the transport an agent uses, not the counting properties of the underlying model, so it does not affect any conclusion; per-vendor MCP availability should be re-checked at integration time.
- Open First-party test limits: the LoRA comparison changed two variables at once (a different base model and the LoRA), ran 1,000 training steps against 1,500–3,000-step guidance, used one seed per brief, and relies on the production’s own trace-rule QA — and the baseline failure images were deleted, so only their pre-deletion tallies survive. Full limits are stated in the first-party section; cite its direction, not its percentages as benchmark rates.
- Proofed 13 Nov 2026; 24 corrections applied (spelling, figures, citations).
- 14 Nov 2026: the headline claim was scoped to construction rather than puppet rigs alone; the counting figures were tied to the models actually measured (SDXL and DALL·E 3); and Exhibit 4 was reclassified as a failure under the trace rule — its count is exact, but one arm exits the frame.
- 16 Nov 2026: a postscript was added — the Sunny character-sheet episode of that day, in which this report’s own QA failed the count in both directions and its tallies were withdrawn. See the postscript.
- 18 Nov 2026: a second postscript was added — the Muse Image test of that day, in which the first self-checking generator was run through the same twenty briefs and scored 2 clean passes in 20. Proofed 18 Nov 2026. See Postscript 2.
- The “8 arms” test case was treated as an arbitrary exact limb count (the octopus case in the brief), generalizable to any exact count.
Postscript — 16 November 2026: the checker, checked
Added 16 November 2026, after the events it describes. The original report above is unchanged.
Three days after this report was published, the studio rebuilt its cast’s character sheets under the trace rule, and the rule caught its own referee.
Sunny is the cast’s yellow octopus — golden shadow spots, orange suction cups on the undersides only, amber eyes, a coral-pink bow headband. Muse generated four full-body images of her (two fronts, two backs) and built her palette sheet. All four generations failed the count: the fronts came back at 10 and 12 arms, the backs at 12 and 10.
The editor took two of the images and the palette sheet to ChatGPT to have the extra arms removed, then had ChatGPT produce a complete master character sheet. Reviewing that sheet, the editor found the failure class this report calls the chopped arm — not whole extra arms, but fragments: small pieces of arm tucked underneath visible arms, and two small arms under the body in each of the signature poses. His correction brief to ChatGPT, verbatim (quoted as sent):
Corrections. Signature Poses section - Thinking, Waving, and Celebrating poses, zoom in under Sunny's body, each pose has 2 small arms underneath Sunny's body. Please remove them. Turnaround - Full Body section - three-quarter left, image right side, second arm from the top, there a tiny piece of additional arm on the bottom-side, please remove the little piece of arm. Left Profile - image right side, second arm from the top, there is a tiny piece of additional arm underneath the visible arm, please remove the little piece of arm. Three-quarter Right, image left side, second arm from the top, there is a tiny piece of additional arm underneath the visible arm, please remove the little piece of arm. Right Profile, image left side, second arm from the top, there is a tiny piece of additional arm underneath the visible arm, third arm from the top, there is a tiny piece of additional arm underneath the visible arm please remove the little pieces of arm. do enhance Sunny. Do not make other changes. do you have any questions for me.
ChatGPT applied every correction and changed nothing else. The editor brought the finished sheet back to Muse for trace-rule QA.
Muse reported 10 arms on the front key art, 10 on the rear view, 10 on the three-quarter left, and 9 on the Celebrating pose. The editor answered that he did not see them — and that he had not seen them before, which is why he had brought the sheet to be checked. Re-examined with an independent pointing count — a vision tool required to place a marker on each tip it counts — the key art, the one panel with the whole figure in frame and every tip separated, counted exactly 8. Muse’s tallies were withdrawn, and the editor’s count stood for the other panels.
The error is worth describing precisely, because it is the mirror image of the generators’. The disagreement was never more than one tip per side, in the zone where arms stack and curl back over themselves. Reading zoomed crops, Muse split single arms into two, counting a curl along an arm’s length as a second arm’s tip. The pointing tool is no oracle either: on the densest poses it undercounted, finding 4 tips where the editor counted 8. Where the fan was open, it corroborated the editor. Where the fan was closed, it settled nothing.
The same morning had already supplied the paired case. Checking the editor’s ChatGPT-built Huxley sheet, Muse read 7 arms on the three-quarter-right panel; the editor pushed back; at full resolution the panel counted 8 — two near-parallel arms had merged into one at small zoom. One checker, one day, both directions: arms merged that were two, and arms split that were one.
Nothing in this episode moves the report’s conclusion. Construction remains the only route that can promise the count, because it is the only route that does not depend on reading the count back out of pixels. What the episode adds is the symmetrical limit on the other side of the pipeline: verification by eyeball cannot promise it either — including this report’s own QA, performed by the same kind of visual system whose failures fill the sections above. What worked on 16 November was neither generation nor automated checking. It was a human who knew the design, naming defects one panel at a time — second arm from the top, image right side — and a corrector that followed the brief exactly. The methods note in the first-party section of this report has said all along that the editor’s count governs any dispute. On 16 November 2026, it governed twice.
Postscript — 18 November 2026: the planner, tested
Added 18 November 2026, after the events it describes. The original report and the 16 November postscript above are unchanged.
Two days after the postscript above, a new candidate arrived with the strongest claim yet to be the exception. Muse Image, the first image model from Meta Superintelligence Labs (released 7 July 2026), is sold on behavior, not just rendering: it is described as agentic — it plans a request before it renders, searches the web for references and current facts, and reviews and corrects its own output. Every generator in the sections above maps a prompt to pixels in one pass and never looks back. If any generator could hold an exact count, a self-checking one is the natural candidate. So we ran it through the same test as everything else in this report.
The method was the one already on record in the first-party section. The same twenty pose briefs as the November exercises — same explicit arm maps, same flat-row language (“one single flat row like a paper cutout, NO arms behind the body, NO back row, wide triangular gaps, body held HIGH”), same rule that a prop gets at most one arm, and the same single reference image: the locked character sheet’s full-body front view of Huxley, the studio’s red octopus. One roll per brief, no re-rolls, no selection. Scoring was under the trace rule — exactly 8 arms, every visible segment traced continuously to an emergence or a tip — and, applying the lesson of 16 November, every count was cross-checked with an independent pointing count. The two agreed on all twenty images. The editor’s count governs any dispute, as it has throughout.
One disclosure about access. The test ran through fal.ai’s serving of the model (muse-image-1.0) at $0.01 per image — the same price Meta lists for its own API — for a total of $0.20. Meta’s direct developer route was not used: its sign-in was unreachable from the studio’s assistant browser, and its published setup requires a payment method to be added before any calls are made. Same model, same published price; the serving route is the only difference, and it is recorded here rather than smoothed over.
The result: 2 clean passes in 20. The baseline generator scored 7 in 20 on identical briefs; the trained LoRA scored 0 in 10. Count-correct, the planner managed 3 in 20 against the baseline’s 8.
Its signature error is worth naming, because it is this report’s central mechanism wearing a new coat. The recurring wrong count is 10, built as six lower legs instead of four — the model’s own default octopus template appears to carry a six-leg lower row, and neither the brief’s explicit four-leg map nor the model’s own review pass overrode it. Around that constant, the familiar failures recur: the two meditation-style chest curls added on top of a complete set (Meditating, 12; Idea, 10 — the additive failure, unchanged); back rows returning on Shrug (11) and Dancing (10); Sleeping sprawled into a double fan of 15 arms and Gliding into 14 — the worst counts recorded in any test for this report, on the brief that the baseline passes clean (Exhibit 1a, above). Counting reached exactly 8 and was disqualified by its own raised arms, each forking into a spiral plus a pointed, finger-like tip. Reading broke the one-arm rule again, holding its book with two arms. And the failure direction is no longer reliably over: Bowing came back with 6 arms and no upper arms at all; Presenting, Welcoming and the wave retest with 7.
What the model did better than anything tested here is the thing that is not counting. All twenty images are unmistakably the same character — the red, the darker spots, the gold-amber eyes, the silver headphones present in every single frame — in the studio’s storybook style, from one reference image and no training. The LoRA locked identity through a paid training run; this did it for a cent an image, with no training at all. If the question were “can AI keep a character?”, this postscript would read very differently.
Its two clean passes were Celebrating and Proud — both poses the baseline generator failed at 10. Six of the baseline’s seven clean passes failed here. That symmetry is the finding in miniature: a pose passing tells you about the roll, not about the pose, the prompt, or the model. Generate-and-select remains a lottery. This model’s ticket is cheaper and its character work is better, and its odds on the count are worse.
Nothing in this test moves the report’s conclusion, and one part of it sharpens the conclusion. The planning and self-review happen inside the generation; the reviewer is the same kind of visual system as the renderer, and it no more counted the arms than the checker of 16 November could. A promise requires a step that does not depend on reading the count back out of pixels. Construction is still the only route that has one.
Sources
All links as carried in the underlying research (13 Nov 2026). “Verified live” and “index” follow the research run’s own labels.
- Binyamin et al., Make It Count: Text-to-Image Generation with an Accurate Number of Objects (CountGen), CVPR 2025 / arXiv:2406.10210 — ar5iv.labs.arxiv.org/html/2406.10210 · index, full text opened
- Zhao et al., Demystifying Numerosity in Diffusion Models — Limitations and Remedies, arXiv:2510.11117 — arxiv.org/html/2510.11117v1 · index, full text opened
- Ma et al., Evaluating and Predicting Distorted Human Body Parts for Generated Images (Distortion-5K), arXiv:2503.00811 — arxiv.org/abs/2503.00811v1 · index
- Fang et al., HumanRefiner: Benchmarking Abnormal Human Generation… (AbHuman), arXiv:2407.06937 — arxiv.org/html/2407.06937v1 · index, full text opened
- Kamali et al., Characterizing Photorealism and Artifacts in Diffusion Model-Generated Images, CHI 2025 / arXiv:2502.11989 — arxiv.org/html/2502.11989v1 · verified against the primary source, 13 Nov 2026
- Jain et al., HumanBench: Two Heads, No Legs, But Mostly Human, WACV 2026 — openaccess.thecvf.com (PDF) · index
- Zhang, Rao & Agrawala, Adding Conditional Control to Text-to-Image Diffusion Models (ControlNet), ICCV 2023 / arXiv:2302.05543 — arxiv.org/abs/2302.05543 · index
- Mondal et al., CountLoop: Training-Free High-Instance Image Generation via Iterative Agent Guidance, arXiv:2508.16644 — arxiv.org/html/2508.16644v2 · index
- ComfyUI, Server Routes (HTTP and WebSocket API) — docs.comfy.org/development/comfyui-server/comms_routes · verified live
- Inc. (Ben Sherry), OpenAI’s New Image-Gen Tech Is Now Available for Businesses (gpt-image-1 API, 23 Apr 2025) — inc.com · index; OpenAI API, Images and vision — platform.openai.com/docs/guides/vision · index
- AI Tool Blog, Recraft SVG Export: Both Documented Routes — aitool-blog.com/recraft/guides/recraft-svg-vector-export · index; PromptZone, Recraft V3 guide to raster, vector, and API design workflows — promptzone.com · index
- AI Tool Blog, Midjourney API: No Public Endpoint, and What You Can Do — aitool-blog.com/midjourney/developers/midjourney-api-guide · index
- AIFreeAPI, Midjourney API: No Official Access and What to Use Instead — aifreeapi.com/en/posts/midjourney-api-guide · index
- OpenAI, Terms of Use (eff. 1 Jan 2026) — openai.com/policies/terms-of-use · index (live window blocked by bot check, not bypassed)
- Stability AI, Terms of Service (§11 Disclaimer) — stability.ai/terms-of-service · index; Stability AI, Platform documentation — docs.stability.ai · index
- Prompt Architects, Extra Fingers in AI Images: Why It Happens and How to Fix It — prompt-architects.com · index; cross-vendor doc check dated Aug 2026, secondary source
- Neolemon, AI Children’s Book Illustration Mistakes to Avoid (2026) — neolemon.com · index
- Neolemon, Why AI Characters Keep Changing: 7 Fixes (2026) — neolemon.com · index; vendor blog
- Pencil Help, What Common Errors Should I Look Out for in Image Generation? — help.trypencil.com · index
- P20V, How to Fix AI-Generated Image Artifacts — p20v.com · index
- Equestricare (Facebook), AI horse-anatomy diagram dissection — facebook.com/Equestricare (post) · index
- Valerie Oberreiter Photography (Instagram Reel), AI horse extra / distorted legs — instagram.com/reel/DUTMzCaCN_d · index
- Columbia Journalism Review, The Business of Balance (Ground News method) — cjr.org/analysis/the-business-of-balance-ground-news · index
- Blender Studio, Snow — Character Rig — studio.blender.org/characters/snow/v3 · index
- Blender Deluxe, Automate Blender 5.2 with Python: bpy Scripting Guide — blenderdeluxe.com · index
- OpenAI, Services Agreement (eff. 1 Jan 2026) — openai.com/en-GB/policies/services-agreement · index
- AI Wiki, Midjourney V7 (quoting Midjourney’s official V7 release post) — aiwiki.ai/wiki/midjourney_v7 · index
- Stability AI, Stable Diffusion 3.5 Large model card (Hugging Face) — huggingface.co/stabilityai/stable-diffusion-3.5-large · index
- Google Gen AI SDK documentation (Imagen
generate_images) — googleapis.github.io/python-genai · index - Stability AI Knowledge Base, Self Hosting 101: Deploying Stable Diffusion Models — kb.stability.ai · index
- fal.ai, Playground v2.5 Image-to-Image API Docs — fal.ai/models/fal-ai/playground-v25 · index
- Shortcut Tools, Stable Diffusion commands (A1111
--api/--nowebuiflags, from the WebUI wiki / source) — shortcut-tools.com · index - Ideogram, API Setup — Developer Documentation — developer.ideogram.ai · index
- AnchorTerminal, Leonardo.Ai vs Recraft for AI agents in 2026 (hosted endpoints for both APIs) — anchorterminal.com/compare/leonardo-ai-vs-recraft · index
- Adobe, Firefly API — Overview — developer.adobe.com/firefly-services · index; Adobe, Structure Image Reference — Firefly APIs — developer.adobe.com (structure reference) · index
- Runway, API Getting Started Guide — Runway Dev — docs.dev.runwayml.com · index
- Avalos, F. (editor) & Muse, First-Party Evidence: The Huxley Pose Exercises and the LoRA Test, 13 Nov 2026 — first-party experimental record produced during comic production (20 pose generations; fal.ai FLUX.1 [dev] LoRA, 21 training images, 1,000 steps, $2.35 all-in), tallies recorded contemporaneously in the project log before the struck baseline failures were deleted; exhibits reproduced in the first-party section above. · first-party — not web-derived; limits and confounds stated in the section
- ChatGPT, infographic answering “Is it just a matter of training the renderer on eight-armed octopuses?”, generated 13 Nov 2026 in response to the editor’s question and supplied by the editor the same day. ChatGPT’s accompanying text answer was more hedged than its graphic — it recommended the reference library first and stated a trained model still needs visual verification; the graphic’s promise is audited against the first-party test in Exhibit 5, in the first-party section. · reproduced as an exhibit of the claim — not endorsed as a finding; its “all exactly eight arms” sample caption was trace-checked by the editor on 13 November 2026 and fails — 0 of 9 images verify at exactly 8
- Ngo et al., Learning to Generate Multiple Objects from Dense and Occluded Layouts (AIBL), arXiv preprint, NeurIPS 2026 (arXiv:2607.03488) — arxiv.org/html/2607.03488 · Table 2 (CoCoCount / T2I-CompBench counting: 58 / 60 / 65) verified 13 Nov 2026
- Wadhwa et al., NumBench: Diagnosing Counting Failures in Text-to-Image Models, arXiv:2608.28206 (28 Aug 2026) — arxiv.org/abs/2608.28206v1 · verified against the arXiv abstract, 13 Nov 2026 (640,000 prompts, counts 1–100)
- Google DeepMind, Imagen 4 Model Card (20 May 2025) — cited by title and date; the card carries no stable per-version URL. · verified against the primary source, 13 Nov 2026
- Koch et al., A Two-Stage System for Layout-Controlled Image Generation using Large Language Models and Diffusion Models, arXiv:2511.06888 (10 Nov 2025) — arxiv.org/html/2511.06888v1 · abstract and §3.2: task decomposition improves object recall from 57.2% to 99.9% for complex scenes in the table-setting domain; verified against the arXiv paper, 14 Nov 2026
Bottom line: Which art tool can an AI agent drive — and promise exactly 8 arms? A puppet rig: a Blender 3D armature, a Spine / Live2D 2D rig, or — simplest and most auditable — an SVG vector puppet, built with exactly eight arm parts. Eight arms in, eight arms out — in every pose, every frame, every episode. That is a promise you can put in a contract, with the rig file as the evidence. No AI image generator can make it.
Honed Reports · Researched 13 November 2026. Figures carry the hedges their sources carry; see “Could not verify / open questions” for what remains open.