GPT writes fluently but has never seen a photo — the arc that gave text models eyes

A next-word predictor writes, reasons and follows instructions, and it is blind in a way no amount of tuning fixes: everything it receives is text. What happened in the years that followed was not the replacement of that model. It was the same attention-only block being pointed at one different thing at a time, with each fix relocating the bottleneck rather than removing it. First an objective that let language address images, then a single trained matrix onto a frozen eye, then an arithmetic bill for every pixel, then a coordinate system that had to describe space and time. The arc's last stage moves the boundary from seeing to acting, and it ends on a measured failure rather than a victory lap.

GPT is blind because its input is text — and one attention-only block serves all four stages

The arc is four stages of one unchanged block, and each stage's leftover hole is what forced the next one to exist.

The block underneath all four is one stack. Its paper describes the encoder as "a stack of $N=6$ identical layers. Each layer has two sub-layers. The first is a multi-head self-attention mechanism, and the second is a simple, position-wise fully connected feed-forward network", with a residual connection and layer normalization around each sub-layer, and it adds positional encodings to the input embeddings at the bottom of the stack because there is no recurrence and no convolution to encode order otherwiseTransformer.

Caption: The paper's own encoder-decoder diagram. What survives into every later stage is the sub-layer recipe: attention, Add & Norm, feed-forward, Add & Norm. The paper injects order by summing positional information into the embeddings at the bottom. What the GPT line drops is the encoder-decoder split itself, the encoder stack and the cross-attention sub-layer that reads it. The diagram shows the forward computation only; it contains no decoder-only variant, no training loop, and nothing about images or audio.Transformer

Two facts about that 2017 paper matter for reading the rest of this article accurately. It demonstrated generality on one extra text task, English constituency parsing, and its conclusion only plans extension to "input and output modalities other than text … such as images, audio and video". And it contains no decoder-only configuration at all. A masked self-attention stack with the encoder and the cross-attention sub-layer removed is a later simplification, and the paper where that family's architecture and objective are stated describes its model as using the earlier GPT-2 architecture with sparse attention patterns in the transformer layersGPT-3.

The objective is what makes the first stage blind. GPT-3 is "an autoregressive language model with 175 billion parameters", and for every task it is "applied without any gradient updates or fine-tuning, with tasks and few-shot demonstrations specified purely via text interaction with the model"GPT-3. Behaviour therefore changes by changing what is fed in, never by retraining. The paper draws the contrast itself: only the fine-tuning panel of its four-panel figure carries gradient-update arrows, while zero-shot, one-shot and few-shot supply a task description and some examples and let the frozen model complete the pattern.

Caption: Zero-shot, one-shot and few-shot contrasted with traditional fine-tuning. Only the fine-tuning panel contains gradient-update arrows, which is the whole point: the demonstrations live in the prompt, and the weights do not move. The figure carries no accuracy numbers, so nothing can be read off it about which setting scores better.GPT-3

The lecture deck tells the same story in its own words, and its two slides are worth keeping separate from the papers, because their numbers are the deck's and not the sources'. The deck's evolution chart gives GPT-1 as 117 million parameters and GPT-4 as roughly one trillion, with its own caveat that it is "not sure" whether GPT-4 is a fine-tuned version of the previous model. The GPT-3 paper states 100 million parameters for GPT-1 in its own introduction, so the deck's figure for that row disagrees with the primary source; only the 175B figure for GPT-3 is confirmed by the paper. The deck's few-shot slide is the same idea as the paper's fourth panel drawn a second way, and it is useful for one reason: its one-line definition, that the model "sees a few examples of the task" and that "no gradient updates are performed", is the shortest statement of the pattern the whole arc repeats.

Caption: The lecture deck's own chart of GPT-1 through GPT-4, a left-to-right arrow with five numbered stages and one info box per model. The parameter counts and claims in those boxes are the deck's numbers, not verified primary-source facts: the paper states 100 million parameters for GPT-1 rather than the deck's 117 million, and the deck's own "not sure if its a fine tuned version" line is a hedge rather than a finding.

Caption: The deck's rendering of few-shot prompting: a line-numbered prompt block whose first line is the task description, whose next three lines are examples, and whose last line is the prompt to complete, with the note that no gradient updates are performed. It is the deck's picture of the same mechanism as the paper's four-panel figure, not a second independent piece of evidence.

