Posts Tagged
‘Workflows’

You’ve watched an algorithm misclassify an urgent customer complaint as noise, and felt that tight drop in your stomach—the kind that comes when an SLA is breached, a deal slips away, or an employee’s application is mishandled. The promise of AI is speed and scale, but the real risk is handing critical decisions to a system that doesn’t yet share your context, priorities, or judgment. Human-in-the-loop (HITL) design is the antidote: not a retreat from automation, but a surgical integration of people where their judgment matters most.

This article gives a practical framework for deciding exactly where to place humans so workflows remain fast, safe, and continuously improving. You’ll get patterns to apply, concrete escalation and confidence rules to define, metrics to watch, tool choices to consider, and change-management tactics to get teams aligned.

A simple practical framework

1. Map the decision points and outcomes
   • Break the process into discrete decision nodes (e.g., qualify lead, approve offer, refund ticket).
   • For each node, identify the potential outcomes and their downstream impact: revenue risk, compliance exposure, customer satisfaction, employee morale.
2. Classify by volume, risk, and ambiguity
   • Volume: how many inputs per day/week?
   • Risk: what happens if the decision is wrong?
   • Ambiguity: how often will edge cases or context be needed?
   • This triage tells you where automation will help most, and where humans must stay involved.
3. Choose a HITL pattern
   • Pre-screen / auto-reject / flag: let models filter obvious negatives or positives, auto-reject low-value noise, and flag ambiguous or risky items for human review.
   • Human verification for high-impact outcomes: require explicit human approval when financial, legal, or reputational consequences exceed a threshold.
   • Batch review for low-risk cases: consolidate many similar low-risk items into a short human review session to reduce context switching and fatigue.
4. Define triggers and confidence thresholds
   • Use model confidence scores to route items. High confidence -> auto-action. Low confidence or borderline confidence -> human.
   • Define business-grounded thresholds. For example: if the model predicts “eligible for refund” with 95% confidence, auto-issue; if 60–95% confidence, send to human; below 60%, escalate to senior reviewer.
   • Include context-based triggers: customer status (VIP), legal flags, or recent escalations should override confidence thresholds.
5. Build feedback loops that retrain and improve
   • Capture human decisions and corrections as labeled data.
   • Prioritize retraining on cases with high disagreement or high impact.
   • Maintain an “edge case” store to analyze failure modes and adjust either the model or the decision rules.

Patterns in practice (how to place people)

• Pre-screen / auto-reject / flag: Useful for noisy, high-volume inputs. Example: a sales ops team uses a classifier to drop spam or unqualified leads automatically, while leads that look promising but low-confidence are flagged to a human rep who can add context. This reduces distraction while preserving opportunities.
• Human verification for high-impact outcomes: Use when wrong decisions carry real cost. Example: in HR, a model may narrow candidate pools, but final interview outcomes or offer decisions go to a human hiring manager who considers soft signals the model can’t see.
• Batch review for low-risk cases: Group low-stakes claims, returns, or policy exceptions into short review windows. This preserves throughput and concentrates human attention, lowering cognitive load and interruptions.

Measuring success: the metrics that matter

• Accuracy and error type: Track both overall accuracy and the kinds of errors (false positives vs false negatives). Which errors hurt the business most?
• Throughput and latency: Monitor end-to-end cycle time with and without human steps. Are humans creating unacceptable bottlenecks?
• Human burden and interruption cost: Measure time per review, queue wait times, and reviewer idle/overload patterns. Optimize for fewer context switches and smarter batching.
• Escalation rate and rework: How often do escalations occur? Are human decisions reversed later? High rework suggests either thresholds are wrong or training data is insufficient.
• Model drift indicators: Monitor shifts in input distributions and rising disagreement between model and human reviewers.

Tooling: what to pick and why

• Auto-labeling & weak supervision: Use auto-labeling frameworks to bootstrap training sets, but treat them as starting points. They speed labeling but require human curation for edge cases.
• Annotation interfaces: Pick tools that let humans annotate quickly with context (attachments, conversation history), keyboard shortcuts, and quality checks. UX here directly affects review speed and accuracy.
• Workflow orchestration: Implement a system that routes cases based on confidence, context, and SLAs. Orchestration should handle retry logic, priority overrides, and auditing for compliance.
• Telemetry & MLOps: Integrate logging of model scores, human decisions, timestamps, and feature drift signals to feed back into model retraining cycles.

