DOGMA PresenceText v1.0.11

What it is

Two inputs, one output, and its whole purpose is to not run things.

DOGMAPresenceTextV111 takes a DOGMA_PLAN - the category proposal from the planner stage - and a text input carrying a VLM's presence verdict. If there's a plan, it passes the text through as presence_text. If there's no plan, it returns [] and the upstream model never gets asked.

The clever part isn't the pass-through, it's the word lazy on that text input. In ComfyUI, a normal required input forces its producer to execute: connect a VLM node's output to something and the VLM runs, every time, whether or not the result is going to be used. An input declared lazy gets to say "not yet" through a check_lazy_status callback. This node's version reads:

return ['text'] if there's a proposal and text hasn't arrived; return [] otherwise.

So on a frame where the inventory stage found zero usable categories - an empty plan, or a plan whose categories were all canonicalised to inactive - the presence check is skipped entirely and you save an 8B vision model load that would have told you "nothing present" about nothing.

Why that's worth a node

The pack this belongs to came out of exactly that pain. The 1.0.7 release notes are a description of a workflow where an ordinary list-mapped VLM node with unload_after=True reloaded and re-quantized an 8B model for every item in a list, and the fix was an adapter that owns one worker for one list and clears it in a finally block. When your audit loop costs a model load per call, "don't call it when there's nothing to check" stops being a micro-optimisation and starts being the difference between a two-minute run and a fifteen-minute one.

The pattern is repeated all over the 1.0.11 release: three lazy phase switches, a lazy save node, a lazy coverage search that skips its SAM model and CLIP inputs when the category is inactive. This is the smallest instance of it.

Inputs and outputs

• proposal (DOGMA_PLAN) - the category proposal bundle from the planner stage (DOGMAProposeCategoriesV111 produces this along with the prompt you send to the VLM).
• text (STRING, forced to a wire, lazy) - the VLM's answer about which proposed categories are visibly present. It's the same string list the verifier node downstream wants.

Output:

• presence_text (STRING) - the text, passed through untouched, or the literal [] when there was no proposal. Wire it into DOGMAVerifiedPlan8V111, which parses it as a JSON array of {id, verdict, evidence} rows and marks each proposed category CONFIRMED or SKIPPED.

Emitting [] rather than erroring is the right call: an empty array parses cleanly, every category ends up SKIPPED for lack of a positive verdict, and the graph continues with "nothing to render" instead of a stack trace. Note the direction of that logic, too - the design is that a missing verdict can never confirm a category. Uncertainty fails closed.

Getting it wrong

Lazy only works if nothing else needs the VLM. If some other node in your graph also consumes the VLM's output, ComfyUI has to run it to satisfy that consumer, and this gate saves you nothing. The optimisation is real but local: it depends on the model output having exactly this one consumer.

It's not a validator. This node does not inspect the text, does not check that the verdicts parse, and does not verify anything against the image. Parsing, duplicate-ID detection and the accept/skip logic all live in the verifier node downstream. This is a gate, not a check - if your VLM returns malformed JSON, you'll find out there.

If proposal is falsy, your text is thrown away. That's usually what you want, but if you're reusing this node for something else - say, feeding a caption branch - remember its answer to "is there anything to look at?" is entirely the plan's truthiness.

Install

Manager → search DOGMA Nodes (publisher axior), or:

cd ComfyUI/custom_nodes
git clone https://github.com/axior/ComfyUI-DOGMA-Nodes
# restart ComfyUI

scipy>=1.10 is the pack's only declared Python dependency, and the pack downloads no models and patches nothing in ComfyUI core. The VLM itself is your choice - the pack's workflows use ModernVLM from comfyui_vlm_nodes, and the 1.0.12 changelog documents capping that planner's output at 320 tokens with a single recovery attempt at 192 because long repetitive JSON was being truncated mid-object. If you're building the same loop with a different VLM, expect to spend a few minutes on output length and JSON validity; that part isn't node-specific, it's just VLM-shaped work.