Blindness here is structural, not a gap in tuning. The paper says it directly: large pretrained language models "are not grounded in other domains of experience, such as video or real-world physical interaction, and thus lack a large amount of context about the world", and it names "adding additional modalities such as images to provide grounding and a better model of the world" as the direction worth pursuingGPT-3. The hole the next stage fills is stated by the paper that has it.

CLIP sees by matching instead of generating — which is why it hands back vectors, not sentences

CLIP's achievement and its ceiling are the same design decision. By learning to match rather than to generate, it made visual representation addressable in natural language and made itself unable to speak.

The baseline it inverts is a closed-world classifier: human annotators label millions of images with category names, a model is trained to map each image to its label, and the deployed model classifies into those fixed categories. A 1,001st category needs new data and retraining, the labels are isolated words with no relationships between them, and the result is classification rather than semantic understanding. CLIP's move is to invert the task. Instead of predicting a label, it predicts "which caption goes with which image" across a dataset of 400 million image-text pairs collected from the internet, and after pre-training, as the paper puts it, "natural language is used to reference learned visual concepts (or describe new ones) enabling zero-shot transfer of the model to downstream tasks"CLIP.

Caption: Three panels that carry the whole stage. The left panel is the standard supervised image model CLIP inverts: a CNN backbone feeding a linear classifier over a fixed label set. The centre panel is the inverted task, an N×N grid of cosine similarities whose diagonal marks the pairs that actually occurred. The right panel is zero-shot inference, where the class names are written into a prompt, embedded by the text encoder, and compared against the embedded image. The text encoder embeds prompts, it does not write captions.CLIP

The trick that makes the representation addressable is that the zero-shot classifier is not trained at all. For each dataset, the class names are the candidate texts; image and text embeddings are compared by cosine similarity and softmaxed, and the paper describes the prediction layer as "a multinomial logistic regression classifier with L2-normalized inputs, L2-normalized weights, no bias, and temperature scaling". A sentence points the model at a class, and the weights of that classifier are generated by the text encoder rather than learned per task.

The headline number is worth stating with its metric and its qualifier attached. On ImageNet zero-shot top-1 accuracy, the best CLIP model moves the result from a proof-of-concept 11.5% to 76.2%, while using none of that dataset's 1.28 million crowd-labelled training examples, and it matches the original ResNet-50 in the paper's own words rather than on a printed baseline number. Across a 27-dataset suite, a zero-shot CLIP classifier beats a fully supervised linear classifier fitted on ResNet-50 features on 16 of them.

The ceiling is the same decision seen from the other side. CLIP is "still limited to choosing from only those concepts in a given zero-shot classifier", which the paper calls "a significant restriction compared to a truly flexible approach like image captioning which could generate novel outputs"CLIP. That whole-image-against-whole-sentence training signal also means the model never learns region-level correspondence: it can tell that a dog and a cat are both in the frame, but not that the dog is to the left of the cat. The visual result of the constraint is easy to see: every cell of the paper's prediction grid offers a fixed list of candidate class names, a prompt template and a probability, and never a sentence.

Caption: A grid of examples from 36 CLIP zero-shot classifiers. Each cell shows an input image and, under it, the top five class-name predictions with the prompt template used and a probability, ground truth in green and a wrong top-1 in orange. What the picture shows is the boundary: the output is always a choice from a supplied class list, never free-form text about the image. It is a qualitative visualisation, not a benchmark result.CLIP

That same design decision is why CLIP became something later systems reuse instead of something that got superseded: the paper released the code and the pre-trained weights, so the frozen eye could be plugged into a system that already had a generator and a conversational host. Keeping the three verbs apart matters here. CLIP sees in the sense that it produces a representation language can address; it does not understand an image the way a captioning model does, and it does not ground a region.

A single trained matrix is the whole bridge — and it improved by redesign, not by growing the LLM

The second hand-off needs no shared embedding space and no retraining of the two large models. One trainable matrix is enough, and it then got better three times by redesign rather than by size.

The question LLaVA answers is how to get a vision encoder's vectors and a language model's tokens into one sequence when the two were trained separately and share no space. Its answer is the smallest possible one. The vision encoder is a frozen CLIP ViT-L/14 producing visual features, the projection is "a simple linear layer to connect image features into the word embedding space", and the language model is a frozen VicunaLLaVA. Only that one matrix moves in the first training stage.

