How HarmonyOS 7's Agent-First Design Is Reshaping Mobile Vision

A New Kind of Operating System

When HarmonyOS 7's developer beta landed at HDC 2026, most of the buzz centered on raw performance numbers and the usual feature lists. But for developers who actually build for the platform, the real story is something quieter and more structural: the entire system is being reorganized around AI agents.

Think about how an operating system has traditionally worked. You want to do something, so you pick an app, open it, and tap through a series of screens. HarmonyOS 7 flips that. You state your intent—say, "sign me up for the marathon"—and the system figures out which capabilities to invoke, how to sequence them, and how to coordinate multiple agents behind the scenes.

That shift doesn't just change the user experience. It changes what it means to write an app in the first place. Your application is no longer a passive icon waiting to be tapped. It can expose itself as a schedulable agent, ready to be called by the system when a user's intent matches its declared capabilities.

Six Layers, One Architecture

Under the hood, HarmonyOS 7's agent framework—HMAF 2.0—is built as a six-layer stack. At the top is Xiaoyi, the system-level assistant that acts as the entry point for user requests. Below it, HMAF 2.0 handles task decomposition, breaking a single sentence into discrete steps and managing how multiple agents talk to each other. Then comes the AI foundation: the open-sourced openPangu 2.0 and an on-device 30B model. The system layer adds the Ark engine, Star Shield security, and the cross-device connectivity fabric. Developer tools—DevEco Code and DevEco CLI—sit above that, and at the bottom are concrete scenarios like spatial computing.

For developers, the most immediate change is in how you register your app's capabilities. Instead of just writing UI and business logic, you now declare what your app can do, the parameters it expects, and the callback it will use. The system matches user intent against those declarations and hands your agent a structured task—not a freeform sentence, but a typed object with fields like race name and date.

Here's a simplified example from the interview, showing how a marathon registration capability might hook into HMAF:

import { agentService } from '@kit.AgentKit';
@agentService.AgentExtension
export default class MarathonAgent extends agentService.AgentExtension {
declareCapabilities(): agentService.Capability[] {
return [{
id: 'sign_up.marathon',
description: 'Register for a marathon event',
inputSchema: {
type: 'object',
properties: {
race: { type: 'string', description: 'Race name' },
date: { type: 'string', description: 'Race date' },
location: { type: 'string', description: 'City' }
},
required: ['race', 'date']
}
}];
}
async onInvoke(task: agentService.TaskInfo): Promise<agentService.TaskResult> {
const { race, date } = task.arguments;
// invoke calendar, payment, health data skills...
const schedule = await this.invokeSkill('calendar.add_reminder', { race, date });
return { status: 'success', result: schedule };
}
}

This is a far cry from a voice assistant calling a single API. It's a multi-agent collaboration where the system's planner decides which agents to bring in and how to sequence their work.

Open Source and On-Device AI

Beyond the agent framework, HarmonyOS 7 also open-sources openPangu 2.0. The Pro version packs 505 billion parameters; the Flash version has 92 billion. Both support a 512K token context window. But the more interesting metric is throughput: Huawei claims single-card throughput that's double that of mainstream open-source models, thanks to deep Ascend hardware integration.

Performance wise, the system introduces a "performance model" that predicts and preloads resources. App launch times improve by 24% for system apps and 34% for third-party apps. Game frame-rate stability is up 40%, all while keeping annual resource growth under 10%—below the industry average.

Security also leans on on-device AI. The Star Shield architecture uses a small model to detect scam patterns in real time, identifying seven major fraud categories in seconds. So far it's blocked 3.47 million potential scams, and major apps like Alipay and Douyin are already integrated.

Two Tracks for Developer Tools

Huawei's developer tool strategy is deliberately dual-track. DevEco Code is the "co-pilot" that comes with its own reasoning engine. You give it a requirement, and it plans, writes, compiles, debugs, and even fixes errors on its own. DevEco CLI, on the other hand, is a command-line interface that exposes HarmonyOS's atomic capabilities—project management, build checks, debugging—as commands. It doesn't make decisions; it just opens the door for any agent to drive the toolchain, whether that's Claude, Cursor, or your own in-house agent.

The two serve different audiences. DevEco Code is for teams starting fresh or needing fast delivery. DevEco CLI is for larger teams that already have an agent infrastructure and don't want to rip it out. They complement each other rather than compete.

Under the hood, DevEco Code combines Huawei's self-developed Bifang engine with the open-source OpenCode framework. Bifang is the brain—it handles planning, reasoning, and tool invocation. OpenCode provides the terminal UI, configuration, and the plugin ecosystem (MCP, Skills, Plugins). The split lets Huawei deeply optimize for its own toolchain while still playing nice with the broader ecosystem. Any third-party tool that speaks MCP can plug in.

Internally, DevEco Code runs two agents in tandem. A Plan Agent analyzes the requirement and produces a step-by-step plan. A Build Agent executes that plan—writing code, compiling, running tests, and fixing failures. The Plan Agent doesn't just write code; it modifies project resources and UI files. For example, if you ask for an app that works on both phone and tablet, it'll automatically insert breakpoint-based layout logic into your ArkTS components, something you'd normally have to do by hand.