Short, concrete examples

• Sales ops: A lead-scoring model processes hundreds of inbound leads. 60% are low-confidence spam and are auto-rejected; 30% are high-confidence qualified and get routed to reps immediately; the remaining 10% are flagged for a human rep to review in a daily batch. Team burden drops, and reps spend time where judgment yields most value.
• HR decisions: Resume parsing and role-fit prediction reduce initial screening time. For managerial roles, any candidate with a predicted hire score in the mid-range is escalated to a hiring lead for interview selection. Final offers require human sign-off when compensation bands exceed predefined thresholds.
• Customer escalations: Support triage auto-resolves common, low-value issues. When a ticket is flagged as high sentiment risk, high monetary value, or shows an anomaly in model confidence, it is immediately escalated to a senior agent who sees customer history and can make judgment calls.

Change management: getting people to trust the loop

• Start small and measurable: Pilot a single node, measure the outcomes, then expand. Quick wins build trust.
• Make decisions reversible and visible: Show reviewers the model reasoning, confidence, and an audit trail. Transparency reduces “automation anxiety.”
• Set SLAs and workload rules: Define clear SLAs for human review to avoid backlog and resentment. Use batching to protect attention.
• Train reviewers and reward accuracy: Invest in onboarding reviewers on how to interpret model outputs. Recognize the value of high-quality human labels.
• Iterate on ergonomics: Remove friction—reduce clicks, surface relevant context, and allow bulk actions when appropriate.

Final thought

Designing HITL automation is less about avoiding automation and more about surgical placement of human judgment to amplify what machines do well and to catch what they don’t. When you map decisions, classify risk and volume, choose the right pattern, and close the feedback loop, you get workflows that are faster, safer, and continuously improving.

If you’re looking to put this into practice, MyMobileLyfe can help you evaluate where to insert human oversight, set confident thresholds and escalation paths, choose the right tooling, and build the feedback mechanisms that keep models honest and workflows efficient. Learn more about how MyMobileLyfe helps businesses use AI, automation, and data to improve productivity and save money: https://www.mymobilelyfe.com/artificial-intelligence-ai-services/

You know the feeling: a morning inbox full of exception alerts, a queue of stalled tasks with no clear owner, and an SLA clock quietly bleeding minutes while engineers and agents pass responsibility back and forth. Routine processes that should be predictable instead behave like living organisms — conditionals, edge cases, conflicting data across systems, and human judgment calls everywhere. Simple “if this then that” automation breaks down fast.

Intelligent workflow orchestration gives those processes a backbone. By combining machine learning models, rules engines, and a robust orchestration layer (RPA or workflow platforms), you can automate decision-heavy flows end-to-end — surfacing the right exceptions, predicting the best next action, routing work to the optimal owner, and engaging humans only when required. Below is a pragmatic playbook for operations leaders and automation teams who need to move beyond brittle task automation and build resilient, auditable, decision-aware processes.

Start with the pain: map every decision point

• Walk the path like a detective. Interview frontline staff and trace a case from start to finish. What alternatives are evaluated manually? Where do data conflicts occur across systems? Which checks cause rework?
• Capture decision points explicitly — not “step 4,” but “how to resolve price mismatch” or “should this refund be autoapproved?” For each, log inputs, current owner, time to resolution, and business impact (SLA breach, cost, customer churn risk).
• Prioritize: focus first on decisions that are frequent, time-consuming, and have clear signals in existing data.

Classify decisions: rules vs. predictions

• Deterministic decisions: these are “hard rules” — regulatory checks, policy thresholds, or boolean validations. Encode these in a rules engine or decision table (Drools, open-source decision tables, or vendor rule modules).
• Probabilistic decisions: things like fraud likelihood, churn-risk prioritization, or next best action are best handled with predictive models. These models work with noisy signals and give a confidence score that the orchestrator can consume.
• Many real-world decisions are hybrid: use rules to filter obvious cases, and models to handle ambiguous ones.

Choose models and signals pragmatically

• Use the simplest model that solves the problem. A gradient-boosted tree may beat a deep network for tabular data and is easier to explain.
• Build models around actionable signals already available: transaction metadata, customer behavior events, historical resolution times, agent skill tags. Don’t invent new data sources unless there’s a clear ROI for the extraction effort.
• Log feature lineage. Knowing which signal drove a recommendation is crucial for debugging and compliance.

