AI Agents in Practice: From Code Generation to Self‑Healing Ops – Driving Enterprise‑Level Efficiency

The livestream on June 11, 2026, titled “AI Agent Practical Deployment: From Code Generation to Operational Self‑Healing, an Enterprise‑Level Efficiency Revolution,” featured three senior practitioners who approached AI agents from real‑world pain points rather than abstract model hype.

Three Deployment Paths Target a Common Reality

All speakers agreed that the primary bottleneck for AI agents in enterprises is not model capability but engineering, organization, and risk control. They identified three practical routes: (1) reverse‑engineering and restructuring legacy codebases, (2) integrating AI into the full development lifecycle (requirements, coding, testing, knowledge capture), and (3) applying AI to high‑risk operational tasks with strict verification.

Context Over Code When Dealing with Legacy Systems

Liú Xíngxíng (Ping An Life) highlighted three challenges of old systems: massive code volume, missing documentation, and the need to translate technical logic into business language. He advocated a “layered, domain‑sliced” approach—first building a code graph, then feeding only the most relevant fragments to the model, thereby avoiding token limits and hallucinations.

Xióng Wěi (China Mobile Jiutian) stressed that operational agents must provide trustworthy, auditable suggestions. In production, a wrong recommendation can cause outages, so agents need risk‑assessment, rollback, and evidence‑chain mechanisms before any action.

Yàn Qiáozhì (Sangfor) framed the problem at the engineering level: models cannot see the whole repository nor focus on a single file without losing context. He proposed a workflow of requirement clarification → knowledge engineering → left‑shifted quality checks, turning AI from a curiosity into a repeatable process.

Why Fast Generation Does Not Equal Trust

Liú presented a “front‑middle‑back” control pipeline: compress input context, inject skills/prompts and business knowledge, then standardize output with PRD or architecture templates. He emphasized that hallucinations are inevitable, so a dual‑model review loop and continuous skill refinement are essential.

Xióng illustrated that AI‑rewritten SQL must be evaluated on execution plans, result rows, key metrics, and performance impact—not merely syntax correctness.

Yàn argued that constraints (security lines, architectural rules, coding standards) must be encoded before generation; post‑generation testing, IDE feedback, and automated checks then close the feedback loop.

From Skepticism to Organizational Trust

All three noted that trust is built through small, verifiable pilots that demonstrate consistent, low‑risk outcomes. Liú described moving from “feed the model everything” to a disciplined, sliced approach, which gradually convinced his team.

Xióng warned that engineers fear replacement; he recommends starting with low‑risk, high‑frequency tasks (unit‑test generation, documentation, comment completion) to showcase tangible benefits without threatening jobs.

Metrics That Matter Beyond Individual Speed

Liú suggested measuring average task time, pass‑rate of produced artifacts, and tool reuse rate. Xióng added system‑level metrics: automation closure rate, experience‑capture rate, and reduction of repetitive work, emphasizing end‑to‑end cycle‑time shortening over raw code‑generation speed.

Rule‑Model Division

Liú proposed a “rigid baseline + soft capability” split: rules lock down zero‑tolerance areas, models handle probabilistic reasoning. Xióng refined this into three rule layers—hard security lines, business/architecture constraints, and stylistic preferences—allowing models to operate safely within defined boundaries.

Legacy Systems as the First Battlefield

Liú argued that AI should be introduced early in the lifecycle—during requirement capture and structural analysis—rather than as a last‑minute rescue for unreadable code. Xióng warned that naïvely optimizing local logic in legacy systems can break hidden inter‑module balances, so gradual interface‑first refactoring is preferred.

Future Outlook: Standardized Work Will Be Replaced First

All speakers predicted that in the next three years, AI agents will take over highly standardized, rule‑driven tasks: code comments, unit tests, simple API scaffolding, documentation, routine ops checks, log triage, and low‑value data analysis. Complex design, risk assessment, compliance, and strategic decisions will remain human‑led.

Key Takeaways

Enterprise AI success hinges on engineering rigor, organizational processes, and risk controls, not just model size.

Effective deployment requires context‑aware code slicing, constraint‑first generation, and continuous human‑in‑the‑loop verification.

Metrics must capture end‑to‑end delivery impact, not just code‑generation speed.

Legacy systems are not obstacles but the initial arena for AI‑augmented transformation.

The next wave of AI agents will automate standardized work while leaving high‑level judgment to humans.