The Hard Part: Fragmentation and AI Training Data

For small and mid-sized teams, the biggest pain point is device fragmentation. HarmonyOS runs on everything from budget phones to high-end foldables to cars and wearables. Each has different screen sizes, chips, memory, and API levels. Small teams rarely have enough test devices to cover the matrix, so bugs—installation failures, launch crashes, UI glitches—often surface only after users get the app.

Huawei offers some help: EasyGo for parallel views on foldables, and automated UX detection that spots layout issues like oversized text or overlapping elements and points you to the exact source line. But there are gaps. DevEco Code doesn't support Linux, which hurts open-source and server-side workflows. And it leans heavily on DevEco Studio, so a pure command-line experience is limited.

More critically, there simply isn't enough ArkTS in the training data for general-purpose AI models. Models write Swift or Kotlin with ease because they've seen mountains of it. ArkTS is newer, so AI-generated code often needs 15–20% manual correction. That gap won't close overnight. Community efforts like the harmonyos-ai-skill project—a single Markdown file that packs thousands of lines of HarmonyOS knowledge—help bridge the gap by letting tools like Claude or Cursor pull in that context.

How HarmonyOS Stacks Up Against iOS and Android

At their respective developer conferences this year, Apple and Google also talked about AI tools, but the framing was different. Apple split Xcode and Apple Intelligence into two separate narratives. Google broke things into four tracks—AI tools, models, Android Studio, and so on. Huawei, by contrast, put everything in one keynote, presenting a unified "AI operating system" story.

That's not just presentation. It reflects a deeper architectural philosophy. Apple's Xcode 27 uses a bridge to let third-party agents like Claude or Codex plug in via MCP, with 20 built-in tools exposed. Google shut down its open-source Gemini CLI and moved to a closed-source Antigravity, tightly coupled to its own models. Huawei is doing both: a full-featured IDE with built-in intelligence, plus a CLI that opens the same capabilities to any external agent.

Model strategy differs too. Apple's Xcode is free, but you pay for third-party models (Claude Pro starts around $20/month). Google's enterprise tier runs $45 per user per month, with a $100 tier added this year. Huawei gives you free access with built-in GLM-5.1, allowing 50 calls per minute, and lets you switch to DeepSeek or OpenAI if you prefer. It's a clear bid to attract developers early.

Skill ecosystems are also diverging. Apple has a few in-house skills. Google is taking a managed, cloud-first approach. Huawei offers over 70 curated skills covering multi-device development, problem diagnosis, and service generation. Notably, both Apple and Huawei use the same SKILL.md open format—a quiet sign that "skill-as-code" is becoming a de facto standard.

Underneath it all, cross-device connectivity is a fundamental difference. HarmonyOS's distributed soft bus puts device-to-device communication into the OS itself, so capabilities can be shared across brands seamlessly. Android relies on a patchwork of protocols (Wear OS, Android Auto, Matter) that vary by manufacturer. Apple's Continuity is smooth but locked to its own hardware. For developers, that means ArkUI is currently the only UI framework that truly spans phones, tablets, PCs, cars, watches, and large screens from a single codebase.

Can Development and Runtime Agents Finally Connect?

According to Counterpoint, HarmonyOS now holds 19% of the Chinese smartphone market—ahead of iOS for seven consecutive quarters—with over 11 million registered developers and 400,000 apps. But only 23,000 of those are fully native. The gap isn't developer interest; it's the cost of adaptation.

That's where the AI tools come in. Kuaishou, a major Chinese video app, is the flagship case. Using HarmonyOS's AI tools, they hit an 80% AI code generation rate, 84% acceptance for AI-generated test cases, and 73% adoption of AI repair suggestions. Their overall efficiency rose 1.7x, letting two engineers ship phone, tablet, and car versions simultaneously. But the real lesson isn't the code generation rate—it's the "Agent Loop" approach. Kuaishou built a specialized Skill for concurrency safety (Ark Refiner-Sendable) that automates the entire analysis-to-fix pipeline. A task that used to take two people a week now takes half a day, with a 16% cold-start performance boost.

The takeaway: what matters is closing the loop between development-time agents and runtime agents. Having AI write your app is one thing. Having the OS's AI understand and orchestrate that app is another. HarmonyOS is betting that connecting these two will be the defining move of the next platform war.

What Developers Should Do Now

First, decide which track fits your team. If you're starting fresh, DevEco Code is the faster path. If you have existing systems, DevEco CLI lets you integrate HarmonyOS without a rewrite.

Second, mine the existing Skill library. Concurrency safety and other HarmonyOS-specific pain points already have packaged solutions—don't reinvent them.

Third, grab community knowledge packs like harmonyos-ai-skill. A one-time setup brings your favorite AI tools up to speed on HarmonyOS quirks.

HarmonyOS 7 still has rough edges—no Linux support, sparse ArkTS training data, and an ecosystem that's maturing. But if there's one thing to watch, it's the deep coupling between development and runtime agents. That might be the real differentiator against Apple and Google.