When Your Phone Gets It: HarmonyOS 7 and the Agent Era

Beyond the Spec Sheet: A System That Listens

Two months after HarmonyOS 7's developer beta, the hype has settled. Sure, the numbers are there—app launches up 24% for system apps, 34% for third-party ones, and game frame rates that stutter 40% less. But raw stats don't capture what's really different.

This isn't another OS update with snappier animations and a few new APIs. HarmonyOS 7 is the first mainstream OS built around the idea that you shouldn't have to think in apps. You say what you want, and the system figures out the rest.

For anyone building care-related apps—health tracking, medication reminders, senior care, fitness coaching—this is a big deal. Users in these domains often don't know which app they need. They just say, "I want to run a marathon", and the system should handle the rest.

The Six-Layer Architecture of Intent

Under the hood, HarmonyOS 7 runs on a refreshed intelligent agent framework called HMAF 2.0. It's not a single feature but a layered stack that works together. Here's what it looks like:

• Xiaoyi — the system-level assistant that takes in user requests.
• HMAF 2.0 — the orchestrator that breaks a sentence into subtasks and coordinates multiple agents.
• AI Foundation — includes the open-source openPangu 2.0 models (505B and 92B versions) with 512K context windows.
• System Services — the Ark engine, security shield, and cross-device connectivity.
• Developer Tools — DevEco Code and DevEco CLI.
• Application Scenarios — like spatial computing.

For developers, the key takeaway is that your app can now expose itself as an agent. Instead of waiting for a user to tap an icon, your app can be discovered and invoked by the system based on what the user wants to achieve.

From Voice Commands to True Collaboration

This isn't your grandmother's voice assistant. The old model was a single call-and-response: you ask, it answers. Now, the system can summon multiple agents to work in parallel.

During the keynote, a demo showed a user saying, "Help me sign up for a marathon." Xiaoyi split that into subtasks—checking health data, updating a calendar, searching for events—and dispatched them to different agents that communicated and progressed simultaneously.

On the code side, this means your app needs to declare its capabilities in a way the system understands. You define an input schema, and when the system calls your agent, it passes structured arguments, not raw natural language. Here's a simplified example of how a marathon registration agent might register with 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: 'Event name' },
date: { type: 'string', description: 'Event date' },
location: { type: 'string', description: 'City' }
},
required: ['race', 'date']
}
}];
}
async onInvoke(task: agentService.TaskInfo): Promise<agentService.TaskResult> {
const { race, date } = task.arguments;
// Call other skills like calendar.add_reminder
const schedule = await this.invokeSkill('calendar.add_reminder', { race, date });
return { status: 'success', result: schedule };
}
}

This is a fundamental change in how apps are built. You're no longer just writing UI and business logic; you're designing an interface for the system to understand your app's purpose.

Developers Get a Copilot and a CLI—But Not Both at Once

Huawei's tooling strategy is what they call a "dual-track" approach. There's DevEco Code, a full-fledged AI coding assistant that can plan, write, compile, and debug your app. Think of it as a co-pilot that can take a high-level requirement and turn it into a working project.

Then there's DevEco CLI, a command-line interface that exposes HarmonyOS's build, test, and deploy capabilities to any external agent—like Claude, Cursor, or your own custom setup. It doesn't make decisions; it just provides the hooks.

Which one should you pick? Depends. If you're starting a new project with a small team, DevEco Code gets you up and running fast. If you have an existing CI/CD pipeline and want to integrate HarmonyOS without overhauling your workflow, DevEco CLI is the way.

Inside DevEco Code, there's a two-agent architecture: a Plan Agent that interprets your request and creates a step-by-step execution plan, and a Build Agent that writes code, compiles, and fixes errors automatically. It's not just about generating boilerplate; it can modify existing files, handle layout adaptations for different screen sizes, and even inject cross-device capability declarations.

Real-World Pain Points: Fragmentation and Tooling Gaps

But it's not all smooth sailing. The biggest headache for small teams is device fragmentation. HarmonyOS runs on everything from flagship phones to budget wearables, with wildly different screen sizes, chip sets, and API levels. Testing across all of them is a logistical nightmare.

Huawei offers some tools—like EasyGo for parallel views on foldables and tablets, and an automated UX checker that spots layout issues. But there are still gaps. For one, DevEco Code doesn't support Linux, which alienates a chunk of the developer community. It also leans heavily on DevEco Studio, so the pure command-line experience is limited.

Perhaps the most critical issue is the lack of ArkTS training data in AI models. When you ask an AI to write Swift or Kotlin, it works out of the box because there's years of code to learn from. ArkTS is newer, so the AI-generated code often needs 15-20% manual fixes. That's a significant drag on productivity.

The community is stepping in. There's an open-source project called harmonyos-ai-skill that condenses thousands of lines of HarmonyOS knowledge into a single Markdown file. Once you configure it, Claude, Cursor, and other AI tools can tap into that knowledge base, compensating for the lack of training data.

How HarmonyOS Stacks Up Against Apple and Google

Apple, Google, and Huawei all showcased AI development tools at their respective conferences, but they took different approaches.

Apple's Xcode 27 uses an open integration model. It bridges the MCP protocol with its internal XPC communication, opening up 20 built-in tools that third-party agents like Claude or Codex can use. It's a plug-and-play approach that keeps the model market competitive—you pay for the AI service separately.

Google took a cloud-centric route. They shut down the open-source Gemini CLI and replaced it with a closed-source tool called Antigravity, which is tightly coupled with their own models. Enterprise pricing starts at $45 per user per month, with a $100 tier for premium features.

Huawei's dual-track strategy is different. DevEco Code is free to use and includes a built-in model (Zhipu GLM-5.1) with 50 calls per minute, but you can also plug in DeepSeek, OpenAI, or other compatible models. It's a clear bid to lower the barrier to entry and grow the ecosystem.

When it comes to cross-device interoperability, HarmonyOS has a native distributed bus that works across brands. Android relies on a patchwork of protocols like Wear OS and Android Auto. Apple's Continuity is smooth but locked to its own ecosystem. On the development side, ArkUI is the only framework that lets you write one codebase for phones, tablets, PCs, cars, and watches—though Compose Multiplatform is catching up, and SwiftUI is still Apple-only.

The Real Test: Can Development and Runtime Agents Truly Converge?

Here's the thing: getting AI to write code is one thing. Getting the operating system to intelligently invoke and coordinate those AI-written apps is another. The real challenge is bridging the gap between the development-time agent and the runtime agent.

Huawei is pushing hard on this front. They've integrated both into the same architecture, which suggests they see them as two sides of the same coin. This is where the future of OS competition lies—not in raw model performance, but in how seamlessly the two can work together.

For developers, the actionable advice is:

• Pick your track early: DevEco Code for new projects or quick prototypes; DevEco CLI for integrating with existing systems.
• Reuse the 70+ skills: Many common problems, like concurrency safety, already have pre-built solutions you can drop in.
• Use community knowledge packs: They're a cheap way to make your existing AI tools smarter about HarmonyOS.

HarmonyOS 7 isn't perfect—Linux support is missing, ArkTS training data is thin, and the ecosystem is still maturing. But if there's one thing to watch, it's whether Huawei can truly unify development and runtime AI. If they pull it off, it could redefine what an operating system is capable of—and that's something worth caring about.