Alibaba Cloud's AI-Native R&D Org Transformation: 3-Stage Evolution, 7 Production Pilots & Unresolved Challenges

Alibaba Cloud's CTO product and R&D line has been exploring AI-native R&D organization transformation around a business "North Star" goal. While local results have emerged, deeper problems surface as AI-native practices enter the "deep water zone": point optimizations and local optima are insufficient because R&D teams are embedded in business, organization, and industry collaboration.

Three Core Judgments from Tang Hong (VP of R&D)

Tang Hong reviewed the technology timeline: late 2022 ChatGPT showed general pre-trained models can solve many problems without domain-specific models; reasoning models enabled long-horizon thinking; tools and memory integration let Agents execute tasks autonomously (receive goals, plan, execute, read feedback, iterate). He summarized today's agentic computing paradigm as "Model + Harness + Context": Model handles understanding, judgment, real-time decisions; Context provides comprehensive, unified, continuously updated context; Harness manages autonomous agent operation and continuous evolution.

Based on a three-month exploration across the 6,000-person R&D org, Tang proposed three judgments:

Agent entering the production chain is the true watershed. Not just coding assistance, but Agents participating in end-to-end production.

AI Native is not only about cost reduction ("cost reduction is priority one"), but a competitive dimension leap.

Three evolutionary stages: Tool-native (individuals use Agent tools well) → Workflow-native (Agents stitch multi-step processes) → Org-native (entire organization works in AI-native ways).

Tang emphasized they are still exploring and seek peer validation rather than providing standard answers.

Organizational Perspective from Cai Liang (Org Development Lead)

Cai Liang traced historical org forms (typing pools, punch-card workshops) to show org structure always responds to contemporary technology and capability supply. AI changes scarcity of capabilities, necessitating org restructuring. A new boundary appears: humans must now collaborate with non-human intelligent agents. When Agents undertake tasks, new contracts must be established — no ready-made answers exist; continuous exploration and construction are required.

The exploration categorizes problems into two types:

Growth problems: Extreme optimization within existing framework — inspect requirements, product, design, dev, test, release, ops for any uplift.

Evolution problems: Disrupt and reconstruct everything between AI capabilities and customer value.

The rollout uses a "North Star, Whitespace, Sandbox" approach:

North Star: Mobilizes and stimulates AI-native transformation innovation; decides which innovations get sustained investment.

Whitespace: Innovation need not wait for full management readiness; allows teams to cross role boundaries during experimentation.

Sandbox: Provides supportive environment while controlling impact on main production pipeline.

Observability metrics are for observation and comparison only, not tied to performance reviews, using a "discover new species" mode to avoid metric-driven local over-optimization distortions. Sample-room entry criteria: entered production scenario, observable business results, reuse potential.

Early Local Results

After several months, some local achievements appeared (not representing overall performance; reuse still needs validation):

One project cut full-chain processing time from 2 hours to 5 minutes .

Another completed dozens of requirements in two weeks , shrinking release cycle from 40 days to 2 days , and produced 10+ production-grade Skills .

Two shifts emerged: (1) Core assets reconstructing from artifacts to conditions supporting trusted regeneration; (2) Next-stage platform needs converging to three directions.

Three Platform-Level Directions

Reliable task execution: Around Harness and "spec-as-code", fill execution constraints & runtime governance, multi-agent orchestration, auto verification & acceptance, with hard acceptance gates.

Continuous experience accumulation: Assetize tools, Skills, and MCP (Model Context Protocol); close the loop of experience extraction, evaluation, version evolution; explore capability self-evolution.

Collaboration into the organization: Around multi-agent orchestration and "Agent into org", handle role up-leveling & team blending, Agent identity/permissions, Human+Agent collaboration, end-to-end observability & efficiency analysis, rational Agent scenario selection.

Panel: New Contract Between Humans and AI

Moderated by Cai Liang with Tang Hong, Han Hongyuan (VP, Public Cloud Solutions GM), and Bian Sikai (Ant Bailing Product & Ops Lead, AAIF Ambassador). Key themes:

Personal Practice