Caption: The figure's own labels are the argument. An image enters the frozen vision encoder to give a visual feature, that feature is multiplied by a projection W to give a token-shaped vector, and a language instruction is embedded into the same point, with both streams feeding the language model. W is the only element drawn as trainable between two large frozen blocks. It is the original LLaVA's architecture, not LLaVA-1.5, which replaced the linear projection with a two-layer MLP and moved the encoder to a higher resolution.LLaVA

Two large models with incompatible types, one adapter between them, and the mapping is exact. The vision encoder is a service that returns vectors of one dimension; the language model is a service whose interface accepts embeddings of another. Neither side can be retyped cheaply, since retraining either one is what the minimal design exists to avoid. So you write one adapter that translates one interface into the other and train only the adapter. That is exactly what happens in training stage one, where the encoder and the LLM stay frozen and the projection matrix is the only parameter that moves, and the paper's own gloss on the stage is that it "can be understood as training a compatible visual tokenizer for the frozen LLM". Swapping the linear adapter for a two-layer MLP, which is what LLaVA-1.5 does, is the same move as giving an adapter a nonlinearity: no larger service gets rebuilt.

Why it scaled at all is the other half of the design. The supervision was written, not annotated. The teacher reads text only, and the image reaches it as symbols rather than pixels: captions describing the scene and bounding boxes encoding each object's concept and location. The paper states the consequence plainly, that the image "is not used to prompt GPT", and the only human annotations in the whole pipeline are a few seed examples used as in-context demonstrations.

The volume is 158K unique language-image instruction samples in total, and stage two trains the projection plus the language model on them while the encoder stays frozen. Training is staged for a reason: the projector learns to translate on 595K caption pairs first, before anything else is allowed to move.

The beat that stops this joint from looking like one frozen design is what happened next. LLaVA-1.5 changed three things and roughly doubled the score without growing the language model. The abstract names them in one sentenceLLaVA-1.5: a two-layer MLP connector instead of the single linear layer, a higher-resolution CLIP encoder, and academic-task VQA data with a response-format prompt. The measured cost is small: 1.2M publicly available samples and about one day on a single 8×A100 node.

Caption: A three-part composite: a radar of benchmark standings, a log-scale bar chart of training sample counts in which LLaVA-1.5's bars are visibly the shortest, and a small sketch of the same encoder, projection and language model arrangement with the connector as the trained piece. The radar does not mean LLaVA-1.5 leads every benchmark, and the figure does not plot the score progression; those numbers come from the paper's own ablation table.LLaVA-1.5

Attribution on that ladder has to stay honest, because the deck's version of it is coarser than the paper's. On the MME benchmark the paper's ten rows run 809.6, 1197.0, 1323.8, 1355.2, 1377.6, 1426.5, 1450, 1469.2, 1510.7 and 1531.3. The biggest single jump is the first one, data plus prompting, 809.6 to 1323.8. The MLP connector alone is worth about 31 points. The top rung is the only one that grows the language model from 7B to 13B, so "it roughly doubled without growing the LLM" holds up to the 1510.7 rung and no further.

With the bridge working, the constraint becomes arithmetic: the token bill, and a coordinate that must describe space and time

Once the bridge works, the binding constraint moves from mechanism to arithmetic: how many tokens a picture costs the language model, and how each of those tokens is addressed. Both halves of that input contract changed within eighteen months.

The arithmetic is not large, and that is the point. A 224×224 image with a patch size of 14 is a 16×16 grid, so 256 patches; an MLP after the vision encoder compresses each 2×2 block of them into one token, giving 66 tokens before anything reaches the language modelQwen2-VL. A fixed 224 square therefore costs a fixed bill no matter what is on it, and the previous stage's design had made resolution a constant of the architecture.

Naive dynamic resolution is what turns that constant into a function of the input. Images are processed at their native size, and the token count follows the picture.

Caption: Four inputs at their native sizes, each carrying its own token bill: a tall web-page screenshot (8204×1092) costing 11,427 tokens, a small formula crop (28×224) costing 8, a landscape photo (700×1260) costing 1,125, and a 16-second video strip costing 2,208. The same figure shows the Vision Encoder feeding the decoder; it is not a layer-by-layer architecture diagram, and the counts are illustrative inputs rather than benchmark results.Qwen2-VL

