How AI Can Automate Repetitive Work: From Simple Tools to Intelligent Agents

Introduction

The author reflects on the growing ability of large language models to move from deterministic tasks to more uncertain, complex scenarios. By treating repetitive operational work as a fixed "perception‑decision‑execution" pattern, AI can become a reliable digital collaborator.

Why an “AI collaborator”?

Receiving alerts outside work hours for upstream issues that are not caused by the current team.

Processing hundreds of tickets each year, requiring navigation across multiple platforms, logs, and configurations.

Upstream schema changes that force manual checks of thousands of downstream tasks.

Data‑governance, ticket triage, and baseline operations that consume a lot of time with limited incremental value.

These activities share a highly predictable action path despite differing contexts, making them ideal candidates for automation.

Core Idea: Perception‑Decision‑Execution Loop

Any "repetitive" work that has clear input, logical steps, and fixed actions can be handed to AI. This includes explicit batch labeling as well as seemingly flexible tasks like data‑governance, ticket triage, or night‑shift duties that actually follow a hidden SOP.

The loop consists of three components:

Eye (Perception) : Equip AI with the ability to read information from code repositories, ticket systems, logs, documents, etc., via SDK‑wrapped tools.

Hand (Action) : Expose operations such as creating tasks, commenting, updating statuses, or executing scripts as callable tools.

Brain (Decision) : Let the AI reason over the gathered data and decide the next step, either through a fixed workflow or dynamic planning.

[AI Brain] ←(Prompt/Workflow)→ [Toolset]
   ↑               ↗       ↘
(Decision & Planning) (Read‑type tools) (Action tools)
   (e.g., read code / read ticket) (e.g., create task / comment / publish)

Three Automation Modes

1. Tool Assistant (single‑call analysis)

AI receives a concrete request, calls one or more tools, and returns a concise result.

Typical for batch labeling, document extraction, or quick code analysis.

Advantages: simple, fast, easy to prototype (minutes if tools already exist).

2. Workflow (fixed multi‑step process)

Encapsulates a deterministic SOP with loops and branches (10‑50 steps).

AI orchestrates a series of tool calls, performs intermediate reasoning, and produces a final structured output (JSON, CSV, etc.).

Typical scenarios: data‑governance impact analysis, periodic health checks, complex ticket triage that follows a known checklist.

3. Intelligent Agent (dynamic planning)

AI behaves like a senior engineer: it first understands the problem, then dynamically selects tools, iterates, and adapts the plan.

Suitable for situations where the execution path varies per case (e.g., ad‑hoc incident response, multi‑domain troubleshooting).

Current limitations: requires stronger models, careful prompt design, and concise sub‑agents to avoid endless loops.

Ensuring AI Reliability

Prompt Design Strategies

Specify input format and scope clearly (what the AI will see).

Define quantifiable decision criteria (e.g., "field appears in a JOIN" instead of vague importance).

Force structured output (JSON, table, markdown).

Provide positive and negative examples.

State boundary‑condition handling rules.

Conservative Execution Policy

If confidence is low, return a "needs human review" flag instead of acting.

Prefer safe thresholds (e.g., only execute when confidence > 90%).

Never delete or drop data without explicit high‑confidence approval.

Explainable Output

Always output "Conclusion + Reason + Process".

Prefer a full JSON report that includes raw tool results and step‑by‑step reasoning.

Enable downstream verification and rapid debugging.

Multi‑Layer Verification

Insert observation checkpoints after critical steps.

Add validation steps that compare AI results with known invariants.

Require human confirmation for high‑risk actions.

Repeat execution and require consensus for uncertain outcomes.

Case Studies

Case 1 – Code Impact Analysis (Simple Workflow)

Problem: When an upstream table changes, downstream tasks must be checked for field usage. Manual inspection of 500‑1000 tasks is time‑consuming.

# Pseudocode of the workflow
1. Input list of downstream tasks
2. For each task:
   a. Call "eye" tools to read SQL or file content
   b. AI determines if the changed field appears and whether it participates in a JOIN
   c. Record the judgment
3. Export results to JSON/Excel

Result: The AI processed all tasks in minutes, achieving >95% accuracy. Engineers only needed to review the generated report.

Case 2 – Storage Governance (Complex Workflow)

Goal: Reduce storage cost by automatically evaluating tables for lifecycle shortening, cold‑backup, or deletion.

# High‑level workflow (≈20 nodes)
1. Receive table name
2. Eye: fetch table metadata (size, lifecycle, priority)
3. Eye: retrieve full lineage (upstream sources, downstream consumers)
4. Loop over downstream tasks, read their SQL via eye tools
5. AI analyses actual dependencies (JOIN, data type conversion)
6. Eye: check upstream recovery capabilities
7. AI decides importance & usage
8. AI outputs governance suggestion (offline, shorten TTL, backup)
9. Hand: execute the chosen action or output JSON for manual review

Outcome: The workflow automatically evaluated thousands of tables, cutting storage by ~50% and safely decommissioning low‑value assets without human error.

Case 3 – AI‑Driven Ticket Handling (Hierarchical Agent)

Challenge: Fixed workflows exploded to >50 nodes and could not cover all ticket scenarios. The path of investigation varies per ticket.

Solution: A master agent (brain) decides which specialist sub‑agents to invoke. Each sub‑agent has its own eye/hand tools (log extraction, data lookup, ticket commenting, etc.). The master agent plans the investigation path dynamically.

# Agent hierarchy (simplified)
Master Agent
 ├─ Log Agent (read & parse logs)
 ├─ Data Agent (query lineage, check configs)
 ├─ Ticket Agent (read, comment, close)
 └─ Knowledge Agent (RAG retrieval)

Execution steps:
1. Receive ticket content
2. Understand problem type
3. Plan investigation path
4. Dispatch sub‑agents
5. Aggregate results
6. Determine root cause
7. Generate solution or hand over to human

Result: The system handled many tickets autonomously, performing initial diagnosis and suggesting resolutions. However, for highly variable cases the agent still required human fallback, highlighting current model limits.

Case 4 – Baseline Operation Automation (In Development)

Scenario: A data product depends on dozens of upstream sources. Frequent baseline alerts require manual nudging of upstream owners.

Proposed AI loop:

# Baseline automation flow
1. Periodic monitoring of upstream delivery status
2. On anomaly, AI sends SMS/voice reminders
3. If deadline approaches without recovery, AI automatically decouples the upstream dependency
4. Notify stakeholders via DingTalk
5. After upstream recovers, AI creates back‑fill tasks and ensures data consistency

Goal: Eliminate manual escalation, reduce alert fatigue, and guarantee data freshness.

Takeaways

When >90% of a problem can be expressed as a fixed procedure, AI automation is feasible.

Simple tool assistants are quick to prototype; workflows excel for deterministic multi‑step tasks; agents shine for dynamic, uncertain scenarios.

Reliability hinges on precise prompts, conservative execution policies, explainable outputs, and multi‑layer verification.

Current agents still struggle with highly variable paths; a hybrid approach (workflow + agent) often yields the best trade‑off.

Conclusion

AI is not here to replace humans but to lift them from repetitive execution so they can focus on higher‑value design, optimization, and innovation. By abstracting "see‑think‑act" into reusable AI loops, organizations can turn mundane chores into automated, trustworthy processes.

Team Introduction

The author, Shengquan, works in the Taobao‑Tmall Merchant & Open Platform Technology team. The team builds intelligent services that extend the platform’s capabilities, helping merchants improve efficiency, product experience, and cost structure through AI‑driven automation.