There is a way to use AI that a lot of people still have not fully understood. First came the phase where people used it like a glorified chat: questions, emails, random doubts, not much else. Then came the phase of putting it inside the editor and letting it touch files, which is already a lot more useful. But between that and building a serious workflow there is another leap, and that is exactly what this video is about: stop treating AI like one employee who does everything and start treating it like a team with separate roles. If you want to poke around the tool itself, you can check out the MiniMax plan here.
The idea sounds obvious once you say it out loud. In a company, you do not ask the same person to do the work, review their own work, grade themselves, and then tell you everything looks perfect. But with agents, that is exactly what people do all the time. They ask Claude Code, Cursor, or Codex to build something and then ask that same system to review it. And of course, what a surprise: most of the time it will tell you it looks pretty good.
The Real Problem Is Not Just the Model
What is interesting about Edu’s angle is that he is not selling smoke about some magical new model that supposedly changes everything. The point of the video is much saner than that: when a task drags on, the context window fills up with mud, the agent starts losing the thread, and quality drops. That happens in code, but also in any complex task where analysis, execution, review, and corrections all get mixed into the same session.
That is why he keeps insisting on separating responsibilities. One agent executes, another reviews without having seen the process, and if something is wrong, it gets sent back. That adversarial review is the real appeal of MiniMax Code, which the video shows as a desktop app for Mac and Windows where several agents can work at the same time and, on top of that, everything keeps running on your own machine.
That local-first detail is not minor at all. If you work with private repos, internal documents, or anything else you would rather not send off to someone else’s servers, having the context, files, and memory stay on your own computer changes the whole picture quite a bit.
The video also mentions the underlying model, MiniMax M3, and the important message here is not just the benchmark score. The point is that it plays in the top league, that it supports up to a million tokens of context, and that it is properly multimodal. And in the video, that last part does not stay theoretical, because the first demo goes straight into it.
What the Demo Actually Shows
There is an important difference here between the broad idea and what is actually shown on screen. The recording is not just an abstract repository audit. It starts with something much more visual: Edu feeds MiniMax Code screenshots from an online store and asks it to build a similar product page. He does not give it an endless brief or some obsessive specification. He gives it images, lets the system work, and what comes out is a fairly convincing replica, with gallery, products, cart, and a UI that looks very close to the reference. Not everything was perfect, and the video openly shows a few mistakes and a few invented elements from the agent, but that is exactly why the demo feels more believable.
Then comes the part that, to me, has a lot more substance: he opens his own blog and asks for a very specific improvement. Up to that point, publishing a new post meant manually creating the MDX file inside the repo. The task he gives the system is to build an admin interface for creating posts, uploading images to the CDN, and scheduling publication. And this is where the team-of-agents idea really shows itself.
MiniMax Code starts with several roles already prepared. You see a coder, a verifier, and a general-purpose agent. In the middle of the demo, Edu also creates a planner in plain language, without weird rituals or aerospace-level configuration. That planner starts working in parallel with the coder, while the verifier stays ready to poke holes in the result when needed. The final output is not some vague promise: a real admin panel ends up showing up at the /admin route, with existing posts, editable fields, support for multiple languages, publication-date scheduling, and even content search.
And it matters to describe it like this because that is what really changes the tone of the video. It is not just showing you a nice-sounding concept like “specialized agents.” It is showing you that, with a good instruction, the system built something genuinely useful for the author’s real editorial workflow.
Where It Really Feels Different from Claude Code or Codex
The comparison the video makes is pretty sensible. In tools like Claude Code or Codex, a large task usually moves step by step, inside the same thread, with the same agent carrying the entire context on its back. If it makes a mistake, either you catch it or it slips through. Here the bet is different: let several agents work in parallel, and make sure the one verifying the work is not contaminated by having taken part in the implementation.
On top of that, the demo shows two details that are less flashy than a brand-new UI but matter a lot in daily use. The first is per-project local memory. Edu points out that the system stores context about how the repo is organized, how the user works, and what has been done before, all in editable local files. The second is the operational side: you can schedule tasks to run at a specific time and even launch them from Telegram connected to your PC. In fact, the video sets the bot up live, asks it something from a phone, and then restricts access so it is not left open to just anyone. That security angle deserved to stay in the article because it is not decoration, it is common sense.
With all that, the feeling the demo leaves behind is not so much “this model writes better code” as “this harness is better designed for long-running work.” And honestly, I think that is the right reading.
The Sponsorship Fits, but That Is Not the Main Point
Yes, the video is sponsored by MiniMax, and that is obvious because it talks about plans, discounts, and the download. But to be fair, the sponsorship fits what is being demonstrated. It is not one of those random brand mentions awkwardly jammed into the middle of a technical reflection. The tool itself is the subject of the video.
On pricing, what gets mentioned is a subscription system based on shared tokens across code, image, voice, and other formats, instead of splitting every capability into separate buckets.
That said, the most valuable part of the video is not the discount, and not even the app itself. The valuable part is the underlying idea: if you are going to work seriously in an agentic way, stop thinking in terms of one single agent for everything. Separate roles, reduce self-contamination, leave room for someone to review the work, and stop turning every workflow into an endless conversation where the same system produces, rationalizes, and absolves itself.
MiniMax Code packages that idea well, and the demo makes it clear why that approach can be more reliable. After that, everyone can decide whether this specific tool is worth it, whether another one fits better, or whether they would rather assemble the whole thing themselves. But the important mental shift has nothing to do with brand. It is about understanding that once the work gets complicated, a team usually beats a lone gunman.
If you have been using agents like an overpowered chat for a while, this video has one real virtue: it forces you to rethink the workflow. And honestly, that is worth more than a lot of perfect demos where everything works on the first try. And if you also want to take a look at MiniMax, you can find it here.
What do you think?
Leave your opinion, question or suggestion. Comments are synced with GitHub Discussions .