A visual token is now a line item in the context budget, and that framing is worth spelling out because it explains why the next constraint is arithmetic rather than architecture. The tokens an image consumes occupy the same finite window as the instructions and the conversation, and every one of them costs attention computation at every layer it passes through. So "see more" and "read more" are the same expense: a page screenshot that is worth 11,427 tokens has spent most of a modest window before the question is even asked. That is why the paper also caps the total per video at 16,384 tokens during training, implemented by shrinking each frame's resolution, with inference reported up to 80,000 tokens.

The resolution ladder, one line each rather than a tour: a fixed 224-pixel square in April 2023, a 336-pixel encoder plus a grid split into tiles concatenated with a global view in October 2023, and native dynamic resolution in September 2024.

The coordinate has to grow in the same period, and for a concrete reason. A patch cannot be a flat sequence index any more, because a patch has a row and a column, and a video frame has a time on top of both. Qwen2-VL's answer is to deconstruct the rotary embedding into three components, temporal, height and width, so that a text token uses identical ids on all three axes and reduces to ordinary 1D position encoding, an image patch holds its temporal id constant while height and width carry its row and column, and a video frame increments the temporal id per frameQwen2-VL. The scheme is called M-RoPE, and keeping that name straight matters: the string "2D-RoPE" in the same paper labels the vision encoder's own two-dimensional encoding, not the three-axis scheme.

Caption: The three-way id assignment. A patch keeps its temporal id fixed while height and width carry its row and column; the same patch in a later frame advances only the temporal id; a text token uses one value on all three axes, which collapses the scheme back to ordinary 1D position encoding.

The change is the same lesson as replacing a counter that resets with an absolute timestamp: an index tells you the order of the frames you happened to sample, while a timestamp tells you when the thing actually happened. Both are positions, but only one of them survives a change in sampling rate, and that is exactly the flaw the next release fixes. Qwen2.5-VL states it in its own words: "the temporal position IDs in MRoPE were tied to the number of input frames, which did not account for the speed of content changes or the absolute timing of events within the video"Qwen2.5-VL. The fix aligns the temporal component with absolute time, so the intervals between time ids carry the tempo of the content.

Caption: The pipeline diagram carries the mechanism in two insets. "Sampled MRoPE Time IDs" shows the temporal ids assigned to sampled frames, and below the video branch an axis running from 0.0s to 8.0s sits under the label "Align with Absolute Time", so the time id is a moment in seconds rather than a frame number. The same figure shows the vision encoder feeding the Qwen2.5 decoder and the re-engineered vision transformer stack. It does not show the action format or any interface interaction.Qwen2.5-VL

By late 2025 the design goes one step further and decides that time does not belong in the position channel at all. Qwen3-VL replaces the absolute-time scheme with textual timestamp tokens, prefixing each video temporal patch with a formatted string such as <3.0 seconds>, and adopts an interleaved M-RoPE that distributes the temporal, height and width components across the embedding dimensions so that each axis is represented in both low and high frequency bands. The stated reasons for dropping the previous form are concrete: tying temporal position ids directly to absolute time "produces excessively large and sparse temporal position ids for long videos", and effective learning under that scheme required expensive sampling across many frame ratesQwen3-VL. Its cost is stated too, a modest increase in context length.

Caption: The shape has not changed: a vision encoder, a merger, and a language model. In this release three intermediate layers of the encoder each route through their own MLP merger into the first three layers of the language model, and an inset shows the interleaved position-encoding pattern alongside the text-based video timestamp tokens. The figure is the clearest single view that the arc is one story rather than four, since the encoder, merger and language model arrangement is the one the third stage established.Qwen3-VL

So the joint has three places where it keeps being rebuilt: the projector, the resolution, and the coordinate system. None of the three is a matter of making the language model bigger.

The boundary has moved from seeing to acting — and the bottleneck is now error recovery, not perception

The lecture's capability boundary is a lecture statement, and it has already aged. The acting stage that took its place is genuine, and what limits it is no longer perception.

The deck's own cannot-do list is worth stating first as the deck's: a vision-language model can describe image contents, answer visual questions, read document text and ground video, but it cannot click a button, run code and iterate, operate a phone or desktop, or hold a persistent multi-step task. No primary source for that particular list turned up in this material, so it stands as the lecture's framing of where the boundary was.

