When Operating Systems Learned Intent: How HarmonyOS 7 Is Reworking the Developer's Role

The Quiet Shift Beneath the Performance Numbers

Two months after HarmonyOS 7's developer beta debut at HDC 2026, the headlines have focused on speed bumps and feature lists. But those metrics, while flashy, tell only part of the story. The real change is structural: HarmonyOS 7 is the first major mobile OS to reorganize itself around AI agents from the ground up.

Traditionally, an operating system is a place where you install and launch apps. You want to book a flight? Open the airline app, navigate menus, fill forms. HarmonyOS 7 flips that flow. You state your intent—“book me a flight”—and the system figures out which capabilities to summon and how to stitch them together.

That shift isn't just a nifty demo trick. It changes the contract between developers and the platform. Your app is no longer a passive icon waiting to be tapped; it becomes a service that the OS can discover and invoke based on what the user is trying to do.

The Six Layers of Agent-Centric Architecture

Under the hood, HarmonyOS 7's agent framework (HMAF 2.0) is a six-layer stack:

• Xiaoyi – the system-wide assistant that serves as the user's entry point.
• HMAF 2.0 – handles task decomposition and orchestrates communication between multiple agents.
• AI Foundation – includes the open-source openPangu 2.0 (with 505B and 92B versions) and an on-device 30B model.
• System Services – Ark engine, StarShield security, and Cross-Device Connect.
• Developer Tools – DevEco Code and DevEco CLI.
• Scenario Layer – spatial computing and other specific use cases.

For developers, the most immediate change is that you can now register your app as an agent. A simple example: a marathon registration capability might declare itself with a capability descriptor, exposing its input schema and a callback. When a user says “sign me up for the marathon,” Xiaoyi breaks that into subtasks and dispatches structured parameters to your agent—no natural language parsing on your end.

openPangu 2.0 and the Performance Play

The open-sourcing of openPangu 2.0 is notable, but not just for its parameter count. Huawei claims single-card throughput is double that of mainstream open models, thanks to Ascend-native optimizations. That's a meaningful metric for developers who want to run models without burning cloud credits.

Performance-wise, HarmonyOS 7 introduces a “performance model” in the scheduler. App launch times are down 24% for system apps and 34% for third-party apps. Game frame stability improved 40%. Annual load growth is capped at 10%, below the industry average.

Security also gets an AI boost: the StarShield architecture uses on-device AI to spot seven major fraud patterns in seconds. Huawei says it has already prevented 3.47 million potential scams, with Alipay and Douyin onboard.

Two-Track Developer Tools: DevEco Code and DevEco CLI

Huawei's developer tooling takes a “two-track” approach. DevEco Code is the “copilot with a brain”—it plans, writes, compiles, and fixes code autonomously. DevEco CLI, on the other hand, is a command-line interface that exposes HarmonyOS's atomic capabilities (project management, builds, debugging) as commands. That way, teams using Claude, Cursor, or their own agents can plug in without abandoning their existing workflow.

DevEco Code is built on Huawei's self-developed Bifang engine (similar in role to Claude Agent SDK) and the open-source OpenCode framework. Bifang handles reasoning and tool invocation; OpenCode provides the terminal UI, configuration, and plugin ecosystem (MCP, Skill, Plugin). The blend of proprietary and open-source is deliberate: deep integration with DevEco Studio and Hvigor, plus compatibility with any MCP-compatible tool.

Inside DevEco Code, two agents collaborate: Plan Agent breaks down the request into steps; Build Agent writes code, compiles, and fixes errors. It even modifies project resources directly. For example, if you say “make it work on phones and tablets,” Plan Agent might automatically insert responsive layout code using the ArkUI @Builder pattern—no manual breakpoint handling.

The Hard Reality: Fragmentation and Tool Gaps

For small and mid-sized teams, the biggest headache is device fragmentation. HarmonyOS runs on everything from budget phones to foldables, cars, and wearables. Each has different screen sizes, chips, and API levels. Testing across all of them is impossible for most teams, so bugs like install failures, crashes, or UI glitches often surface only after release.

Huawei offers tools like EasyGo Parallel View (a config file that gives apps a landscape-ready layout on foldables) and an automated UX checker that flags oversized images, text truncation, and overlapping elements. But three gaps remain:

• DevEco Code lacks Linux support—builds and debugging only work on Windows and macOS.
• It's still tightly coupled to DevEco Studio; pure command-line use is limited.
• ArkTS training data is scarce. AI tools generate Swift or Kotlin almost flawlessly, but for ArkTS, about 15–20% of generated code needs manual fixes.

Community projects like harmonyos-ai-skill try to fill the gap by packaging thousands of lines of HarmonyOS knowledge into a single Markdown file that Claude, Cursor, and Copilot can load.

Diverging Paths: Apple, Google, and Huawei

Apple, Google, and Huawei are all pushing AI-assisted development, but their philosophies differ sharply.

Apple's approach is “open access.” Xcode 27 uses a bridge (mcpbridge) to connect the MCP protocol with Apple's internal XPC, exposing 20 built-in tools to third-party agents like Claude and Codex.

Google is “cloud-first.” It killed off the open-source Gemini CLI in favor of a closed-source Antigravity, which sparked developer backlash. Pricing is tied to Gemini subscriptions (enterprise at $45/user/month, with a $100 tier).

Huawei is “two-track.” DevEco Code is free (with a built-in GLM-5.1 model, 50 calls per minute), and DevEco CLI is open for integration. Developers can also switch to DeepSeek or OpenAI models. The goal is to attract developers now, monetize later.

On the skill ecosystem, Apple has a few official skills; Google has no clear local skill count; Huawei offers 70+ curated skills covering multi-device, debugging, and service generation. Notably, both Apple and Huawei use the SKILL.md open format—a sign that “skill-as-code” is becoming a cross-platform standard.

The Real Test: Closing the Loop Between Development and Runtime Agents

HarmonyOS's market share in China hit 19% in May (Counterpoint), overtaking iOS for seven straight quarters. Over 11 million registered developers and 400,000 apps exist, but only 23,000 are truly native. That gap is where AI tools come in.

Kuaishou's case is instructive. Their internal AI coding tool had already achieved a 30–40% code generation rate, but delivery speed didn't improve. The bottleneck wasn't writing code—it was analysis, refactoring, and verification. By partnering with Huawei to build a specialized skill (Ark Refiner-Sendable) that automates concurrency safety refactoring, they cut a two-person, one-week task to half a day, with a 16% cold-start performance boost.

The takeaway isn't the 80% code generation rate or 84% test case adoption. It's that solving specific engineering problems with targeted skills works. That's more valuable than chasing generic code generation numbers.

For developers, the strategic question is whether to adopt DevEco Code or CLI, which skills to reuse, and how to supplement AI tools with community knowledge packs. HarmonyOS 7 is still rough around the edges—Linux support, ArkTS corpus, ecosystem maturity—but the direction is clear: the OS is being rebuilt around agents, and the line between writing an app and the system using it is blurring.

That convergence might be HarmonyOS's real differentiator. Not the model size, not the performance numbers, but the promise that the code you write today will be understood and orchestrated by the system tomorrow.