Agentic AI for Smart Meter Reading & Anomaly Detection : A Developer’s Guide

Mrinmoy Aich — Sat, 09 Aug 2025 05:21:00 +0000

Introduction

Smart meters are transforming how utilities monitor and manage energy consumption by providing granular, real-time usage data. However, the flood of data presents new challenges: how can utilities automatically detect anomalies like sudden usage spikes or malfunctioning meters without constant human supervision?
This is where agentic AI comes into play. An agentic AI system acts autonomously ingesting meter data, analyzing it for irregularities, and taking proactive actions like sending alerts or scheduling maintenance. In this article, I’ll Walk you through a practical AI-driven approach for smart meter anomaly detection, complete with example data, code snippets, and suggestions for visual aids to clarify the workflow.

Why Use Agentic AI in Smart Metering?

Agentic AI agents are distinct because they:

Operate independently without human intervention.
Make contextual decisions based on data patterns.
Continuously learn and adapt over time (in more advanced setups).
Scale easily to manage thousands or millions of devices.

For utilities, this means faster detection of issues like power theft, equipment faults, or communication failures—minimizing revenue loss and improving service reliability.

High-Level Architecture

Here’s a typical architecture for an agentic AI smart meter anomaly detection system:

Data Collection & Preprocessing

Smart meters usually generate time-series data—say, hourly kWh consumption values. Before detection, the agent needs clean, normalized data.

Example raw data for one meter (hourly kWh):

Hour Usage (kWh)
1     1.05
2     1.10
3     1.00
4     8.50
5     1.20
6     1.15

Notice the spike at hour 4.

Common preprocessing steps:

Fill missing readings with interpolation.
Normalize usage by expected baseline (e.g., seasonal averages).
Smooth noisy data with moving averages or exponential smoothing.

Core Anomaly Detection Logic

1. Threshold-Based Spike Detection

A simple yet effective approach is to flag readings that suddenly jump by a factor beyond a threshold relative to recent average consumption.

python


def detect_spikes(readings, window=3, spike_factor=3.0):
    anomalies = []
    for i in range(window, len(readings)):
        baseline = sum(readings[i-window:i]) / window
        if readings[i] > spike_factor * baseline:
            anomalies.append((i, readings[i], 'spike'))
    return anomalies

2. Flatline or Zero Usage Detection

Meters that report constant zero or near-zero readings over extended periods may be malfunctioning.

python

def detect_flatlines(readings, flat_threshold=0.05):
    # Check if all values are close to zero
    if all(abs(val) < flat_threshold for val in readings):
        return True
    return False

3. Seasonal or Contextual Anomaly Detection (Expanded)

Real-world consumption patterns depend on the time of day, weather, or day of week. Incorporating seasonal models improves accuracy.
For example, a z-score based anomaly detection normalizes against historical means and standard deviations:

python

import numpy as np

def detect_zscore_anomalies(readings, historical_mean, historical_std, threshold=3):
    anomalies = []
    for i, val in enumerate(readings):
        z_score = (val - historical_mean[i]) / historical_std[i]
        if abs(z_score) > threshold:
            anomalies.append((i, val, 'seasonal_anomaly'))
    return anomalies

Putting It All Together: Agentic AI Workflow

python

class SmartMeterAgent:
    def __init__(self, spike_factor=3.0, flat_threshold=0.05):
        self.spike_factor = spike_factor
        self.flat_threshold = flat_threshold

    def ingest_data(self, meter_id):
        # Fetch latest 24 hourly readings (stub function)
        return fetch_meter_data(meter_id)

    def preprocess(self, readings):
        # Example: fill missing data, smooth readings
        return smooth_readings(fill_missing(readings))

    def analyze(self, readings, historical_mean=None, historical_std=None):
        anomalies = detect_spikes(readings, spike_factor=self.spike_factor)
        if detect_flatlines(readings, flat_threshold=self.flat_threshold):
            anomalies.append(('flatline', 0, readings[0]))
        if historical_mean and historical_std:
            anomalies.extend(detect_zscore_anomalies(readings, historical_mean, historical_std))
        return anomalies

    def act(self, meter_id, anomalies):
        if not anomalies:
            log(f"Meter {meter_id}: Normal readings")
            return
        for idx, val, typ in anomalies:
            if typ == 'spike':
                alert(f"Spike detected on meter {meter_id} at index {idx}: {val} kWh")
            elif typ == 'flatline':
                schedule_maintenance(meter_id)
            elif typ == 'seasonal_anomaly':
                alert(f"Seasonal anomaly on meter {meter_id} at index {idx}: {val} kWh")

    def run(self, meter_id, historical_mean=None, historical_std=None):
        raw = self.ingest_data(meter_id)
        processed = self.preprocess(raw)
        anomalies = self.analyze(processed, historical_mean, historical_std)
        self.act(meter_id, anomalies)