Tang Hong: Must stay humble, truly learn the new tech. He feels coding passion returning to early-career levels. To understand AI Native, one must first use it, change own problem-solving, then influence peers.

Han Hongyuan: Distinguishes Coding, Programming, Software Development. Code ≠ Software; true software has vast functional/non-functional requirements. Coding Agents address implementation volume, but turning code into deliverable, sellable, sustainable software leaves huge discussion space.

Bian Sikai: Code is raw material; making good software, then good service, involves a long value chain. Remains long-term bullish on SaaS ("Service as Software"). Coding cost drops, but other readiness/evaluation requirements may rise. Professional capability demand won't decrease.

What Remains Scarce When Code Gets Cheap?

Han: Software vs program difference lies in run, verify, repeat verification. Requirements and tests never cover all production issues; AI may not either. Some programs can be "daily disposable", but real software won't be. Software must undergo full lifecycle and sufficient real runs to mature. Infra software's non-functional requirements, architecture governance, continuous evolution matter far more than writing code — still need long-term honing.

Tang: Code generation cheapness exposes other problems. Traditional waterfall assumed labor cost highest, so avoid rework via heavy design/spec reviews. Now iteration speeds up; heavy process becomes new bottleneck. Human handoffs slower than machine. PMs doing dev work, devs doing PM work — because any two entities have coordination cost. Example: frontend/backend libs separate; slow change was fine. Now both iterate fast, backend moves ahead, frontend can't catch up. Better to put code in same repo and change together. Software definition, software engineering, human roles may all change comprehensively.

Bian: Each tech cycle reorganizes roles (e.g., data analyst, data scientist emerged with big data). Problems they solve unchanged: customers still need to run business, balance supply/demand. Don't get carried away thinking Vibe Coding builds enterprise systems. Performance/security engineers remain multi-year trained pros. Workloads change (REST→Token), system design changes, but structural/security/performance problems persist. Real change is customer-side delivery and customer imagination of new things. Need creative people to build new works so others realize "oh, it can be like this". Age less important; openness and scientific method matter.

Professional Boundaries Blurring

Tang: Expert capabilities are islands; AI coverage is rising sea level. Islands shrink. AI still weak in product design, interaction, complex non-functional design, but visibly improving. Hard system problems can be solved via language, tools, engineering systems together. AI doesn't solve everything out of thin air, but with right tools enters more domains. Experts won't vanish, but bar rises. One uniquely human trait: if product is for humans, usability/comfort involves taste and product sense — hard to fully automate.

Deterministic Software vs Non-Deterministic Models

Han: Overlap of product into dev, dev into product helps collaboration. Past blockers were poor handoffs; without entering each other's domain, handoffs can't be smooth. But models change fast, injecting non-determinism into systems that crave determinism. If your AI app can't leverage new model capabilities when released, reflect on whether you're truly using AI. Don't lock model to old version. Yet can't assume AI replaces humans end-to-end. Example: MySQL has full docs, clear interfaces, known issues. Has anyone used AI to rewrite a better MySQL and actually replace it? No. Compilers run once; databases run continuously. For infra software, AI writing once and running reliably long-term is unproven. He leans conservative.

Bian: Infrastructure is relative — MySQL is app to container/OS folks. We're in a very early, wild-west stage. Model state brings instability; weird outputs may be features, not bugs. It's an irregular brick, more like cement. Harness similarly: simple problems solved, next stage needs more testing facing non-determinism. Software is deterministic; human world isn't. We used software to converge partial uncertainty into deterministic flows; now using non-deterministic model for non-deterministic customer needs requires redesigning the middle layer. "Service as Software" still holds: abstract deterministic parts as Building Blocks, stack with Model+Context to handle uncertain needs. More perspective shift than total upheaval. Engineers can readjust, re-adapt; not just "who gets eliminated".

What Should R&D Org Change First?

Tang: Can't answer by swapping one mechanism — mechanisms interlock. Most important: believe the future will arrive. Everything could break/change. Find an evolution path: break here, adjust there, but keep a path through. Example: today software boundaries must be precise (I/O, params, versions, compat). Agent era explores API negotiation: ask what you can do, search/select, services converse like humans. Not all software needs this (RPC, MySQL may not). But where uncertainty rises, boundaries may shift. When you believe that future, examine if current rules can break when they conflict.