What moved is visible in the releases. Grounding output is expressed in the input image's actual pixel dimensions rather than normalized coordinates, and the training data for device operation was unified across mobile, web and desktop into what the report calls "a function call format with a shared action space"Qwen2.5-VL. The lecture's four-verb list and its coordinate example are the lecture's; the paper itself never enumerates individual actions, so the honest version of the claim is the shared action space rather than a verb inventory. By late 2025, GUI-agent interaction data appears in one such model's training mix, alongside function-calling and search trajectories, with the training corpus explicitly including cross-platform desktop, mobile and web environmentsQwen3-VL.

Caption: A basketball photograph annotated with six colour-matched points and labels naming players and body parts, the visual half of a point-grounding demo. It makes "the model names a coordinate" concrete: the point primitive is the same shape a click target needs. The pixel values themselves live in the JSON text beside it on the release page, not in the picture, and this is an object-grounding example on a natural photograph rather than an interface screenshot.Qwen2.5-VL

The stop-check on all of this is a measurement rather than a model. Computer-use agents are agents that "automate digital workflows via fine-grained keyboard and mouse operations"ReTrace, and the 2026 study that supplies this article's closing evidence stops asking whether an agent can do a task and starts asking whether it can put the world back after it has already broken it. Its criterion is stated in one line: identical downstream actions from the recovered and target states must yield identical outcomes. That criterion is stricter than it looks, because a screenshot comparison is not enough. Latent parts of the environment can change without any visible difference, so a recovered state can look right and still behave differently.

Caption: A three-panel measurement pipeline. Panel A rolls out each policy and replays the identical action sequence several times to build a dataset whose transitions are repeatable. Panel B selects a state as the recovery target and perturbs the agent off-track into a genuinely erroneous state. Panel C lets the agent act from the recovered state, then replays the remaining actions of the original trajectory from there and compares whether the original task outcome is reproduced. It is a measurement procedure, not an architecture, and it contains no scores, no model names and no error taxonomy.ReTrace

The finding that matters is not that agents are unreliable. It is that the capability is present and not called for. The recovery capability of current computer-use agents "is latent rather than absent, but such capabilities are not effectively elicited during standard forward task execution"ReTrace. Read against the earlier stages, that is a statement about invocation rather than about weights: the same block that can already name a coordinate is not being asked, in normal execution, to notice that it has drifted. The measured gap is wide. On short-horizon implicit recovery on the OSWorld benchmark, the strongest open-source post-trained agent averages below 1% recovery, while one closed-source agent reaches 26.98% at a recovery budget of 2; supplying explicit recovery instructions moves recovery success by an average margin of 17.86% across the Linux and Windows environments. The end-to-end picture is small and not uniform: in the OSWorld comparison the paper reports in its end-to-end table, under the same recovery-target contextualization setting over two independent runs, two of the four models move down (UI-TARS-1.5-7B 17.25% → 15.74%, EvoCUA-32B 54.88% → 51.55%) while the two stronger ones move up (Qwen3.5-9B 38.76% → 41.56%, Claude-Sonnet-4.6 70.27% → 71.81%). The paper's explanation of why even that is a gain worth having is a good summary of what still breaks: even imperfect recovery can unlock latent capability, and weak recovery can actively derail a trajectory.

The two concrete failure modes are worth naming, because both are about state rather than about seeing. In the first, agents fixate on elements distinct from the target state and rely on them when choosing the next action. In the second, agents assume the restored state matches the target and fail to register the discrepancy. Neither is a perception failure in the sense the earlier stages were about.

Four stages, one hand-off story: a reusable block plus a power law explain why the arc kept moving

The arc moved four times without needing a new idea each time, and two ideas explain why: one block that accepts whatever is fed into it, and a scaling relationship that made size a reliable lever. Neither is unlimited, and the limits are worth as much as the claims.

The block is the first idea, and the reason a second modality needed no rewrite is that there was nothing modality-specific in it to rewrite. It is a sequence of tokens plus a positional signal, and the sub-layer pattern does not care whether a token came from a word piece or a patch. That is a reading of the architecture, and it should be kept apart from what the paper actually demonstrated: one extra text task, with images and audio named only as a future plan.