Example Use Case: Sample Data and Output

Suppose for Meter ID 123:

Raw readings: [1.0, 1.1, 1.2, 10.5, 1.3, 1.1, 1.0]
Historical mean: [1.05, 1.10, 1.15, 1.20, 1.15, 1.10, 1.05]
Historical std dev: [0.1, 0.1, 0.1, 0.15, 0.1, 0.1, 0.1]

The agent detects:

A spike at index 3 (10.5 kWh vs. mean 1.20),
Raises a spike alert automatically.

Flow Chart

Best Practices and Next Steps

Use rolling windows to smooth data and detect short-term anomalies.
Leverage historical and contextual data (weather, holidays) to reduce false alarms.
Consider integrating machine learning models (Isolation Forest, LSTM autoencoders) for more sophisticated anomaly detection.
Continuously train and tune agent thresholds based on feedback.
Build a dashboard for operators to visualize anomalies and agent actions.

Conclusion
Agentic AI provides a scalable, autonomous solution for smart meter anomaly detection, empowering utilities to proactively manage their networks with reduced manual effort. The example solution here is a solid foundation, and you can extend it with more advanced analytics and domain knowledge to build robust, real-world systems.
If you’re building smart utility applications, starting with agentic AI agents like this can drastically improve monitoring efficiency and operational reliability.

Oracle Visual Builder (VB) Authentication Using External Identity Provider Instead of Oracle IAM

Mrinmoy Aich — Wed, 14 May 2025 16:42:21 +0000

Business Scenario:

A large enterprise wants to build a Vendor Management Portal using Oracle Visual Builder (VB) but prefers to use Azure Active Directory (Azure AD) for authentication instead of Oracle Identity Cloud Service (IDCS).

The goal is to:

Authenticate users via Azure AD instead of IDCS.
Fetch user details (Name, Email, Role, etc.) from Azure AD.
Allow only authorized users to access the application.
Enable seamless integration with existing enterprise identity management.

Implementation :

Configurations in Azure.

Azure Configuration:

The user should log in to the Microsoft Azure Cloud Environment.

Create an application from the link “App Registration”.

Click on “New Registration” link.

Provide a name for the application.
Choose the supported account types as “Personal Microsoft
accounts only”.
Choose the Redirect URI as “Single page application” and
redirect url is your VB application, like https://xxx-xxxx-
oic-portals.builder.us-phoenix-
1.ocp.oraclecloud.com/ic/builder/rt/OracleUtilityDemo/1.0/webApps/utilityapp.
Then click on “Register”.

From the “App Registration” page, click on the newly created app.

From the following page, capture the below information.

Client ID : 1de6e6e9-27ae-49a3-95a8-8afc4a2af71b

Also ask your Azure Admin to provide the tenant id for Azure.

This will complete your Azure activities.

2 Visual Builder Work:

Create a VB application and put the functionalities you want to create for the app.
Now the following task needed to integrate Microsoft authentication in front of your Visual Builder application.
For this application, we need to use a custom security provider.
First inside the Visual Builder application, we will import a javascript file called “msal-browser.min.js"

Now you need to do the major step by creating a Security provider for Azure. To implement an AzureSecurityProvider that extends the DefaultSecurityProvider and overrides the fetchCurrentUser(config) method, you would typically create a custom security provider in a JavaScript environment, possibly in an application framework where security or authentication providers can be customized. There are few methods which present in DefaultSecurityProvider. Which we need to overwrite in this custom security provider.

On the Web Apps tab in the Navigator, select your web app, then click the JSON tab to open the app-flow.json file. Search for the following part and change with your security provider.

"userConfig": { "type": "resources/js/azureSecurityProvider", "configuration": { }, "embedding": "deny" }

Now Stage the VB application and run it.

Running the Application :

Once we will run the application Microsoft login page will appear.

Your new login screen.

It will ask for password.

Once you login successfully, it will redirect you to your Visual Builder application and display the data.

Thank you.

DEV Community: Mrinmoy Aich

Agentic AI for Smart Meter Reading & Anomaly Detection : A Developer’s Guide

Putting It All Together: Agentic AI Workflow

Oracle Visual Builder (VB) Authentication Using External Identity Provider Instead of Oracle IAM

Business Scenario:

The goal is to:

Implementation :