| 4 min read

Using AI Agents for Internal Workflow Automation

AI agents workflow automation business process Python internal tools productivity

The Untapped Opportunity in Internal Workflows

Most AI engineering content focuses on customer-facing products. But some of the highest-ROI applications of AI are internal: automating the tedious, repetitive workflows that eat up hours of time inside organisations. These are not glamorous projects, but they deliver measurable value immediately.

In my role at Dyson, I have built several internal AI automations. Here are the patterns and principles that work.

Identifying Automation Candidates

Not every internal workflow benefits from AI. The best candidates share these characteristics:

  • Repetitive: The task happens regularly (daily, weekly, or triggered by events)
  • Rule-based with exceptions: There are clear rules, but enough edge cases that simple if/else logic is not sufficient
  • Time-consuming: The task takes significant human time relative to its complexity
  • Low risk if partially wrong: Errors can be caught in review rather than causing immediate damage
  • Digital inputs and outputs: The information is already in digital form (emails, spreadsheets, databases)

Pattern 1: Data Processing and Classification

One of the most common internal tasks is processing incoming data and routing it to the right team or category. This is a perfect fit for AI classification:

class IncomingRequestClassifier:
    def __init__(self, ai_client):
        self.ai_client = ai_client
        self.categories = [
            {"name": "technical_support", "description": "Issues with products or systems"},
            {"name": "billing_query", "description": "Questions about invoices or payments"},
            {"name": "feature_request", "description": "Suggestions for new features"},
            {"name": "complaint", "description": "Dissatisfaction with service or product"},
            {"name": "general_enquiry", "description": "Other questions or information requests"}
        ]
    
    async def classify(self, request_text: str) -> dict:
        prompt = f"""Classify this customer request into one of these categories:
        {json.dumps(self.categories)}
        
        Request: {request_text}
        
        Return JSON: {{"category": str, "confidence": float, "priority": "low|medium|high", "summary": str}}"""
        
        response = await self.ai_client.complete(prompt, model="claude-haiku-4-20250414")
        return json.loads(response)

This pattern replaces manual triage that might take 2 to 5 minutes per request. With hundreds of requests per week, the time savings are substantial.

Pattern 2: Report Generation

Weekly and monthly reports are a perfect automation target. They follow a consistent format, draw from known data sources, and require synthesis that AI handles well:

class WeeklyReportGenerator:
    def __init__(self, ai_client, data_sources):
        self.ai_client = ai_client
        self.data_sources = data_sources
    
    async def generate(self, week_start: date) -> str:
        # Gather data from all sources
        metrics = await self.data_sources.get_weekly_metrics(week_start)
        incidents = await self.data_sources.get_incidents(week_start)
        achievements = await self.data_sources.get_completed_tasks(week_start)
        
        prompt = f"""Generate a weekly team report for the week starting {week_start}.
        
        Metrics: {json.dumps(metrics)}
        Incidents: {json.dumps(incidents)}
        Completed work: {json.dumps(achievements)}
        
        Format: Executive summary (3 sentences), then sections for Metrics, 
        Highlights, Issues, and Next Week's Focus. Use bullet points. 
        Keep it concise and action-oriented."""
        
        return await self.ai_client.complete(prompt)

Pattern 3: Document Review and Summarisation

Internal documents often need review before approval. An AI agent can do a first pass, flagging issues and summarising content for human reviewers:

  • Policy documents: check for completeness against a template, flag inconsistencies
  • Contracts: extract key terms, highlight unusual clauses, compare against standard terms
  • Technical specs: verify all required sections are present, flag vague requirements

The key here is that the AI does not make the decision. It prepares the review, highlighting what matters and flagging concerns, so the human reviewer can work faster and more thoroughly.

Pattern 4: Approval Workflow Enhancement

Many organisations have approval workflows that are bottlenecked by human review. AI can accelerate these by pre-analysing requests:

class PurchaseRequestAnalyser:
    async def analyse(self, request: PurchaseRequest) -> dict:
        # Check against policy rules
        policy_check = self.check_policy_compliance(request)
        
        # AI analysis for context
        ai_analysis = await self.ai_client.complete(
            f"""Analyse this purchase request:
            Item: {request.description}
            Amount: {request.amount}
            Justification: {request.justification}
            
            Assess: Is the justification clear? Is the amount reasonable for this 
            type of purchase? Any concerns?
            
            Return JSON: {{"recommendation": "approve|review|flag", 
                          "reasoning": str, "concerns": [str]}}"""
        )
        
        return {
            "policy_compliant": policy_check,
            "ai_analysis": json.loads(ai_analysis),
            "auto_approvable": policy_check and json.loads(ai_analysis)["recommendation"] == "approve"
        }

Human-in-the-Loop Design

For internal workflows, always design with human oversight. The AI accelerates the process but does not replace human judgement. This means:

  • Transparent reasoning: Always show why the AI made a recommendation
  • Easy override: Humans can override any AI decision with one click
  • Audit trail: Every AI action is logged with its reasoning for compliance and review
  • Confidence thresholds: Low-confidence AI decisions are automatically escalated to humans

Measuring Impact

To justify the investment in building these automations, you need to measure their impact:

  • Time saved: How many hours per week does the automation save?
  • Throughput: How many more items can be processed per day?
  • Accuracy: Does the AI classification match human classification? Track agreement rates.
  • Error rate: How often do AI recommendations need to be overridden?

Getting Organisational Buy-In

The hardest part of internal AI automation is often not technical. It is getting people to trust and adopt it. Some strategies that have worked for me:

  • Start with a shadow mode: Run the AI alongside the existing process for two weeks without changing anything. Compare results.
  • Pick a champion: Find one team member who is frustrated with the manual process and let them pilot the tool.
  • Show the time savings: Nothing convinces a manager faster than "this saved the team 8 hours last week."
  • Make it optional at first: Let people choose to use the AI assistance. Forced adoption creates resistance.

The Bottom Line

Internal workflow automation is where AI engineering delivers the most immediate, measurable value. The projects are not flashy, but they compound: every hour saved is an hour your team can spend on work that actually requires human creativity and judgement. Start with the most repetitive, time-consuming workflow in your organisation and build a simple AI agent to assist with it. The ROI will make the case for everything that follows.

Steve Light is an AI engineer based in South West England, building multi-agent pipelines, automation tools, and production AI applications. View full CV | More posts