How AI Agents Are Reshaping Developer Workflows in the New HarmonyOS

The Big Shift: From Apps to Intent

When HarmonyOS 7's developer beta landed at HDC 2026, most coverage focused on performance numbers and new features. But after two months of real-world tinkering, the deeper story is becoming clear: this isn't just another OS update. The entire architecture is being reorganized around AI agents.

Think about how we use operating systems today. You want to book a flight, so you open the airline app. You want to track a package, so you open the tracking app. The OS is basically a launcher—it sits there until you pick an app and do the work yourself.

HarmonyOS 7 flips that model. Instead of you deciding which app to use, you just state your intent—"help me sign up for a marathon"—and the system figures out which capabilities to pull in. It breaks your request into sub-tasks, coordinates multiple mini-agents (health, calendar, search), and gets the job done. That's a fundamental change in how software gets built and consumed.

HMAF 2.0: The Six-Layer Agent Stack

At the core of this shift is the HarmonyOS Multi-Agent Framework, now in version 2.0. It's a six-layer architecture that ties everything together:

• Xiaoyi – the system-level assistant that acts as the user's entry point.
• HMAF 2.0 – handles task decomposition and manages inter-agent communication.
• AI Base – powered by openPangu 2.0 (open-sourced, with a 505B Pro version and 92B Flash version, both supporting 512K context) and an on-device 30B model.
• System Services – Ark engine, Star Shield security, and Galaxy Connect.
• Developer Tools – DevEco Code and DevEco CLI.
• Scenarios – spatial computing and other specialized domains.

For developers, the practical takeaway is that your app can now register itself as a "callable agent." You expose your capabilities—what you can do, what parameters you need, and how to invoke you—and the system handles the rest. The code snippet from the keynote shows a marathon sign-up agent: it declares its capabilities with a schema, and the system can call it with structured parameters rather than forcing a natural-language back-and-forth.

DevEco Code and DevEco CLI: A Two-Track Approach

Huawei is taking a dual-track approach to developer tools, and it's smarter than it looks at first glance.

DevEco Code is the "copilot" for teams starting fresh. It plans, writes, compiles, and debugs—basically, it has a brain. It's powered by a self-developed engine called Bifang (think of it as the reasoning core) layered on top of the open-source OpenCode framework (which provides the terminal UI and extensibility via MCP, skills, and plugins).

DevEco CLI is the opposite: it doesn't make decisions. It just exposes HarmonyOS's atomic capabilities—build, check, debug—as commands that any AI agent (Claude, Cursor, your own) can call. This is perfect for teams that already have an AI workflow and just want to plug HarmonyOS into it.

The two tracks serve different needs. New projects and small teams can jump into DevEco Code and get from zero to one fast. Larger organizations with existing CI/CD pipelines can adopt DevEco CLI without ripping out their current setup. It's not either/or—it's both, depending on where you sit.

The Real Pain: Fragmentation and the Gap in Training Data

Here's the thing that doesn't show up in keynote demos: HarmonyOS devices are a mess of screen sizes, chips, and API versions. From flagship phones to budget wearables, the fragmentation is real. Small teams often have only a couple of test devices, so bugs surface after launch—crashes, layout issues, performance hiccups—and that's when users churn.

Huawei offers tools like EasyGo for foldables and tablets, and an automated UX checker that spots layout problems and points to the exact source line. But there are still gaps. DevEco Code doesn't run on Linux, which annoys server-side developers. And the bigger issue: ArkTS training data is thin.

Most AI tools are great at Swift and Kotlin because there's decades of code to learn from. ArkTS is new, so generated code needs manual fixes about 15–20% of the time. That's a data problem, not a tool problem, and it won't be solved overnight. The community is stepping in with open-source knowledge packs like harmonyos-ai-skill, which condense thousands of lines of docs into a single Markdown file you can feed to Claude or Cursor.

How Huawei, Apple, and Google Diverge on Agent Strategy

If you step back, the three giants are taking very different paths.

Apple is all about open integration. Xcode 27 uses a bridge (mcpbridge) to let third-party agents like Claude and Codex plug in. It's free to use Xcode itself, but you pay for the models—Claude Pro starts around $20 a month.

Google is going all-in on its own stack. It killed the open-source Gemini CLI and replaced it with the closed-source Antigravity. Enterprise pricing is steep: $45 per user per month, with a $100 tier now available.

Huawei is doing the two-track thing. DevEco Code and CLI are free to use, with built-in GLM-5.1 (50 calls per minute) and the option to switch to DeepSeek or OpenAI models. The goal is obvious: get developers in the door, build the ecosystem, worry about monetization later.

There's also a subtle but telling detail: both Apple and Huawei are using the SKILL.md open format for agent skills. That's a sign that "skill-as-code" is becoming a de facto standard across platforms.

Cross-Device: The OS-Level Advantage

When it comes to multi-device, HarmonyOS has a structural edge. The distributed soft bus is baked into the OS, so cross-device calls work like native operations—find a device, connect, and use it. Android is a patchwork of protocols (Wear OS, Android Auto, Matter) that vary by manufacturer. Apple's Continuity is smooth but only works within its own walled garden.

In code, that means a HarmonyOS app can migrate a video stream to a nearby smart TV with a single API call. On Android, you'd be stitching together vendor-specific SDKs. On iOS, you're limited to Apple devices. ArkUI is also the only UI framework that runs across phones, tablets, PCs, cars, watches, and big screens—Compose Multiplatform is still evolving, and SwiftUI is Apple-only.

This isn't marketing fluff. It's a fundamental difference in how the OS treats cross-device as a first-class citizen.

Closing the Loop: Dev-Time and Runtime Agents

The most interesting part of the HarmonyOS story is how it's trying to connect the AI that writes code with the AI that runs it. Huawei talks about this as a "closed loop"—the code generated by DevEco Code should be automatically recognizable and schedulable by the runtime agent system (Xiaoyi + HMAF).

That's harder than it sounds. Writing code fast doesn't automatically make delivery faster. Kuaishou, a major Chinese app, found that even with 30–40% code generation rates, their delivery speed barely budged. The bottleneck was analysis, design, and refactoring—not typing.

So they worked with Huawei to build a special skill called Ark Refiner-Sendable that automates concurrency safety for HarmonyOS. It analyzes, locates, fixes, and verifies issues in one go. What used to take two people a week now takes half a day, and cold-start performance improved by 16%.

The lesson here isn't the 80% code generation rate. It's that building targeted skills for specific engineering problems is the real win, not chasing a generic AI code generator.

What Developers Should Do Now

If you're evaluating HarmonyOS, here's some practical advice:

• Pick your track. New project? Use DevEco Code. Existing system? Integrate DevEco CLI into your current pipeline.
• Explore the 70+ skills. Concurrency safety, multi-device adaptation, and other pain points already have battle-tested solutions.
• Use community knowledge packs. A one-time setup can make your existing AI tools way more useful for ArkTS.

HarmonyOS 7 still has rough edges—no Linux support, thin training data, and a young ecosystem. But the direction is clear: it's betting that the future of OS competition lies in how well dev-time and runtime agents can work together. If that bet pays off, it could change how we think about building software for any platform.