HarmonyOS 7's AI Agents Are Changing How Developers Build Apps

The Shift from Apps to Intent

For decades, operating systems have been glorified app launchers. You want to do something, you find the right app, open it, and click through a dozen screens. HarmonyOS 7 wants to flip that script. Instead of you navigating to an app, you just say what you want—and the system figures out which apps and services to stitch together to make it happen.

That's not a small tweak. It's a fundamental rethink of where the intelligence lives. Senior developer and HarmonyOS advocate Liu Guangzhi, who's spent years deep in the ecosystem, believes this is the real story of HarmonyOS 7—not the benchmark numbers or new features, but the fact that the entire system is now organized around AI agents.

Six Layers of Agent Architecture

Under the hood, HarmonyOS 7's agent framework (HMAF 2.0) is built in six distinct layers. At the top sits Xiaoyi, the system-level assistant that takes your raw request. Below it, HMAF 2.0 breaks that request into tasks and coordinates multiple specialized agents. The AI foundation layer includes Huawei's open-source openPangu 2.0 model and a 30B on-device model. System services like the Ark engine and security framework sit underneath, and developer tools like DevEco Code and CLI form the fifth layer. Finally, there are specific scenarios—think spatial computing—that tie it all together.

What does this mean for a developer? Your app is no longer a passive icon waiting to be tapped. It can expose itself as an agent that the system can call upon. The demo at HDC showed a user saying "sign me up for a marathon," and Xiaoyi coordinating health, calendar, and search agents to handle it in parallel.

On the code side, this means registering your app's capabilities with HMAF. You declare what your agent can do, define the parameters it accepts, and provide a callback. The system handles the rest—matching intent, dispatching structured tasks, and coordinating multi-agent collaboration.

New Tools: Two Tracks, One Goal

Huawei's developer tools follow what Liu calls a "dual-track" approach. The first is DevEco Code, a fully autonomous IDE that can plan, write, compile, and debug your app—like a self-driving car for development. It's designed for new projects and teams that want to move fast.

The second is DevEco CLI. This is a command-line tool that exposes HarmonyOS's underlying capabilities—build, debug, device management—as commands. It doesn't make decisions for you. Instead, it lets any existing AI agent (Claude, Cursor, or your own in-house system) plug into HarmonyOS's toolchain. This is for teams that already have their own AI workflows and don't want to switch to a new IDE.

The two tracks aren't competing. They serve different needs. DevEco Code is for greenfield projects. DevEco CLI is for teams that want to integrate HarmonyOS into their existing pipeline without starting over.

Under the Hood: Plan Agent and Build Agent

DevEco Code itself is built on Huawei's proprietary Bifang engine, which handles the agent's thinking and planning, plus the open-source OpenCode framework for terminal interaction and ecosystem support. It uses two agents in tandem: a Plan Agent that understands your requirements and breaks them into a step-by-step plan, and a Build Agent that executes—writing code, compiling, and fixing errors automatically.

One clever trick: the Plan Agent doesn't just write code. It also modifies your project's resources and pages. For example, if you say your app needs to work on both phones and TVs, the Plan Agent will automatically insert responsive layout code with breakpoints and cross-device capability declarations. You don't have to remember to do it later—the agent bakes it into the plan from the start.

Pain Points: Fragmentation and Tooling Gaps

For small teams, the biggest headache is device fragmentation. HarmonyOS runs on everything from budget phones to premium foldables, plus tablets, cars, wearables, and smart screens. Each has different screen sizes, chips, memory, and API levels. Most small teams only have a few test devices, so issues like install failures, crashes, or UI glitches don't show up until users hit them.

Huawei offers some help. EasyGo's "Parallel View" lets you write a config file to get a proper landscape layout on foldables and tablets. An automated UX checker can flag oversized images, text truncation, and overlapping content, pointing you to the exact source line. But there are still gaps.

DevEco Code doesn't run on Linux, which is a letdown for server-side developers and open-source contributors. It's also tied heavily to DevEco Studio—the pure command-line experience is limited. Most critically, AI models don't have enough ArkTS training data. When you ask an AI to write Swift or Kotlin, it's usually spot-on. With ArkTS, expect 15–20% of the generated code to need manual fixes. That gap won't close overnight—Swift and Kotlin have years of accumulated training data.

The community is stepping up. Projects like harmonyos-ai-skill pack thousands of lines of HarmonyOS knowledge into a single Markdown file, which can be loaded into Claude, Cursor, or Copilot to give them a crash course in ArkTS and HarmonyOS APIs.

How HarmonyOS, iOS, and Android Differ

Apple, Google, and Huawei each took a different path with AI. Apple keeps Xcode and Apple Intelligence as separate stories, with Xcode 27 bridging to third-party agents via MCP. Google shut down its open-source Gemini CLI and went closed-source with Antigravity, which caused a stir in the developer community. Huawei, by contrast, bundles everything—DevEco Code, DevEco CLI, HarmonyOS 7, Xiaoyi, and HMAF 2.0—into one cohesive keynote and one architecture diagram.

Pricing models differ too. Xcode is free, but you pay for the AI models you plug in. Google's enterprise Gemini costs $45/user/month (with a $100 tier). Huawei is free for now, with 50 calls per minute to its built-in model, and you can switch to DeepSeek or OpenAI if you want.

Huawei also offers 70+ pre-built "Skills" for specific tasks like multi-device development and problem diagnosis. Both Apple and Huawei use the SKILL.md open format, which is becoming a de facto standard.

Cross-Device: The Real Differentiator

Where HarmonyOS really stands apart is cross-device communication. Its distributed soft bus is baked into the OS, so any device can discover and talk to any other device—across brands, no pairing required. Android relies on a messy mix of protocols (Wear OS, Android Auto, Matter) that vary by manufacturer. Apple's Continuity is smooth but locked to Apple devices.

In code, that means a cross-device call on HarmonyOS is a simple system-level operation. On Android, you're stitching together vendor-specific implementations. ArkUI is also the only UI framework that runs on phones, tablets, PCs, cars, watches, and screens from a single codebase. SwiftUI is great but Apple-only. Compose Multiplatform is still evolving.

The Kuaishou Case: Real-World Impact

Kuaishou, a major Chinese video app, is the poster child for HarmonyOS's AI tools. They reported 80% AI code generation, 84% direct adoption of AI-generated test cases, and 73% acceptance of AI repair suggestions. But the real insight isn't the code generation rate—it's that Kuaishou's existing AI tool didn't speed up delivery until they tackled the whole workflow.

They built a custom Skill called Ark Refiner-Sendable, which automates the analysis, fixing, and verification of concurrency safety issues—a common pain point in HarmonyOS. A task that took two people a week now takes half a day, and cold-start performance improved by 16%. That's the kind of targeted, problem-specific automation that makes a difference.

What's Next for Developers

So where does this leave you? First, figure out which track fits your team. New project? Use DevEco Code. Existing system? Plug into DevEco CLI. Second, check out the 70+ Skills already available—someone may have already solved the exact problem you're facing. Third, grab a community knowledge pack to supercharge your favorite AI tool.

HarmonyOS 7 isn't perfect. Linux support is missing, ArkTS training data is thin, and the ecosystem is still maturing. But the direction is clear: the next OS battle won't be about who has the smartest model or the fastest benchmark. It'll be about how well development-time agents and runtime agents can work together. Huawei is betting that closing that loop is the future—and they're building the whole system around it.