Native VLM Segmentation: The Mechanics of Generating Masks from Pure Tokens

The Autoregressive Mask Token Economy

The first thing to understand about pure VLM segmentation is that there is no mask head, no convolutional decoder, no upsampling feature pyramid. There is only the transformer, the vocabulary it was trained on, and the next-token prediction loop. When Astra "does segmentation," it is doing something deceptively simple: it is writing a description of the mask as text, and the model happens to be extremely good at that task.

The input side is straightforward enough. A high-resolution image gets tiled or patched into visual tokens, roughly 2,052 tokens per image. That's a generous visual budget, deliberately tuned so that sub-object spatial details survive into the representation. You don't get fine contour delineation from a coarse tokenization; the model needs enough visual fidelity in context to even attempt precise geometry.

The output side is where things get radical. Instead of emitting a compact latent vector that a decoder turns into a mask, the model generates thousands of discrete tokens (around 4,685 per image) in the same sequence it uses for reasoning, conversation, and grounding. Some of those tokens are reasoning tokens, the model working through the scene, resolving occlusions, deciding which instances to segment. Many of them are spatial tokens: polygon vertices as [x, y] pairs, compressed RLE strings, or vector-quantized codebook entries. The mask doesn't exist as a tensor anywhere until you parse the output stream; it exists as a sequence of words.

This is the unification that makes the approach compelling. Critically, the reasoning and the geometry share the same autoregressive decoder, so the test-time reasoning actually conditions the mask generation. The model can "think" about a query like segment the object that would fall first if the table tilted and let those reasoning tokens inform the subsequent coordinate emissions. A hybrid system with a [SEG] token routed into SAM's prompt space cannot do this; the reasoning ends where the decoder begins.

But that unification has a price, and it is entirely a cost of sequential generation. Producing 4,685 output tokens means 4,685 autoregressive decode steps per image. Each step depends on the previous one, there's no parallelism to exploit in the decode loop beyond what the batch provides, and the KV cache grows with every emitted token. For an inference engine like vLLM, that's the difference between serving hundreds of concurrent lightweight requests and serving a handful of segmentation requests. Memory bandwidth becomes the bottleneck, and GPU occupancy plummets when a single request holds a multi-thousand-token KV cache. I've seen this pattern enough times to know: the architectural elegance of "everything is a token" is real, but the serving economics are unforgiving.

flowchart LR
    subgraph Input
        IMG[Input Image] --> PATCH[Patching / Dynamic Tiling]
    end
    subgraph Model
        PATCH --> TOK[Visual Tokens ~2K]
        TOK --> TRANS[Unified Autoregressive Transformer<br>Same stack for language and visual tokens]
    end
    subgraph Output
        TRANS --> STREAM[Output Token Stream]
        STREAM --> R1[Reasoning Tokens<br>resolving occlusion, deciding instances]
        STREAM --> S1[Spatial Tokens: Vertex 1 x,y]
        STREAM --> S2[Spatial Tokens: Vertex 2 x,y]
        STREAM --> R2[More Reasoning Tokens]
        STREAM --> S3[Spatial Tokens: RLE string segment]
        R1 --> MASKS[Multiple Masks Reconstructed<br>from parsed output stream]
        S1 --> MASKS
        S2 --> MASKS
        S3 --> MASKS
    end

What Breaks When Coordinates Become Words

Autoregressive geometry is not really geometry anymore. It is grammar. And grammars can produce structurally valid sentences that describe impossible shapes. This is the core failure mode: coordinate drift. Each vertex is emitted conditioned on the previous token, so a single hallucinated coordinate doesn't just produce a local error, it steers the entire subsequent sequence. The model can smoothly generate a "correct-looking" polygon that actually self-intersects, or fail to close the loop entirely and just keep emitting vertices until the generation stops. A mask decoder like SAM never does this; its convolutional upsampling is constrained by spatial priors that enforce continuous, closed regions. An autoregressive model has no such constraint unless you post-process.

The errors cascade. In a multi-instance scene, the boundary error on object one corrupts the KV-cache context for object two, and the model's subsequent contour emissions drift further from ground truth. It's the classic autoregressive error accumulation problem, but now applied to geometry instead of text, where a single bad coordinate can be catastrophically visible downstream.