The power law is the second, and its subject is narrow. It is about the cross-entropy loss: "the loss scales as a power-law with model size, dataset size, and the amount of compute used for training, with some trends spanning more than seven orders of magnitude", architectural details such as width or depth have minimal effect within a wide range, and larger models are significantly more sample-efficientScalingLaws. Under a fixed compute budget the paper's own recommendation is to spend it mostly on a bigger model and bigger batches rather than more serial steps, and the experiments are decoder-only Transformers on one text corpus, so nothing in it measures a multimodal model.

The same paper warns against the inference a reader will want to make. "Smooth quantitative change can mask major qualitative improvements", and "the smooth improvements in language model loss may hide seemingly qualitative changes in capability"ScalingLaws. The law predicts a number, not a list of abilities, and reading abilities off a smooth curve is the mistake it flags.

The claim that abilities appear at thresholds is a separate one, and it is contested. Its definition is precise: "an ability is emergent if it is not present in smaller models but is present in larger models", and therefore "emergent abilities cannot be predicted simply by extrapolating the performance of smaller models"Emergence. Its own qualifiers are equally precise: the scale at which an ability is first observed to emerge "depends on a number of factors and is not an immutable property of the ability", model scale is not the singular factor, and the choice of metric changes what looks discontinuous. A published counter-argument (Schaeffer et al., 2023) goes further and argues that the apparent thresholds are manufactured by discontinuous metrics. The honest way to carry this into the rest of the arc is as a claim under dispute rather than as settled law, which is also why it cannot be used to promise that the acting stage's remaining failure will be solved by more parameters.

The lecture's own growth tables are useful as a sense of scale, and only as the lecture's. Its dataset table pairs GPT-1's 117 million tokens with GPT-2's 40GB of text and GPT-3's 45TB, and its model-size table renders 117M, 1.5B and 175B as equivalent numbers of ResNet-18 models, roughly 10, 128 and 14,957. None of those values comes from the scaling-law paper, whose own regime is far smaller, and only the 175B figure for GPT-3 is confirmed by the GPT-3 paper. They are the deck's numbers and are labelled as such.

Caption: The lecture deck's two-column table of dataset sizes: GPT-1 at 117 million tokens, GPT-2 at 40GB of text data, GPT-3 at 45TB of text data. These are the deck's values, and they also mix units, so they are a rough sense of growth rather than a measured series.

Caption: The lecture deck's model-size table, with an "equivalent ResNet-18 models" column: 117M parameters as roughly 10 ResNet-18s, 1.5B as roughly 128, and 175B as roughly 14,957. The ResNet-18 multiples are the deck's rhetorical bridge to a sense of scale, not a measurement anyone made.

What makes these four stages one story rather than four is that each one handed its output to the next as an input, and nothing was replaced along the way.

Caption: The hand-off chain rather than a replacement chain. Each station inherits the previous station's output as an input, the block underneath stays the same, and the question at each arrow is the hole the station before it left open.

The dates are worth having in one place, because they show how compressed the changes were once the bridge existed.

An attention-only block that never changed shape, pointed at text and then at images and then at video, plus a scaling relationship that answered "how do we get better" for five years, is enough to explain how the arc kept moving without a new idea at every step. It also explains why the arc has no clean ending. The capability boundary at the far edge is not a modelling limit of the kind the earlier stages had; it is a capability that exists in the weights and is not called for during normal execution, which is a different kind of problem from the ones the projector, the resolution and the coordinate each solved.

参考文献

1. Attention Is All You Need — arXiv:1706.03762
2. Language Models are Few-Shot Learners — arXiv:2005.14165
3. Scaling Laws for Neural Language Models — arXiv:2001.08361
4. Emergent Abilities of Large Language Models — arXiv:2206.07682
5. Learning Transferable Visual Models From Natural Language Supervision (CLIP) — arXiv:2103.00020
6. Visual Instruction Tuning (LLaVA) — arXiv:2304.08485
7. Improved Baselines with Visual Instruction Tuning (LLaVA-1.5) — arXiv:2310.03744
8. Qwen2-VL: Enhancing Vision-Language Model's Perception of the World at Any Resolution — arXiv:2409.12191
9. Qwen2.5-VL Technical Report — arXiv:2502.13923
10. Qwen3-VL Technical Report — arXiv:2511.21631
11. Lost in Recovery: Demystifying Recovery Behavior of Computer-Use Agents via Goal-Oriented Action Replay — arXiv:2610.27954