Design an orchestration layer that thinks, routes, and remembers

• The orchestration platform is the brain: it evaluates rules and model outputs, decides the next step, and routes tasks. Options include workflow engines (Camunda, Temporal), RPA suites (UiPath, Automation Anywhere, Blue Prism) integrated with orchestration, or event-driven architectures built on Kafka or cloud-native services.
• Build human-in-the-loop gates into the workflow where model confidence is low or a regulatory override is required. Present clear context to the human reviewer: model score, top contributing signals, suggested actions, and historical outcomes.
• Create explicit fallback paths for system failures or unavailable models — deterministic rules that keep the business running.

Make feedback loops and audit trails first-class features

• Every automated decision must be logged with inputs, model version, confidence, rule version, and action taken. Adopt event sourcing or immutable logs so auditors and engineers can reconstruct decisions.
• Capture human overrides and route those cases back into model training datasets. That continuous feedback loop decreases drift and improves relevance.
• Version everything: models, rules, orchestration definitions, and connectors. Tie versions to production events for traceability.

Integrate where the data lives — and limit brittle connectors

• Use API-first integrations and event streams rather than screen-scraping or fragile UI automation for critical decision inputs. Where RPA is necessary (legacy portals), isolate it behind adapters and monitor for UI changes.
• Centralize contextual data in a decision store or feature store for consistent, low-latency reads across models and workflows.
• Keep data enrichment services (third-party scoring, name matching, external fraud feeds) modular so you can swap providers without rewriting the orchestrator.

Measure the right things — and measure before/after baselines

• Baseline metrics: average handle time, touchless rate (fully automated vs. human touch), exception rate, rework incidence, SLA violation minutes, and cost per case.
• After deployment, track changes in those metrics and also model-specific telemetry: prediction distribution, calibration, false positive/negative rates.
• Report ROI in terms operations care about: hours saved, reduction in escalations, and cost delta from manual processing.

Mitigate risk: drift, explainability, and compliance

• Monitor for model drift and data input drift. Alerts should trigger retraining pipelines or automatic rollbacks to validated rule-based behavior.
• For regulated processes, require explainable outputs: use interpretable models or explainability layers (SHAP, LIME) and surface human-readable reasons for recommended actions.
• Maintain a governance checklist before each deployment: legal review, audit trail completeness, roll-forward and rollback plans, and SLAs for human response in human-in-loop gates.

Realistic use cases and vendor patterns

• Invoice processing: rules validate invoices under a threshold; ML predicts which vendor invoices will need manual review; the orchestrator routes probable exceptions to accounts payable specialists with past-resolution context.
• Customer disputes: a model estimates dispute legitimacy; high-confidence fraudulent claims move to auto-reject rules, low-confidence claims go to a review queue prioritized by predicted churn impact.
• Loan servicing: deterministic regulatory checks plus risk models determine who needs human underwriting; the orchestrator ensures required documents are present and tracks each decision for compliance.

Vendor patterns you’ll see in the field: a workflow engine (Camunda, Temporal, or a cloud workflow) coordinating tasks, a feature store and ML service (SageMaker, Vertex AI, Azure ML or in-house models), a rules engine or decision table for gatekeeping, and RPA bots for legacy integrations. Use message buses or APIs to decouple services so the orchestrator can evolve without rewriting every connector.

Pitfalls to avoid

• Don’t automate without measurement. If you can’t show a baseline, you can’t prove value.
• Avoid black-box blind deployments. If agents can’t understand why the automation suggested an action, they will override or bypass it.
• Don’t neglect human workflows. Automation that ignores human schedules, skill levels, or ergonomics creates resistance and hidden costs.
• Beware of connectors that are “cheap” but brittle. They cost more over time than a proper API integration.

Start small, ship often, iterate fast

Begin with a single, high-impact decision point: map it, instrument it, and run a shadow mode where models make recommendations without taking action. Measure alignment with human decisions, tune thresholds, then enable auto-actions for high-confidence cases. Expand outward, keeping observability, governance, and human experience central.