There's also a resolution mismatch. Coordinate bins, whether normalized integers or discrete codebook entries, impose spatial quantization. At standard image resolutions the stepping is tolerable, but push to 4K satellite or medical imagery and a 0.1% quantization error becomes a multi-pixel offset that produces jagged, staircase boundaries. High-frequency detail (hair strands, cables, cell membranes) is the worst case; the token budget needed to represent even a rough approximation of these structures spirals.

And crowded scenes expose the token budget as a hard wall. Instance count scales linearly with token consumption, so a scene with forty small objects can exhaust the output limit mid-generation, leaving the rest of the image unsegmented. There is no "return partial results" mechanism in a sequence that truncated. Syntactic corruption compounds this. A premature end-of-turn token, a malformed RLE prefix, a parsing hiccup in a JSON schema, any of these renders the entire output unparseable. For multi-thousand-token outputs, the probability of at least one decoding irregularity is not negligible.

stateDiagram-v2
    [*] --> EmittingVertex1
    EmittingVertex1 --> EmittingVertex2
    EmittingVertex2 --> EmittingVertex3
    EmittingVertex3 --> SelfIntersectionDetected: coordinate error
    SelfIntersectionDetected --> CorrectionViaReEmission: model re-emits vertex
    CorrectionViaReEmission --> PolygonClosed
    EmittingVertex3 --> PolygonClosed: no errors, loop closed
    EmittingVertex3 --> UnclosedNoEndSequence: drift, no closing vertex
    EmittingVertex3 --> TokenBudgetExhausted: output limit hit
    TokenBudgetExhausted --> [*]: generation crashes
    UnclosedNoEndSequence --> [*]: failure, unparseable output
    PolygonClosed --> [*]: valid mask emitted

Why Hybrid Pipelines Still Hold the Latency Crown

The tradeoff between architectural elegance and serving practicality is stark when you put the numbers side by side. A pure VLM spends somewhere in the range of 4,000 to 6,000 output tokens per image on segmentation. A hybrid system — one that uses a VLM to generate a [SEG] token and routes that hidden state into a SAM decoder — needs maybe 50 to 200 tokens. A pipeline system like Grounding DINO feeding bounding boxes into SAM is even leaner on the language side. The mask generation itself happens in a single forward pass through a convolutional or transformer decoder, which is a fundamentally different compute profile from 4,685 sequential autoregressive steps.

Latency follows directly from this. Pure VLM segmentation takes seconds to tens of seconds per image because each output token requires a full decode step with memory-bandwidth-bound attention. Hybrid and pipeline systems complete in sub-second time. This isn't a marginal difference; it's the difference between an interactive robot that can see and react in real-time and one that pauses to think for several seconds before every action. For video streaming, robotic control loops, or high-volume document processing, the pure VLM's latency is simply non-viable.

Cost is the other casualty. Inference engines bill on tokens, and a segmentation request that consumes thousands of output tokens dominates a serving queue. The KV-cache memory bloat from multi-thousand-token contexts drastically reduces the batch size an engine like vLLM can serve concurrently. You're not just paying more per request; you're reducing total throughput for every other request on the GPU.

I should be clear about what the hybrid gives up. When you route the VLM's state into SAM, you lose the unified reasoning that makes pure VLM segmentation interesting. The model can no longer interleave reasoning tokens with coordinate tokens, conditioning mask generation on complex semantic deductions. In-context adaptation also suffers. Hybrid systems require task-specific fine-tuning (LoRA on decoders, new adapters for niche domains), while pure VLMs can absorb few-shot demonstration prompts for new segmentation categories without weight changes.

The boundary precision question is nuanced. SAM's inductive biases give it an edge on thin, high-frequency structures — sub-pixel feature maps and edge-aligned pathways that coordinate tokenization cannot easily match. But for complex semantic reasoning, pure VLM wins decisively. If you need "segment the tools that are inappropriate for sterile surgery," that's a reasoning task that happens to produce masks, not a mask task that happens to involve reasoning.

