Opencv University

Opencv University Take your first steps to Mastery in AI with our Free Bootcamp. Kickstarter Masters in AI Art Generation : bit.ly/3JYh7A6

Welcome to the world’s most trustworthy destination for learning Computer Vision, Deep Learning, and AI.

08/17/2026

(Mixture of Experts: Why a Collection of Agents Beats a Single One)

Let me tell you why a single agent will fail on a complicated task: what you need is a collection of agents. Even with the same model, when you tell one agent it generates text and another that it generates visuals, they behave differently, because you have given them an identity. Without that identity, the model does not reliably know how to generate the image or video properly, but tell it "this is your job" and it suddenly does better. And there is a technical reason for it.

These models may have a trillion parameters, but they do not use all of them on every query. Under the hood they are mixture-of-experts models, so only part of the network is active at a time. You can think of a model not as one model, but as a collection of around 10 models trained together, with a router that decides which experts, maybe 2 or 3 of the 10, will answer your request. So "generate an image" routes to a different collection of experts than code does.

Giving each agent a distinct identity, one to write code and another to test it, works with that routing rather than against it. If you have used a single agent or a collection of agents, I would love to hear how you used it and what effect it had on your final output. Let me know in the comments.

08/17/2026

(Muse Glimmer, Part 3: The Benchmark and Guardrail Reality Check)

The most interesting thing about Meta's new open agent is that it does not win every benchmark, and that makes the benchmark story more useful. In Meta's published evaluation, Muse Glimmer scored 75.5 on MCP Atlas and 74.6 on DeepSearch QA, ahead of Qwen3.6-27B and Gemma4-31B, and it edged Qwen on SWE-Bench Pro. But Meta's own table shows Qwen scoring higher on SWE-Bench Verified, TerminalBench, and OSWorld-Verified, because "best model" is not one number. A coding agent, a browser agent, and a research agent stress different capabilities.

There is a caveat worth knowing: Meta's figures mix self-reports with internal reproductions and may not reflect every rival's best setup, so treat benchmarks as evidence, not a purchase order. The bigger issue is that this agent takes actions, not just text. It runs long plans, reads screenshots and documents, and recovers from failures, which makes bad permissions and prompt injection more consequential.

Meta's model card recommends additional guardrails and human confirmation for irreversible actions, and that should be the baseline: sandbox it, grant minimum permissions, require approval before it sends, changes, spends, or publishes, and keep logs. The right question is not whether Muse Glimmer tops one chart, but whether it reliably improves your workflow within controls you can trust.

Full details: https://research.meta.ai/blog/introducing-muse-glimmer-open-agentic-model

08/14/2026

(Nobody Can Proofread Their Own Work, Not Even AI)

Do not use a single agent for a complicated task. Use a collection of agents. Even within one model, a request routes to a different set of experts depending on what you ask, so "generate an image" uses a different collection of experts than a coding request. When you run a collection of agents and give each one an identity, you are steering the model on purpose: one agent writes the code, and another writes a test script against it. Those two working together beat a single model told to create the code and also test it, and they are not adversarial.

It is very humanlike. When you ask a person to check their own work, it is difficult, because their mind is hooked onto what they just produced. It is the best work they think they can do, so they lack perspective on it. Ask someone else of equal capability to look, and they will often point out what you missed.

That is the idea behind a collection of agents, and it matters most when the task is complicated. If you have used a single agent or a collection of agents, I would love to hear how you used it and what effect it had on your final output. Let me know in the comments.

08/14/2026

(Muse Glimmer, Part 2: The Hardware Fine Print)

A 30 billion parameter AI model normally needs more than 55 gigabytes of memory at full precision, so how can Meta say Muse Glimmer fits on a personal machine? The answer is two engineering choices: aggressive quantization and speculative decoding. Quantization compresses every weight to roughly 4 bits, bringing the language model below 20 gigabytes. But that is not the whole budget, because the system also needs the KV cache, an image understanding encoder, and a small companion model. Meta's roughly 17 gigabyte K-quant release targets a 24 gigabyte VRAM budget, and its higher-precision version targets 32 gigabytes.