If you’re ready to move beyond rule-only automation and scale intelligent decision-driven workflows, MyMobileLyfe can help. Their AI, automation, and data services specialize in building model-backed orchestration, integrating with existing systems, and setting up governance and monitoring so teams save time and reduce costs while maintaining compliance. Learn more at https://www.mymobilelyfe.com/artificial-intelligence-ai-services/.

You know the scene: an inbox littered with duplicate requests, a team member reformatting a report for the third time this week, or a never-ending reconciliation spreadsheet that eats afternoon hours. You can feel the drag—time siphoned into routine handoffs, creativity stifled, and budgets bleeding into repetitive labor. Most organizations agree automation is the answer, but the question that stops them cold is: where do we start?

Manual selection is guesswork. Leaders pick processes based on anecdote or volume alone, then discover after expensive development that exceptions or unstable steps make automation brittle. AI-driven task mining changes that. It shifts automation planning from intuition to evidence, surfacing the precise, repeatable workflows that will deliver real time savings and operational relief.

What task mining actually does

At its core, AI-driven task mining instruments the work you already do and learns its patterns. It ingests system logs, application usage traces, and user interaction events—clicks, keystrokes, form fills—then reconstructs real sequences of work rather than relying on hypothetical process maps. Using unsupervised learning and sequence-mining algorithms, the technology clusters similar activity traces into recurring task patterns, exposing variations, handoffs, and pain points that humans often miss.

The output is not a laundry list of possible automations but a prioritized roadmap: groups of activities that are highly repetitive, stable in execution, and ripe for robotic process automation (RPA) or low-code tooling. Task mining also helps estimate the potential return by combining frequency of occurrence with measured time per instance, exceptions rate, and the effort required to build and maintain an automation.

How task mining surfaces high-value opportunities

• Discover real patterns: Instead of assuming everyone follows the documented procedure, task mining shows how people actually work—shortcuts, extra verification steps, and the ways systems are used together.
• Cluster variants: The tool groups similar sequences to reveal “most common” paths and the minority of cases that create exceptions. That differentiation is crucial for choosing where automation will be robust.
• Quantify impact: By measuring time per occurrence and counting frequency, task mining estimates potential hours saved and helps prioritize where development time will pay back fastest.
• Rank by feasibility: Algorithms score opportunities on impact and complexity—factors such as exception rate, data stability, and integration requirements—so you avoid investing in processes that will constantly break.

A practical pilot blueprint

Starting small with clear guardrails pays off. Here’s a pilot pathway that balances speed with rigor.

1. Define scope and objectives
   Pick a function with frequent, repetitive tasks and measurable baseline metrics—accounts payable approvals, customer onboarding steps, or order adjustments. Clarify the success metrics you’ll track: cycle time, tasks per day per employee, and error rate.
2. Collect the right data
   Instrument endpoints carefully: application logs, workflow systems, and keyboard/mouse activity that shows process steps. Use lightweight collectors where possible to reduce user disruption. Keep data retention purposeful—collect only what you need to map sequences and measure time.
3. Address privacy and compliance up front
   Obtain user consent and document the legal basis for monitoring. Implement data minimization, mask or obfuscate personally identifiable information (PII), and prefer aggregated views for analysis. If regulatory constraints are strict, run analysis in a segregated environment or on-premises tooling.
4. Engage stakeholders
   Bring operational leads, IT, and the workers who perform the tasks into the loop early. Their context helps interpret clusters and flags special-case logic that the AI might misread. Involving them reduces resistance and surfaces UX improvements you might automate away.
5. Build a rapid proof-of-concept
   Select one high-confidence candidate from the task mining output—ideally a low-complexity, high-frequency task. Implement an RPA or low-code automation for that flow, instrument the automation, and run side-by-side with manual execution. Use your pre-defined metrics to evaluate time saved, error reductions, and user acceptance.
6. Measure and iterate
   Compare before-and-after metrics. Look not just at time saved but at changes in error rates, rework, and employee experience. Use those learnings to refine the ranking criteria for subsequent automations.

From pilot to scale: governance and reuse

Scaling automation without governance is how you end up with fragile bots and duplicated work. Put these practices in place as you expand:

• Establish an automation center of excellence (CoE) or governance group focused on standards, reusable components, and exception-handling patterns.
• Create a component library for common actions (e.g., logins, standard API calls, data transformations) so automations are built from modular, tested blocks.
• Monitor post-deployment performance continuously; task mining isn’t a one-time exercise. Use continuous discovery to detect when workflows evolve and when automations need adjustment.
• Enable citizen development with guardrails: empower business teams to create automations using low-code tools, but require designs to pass through CoE review for security and maintainability.