Metric	Pure VLM Segmentation	Hybrid (VLM + SAM Decoder)	Pipeline (Detector + SAM)
Output Tokens/Image	~4,000 – 6,000	~50 – 200	~10 – 50 (box coords + prompts)
Latency	Seconds to tens of seconds	Sub-second	Sub-second (fastest)
Cost Per Inference	Extremely high (thousands of output tokens)	Low-to-moderate	Low (lightweight orchestrator)
Determinism	Non-deterministic (sampling temperature affects contours)	Deterministic mask boundary extraction	Deterministic (detector + SAM)
Reasoning Ability	Excellent (interleaves reasoning with geometry)	Good (reasoning ends at decoder)	Limited (no unified reasoning)
In-Context Adaptation	Strong (few-shot prompting, no fine-tuning)	Weak (requires task-specific fine-tuning)	Moderate (depends on detector's open-vocab coverage)
Boundary Precision	Coarser, prone to polygonization	Very high (SAM's edge-aligned inductive biases)	Very high (SAM output)

The Case for In-Context Segmentation Without Fine-Tuning

The most underappreciated consequence of pure VLM segmentation is what it does to the adaptation problem. When masks are just another token sequence in the model's vocabulary, they inherit all the properties of the language model's long-context capabilities. That's not a marginal convenience; it's a fundamentally different workflow for domain adaptation.

Consider a niche domain like medical imaging. In a hybrid pipeline, adapting to segment a specific anomaly type requires retraining or fine-tuning—a LoRA on the SAM decoder, a new adapter for the VLM, or curated training pairs. That's heavyweight infrastructure for what might be a small-scale or exploratory use case. With a pure VLM, the same adaptation can happen in the prompt. Show the model a handful of examples of the target structure, along with their mask representations, in a single long-context request, and it can absorb the pattern without any weight changes.

This works because the token economy supports many-shot in-context learning far more naturally than a [SEG]-token architecture does. A hybrid model routes a hidden state into a specialized decoder; the decoder has no mechanism to learn from demonstrations in context. The pure VLM, by contrast, can reason over the examples, extract the underlying visual regularities, and condition its subsequent coordinate emissions accordingly.

There are real limitations. ICL in this regime demands significant context window capacity—you're carrying visual tokens for every demonstration plus the spatial tokens they're associated with. The input budget per image is already 2,052 tokens, so a four-example demonstration adds roughly eight thousand tokens before you even ask the model to segment anything new. And the boundary fidelity of ICL-adapted segmentation is generally coarser than fine-tuned expert heads. In-context hints help the model understand what to segment, but they don't provide the high-frequency structural priors that a trained meta-learning approach would bring.

The trade is temporal instead of parametric. You sacrifice some boundary precision and token efficiency for the ability to adapt an entire segmentation capability in minutes rather than weeks. When the domain is transient, exploratory, or genuinely niche, that speed is the difference between a useful tool and a stalled project.## Post-Processing Guardrails: Repairing the Token Spray

If running a pure VLM segmentation model in production, the first thing to internalize is that the model's output is a suggestion, not a mask. The raw token stream contains polygon vertices, RLE strings, or codebook sequences that are only meaningful after parsing and geometric validation. The production system needs a post-processing layer that treats every output as suspect until proven otherwise.

The parsing stage is the first point of failure. Minor schema deviations, premature end-of-turn tokens, or partial RLE strings can render the entire output stream unparseable. Structured output decoding at the inference engine level—CFG grammars, JSON-schema constraints—reduces this risk substantially by constraining the token sampling distribution itself. The model cannot accidentally emit a malformed sequence if the grammar forbids it. This is the cheapest guardrail and should be part of the serving setup, not an afterthought.

Once parsed, geometric sanitization begins. The first objective is fixing self-intersections. A polygon where edges cross—which autoregressive coordinate drift produces frequently—can be repaired using Shapely's buffer(0) heuristic, which resolves invalid geometry by computing the buffer of a polygon with distance zero. This effectively re-shapes the contour into a valid, non-self-intersecting region. Closing open contours and correcting winding orientation follow. A mask that traces back to its starting point is trivial to enforce programmatically, but preserving the orientation convention that downstream consumers expect requires checking the signed area and reversing coordinates if needed.

Polygon simplification via the Douglas-Peucker algorithm is the next step. Autoregressive models often emit redundant collinear vertices during reasoning-heavy generations. Reducing these to a minimal set of significant vertices improves storage efficiency and downstream rendering performance without materially degrading boundary fidelity.

A validation layer then checks the output against the requested schema and confidence thresholds. If the parsed mask is incomplete, the geometry is irrecoverably invalid, or the model's confidence for the segment falls below a threshold, the system should fall back to an alternative path: a SAM decoder for high-precision cases, or a deterministic detector plus SAM pipeline for rapid traversal. This doesn't need to be a full-fidelity segment path; a hybrid fallback that handles the edge cases the pure VLM handles poorly—thin structures, crowded scenes, token truncation—is the pragmatic production decision.

flowchart LR
    A[Raw VLM Output Token Stream] --> B[Parse to Coordinate Sequences<br>RLE strings, vertex pairs]
    B --> C[Sanitize Geometry<br>buffer(0) fixes self-intersections, close contours, correct winding]
    C --> D[Simplify Polygon Vertices<br>Douglas-Peucker removes redundant points]
    D --> E[Validate Against Schema<br>check format, completeness, confidence]
    E --> F{Pass Validation?}
    F -- Yes --> G[Final Mask Output]
    F -- No --> H[Fallback to SAM Mask Decoder<br>single-pass, deterministic]
    H --> G

When to Use Pure VLM vs Hybrid: Production Decision Matrix

The real question in production isn't which approach is "better"—it's which failure mode you can tolerate. Pure VLM segmentation trades throughput and determinism for reasoning depth and adaptivity. Hybrid pipelines trade unified reasoning for speed and precision. The decision matrix below reflects that tradeoff in operational terms.

I'd reach for pure VLM when the segmentation task is really a reasoning task that happens to produce masks. The "tools inappropriate for sterile surgery" example is paradigmatic: the hard part isn't identifying boundaries, it's understanding the semantic constraints that determine which boundaries matter. A hybrid system would need cumbersome orchestration to encode that reasoning, splitting it between VLM and detector in a way that loses the tight coupling between decision and geometry. Pure VLM also wins when you need rapid domain adaptation without re-training—the many-shot ICL path—especially for exploratory use cases where the target distribution may shift while you're still evaluating.

The applications a reader can build around this are diverse. A "Reasoning-Driven Mask" API for niche domains would take user queries requiring semantic understanding and return segmentation masks via long-context in-context learning, demonstrating adaptation without fine-tuning. The watch items are token budget per image, latency spikes, and malformed outputs—hence the fallback to SAM for any task requiring pixel-level precision. Alternatively, a hybrid "Reasoning + Pixel" segmentation system where the VLM reasons and outputs intent (bounding boxes or [SEG] tokens), then SAM generates high-fidelity masks, with routing logic that sends complex semantic queries to pure VLM and real-time traffic to the pipeline. The integration overhead is parsing VLM output into SAM prompt format, but the deterministic latency from SAM is worth it for interactive use. A third option—a post-processing library for autoregressive mask sanitization—is a self-contained utility: auto-repair polygon geometry from any VLM output, validate schemas, detect truncation, and recover error paths. Performance testing with thousands of polygons is critical.

Avoid pure VLM where throughput dominates. Video processing, robotic control loops, high-volume document extraction—all of these need sub-second responses with deterministic outputs, and a thousand-token autoregressive generation cannot deliver that on cost-effective hardware. Pixel-perfect boundaries are another avoid criterion. SAM's inductive bias toward edge alignment and sub-pixel features beats coordinate tokenization on thin structures and alpha masking.

The advantage of hybrid is that you can still get reasoning benefits from the VLM—it generates the box prompts, decides what matters, hands off to SAM for the precise geometry. This works well when the reasoning and segmentation are naturally separable: the model identifies regions of interest, the decoder computes boundaries. Pure VLM shines precisely where that separation breaks down, where each boundary emission depends on the reasoning that preceded it. Choose based on where the coupling lives in your task, not on architectural fashion.

Decision Criterion	Choose Pure VLM	Choose Hybrid (VLM + SAM)
Critical need for in-context adaptation without training	✓	✗
Complex multi-step reasoning tightly coupled to mask selection	✓	✗
Sub-second latency required (real-time video, robotics)	✗	✓
High-volume / high-throughput processing (cost per request critical)	✗	✓
Pixel-perfect boundaries or thin/porous structures	✗	✓
Deterministic, reproducible contour output	✗	✓
Tolerance for multi-second latency per request	✓	✗
Large output token budget acceptable (thousands per image)	✓	✗

Resources

• [2405.09798] Many-Shot In-Context Learning in Multimodal Foundation Models