Why AI Still Struggles to Read an Analog Clock

A single analog clock face packs more “real-world complexity” than most teams expect.

That sounds dramatic—until you look at what researchers found this fall: four multimodal large language models (MLLMs) initially failed to reliably tell time from analog clock images, even when the clocks were clean, synthetic, and perfectly legible to humans. The study (published 16 October 2025 in IEEE Internet Computing) used a synthetic dataset covering 43,000+ indicated times, then improved results with 5,000 additional training images—only to see performance slide again when the models were tested on a new collection of clock images.

If you work in AI in robotics, automation, perception systems, or industrial AI deployment, this isn’t a quirky “AI can’t do a child’s task” headline. It’s a short, sharp lesson about generalization, spatial reasoning, and how small perception errors can cascade into bad decisions—exactly the failure mode that keeps operations leaders up at night.

The clock problem is really a perception stack problem

Answer first: MLLMs don’t fail at clocks because “time is hard.” They fail because clock reading requires a chain of visual decisions, and errors early in the chain compound downstream.

To read an analog clock, a system must:

1. Detect and separate objects (face, hour hand, minute hand, tick marks, numbers)
2. Disambiguate similar parts (short vs. long hands; overlapping hands; hand thickness)
3. Estimate precise angles (spatial orientation relative to 12 o’clock)
4. Convert geometry into a symbolic output (“10:08”, not “10-ish”)

Humans do this with embarrassing ease because we’ve internalized the rules and can tolerate distortions. Many MLLMs, by contrast, are strong at pattern matching but brittle when patterns shift.

Here’s the important stance: clock reading is a proxy for the kind of “small geometry, high consequence” perception robotics depends on. If your robot misreads a dial, a gauge, a syringe pump setting, or a control knob by a small amount, the operational consequence can be large.

Why this matters beyond clocks

In the broader “Artificial Intelligence & Robotics: Transforming Industries Worldwide” story, clock reading maps directly to real deployment realities:

• Manufacturing: interpreting analog gauges, calipers, dial indicators, and machine panel states
• Logistics: reading labels in awkward orientations and lighting, interpreting partial occlusions
• Healthcare: interpreting imaging or device settings where precision beats “good enough”
• Autonomous systems: parsing signage, hand signals, instrument clusters, and edge-case visuals

The clock is the simplest “real-world instrument panel.” And the models still stumble.

What the IEEE study actually shows (and why it’s a big deal)

Answer first: The research suggests that one weak visual sub-skill (like identifying clock hands) can trigger a cascade that harms other skills (like spatial angle estimation), which then breaks the final answer.

Assistant professor Javier Conde and collaborators built a large set of synthetic analog clock images that collectively showed more than 43,000 times. They tested four MLLMs on a subset. All four initially failed to tell time accurately.

Then the team fine-tuned the models using an extra 5,000 images, evaluated on unseen images, and saw improved results. But the improvement didn’t hold when the models faced a new collection of clock images.

That pattern is familiar to anyone who has shipped computer vision systems:

• Fine-tuning often boosts performance on “nearby” data.
• Performance drops when the deployment environment shifts.

The crucial insight from their deeper experiments: when the researchers introduced clock variants—distorted faces or novel hand styles like arrow tips—performance often collapsed, even though humans could still read the time easily (the team even referenced Salvador Dalí’s The Persistence of Memory as an intuition for how distortion doesn’t faze people).

Distortion vs. novelty: the models didn’t fail the way humans fail

Humans typically fail on clocks when:

• the clock is too small to see,
• the hands are missing,
• the face is unreadable.

The models, however, struggled with changes that feel cosmetic to us:

• warped shapes,
• unusual hands,
• and the combination of altered hands + altered geometry.

That “combination” point matters. Conde’s team found that if the model made an error recognizing the hands, spatial errors increased—a classic cascading failure.

In real-world robotics, this is the difference between:

• a robot that sometimes mis-detects an object, but recovers downstream, and
• a robot that mis-detects an object and then confidently computes the wrong action.

Confidence paired with wrongness is the real hazard.

The real limitation: generalization, not raw intelligence

Answer first: The clock results are a clean demonstration of weak generalization—models perform well on what they’ve seen, then degrade on unfamiliar variations.

Teams often interpret multimodal AI failures as a “model size” issue. Sometimes it is. But more often, it’s a distribution shift issue:

• Training data clocks look a certain way.
• Your factory’s gauges, your hospital devices, or your vehicle displays don’t.

December is a good time to be honest about this because many organizations are planning 2026 automation roadmaps right now. If your plan assumes “we’ll fine-tune once and be done,” you’ll pay for that optimism later.

Why more data isn’t always the cure

A tempting conclusion is: “Add more clock images.” The study hints that additional fine-tuning helps—but it also shows the gains don’t automatically transfer to new clock collections.