Realistic examples without hype

• Small business: A regional service provider discovered through task mining that a large portion of their support reps’ time was spent copying customer details between two systems. The sequence was consistent and low-variance—ideal for a lightweight automation that eliminated the duplication of effort and allowed reps to focus on problem solving instead of data entry.
• Mid-sized company: A finance team’s month-end reconciliation had many manual lookups across spreadsheets and systems. Task mining revealed the most common reconciliation path and the handful of exceptions that previously prevented safe automation. By automating the common path and building exception workflows for outliers, the team shortened cycle time and reduced manual fatigue.
• Enterprise: Across a multinational organization, task mining across multiple ERPs exposed redundant approval sequences and inconsistent integrations. Clustering showed patterns that could be standardized and automated globally, enabling a consolidated automation strategy rather than dozens of point solutions.

What to expect—and what not to expect

Task mining will not magically automate every tedious workflow overnight. It exposes where automation will be durable and where human judgment must remain. You should expect a mix: quick wins that remove obvious drudgery, and longer projects that require API integrations or process redesigns. The goal is cumulative improvement—small automations compound into measurable productivity change.

Bring expertise to the table

Many organizations find the technical parts—instrumentation, privacy-safe data handling, and algorithm tuning—are best handled with partners who have practical experience. If you want to turn your discovery data into prioritized automations that actually stick in production, you don’t have to go it alone.

MyMobileLyfe can help businesses use AI, automation, and data to improve their productivity and save money. Their services are geared toward turning task-mining insights into concrete automation roadmaps, pilot deployments, and scaling practices that maintain security and compliance while delivering real operational relief.

If your teams are tired of firefighting repetitive tasks and ready to reclaim hours of productive work, AI-driven task mining gives you a prioritized, evidence-based path forward—and partners like MyMobileLyfe can help you move from discovery to dependable automation.

There’s a particular kind of dread that creeps up just after a Slack ping at 2 a.m.: an order has stalled, a fulfillment barcode failed, or a critical ticket has escalated with no clear owner. Teams spend days manually sifting logs, running queries, and debating whether a problem is real or noise. That slow, repetitive triage is not just demoralizing—it’s expensive. Missed handoffs cost revenue, delayed shipments damage reputation, and human attention wasted on false alarms is a hidden tax on every operation.

The good news is you don’t need to hire more people to fix this. You need a different layer: an AI-powered exception-handling system that detects outliers, prioritizes by business impact, recommends or applies fixes, and brings humans in only when they add value. Here’s how to design that layer so it reduces toil, shortens resolution cycles, and leaves a traceable audit trail for continuous improvement.

What an AI exception-handling layer does

• Detects anomalies or rule violations across orders, customer handoffs, fulfillment, and production.
• Scores and prioritizes incidents based on business impact (revenue, SLA risk, customer value).
• Recommends automated or manual remediation and executes safe fixes where appropriate.
• Routes high-priority incidents to the right person with context and an audit log of decisions.

Core building blocks (practical and modular)

• Data layer: Consolidate relevant signals — order events, ticket metadata, inventory levels, machine telemetry, timestamps, and CRM tags. A unified event stream simplifies detection and auditing.
• Simple rules and thresholds: Start with clear operational rules (e.g., “shipment not scanned within X hours”) that catch obvious exceptions with no ML required.
• Anomaly-detection models: Use statistical methods or lightweight ML (z-score, moving averages, isolation forest, density-based methods, or reconstruction error with autoencoders) to surface outliers not captured by rules.
• Business-rule engine: Translate business priorities into automated actions and escalation logic. Keep the engine auditable and externalized from application code so non-developers can safely adjust behavior.
• Decision trees and playbooks: Define deterministic remediation steps for common exceptions (retry API call, reassign order, trigger manual review).
• Automation/workflow platform: Connect playbooks to systems (ERP, WMS, ticketing, email/SMS) so recommended actions can be auto-executed or proposed for human approval.
• Human-in-the-loop orchestration: Ensure humans can approve, override, or update automation. Capture their decisions as labeled examples for model retraining.
• Audit and feedback loop: Log detection rationale, decisions, and outcomes to improve rules and models over time.