Han: Two things: (1) Break functional boundaries in dev — more overlap, AI helps enter previously out-of-scope areas; overlap enables smoother communication. (2) Software maturity must come from sufficient runs and verification. If code, interfaces, contracts unstable, no repeat verification; each run reintroduces risk. Many non-functional issues only surface in production after extensive customer env validation.

Bian: Do less: ask less "why doesn't this exist" and "is this my job". In chaotic times, missing things are just missing — go write, go create. Org boundaries evolve with transition states. Instead of debating ownership, ask: business/customer problem unsolved, can I do more? Do more: build tools. Lack new tools and new "atomic capabilities". Agent sending email calls Gmail, doesn't rebuild IMAP. Good tool encapsulation ≈ atomic capability. Future middleware may come from recomposing these atomic capabilities. Currently too little done; engineers weren't encouraged because it looked small, but today it's harder and more important — many capabilities need re-abstraction.

Seven Sample Rooms (Production Pilots)

Forum covered seven dimensions; each will get a dedicated follow-up article. Highlights:

1. Product Design Evolution: Human-Led → Human-AI Full-Chain Collaboration

Zhong Yaorong, Product Management Director

Bottleneck shifted from PRD production to product judgment & customer understanding. Built full-chain knowledge system, not just PRD generator. Results: ~2/3 needs no longer need human line-by-line review; value judgment accuracy >90%; need response time -45%; backlog handling efficiency +50%+; ~80% PRDs AI-generated; end-to-end product experience eval from 4hrs to 30mins.

2. Code Review Evolution: General Review → Domain Expert (Kitta)

Zhou Yuanhang, Technical Expert

Data: CVE reports +394%, critical vulns +811%; code bug rate +9%; avg PR size +154%; review time +91%. Anolis community monthly PR merges for two kernel distros grew 8.9x in two years. AI Native R&D can't stop at writing code; need Agentic CI across production, verification, delivery. Code review is first quality gate. In large open-source projects, AI reads code but not the project — lacks domain knowledge, dev practices, flow rules, when to alert vs stay silent. Kitta built in three steps: extract review principles, defect patterns, conventions from GitHub/LKML/project history; dual-wheel customization (process defines where to look, knowledge decides how); continuous calibration via offline eval and online behavior. Results: 17-30% review quality uplift across six domains; serving Anolis ANCK kernel, 70k+ patches reviewed, gate accuracy 97%, merge rate 62%.

3. Code Fix Evolution: Alert → Auto Fix (PolarDB-X Loop)

Sheng Taotao, Senior R&D Engineer

Personal anecdote: two-line fix took a day of log/monitoring analysis, near a week to reproduce, plus tests/review. AI writing two lines saves little; want Agent to handle alert-to-fix-delivery end-to-end. Used existing APIs/CLI for Agent to query monitoring, logs, instance topology. For legacy platforms lacking tools, Agent analyzed web requests/auth, wrapped needed functions as CLI. For run verification: re-implemented JDB CLI on Java Debug Interface for structured returns, session management, thread-specific breakpoints; servitized large heap dump analysis; provided PolarDB-X Zero second-level temp instances and K8s full clusters for reproduction. Now running in cloud: 100% alerts get Agent first-pass analysis/handling; half-year: from 10k+ alerts identified 200+ defects, >70% stably reproducible, Agent-fixed into review. Three engineering heuristics: R&D systems must be callable, processes verifiable, tasks runnable 7x24 in cloud.

4. R&D Collaboration Evolution: Coding Efficiency → End-to-End Delivery (Cloud Communication)

Zhao Bin, Senior R&D Engineer

