Tencent Video's AI-Native Knowledge Flow Across Working, Coding, OnCall
Tencent Video details its AI-native knowledge system connecting business operations (Working), engineering delivery (Coding), and production support (OnCall) through a four-type knowledge taxonomy, a produce-consume-manage loop, and evolutionary stages from tool adoption to organizational knowledge flywheel, achieving 90% self-service data query automation and 86% efficiency gain in live streaming reconstruction.
Background: From Personal to Organizational Efficiency
The article opens with a paradox: personal AI tools create a "fireworks feast" of individual productivity, yet organizational output does not rise correspondingly. The core issue is that personal efficiency gains do not automatically translate to organizational gains because workflows remain untransformed. Seven specific problems are identified: knowledge not precipitated (locked in individuals), capabilities not reused (repeated reinvention), standards not unified (uncontrolled "vibe coding"), context islands (AI lacks organizational data/lineage/standards), AI divide (gap between skilled and unskilled users widens), missing enterprise features (permission control, audit logs, compliance), and disconnected processes (technical/experience debt scattered across siloed systems).
AI Application Maturity Model (L0–L5)
The team defines a six-level maturity model:
L0 – Pure Manual: No automation; human executes everything.
L1 – AI Tool Penetration: Independent AI apps; human uses tools.
L2 – AI Process Embedding: Embedded Copilot; human leads process.
L3 – Agent Collaboration: Agent workbench; human approves/decides.
L4 – High Autonomy: Autonomous agent system; human supervises/strategizes.
L5 – Full Autonomy: AI operational brain; human sets goals.
Current scenarios sit at late L2 / early L3 — a watershed where work shifts from human-driven with AI assistance to AI-driven with human assistance.
Knowledge as Soil for Organizational AI
Knowledge is the foundation. The team structures knowledge flow in two dimensions:
1. Produce → Consume → Manage Loop
Produce: Extract knowledge from code, data, documents, cases, real operations.
Consume: Let humans and agents invoke knowledge on demand during analysis, development, troubleshooting.
Manage: Update, deduplicate, evaluate, audit, and control permissions based on usage feedback.
Updates must happen inside real work (e.g., at PR submit, review completion, root-cause tagging, issue closure), not as after-the-fact documentation.
2. Personal → Team → Platform Flow
Personal knowledge: One-off debugging conclusion, useful prompt, operational experience.
Team knowledge: Curated and validated into team repos, domain knowledge bases, standard Skills.
Platform knowledge: Abstracted into universal rules, public tools, unified interfaces for broader reuse.
Four-step conversion is critical: personal judgment → structured asset → real-task validation → default workflow consumption . Missing any step breaks long-term reuse.
Four Knowledge Types Managed Separately
Environmental: "What is happening now" — hot events, OnCall incidents, experiment rollouts, client versions, sentiment, code commits.
Decision: "Why this judgment, what next" — monitoring rules, decision rationale, attribution logic, thresholds, guardrails.
Business: "By what standard" — business processes, code specs, data specs, SOPs, test specs.
Factual: "What concrete artifacts" — data tables, metrics, APIs, code topology, module definitions, historical instances.
Separation avoids interference of update frequency, permissions, and retrieval methods.
Five Usability Criteria
Findable: catalog, metadata, routing direct tasks to correct scope.
Usable: content directly supports analysis, design, coding, troubleshooting — not just background.
Traceable: know which rule, case, version was referenced.
Verifiable: correctness judged via data results, compilation, tests, evaluation, or human review.
Recyclable: issues found in actual use feed next update cycle.
Three Scenario Implementation Paths
3.1 AI Working: Business Knowledge into Operations Workflow
Problem
Data knowledge scattered across systems; business judgment trapped in expert experience. Mere data query access is insufficient — agents must understand why metrics change and what action to take.
Three-Layer Structure
Public capability layer: routing, metadata query, knowledge Q&A shared by all business lines.
Business-line sub-repos: split by commercialization, growth, operations, membership, product, OTT, PC, user portrait, sports, etc.
Public knowledge base: unified maintenance of data tables, dashboards, metric dimensions, production logic, decision logic.
Business semantics organized by object, action, rule — capturing not just "what a metric is" but its business object, usage action, and judgment rules.
Production, Consumption, Update, Governance
Produce: Auto-collect metadata, dashboards, analysis reports, data production logic; experts supplement business operations, decision logic, exceptions.
Consume: Via OvWork workbench providing data query, analysis, content operations, hotspot operations, intelligent delivery, task operations. Routing sends tasks to appropriate sub-repo and Skill.
Update: Auto-sense sub-repo changes for incremental data knowledge and routing updates; high-frequency business cases periodically decomposed into business knowledge; evaluation, release, security audit as gatekeepers.
Governance: Business process owners by direction; data knowledge owners by topic; repo permissions, service-side data permissions, audit logs managed together.
Results (Data AI Working Example)
Self-service data query AI ratio 90%, time reduced from 3–5 days to minutes.
OvWork AI Working workbench penetration >80% across product/operations.
90%+ of data task OnCall handled by agent analysis.
Data tracking test efficiency improved ~70%.
3.2 AI Coding: Engineering Knowledge into Delivery Workflow
Why: Engineering Experience Hard to Scale
Code alone ≠ engineering understanding: architecture evolution, module boundaries, default paradigms, cross-repo relationships live outside code.
Existing implementations ≠ correct answers: historical bad cases risk being copied as "best practices".
Knowledge scattered across delivery chain: code, Wiki, MRs, reviews, compile errors, test feedback isolated.
Personal context cannot support organizational scale: multi-end, multi-repo, multi-component contexts unstable via personal prompts.
The live-streaming three-end single-codebase reconstruction exposed these issues, evolving WorkManager from a "code generation tool" into an integrated engineering system covering knowledge, task decomposition, execution, verification, feedback.
Method 1: Layer Knowledge Assets
Three long-term asset layers plus a runtime Working Set:
Public Rules: Dev specs, code review standards, architecture constraints, common dependencies — "What all projects must follow".
Domain Knowledge: Business boundaries, module responsibilities, cross-repo relations, default paradigms — "How this business domain should be done".
Engineering Knowledge: APIs, patterns, decisions, test mappings, corrections — "How to implement and verify this specific task".
Runtime Cache: INDEX, rules-digest, architecture-decisions, topics — "What the current Work actually needs".
Layering solves "what knowledge belongs where"; Runtime Cache solves "what this task truly needs". Avoids two extremes: relying solely on source-code reverse-engineering, and stuffing all knowledge into context at once.
Method 2: Organize with Domain as Retrieval Router
Knowledge pipeline: data collection → knowledge production → knowledge assets → AI application.
Production (three tracks): Cold start (AST/tree-sitter generate API/architecture docs, structure historical Wiki/docs/cases); Human curation (owners add domain boundaries, architecture decisions, public rules); Incremental feedback (compile errors, interface misuse, review/test issues written into corrections, learnings, knowledge.md).
Organization: Locate then deep-read. Retrieval narrows stepwise: domain/component/repo → frontmatter → MANIFEST/INDEX/topology → multi-round retrieval → knowledge-cache. Domain serves as the primary retrieval router.
Consumption embedded in dev workflow: WorkManager binds knowledge consumption to stages: Planner inherits project architecture/rules then decomposes tasks; Dev reads patterns/decisions/engineering knowledge on demand; Review checks rules, good/bad cases, knowledge references; Feedback phase writes new issues back into corrections.
Two engineering constraints key to moving from "knowledge base" to "knowledge runtime": knowledge_refs (references must be traceable) and stage-enforced consumption (correct knowledge must enter context at correct stage).
Method 3: Measure What Matters — Not Just Retrieval Similarity
Five metric categories:
Coverage: % of knowledge-requiring tasks that actually got knowledge_refs.
Hit: Correct patterns/good cases/dependencies in Top-K.
Consumption: Agent actually read and used in corresponding stage, not just "searched and stopped".
Result: After knowledge injection, compile/unit-test/review first-pass rate improvement.
Health: Duplication, conflicts, expiration, corrections feedback, rules promotion monitorable.
Ultimate measure: "Did knowledge help the task complete more correctly?"
Method 4: Spin the Flywheel — Real Delivery Continuously Produces Knowledge
Small flywheel (within Work): Dev/UnitTest/Review issues enter corrections, immediately inherited by subsequent tasks in same Work.
Large flywheel (across Works/teams): High-frequency corrections validated in real tasks and governed by owners gradually promote to project-rules, domain patterns, common-rules — one delivery experience becomes default capability for many tasks.
This is the minimal loop for personal knowledge entering organization: personal judgment → structured asset → real-task validation → workflow default consumption .
Results
700+ business domains covered, 50k+ knowledge files.
Requirement AI penetration ~40%; active developer penetration ~60%.
End-to-end efficiency gains 17%–50% across centers.
Live streaming three-end single-codebase reconstruction: estimated 1023 person-days reduced to 140 person-days, 120k effective lines delivered in two months, 86.3% efficiency gain.
AI Coding now forms an internal R&D knowledge loop: knowledge enters delivery → real tasks validate → errors continuously feedback → new knowledge auto-inherited next round. Knowledge grows with real delivery, not just special projects.
3.3 AI OnCall: Every Troubleshooting Session Precipitates Next Capability
Why: Troubleshooting Experience Hard to Reuse
Expert-dependent: critical judgments concentrated in few domain-familiar people.
Fragmented capabilities: logs, monitoring, releases, experiments, code across platforms.
Long chains: one issue spans multiple ends, modules, systems.
Initial phase connected feedback listening, log analysis, root-cause attribution, alert attribution, report push. Goal evolved from "help complete one troubleshooting" to "precipitate high-value experience from troubleshooting into reusable knowledge for next diagnosis".
Challenges: Broad Knowledge, Long Chains, Heavy Context
From on-call dev view: too much info (logs, monitoring, code, platforms, historical cases), unstable paths, expert-dependent implicit judgments, experience断层 (breakage), scale pressure. From engineering view: knowledge scattered (code, logs, config, rules, historical analysis, human experience), long chains (feedback crosses modules/ends/systems), knowledge drifts (versions, strategies, code change), context overload (system knows much but each diagnosis needs only few high-value evidences).
Overall Path: Coverage → Reliability → Autonomy (CAR Model)
Four knowledge layers in OnCall:
Fact layer: what happened — logs, metrics, config, versions, platform data.
Method layer: how to investigate — troubleshooting SOPs, Skills, query paths, routing strategies.
Judgment layer: basis for conclusion — terminal evidence, confidence, ground truth, rules.
Action layer: what next — fix, rollback, upgrade, actions, guardrails.
Decisions guided by CAR: Cost (engineering investment), Autonomy (how far system goes), Reliability (trustworthiness). Sequence: first coverage, then reliability, then gradually expand autonomy.
Phase 1: Get Knowledge In (Cold Start)
Extract first-version knowledge from business code, historical issues, existing rules, tacit knowledge.
Form basic Skills, investigation paths, issue classification mappings.
Consolidate scattered platform capabilities into unified callable tool interfaces.
Turn "only humans know" into "machine can at least find, call, execute".
Phase 2: Grow Knowledge (GroundTruth Loop)
Traditional "write a Wiki after fix" fails. Embed precipitation into workflow: make knowledge precipitation a natural byproduct of completing real work.
GroundTruth captures not just final root cause but the effective human process: what was queried (logs, metrics, platform data), how (tools, filters), what was seen (key evidence), what was excluded (directions negated), why conclusion reached (judgment basis).
Engineering pipeline: AI analysis error → human calibration → submit GroundTruth → auto-distill → Skill update → unit-test evaluation → owner review.
Solves not just "write knowledge down" but "one human judgment, validated by real issue, becomes next default system capability".
Phase 3: Use Knowledge Precisely (Context Engineering)
Problem shifts from "AI doesn't know" to "AI knows too much". Focus moves from adding knowledge to subtracting context: pre-processing, event extraction, structured evidence chains, missing-evidence supplementation compress context to minimal sufficient evidence.
From "full logs" to "evidence chain" — improves signal-to-noise, reduces cost and misjudgment. Context reduced from 128KB to 32KB; report generation rate 83% → 99%+; accuracy 49.6% → 75.8%. Less context, better outcomes because model sees more complete, relevant key evidence.
Results
Feedback automated analysis penetration 73.03%, accuracy 75.8%.
Alert triggered → OnCall ticket + AI attribution within 10 minutes.
PC end replicated basic infrastructure in two weeks.
Key Insights
Knowledge building is not "build a library" but "build a flow" — knowledge must enter real workflow to be continuously consumed, validated, updated. The continuous loop produce → consume → calibrate → update → re-consume matters more than document count.
Personal knowledge enters organization via process, not advocacy — capture key evidence, analysis paths, judgment conclusions naturally during real troubleshooting, then GroundTruth, evaluation, owner governance gradually precipitate into team knowledge, Skills, Rules, platform capabilities. Precipitation becomes part of work, not extra task.
More knowledge demands better context selection — system knows broadly, each diagnosis needs most relevant, sufficient evidence. Knowledge engineering makes system "know"; context engineering makes model "see right"; ultimately from "knowing more" to "judging accurately".
Capability evolution continues "coverage → reliability → autonomy" as knowledge, evaluation, guardrails mature.
Conclusion: Three Stages of Evolution
Stage 1 (past): Scattered point-wise construction — add AI capabilities directly to business-domain subsystems, tool penetration in R&D and business domains.
Stage 2 (ongoing): Workflow-driven — AI Working, AI Coding, AI OnCall systematically build knowledge systems driven by AI-native work-mode transformation, connecting business and scenarios.
Stage 3 (ongoing/future): Organizational knowledge system — connect business and R&D domains, land more AI-native business workflows, form scalable, reusable personal→organization continuous precipitation capabilities.
Future standard answer unknown. In AI era, imagination boundary determines output boundary; only way to validate imagination is to boldly try.
Signed-in readers can open the original source through BestHub's protected redirect.
This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactand we will review it promptly.
How this landed with the community
Was this worth your time?
0 Comments
Thoughtful readers leave field notes, pushback, and hard-won operational detail here.