Speculative decoding is the second idea. Instead of generating one token at a time, Muse Glimmer uses a lightweight DFlash drafter that proposes a block of tokens in advance, and the main model checks the block in parallel, keeps the good tokens, and corrects the rest. It is like a fast junior writer drafting a sentence while an expert editor approves it: same quality, less waiting. In Meta's setup, that gave 3.1 times faster decoding on an RTX 5090, with gains on M5 Max and M4 Max too.

These are benchmarks, not guarantees for every machine, but they show why this matters for agents. An agent that stalls for minutes between steps feels broken, while a fast one can inspect a result, call another tool, recover from an error, and stay in the flow. Muse Glimmer matters not because it makes 30 billion parameters small, but because it makes that capability practical to try outside a data center.

Full details: https://research.meta.ai/blog/introducing-muse-glimmer-open-agentic-model

08/14/2026

(Why a Single Agent Fails, and a Swarm Doesn't)

Let me tell you why a single agent will fail on a complicated task: what you need is a collection of agents. We put a lot of energy into our blog posts and tutorials, but videos are more engaging when you want to explore an idea rather than just learn it. So I tried turning a blog post into a video, and my first attempt was terrible. The visuals had artifacts, and the narration did not line up with what was on screen.

The fix was not a better prompt. It was a swarm of agents instead of one. And here is what surprised me: even with the same underlying model, when you tell one agent it generates text and another that it generates visuals, they behave differently, because you have given them an identity. Without that identity, an agent does not reliably know how to generate the image or the video properly.

If you have used a single agent or a collection of agents in your own work, I would love to hear how you used it and what effect it had on your final output. Let me know in the comments.

08/13/2026

(Muse Glimmer: Meta's 30B Agent Model That Runs on Your Own Machine)

A 30 billion parameter AI agent that runs on your own machine used to sound like a data center project. Meta just released one as open weights, called Muse Glimmer. It is not primarily a chatbot built for a clever one-line answer. Meta designed it for agents: systems that follow a multi-step plan, call tools, write and debug code, inspect the results, and keep going when a tool call fails.

The weights ship under the permissive Apache 2.0 license, which gives developers far more control over where the model runs and how they adapt it than a cloud-only API does. Muse Glimmer takes interleaved text and images and produces text, so an agent can read a screenshot, chart, or document while working, and its context window of more than 131,000 tokens helps with long conversations, code bases, and large instruction sets.

Running locally does not automatically make everything private or secure, since your tools and data connections still matter, but it can keep a workflow running without a network connection. Meta says it runs on a Mac or PC with a single consumer GPU. The shift is that capable agent behavior is moving from a distant cloud service toward hardware you can own, inspect, and customize.

Full details: https://research.meta.ai/blog/introducing-muse-glimmer-open-agentic-model

08/12/2026

(OpenCV 5 Series: How TRUCO Makes findContours Parallel)

Your existing OpenCV contour code may have become dramatically faster without you changing a single line. OpenCV 4.14 introduced a new internal fast path for findContours called TRUCO, retained in OpenCV 5. It stands for Threaded Raster Unrestricted Contour Ownership, and the important word is ownership.

The classic path uses the serial Suzuki-Abe algorithm. TRUCO divides the image into horizontal row strips processed in parallel. That is normally hard, because a contour can cross from one strip to another and force threads to synchronize or stitch pieces together. TRUCO avoids it by giving each contour start point a deterministic owner, with an upward termination rule ensuring only the rightful owner emits that contour. The result is lock-free parallel extraction with no stitching stage, plus an 8-bit state map instead of 32-bit labeling for less memory bandwidth pressure and faster SIMD scanning.

In the reported benchmarks, TRUCO was about 1.8 to 1.9 times faster single-threaded and roughly 10 to 20 times faster at 20 threads. The one limitation: OpenCV picks TRUCO only for RETR_LIST with no hierarchy requested, and any hierarchy mode falls back to Suzuki. There is no new API, so just keep calling findContours.

Full breakdown with benchmarks: https://learnopencv.com/contour-detection-using-opencv-python-c/

08/10/2026

(Kimi Delta Attention: The Whiteboard That Replaced the Filing Cabinet)

Kimi K3 can read a million tokens without carrying a million token filing cabinet everywhere it goes. Traditional transformers keep a growing KV cache, essentially an index card for every word that came before, so a million token conversation creates an enormous stack that has to be stored and moved.

Kimi Delta Attention keeps a compact working memory instead, more like a smart whiteboard. It has limited space, but it does not grow as the context gets longer. Each new word updates it, adding what matters and erasing what is no longer useful. That update is the delta, and that is where the name comes from. Fine-grained gating lets different parts of memory independently decide what to preserve and what to fade.

K3 is a hybrid, using KDA for most of the stream while keeping conventional attention where exact lookups are valuable. In the earlier Kimi Linear tests, the design cut KV cache use by as much as 75 percent and delivered up to 6 times the decoding throughput at 1 million token context. K3 scales it into a 2.8 trillion parameter model with a 1 million token context window.

Full breakdown: https://www.kimi.com/blog/kimi-k3

08/08/2026

(Kimi Vision API: Send Images and Video in the Right Format)

If Kimi keeps ignoring the image in your API request, your JSON structure may be the reason. Kimi Vision models understand text, objects, shapes, and colors inside images, and models including Kimi K3 also understand video, but you have to send the visual content in the right format. Use the OpenAI Python client, read your Moonshot API key from an environment variable, and set the base URL to api.moonshot.ai/v1. For a local image, base64 is simplest: encode it and place the data URL in an image_url part, then add a separate text part with your question.

The most important detail is that the message content must be a real array of objects. Do not convert it into a JSON string, because it may look similar but Kimi may not process it as visual input. For large or reusable videos, upload the file first and reference the returned file ID as ms://file-id in a video_url.

Kimi supports PNG, JPEG, WebP, and GIF images and video formats including MP4, MPEG, MOV, AVI, and WebM. Tokens are dynamic, so keep images at 4K or below and video at full HD or below, and use the token estimation API before sending a large request. Public image URLs are not supported, so use base64 or file upload, and multiple images are fine as long as the request stays under 100 MB.

Full breakdown: https://platform.kimi.ai/docs/guide/use-kimi-vision-model

08/06/2026

(OpenCV 5 Series: What Changes for Python and cv2 Users)

If you use cv2 in Python, OpenCV 5 changes less than you might fear, but more than you should ignore. It is on PyPI now as opencv-python 5.0.0.93, released July 2, 2026. Python 2 is gone, so OpenCV 5 requires Python 3, and only Python 3 bindings are distributed. The good news is that the module restructuring is mostly transparent: functions remain accessible as cv2.function_name even when the underlying C++ modules moved, so you usually do not need new imports.

Some real changes can still hit a Python project. The classic machine learning module is no longer in the main package unless you build with opencv_contrib, and the guide suggests scikit-learn instead. Caffe and Darknet DNN loaders are gone, so convert models to ONNX and load with readNetFromONNX. Haar cascades and HOG detectors now require opencv_contrib, and for new face detection the guide points to the DNN-based face detector in the main module.

One subtle change: NumPy arrays passed into OpenCV can now map to true one-dimensional arrays, so check any code that assumed a column vector layout. The practical advice is to upgrade in a clean environment, run your tests, and watch old ML APIs, old detectors, old model formats, and array shape assumptions.

Full migration guide: https://opencv.org/opencv-5/

Address

San Francisco, CA

Telephone

+16195357489

Website

Alerts

Be the first to know and let us send you an email when Opencv University posts news and promotions. Your email address will not be used for any other purpose, and you can unsubscribe at any time.

Contact The School

Send a message to Opencv University:

Shortcuts

Share

Category