Traditional dev: coding is one link among requirements, design, test, release, acceptance. When coding accelerates but upstream/downstream still human-handoff, work piles at next manual node. Goal shifted to end-to-end delivery. First solve: how Agents collaborate. Cloud digital-twin-driven automated delivery pipeline runs 7x24, covers domestic SMS, intelligent voice, intelligent scheduling, international SMS. Single digital twin handles 3-4 requirements in parallel; ~2/3 of gated simple requirements achieve end-to-end closed loop. Post-delivery audit of process, artifacts, Agent execution; effective experience written back to knowledge base. Detours: rushed models, underestimated domain jargon/historical knowledge complexity, context hallucination affected judgment.

5. Full-Domain Ops Evolution: Manual Fault Injection → Scalable Benchmark Production (STAROps)

Lou Haibin, Technical Expert

Complete ops eval data should contain execution trajectory, supporting conditions, validation basis, with environment-binding, time-binding, full causal chain. Four Agents collaborate: ScenarioAgent (topic selection), EnvironmentAgent (env build), BuildAgent (fault injection & evidence extraction), SupervisorAgent (quality check); humans set targets, acceptance criteria, final review. Real online issues can be reconstructed via mechanism restoration, equivalent replay, signal alignment into eval sets. Five quality dimensions: quality, coverage, discrimination, scale, freshness. Platform accumulated 1,400+ eval cases; root-cause eval set grew 10x in half-year (58→838), covering 100+ root-cause fault types. Fault injection is one step; real difficulty: ensuring every case verifiable,沉淀able, continuously runnable. Only with this foundation can intelligent ops capability improvement have credible measurement.

6. Org Evolution: Agentic SOC Security Product Self-Evolution Behind Org Restructure

Ren Yi, Senior Security Expert

As more improvements done autonomously by Agents, humans must pre-set four boundary types: goals, quality, permissions, stop conditions. After tech loop closed, org adjusted: integrated product, R&D, security into single team; each need owned by one Owner from goal definition to result acceptance; product experience, engineering delivery, security effectiveness advanced in parallel under same standards. Traditional serial ~51 days scheduling → ~14 days. Role boundaries extend forward/backward around outcomes, but not everyone does everything. Standardized, evaluable, rollbackable tasks → Agent executes, human approves; cross-domain but controllable risk → Owner uses Agent to close loop; high-risk, high-ambiguity, irreversible → pros lead. Phase data: avg need cycle 50.9→13.8 days; window throughput 63.9%→98.9%; ARR growth >100%. Insight: restructuring tech alone insufficient. When Agents run around final outcomes, org must also rally around same outcome — shared goals, unified acceptance, end-to-end accountability, risk division.

7. Product Operations Evolution: Process-Driven → Agent Digital Human Team Growth

Wang Xizheng, Senior Product Operations Expert

Gartner/Salesforce: AI share of marketing work 16%→36% by 2028. Content production, GEO optimization, acquisition AI adoption rising; new problems: traffic attribution harder, content updates lag product iterations. Response: shift from process-driven to Agent collaboration. Full marketing campaign used to take months; now one week. Human effort allocation: was mostly material production; now ~20% production collaboration, ~80% judgment/decision. Built marketing growth Agent digital employee team: 2 humans + 1 Leader Agent + 6 Worker Agents (content topic, content creation, opportunity mgmt, business analysis, product knowledge, traffic optimization). Four main pipelines: product launch, new feature release, opportunity mgmt, data analysis. Coordinating 100+ roles across product, R&D, architects, ops. ~10x efficiency gain.

Still Early Stage

Seven sample rooms took different paths: Cloud Communication binds responsibility to employee digital twins; Agentic SOC tries single Owner spanning functional boundaries; Kitta & STAROps focus on evidence, gates, repeatable eval; Product & Ops teams adjust rhythm and division of labor. All involve Agent entering production → how process & responsibility adjust in sync. Teams still separately defining goals, permissions, acceptance, accountability — no unified approach yet. From cases, teams investing more in problem definition, context quality, result acceptance, responsibility division; also trying to codify personal experience into Context, Skill, Eval, Harness, or platform capabilities. Cross-team reusability needs more production data validation. One forum insufficient for conclusions. Next seven deep-dives will return to each sample room: problem background, process adjustment, gate setup, failure handling, current boundaries.