That’s the signal to take seriously: the problem isn’t only missing examples; it’s the model’s learned representation of spatial relationships and object parts.

In practice, this means you should treat perception tasks like analog reading as engineering problems, not generic “LLM tasks.” You need:

• controlled evaluation suites,
• domain-specific augmentation,
• and explicit measurement of failure modes.

What clock-reading teaches robotics teams about deployment

Answer first: If your AI system interacts with physical environments, you need to design for robustness, not just average accuracy.

Here’s what I’ve found works when organizations try to apply multimodal AI to real-world perception tasks.

1) Build a “nasty” test set before you scale

Most teams test on images that look like their training set—because those are easy to collect.

Instead, create a targeted robustness suite with variations that mimic reality:

• different hand shapes / instrument pointers
• motion blur (vibration on a line is real)
• reflections, glare, and partial occlusion
• rotated viewpoints (technicians don’t take perfect photos)
• lens distortion from wide-angle cameras
• low-light and mixed lighting

A simple rule: If a human can read it after a half-second squint, your model should be expected to handle it—or you need guardrails.

2) Separate the task into measurable stages

Clock reading is a pipeline even when it’s done “end-to-end.” You’ll debug faster if you score each stage:

• hand detection accuracy
• hand classification (hour vs. minute)
• angle estimation error (degrees)
• final time error (minutes)

This is how you avoid the trap of “the model got the time wrong” without knowing why.

3) Use hybrid systems when precision is non-negotiable

For many robotics and industrial AI applications, a hybrid approach is simply safer:

• A vision model detects the clock/gauge region
• A specialized geometry module estimates angles
• A rules engine converts angles to time/reading
• The MLLM provides natural language explanations or handles exceptions

End-to-end MLLMs are attractive because they reduce plumbing. But when the output controls a physical action, predictability beats elegance.

4) Add uncertainty, abstention, and “ask-for-help” behaviors

A robot that always answers is not a feature. It’s a liability.

In high-stakes settings, design explicit behaviors:

• Abstain when confidence is low
• Request another frame / angle
• Trigger a human verification step
• Fall back to redundant sensors (digital readouts, encoder data, telemetry)

Clock reading is a great demo task for this: if the model isn’t sure, it should say so.

Practical implications for key industries

Answer first: The clock study maps directly to where AI and robotics are being adopted fastest: automation-heavy industries that depend on accurate perception.

Manufacturing and process industries

Analog instruments still exist because they’re cheap, rugged, and readable at a glance.

If you’re using computer vision for inspections or autonomous mobile robots (AMRs) for monitoring, validate that your system can handle:

• nonstandard dials (custom markings)
• worn labels
• pointer glare
• non-circular housings

A missed gauge reading can become scrap, downtime, or a safety incident.

Healthcare and medical imaging workflows

The IEEE article notes the risk: subtle perception failures can have severe consequences.

Healthcare AI often lives in a world of:

• unusual viewpoints
• device-specific UI variations
• strict tolerance for error

Even if you aren’t “reading clocks,” you are often interpreting visual signals where a small spatial error equals a different clinical interpretation.

Autonomous driving and robotics perception

The connection to autonomous driving is straightforward: perception needs to hold under endless variation.

A clock face is controlled. Streets aren’t.

If a model struggles with precise orientation on a clock, teams should be cautious about assuming it will reliably infer:

• the direction of a cyclist’s movement,
• a hand gesture from a traffic officer,
• or a partially occluded sign.

A simple checklist before deploying multimodal AI in the physical world

Answer first: Treat multimodal AI as a component that must earn trust through testing, not a magic layer that makes perception “solved.”

Use this checklist during pilots and pre-production:

1. Define the operational design domain (ODD): where, when, and under what conditions the model must work.
2. Create a robustness suite: include distortions, novel shapes, and adversarial-but-realistic variants.
3. Measure intermediate failures: not just final accuracy.
4. Plan for drift: schedule re-evaluations and monitoring as environments change.
5. Implement abstention and escalation: safe behaviors when the model is unsure.
6. Prefer hybrid architectures for precision tasks: geometry + rules + MLLM, not only MLLM.

If you do these six things, “AI can’t read a clock” turns from a punchline into a practical advantage: you catch brittle perception early, before it hits production.

Where this goes next for AI and robotics

MLLMs will improve—researchers are already iterating on better spatial representations, better synthetic-to-real transfer, and more robust visual reasoning. But the clock study is a reminder I wish more buyers heard: capability demos aren’t deployment proofs.

For organizations investing in AI-powered robotics and automation in 2026, the opportunity isn’t just adopting smarter models. It’s building smarter systems—systems that test harder, fail safely, and keep improving in the messiness of the real world.

If an AI assistant can summarize your quarterly report but can’t reliably read a warped clock face, what does that say about the next “simple” visual task you want it to do on your factory floor or in your fleet?