HarmonyOS 7's AI Agents: A New Blueprint for Operating Systems and Developers

The Big Shift: From App Launcher to Intent Handler

When HarmonyOS 7's developer beta dropped at HDC 2026, most coverage focused on speed bumps and new features. But for those who build for the platform, the real story is deeper: Huawei is rearchitecting the operating system around AI agents. Instead of the user picking an app and drilling through menus, the system now listens to a spoken intent, figures out what's needed, and orchestrates a set of capabilities to get it done.

That's a fundamental change in how an OS relates to software. It's no longer a passive container for apps; it's an active coordinator. The demo at HDC made this concrete: a user says, "sign me up for a marathon," and the system breaks that into subtasks, dispatching them to health, calendar, and search agents that work in parallel. This isn't a voice assistant calling one API—it's a multi-agent workflow running at the system level.

HMAF 2.0: The Six-Layer Stack Behind the Magic

The technical foundation is HMAF 2.0, the upgraded HarmonyOS Multi-Agent Framework. It's a six-layer stack: Xiaoyi (the system assistant) at the top, then HMAF for task decomposition and agent orchestration, an AI base with openPangu 2.0 and a 30B on-device model, system services like the Ark engine and security, developer tools (DevEco Code and CLI), and finally, application scenarios.

For developers, the key takeaway is that an app can now expose itself as a schedulable agent. You register capabilities using HMAF's AgentExtension, declare what your app can do, and the system can invoke it with structured parameters. The code snippet in the interview shows a marathon registration agent declaring its input schema and handling a task with an onInvoke method. It's a shift from building static screens to defining dynamic services.

openPangu 2.0 and Performance Gains

The open-source release of openPangu 2.0 is another headline. The Pro version has 505 billion parameters, and Flash has 92 billion, both supporting 512K context. But the more interesting number is throughput: Huawei claims two times the single-card throughput of mainstream open models, thanks to "Ascend-native" optimization. That's a practical advantage for developers running models on Huawei's hardware.

Performance numbers are also strong: system app launch times improved 24%, ecosystem apps 34%, and game frame rate stability 40%, all while keeping annual load growth under 10%. Security got a boost too, with on-device AI catching seven types of scams in seconds—already blocking 347 million potential frauds, with Alipay and Douyin on board.

Developer Tools: The Two-Track Approach

Huawei's tooling strategy is "dual-track." DevEco Code is the full-featured AI IDE, sort of like a copilot that plans, codes, compiles, and fixes errors on its own. DevEco CLI, on the other hand, is a command-line toolkit that exposes HarmonyOS atomic capabilities as commands, so any external AI—Claude, Cursor, or a custom agent—can plug in.

This split makes sense. DevEco Code is for teams starting fresh, needing speed from zero. DevEco CLI is for teams with existing pipelines that want to add HarmonyOS without ripping everything out. They're complementary, not competing. Under the hood, DevEco Code combines Huawei's self-developed Bifang engine (the "brain" for planning and tool use) with the open-source OpenCode framework (the "skeleton" for UI and extensions). That hybrid lets Huawei optimize deep integration while keeping ecosystem compatibility via MCP.

Inside DevEco Code, two agents work together: a Plan Agent that breaks down requirements, and a Build Agent that writes code, compiles, and debugs. It can even modify project resources, like auto-generating responsive layout code for different screen sizes—what they call "one-to-many adaptation." The example shows the Plan Agent inserting @Builder breakpoint branches when a user says the app must work on phones and TVs. That's the development-side agent entering product logic.

Pain Points: Fragmentation and Missing Linux Support

For small and mid-size teams, the biggest headache is device fragmentation. HarmonyOS runs on everything from cheap phones to foldables to cars and wearables, each with different screens, chips, and memory. Testing on all of them is impossible for a small team, so bugs show up after release—install failures, crashes, UI glitches. Huawei offers some relief: EasyGo Parallel View lets you write one config file for foldable and tablet layouts, and a UX auto-checker spots common layout issues and points to the source line. But there are gaps.

DevEco Code doesn't support Linux, which hurts server-side and open-source workflows. It's also tied to DevEco Studio; you can't go full CLI. And the biggest issue: AI models don't have enough ArkTS training data. Unlike Swift or Kotlin, where tools are nearly turnkey, ArkTS code needs 15–20% manual fixes. That's a data problem, not a tool problem, and it won't be solved overnight. The community is stepping in with projects like harmonyos-ai-skill, which packs HarmonyOS knowledge into a Markdown file that can be loaded into Claude or Cursor.

How HarmonyOS, iOS, and Android Diverge

Comparing the three platforms reveals different philosophies. Apple treats developer tools and runtime AI as separate stories—Xcode 27 uses a bridge to let third-party agents in, but it's an add-on. Google is going cloud-first, shutting down the open-source Gemini CLI in favor of a closed Antigravity. Huawei, though, presents a unified narrative: DevEco Code and CLI on the development side, Xiaoyi and HMAF 2.0 on the runtime side, all in one keynote. That's not just presentation; it signals a real architectural commitment to linking the two.

On cost, Apple's Xcode is free but you pay for models like Claude. Google bundles its own Gemini, charging $45 per user per month, with a $100 tier. Huawei gives you free access with GLM-5.1 built in, allowing 50 calls per minute, and you can switch to DeepSeek or OpenAI if you want. That's a deliberate move to attract developers.

Skill ecosystems differ too: Apple has a few official skills, Google relies on cloud, and Huawei offers 70+ curated skills for things like multi-device development and problem diagnosis. Interestingly, both Apple and Huawei use the SKILL.md open format, suggesting "Skill-as-Code" is becoming a de facto standard.

Under the hood, HarmonyOS's distributed soft bus is a native cross-device capability, letting you call another device's feature with a few lines of code. Android needs a patchwork of protocols, and Apple's Continuity is smooth but locked to its own devices. ArkUI is the only UI framework that truly spans brands—phone, tablet, PC, car, watch. That's a structural advantage, not marketing.

The Kuaishou Case: Real Productivity Gains

Kuaishou, a major Chinese app, is the poster child. With Huawei's AI tools, they hit 80% AI code generation, 84% acceptance of AI-generated test cases, and 73% adoption of AI fix suggestions, boosting overall efficiency 1.7x. But the more interesting detail: Kuaishou already had its own AI coding tool, Kwaipilot, which had raised code generation from 1% to 30%—yet delivery speed didn't improve. Why? Because writing code faster isn't the bottleneck; the whole loop—analysis, design, refactoring, validation—was still slow.

So they teamed up with Huawei to build a custom Skill for HarmonyOS concurrency safety, called Ark Refiner-Sendable. It automates the entire flow of finding and fixing data races in Taskpool/Worker usage. A task that used to take two people a week now takes half a day, and cold start performance improved 16%. The lesson: targeted Skills for specific engineering pain points beat generic code generation. Yes, it's an official case study, so take the numbers with a grain of salt, but the method is replicable.

What Comes Next for Developers

The next OS battleground isn't model quality—it's how well development-side agents and runtime agents cooperate. Getting AI to write an app is one thing; getting that app to be seamlessly schedulable by the system's AI is another. HarmonyOS is betting on that integration, and it's ahead of Apple and Google in making it a unified strategy.

For developers, the advice is practical: pick your track (DevEco Code for new projects, CLI for existing systems), mine the 70+ Skills for known problems, and use community knowledge packs to fill the ArkTS data gap. HarmonyOS 7 isn't perfect—Linux support, model training data, and ecosystem maturity are still works in progress. But the direction is clear: a system built around agents, where the line between building an app and running it blurs. That could be the real differentiator in the mobile OS wars.