VLX — Edge-native multimodal AI for real-time perception, reasoning, and action. GitHub: https://teapawt.net/t.co/ZUYXqCM9Lj Discrod: https://teapawt.net/t.co/NJjOYSxgav
Joined October 2024
- Tweets221
- Following126
- Followers598
- Likes257
Streaming video understanding shouldn't mean reprocessing the entire video every time a new frame arrives.
VLX-Flow 1.5 is built around incremental processing and persistent memory.
Here's how it works:
1. Incremental Visual Encoding
Video arrives in sequential segments. The model processes new visual information as it comes in, rather than repeatedly encoding the entire history.
2. Dual-Layer Memory
Visual memory retains recent visual details, while semantic memory preserves useful context from previous observations and interactions.
3. Recurrent Linear Attention
A recurrent state carries historical information forward, allowing the model to continue reasoning without revisiting the full video history.
The result?
More efficient long-running inference, with first-token latency and memory usage remaining stable over time.
A streaming architecture designed for continuous video understanding on edge devices.
Try VLX Flow 1.5 here: platform.om-ai.com/
The Intelligence Behind Knowing When to Respond
A good real-time AI doesn't need to comment on everything it sees. It needs to know which moments matter.
With VLX-Flow 1.5, proactive response goes beyond detecting an event. The model continuously evaluates visual evidence, user instructions, and interaction history to decide what deserves a response.
Here's how it works:
1. Observe: Continuously process incoming video.
2. Evaluate: Check whether the current scene matches the persistent instruction.
3. Respond: Speak up when the target event occurs.
4. Stay Silent: Avoid repeating alerts for events that have already been reported.
This makes silence part of the interaction strategy, not an absence of intelligence.
For always-on applications, knowing when NOT to respond is just as important as knowing when to respond.
Thousands of apples moving down the production line. Need to spot and count them all? 🍎
Just tell VLX-Seek what to look for.
It detects and localizes apples on the conveyor belt, highlighting each target with precise bounding boxes.
No manual labeling. No complicated setup. Just prompt, detect, and count.
Bring smarter visual inspection to your production line with VLX-Seek.
From watching to responding. That's the difference.
"Let me know when the coffee is ready."
VLX-Flow 1.5 continuously observes the video stream, tracks what's happening, and proactively responds when the coffee is done.
No need to keep asking. No need to check repeatedly.
Always-on perception. Timely, proactive response.
Meet VLX-Flow 1.5.
The scene changes. The context carries forward.
VLX-Flow 1.5 follows the coffee-making process as it unfolds—from grinding and tamping to espresso extraction and milk frothing.
Built for real-time, on-device video understanding, VLX Flow maintains visual memory across segments. Version 1.5 builds on that foundation with more coherent continuous descriptions, reducing fragmented narration and repetition.
One stream. An unfolding story.
Try VLX-Flow 1.5: platform.om-ai.com/developer…
VLX-Flow 1.5 is officially live! 🚀
Built for real-time, on-device video understanding, VLX-Flow continuously watches, remembers, and reasons over live video streams — without repeatedly processing the same footage.
And with VLX-Flow 1.5, it gets even smarter about when to respond and when to stay silent.
Here's what VLX-Flow 1.5 sharpens:
🔹 Smarter Proactive Response — Set a standing instruction once. Flow monitors the stream and responds when relevant events occur, without constant prompting.
🔹 More Coherent Continuous Descriptions — Builds on continuous visual memory to maintain context across video segments, delivering more consistent descriptions of how scenes and actions unfold over time.
🔹 More Grounded Real-Time Q&A — Better distinguishes observed facts from missing visual evidence, reducing unsupported answers and improving its ability to decline questions when evidence is insufficient.
🔹 More Efficient On-Device Inference — Reuses cached context and reduces unnecessary token generation, minimizing redundant computation during continuous operation.
From robotics and drones to industrial monitoring, VLX-Flow 1.5 brings AI closer to always-on perception and timely, autonomous responses in the physical world.
Keep watching. Remember what matters. Respond when it counts.
A whole new OmAI experience is here! 🚀
🔥A sleeker interface.
A redesigned homepage, smoother navigation, and a cleaner layout that puts everything you need right at your fingertips.
🧠Meet VLX-Flow 1.6
Always-on perception. Precise, proactive responses. Flow 1.6 continuously understands incoming video and responds when it matters.
🎯Introducing the Task Center
Complete tasks, earn free credits, and unlock more ways to experiment with our models. Your next Physical AI experiment starts here!
More to discover. More to experiment with. More reasons to jump in.
Seeing an object is one thing. Knowing exactly where it is — even in a cluttered real-world scene — is what makes vision useful for Physical AI.
VLX-Seek 1.5 brings fine-grained visual grounding to the edge, with open weights ready for developers to explore.
Built to find. Ready to build.
If you need a VLM that finds things in messy real scenes, look at VLX-Seek.
It is a fine grained perception model for edge and embodied vision.
Not just what is in the image. Where it is. Which instance. And when it is missing.
Instead of making the model spit raw box coordinates, it turns candidates into region tokens and lets the LM select and refer.
Open source inference plus VLX-Seek 1.5 10B weights.
Runs on CUDA, Ascend 910B, and Apple Silicon.
Repo: github.com/om-ai-lab/VLX-See…
Something BIG is coming to OmAI. 👀
We've been working on something exciting behind the scenes, and we're almost ready to share it.
A sneak peek at what's coming:
⚡ Upgraded VLX models — New versions with improved capabilities, bringing us closer to faster, more responsive real-time multimodal AI.
✨ A fresh new look — We're giving the entire platform a makeover, with a cleaner interface, smoother interactions, and a better way to explore what our models can do.
And this is just the beginning.
Better models. Better experience. More possibilities for Physical AI.
Stay tuned. The next chapter of OmAI is almost here.
Busy roads. Multiple lanes. A clearer view of traffic. 🚗
VLX Seek identifies cars across urban road scenes, providing a foundation for vehicle counting, traffic-flow monitoring, and congestion analysis.
Turn everyday camera footage into useful traffic data.
730ms changes what you can build with a 3B vision model.
VLX-Seek 3B now reaches ~730ms end-to-end latency in our current test setup:
NVIDIA T5000 / MAXN
1920×1080 image
27-token output
But the interesting part isn’t the benchmark number itself.
It’s what happens when natural-language visual grounding starts responding at sub-second speed.
You can ask:
“Find the worker standing next to the machine.”
“Locate the damaged package on the conveyor.”
“Find the red vehicle near the entrance.”
And get the target region back fast enough to plug into a larger workflow.
That opens up more practical use cases across:
• Robotics
• Industrial inspection
• Visual agents
• Surveillance analysis
• Edge vision systems
For visual AI, accuracy tells you whether the model can find the target.
Latency determines how usable that ability actually feels.
What if machine vision could find ANYTHING you describe?
We put VLX-Seek through 3 quick tests:
🔩 Count the screws
🔍 Separate bent fasteners from straight ones
⚙️ Find the yellow gear
No fixed class list. No retraining for every new object.
Just tell VLX-Seek what to look for.
From object counting to fine-grained visual grounding, all through natural language.
Try VLX Seek Here: om-agent.com
GitHub: github.com/om-ai-lab/VLX-See…
One optimization won’t get a vision model to sub-second latency. The full stack matters.
For VLX-Seek 3B, we tested each optimization independently against the same vLLM baseline (~1.54s).
Only one optimization was enabled at a time. All other components remained on the baseline vLLM setup.
Here's how each performed:
Vision Engine (TensorRT): ~1.14s
LM W4A4: ~1.28s
FlashInfer GDN Prefill: ~1.51s
LM Head W4A16 only: ~1.46s
Each optimization targets a different bottleneck, but none alone breaks the 1-second barrier.
Now enable them all together: ~1.54s → ~730ms.
The full stack optimizes every major stage of inference:
Vision Processing → Prefill → LM Linear Layers → LM Head
No single magic trick. Just removing bottlenecks, stage by stage. Faster visual grounding starts with optimizing the entire pipeline.