Step-by-step implementation checklist

1. Inventory data and events: List sources, sample formats, and retention. Prioritize the signals that drive business decisions.
2. Define exception taxonomy and impact: Classify exceptions (processing delays, pricing errors, fulfillment misses) and map them to business impact (SLA, revenue, customer retention).
3. Start with rules: Implement simple, high-confidence rules to reduce immediate noise and prove value quickly.
4. Add anomaly detection for the rest: Deploy unsupervised methods to highlight unexpected patterns that rules miss.
5. Score by business impact: Combine anomaly score with impact estimates to prioritize incidents for action.
6. Build playbooks for common exceptions: For each high-frequency exception, define steps that can be automated or that require human review.
7. Integrate with systems and people: Connect to ticketing, messaging, and operational tools; set up routing rules to the right teams.
8. Implement human-in-the-loop and logging: Require approvals where automated actions carry risk; capture outcomes for continuous learning.
9. Pilot, measure, iterate: Run a pilot on a single workflow, refine thresholds, and expand incrementally.

KPIs that matter (and how to measure them)

• Time-to-detect: Measure from when an exception originates to when it’s surfaced to the system. Lower is better.
• Time-to-resolve: Time from detection to remediation closure (auto or manual). Track separately for automated vs. human-resolved incidents.
• False-positive rate: Percentage of surfaced incidents that are not actionable or are noise. Aim to reduce this to preserve trust.
• Human-touch rate: Portion of incidents requiring manual intervention. The goal is to decrease unnecessary human tasks while keeping humans engaged where judgement matters.
• Cost impact or avoided loss: Track incidents that would have resulted in SLA breaches, refunds, or rework and attribute savings where possible.

Common pitfalls and how to avoid them

• Flooding teams with false positives: The quickest way to bury trust is bad alerts. Start conservative, tune thresholds, and prioritize high-confidence rules first.
• Over-automating risky actions: Don’t allow full automation on actions that could cause legal, financial, or safety issues without robust safeguards and approvals.
• Ignoring explainability: Operators need context. Pair ML alerts with simple explanations (which features pushed the score) so humans can validate quickly.
• Data drift and model decay: Put monitoring and retraining triggers in place. If input patterns shift (seasonality, new SKUs, product launches), models must be revisited.
• Siloed decision logic: Keep business rules and playbooks externalized to be edited without code changes; embed versioning and audit trails.

How small and mid-sized teams can start incrementally
You don’t need a large ML team to benefit. Begin on a single high-friction process—say, late shipments that trigger customer emails. Implement a rule to flag obvious delays, add a simple anomaly detector to catch subtle outliers (unusual carrier behavior or sudden surge in a SKU), and build a playbook that retries label printing and notifies the fulfillment lead if retries fail. Capture every human intervention as labeled data; after a few weeks, you’ll have a corpus to refine models and broaden automation.

Examples that feel familiar

• E-commerce: An order stalls between payment and fulfillment. The system detects an unusual payment retry pattern, re-attempts fulfillment API calls, and, if unsuccessful, routes the incident to a payments specialist with the transaction history and suggested refund or reship options.
• Customer support: A surge of short-lived tickets about the same SKU is detected as an anomaly. The platform groups them, auto-tags as “possible product issue,” and escalates to the product lead with aggregated examples and suggested responses.
• Manufacturing: A sensor drift pattern alerts a supervisor before a line fault occurs. Automated low-level mitigations are applied; a maintenance ticket is created with context and priority.

Governance and trust: make reliability non-negotiable
Treat exception automation like any critical operational system. Enforce RBAC, maintain immutable logs, require approvals for high-risk automations, and include override and rollback paths. Regularly audit decisions against outcomes, and include operations teams in governance so the system evolves with the business.

If this sounds like a heavy lift, it doesn’t have to be. An intelligent exception-handling layer is additive: rules first, ML next, automation where safe, with humans always empowered. The result is predictable workstreams, fewer midnight crises, and a team focused on improvement instead of firefighting.

If your organization needs help designing or implementing this—choosing the right models, integrating with existing systems, and setting governance—MyMobileLyfe can help businesses use AI, automation, and data to improve productivity and save money. Learn more about their AI services at https://www.mymobilelyfe.com/artificial-intelligence-ai-services/.