I’ve worked with quite a few networking, monitoring, and security products over the years. Some are excellent, some are unnecessarily complicated, and many come with licensing costs that grow every time you add another computer, server, or network.

That’s one reason I’ve become so interested in Wazuh, a free and open-source cybersecurity monitoring platform.

What started as a way to identify vulnerabilities on my computers and servers has turned into something considerably more interesting.

I now have Wazuh running across two physical locations, collecting security information from Windows and Linux systems, monitoring Proxmox infrastructure, analyzing pfSense firewall logs, discovering network devices with Nmap, and examining public-facing network exposure.

I’ve also connected it to my Microsoft 365 tenant, extending the monitoring beyond my local infrastructure and into the cloud services I use.

On top of that, I’ve built custom watchdogs that monitor the monitoring system itself, configured email alerts, and started integrating artificial intelligence into the security analysis process.

And I’m not using just one AI model.

I have Qwen3.5:9B running locally on my own NVIDIA RTX 3060 graphics card, analyzing selected Wazuh security alerts.

Separately, my locally hosted OpenClaw assistant uses GLM-5.3-Flash, a much larger 321-billion-parameter model hosted by Ollama.com, to independently review security activity through read-only API access.

OpenClaw is also connected to Telegram, giving me another way to receive and investigate security findings.

The remarkable part is that Wazuh, the foundation for this entire project, doesn’t require expensive commercial SIEM licensing.

Of course, getting everything working together hasn’t been effortless.

I’ve spent plenty of time troubleshooting firewall log formats, missing alerts, duplicate events, API permissions, custom scripts, indexing problems, and services that appeared healthy but weren’t actually doing what I expected.

In other words, it has been a proper homelab project.

This is what I’ve built so far, what I’ve learned along the way, and where I’m taking it next.

The Starting Point: An Impressive Security Platform for Free#

Wazuh is an open-source Security Information and Event Management (SIEM) and Extended Detection and Response (XDR) platform.

Those are complicated names for something with a fairly straightforward purpose.

Wazuh collects security information from computers, servers, cloud services, and other infrastructure, analyzes that information for potential problems, and makes the results available through centralized dashboards.

Out of the box, it includes some impressive capabilities:

  • Vulnerability detection for operating systems and installed software
  • Windows and Linux security event monitoring
  • File integrity monitoring
  • Security configuration assessment
  • Authentication and suspicious activity detection
  • Centralized log collection and analysis
  • Microsoft 365 and other cloud-service integrations
  • Custom detection rules and decoders
  • Security dashboards and reporting
  • Email notifications and automated responses
  • API access and external integrations

Many of these are features you’d expect from expensive commercial security products.

Yet Wazuh provides its self-hosted core software for free.

There are no per-endpoint software licensing fees for the open-source platform.

That doesn’t mean operating it costs nothing. You still need computing resources, storage, backups, maintenance, and the technical knowledge to manage it securely. Some connected cloud services also have their own licensing and API requirements.

But having this much security functionality available without purchasing commercial SIEM licensing is remarkable.

My original goal was simple.

I wanted a better way to monitor vulnerabilities and security events across my Windows computers, Linux servers, and Proxmox environment.

I installed Wazuh, deployed agents, and started exploring the information it collected.

That alone was useful.

Then I started examining what I could customize.

That’s when the project really took off.

Building a Security Platform Across Two Locations#

I maintain infrastructure at two separate physical locations.

Rather than operating two completely independent Wazuh installations, I configured a Wazuh cluster.

The primary location runs the master node, while the second location runs a worker node.

Each location has its own monitoring components, with security information collected for centralized analysis.

The architecture looks something like this:

PRIMARY SITE
  |
  +-- Wazuh Master
  +-- pfSense Firewall
  +-- Internal Nmap Scanner
  +-- Windows and Linux Agents
  +-- Proxmox Infrastructure
  |
  |           Wazuh Cluster
  |                 |
  +-----------------+----------------+
                                     |
SECONDARY SITE                       |
  |                                  |
  +-- Wazuh Worker ------------------+
  +-- pfSense Firewall
  +-- Internal Nmap Scanner
  +-- Windows and Linux Agents
  +-- Proxmox Infrastructure
                                     |
                                     v
                              Wazuh Indexer
                                     |
                                     v
                           Centralized Dashboards
                                     ^
                                     |
                           Microsoft 365 Tenant
                           Cloud Audit Events

This provides local collection capabilities at both locations while maintaining a central view of the security environment.

It also creates opportunities for monitoring services between locations.

If an important service at one site becomes unavailable, the other site may still be able to detect that problem.

This isn’t a fully redundant disaster recovery system, but it provides another layer of operational visibility.

As I started adding additional integrations, having local Wazuh infrastructure at both locations became particularly useful.

Wazuh Is Much More Customizable Than I Expected#

One of the things I like most about Wazuh isn’t necessarily what it does out of the box.

It’s what you can make it do.

Wazuh includes a customizable rule engine, log decoders, APIs, scripting capabilities, and support for external integrations.

That means I’m not limited to the monitoring features that come with the original installation.

If another application, cloud service, or network device generates useful security information, there’s often a way to bring that information into Wazuh.

I can write scripts that produce security events, develop custom rules, build monitoring workflows, and create dashboards tailored to my environment.

That’s what has allowed me to expand Wazuh well beyond traditional endpoint monitoring.

I’m now using it as a foundation for:

  • Internal network discovery
  • External security scanning
  • Firewall monitoring
  • Microsoft 365 cloud activity monitoring
  • Vulnerability management
  • Infrastructure health monitoring
  • Automated watchdogs
  • Custom security detection
  • Email notifications
  • Local AI alert analysis
  • AI-assisted security investigations
  • Telegram notifications

The challenge is getting everything to work together reliably.

And I’ve learned that making several different tools communicate correctly is often considerably harder than getting each one to work individually.

Monitoring Microsoft 365 With Wazuh#

One of the features that makes Wazuh particularly useful is its ability to monitor cloud services in addition to local infrastructure.

I’ve connected my Microsoft 365 tenant to Wazuh.

This expands the monitoring environment beyond servers, workstations, and firewalls.

Microsoft 365 is where organizations manage much of their email, collaboration, files, and user identities.

Depending on the services enabled, that can include:

  • Exchange Online
  • SharePoint Online
  • OneDrive
  • Microsoft Teams
  • Microsoft Entra ID
  • Microsoft Defender security services

Those systems generate security-relevant information that can be useful when investigating suspicious activity.

How Microsoft 365 Monitoring Works#

Wazuh includes an Office 365 integration that can retrieve audit events through Microsoft’s Office 365 Management Activity API.

Microsoft also provides security information through Microsoft Graph APIs, which Wazuh can integrate with separately.

The available events depend on the APIs, permissions, subscriptions, and licensing configured in the Microsoft tenant.

The general architecture looks like this:

Microsoft 365 Tenant
        |
        +-- Exchange Online
        +-- SharePoint / OneDrive
        +-- User and Admin Activity
        +-- Microsoft Security Services
        |
        v
Microsoft Cloud APIs
        |
        v
Wazuh Cloud Integration
        |
        v
Collect Audit / Security Events
        |
        v
Wazuh Detection Rules
        |
        v
Centralized Security Monitoring

I like this because it allows cloud activity to become part of a broader security picture.

Traditionally, investigating activity in Microsoft 365 means opening Microsoft’s various administration and security portals.

Those portals are valuable, but they generally focus on Microsoft’s own services.

With Wazuh, I can bring relevant cloud events into the same security monitoring environment where I’m already examining Windows servers, Linux systems, firewalls, and network discovery results.

That creates opportunities to correlate activity across systems that otherwise might be reviewed separately.

What Kind of Microsoft 365 Activity Is Interesting?#

Depending on the configured audit and security data sources, Wazuh can help monitor events involving:

  • User and administrator activity
  • Changes to mailbox settings
  • Mailbox forwarding and other Exchange Online operations
  • SharePoint and OneDrive file activity
  • Changes to permissions and access
  • Security alerts from supported Microsoft services
  • Identity-related activity where appropriate log sources are connected

For example, an unexpected mailbox forwarding rule might deserve investigation.

So might an unusual administrative change or a security alert affecting a Microsoft 365 account.

The important point is that the available coverage is determined by the integration configuration. Connecting Microsoft 365 doesn’t automatically mean every event from every Microsoft security product is being collected.

But having the ability to incorporate these cloud events into Wazuh is a significant advantage.

Why This Matters#

Many organizations no longer keep all their important data on local servers.

Email is in Microsoft 365.

Documents are stored in SharePoint and OneDrive.

Authentication and access management increasingly depend on cloud identity systems.

If a security monitoring system only watches local computers, it may miss important activity happening inside cloud applications.

That’s why I wanted Microsoft 365 included in my Wazuh environment.

I don’t want separate monitoring tools to become isolated islands of information.

I want the ability to investigate security activity across both local and cloud infrastructure.

And because Wazuh is customizable, I can continue expanding the Microsoft 365 integration as my monitoring requirements evolve.

What About Google Workspace?#

Not everyone uses Microsoft 365.

Many organizations use Google Workspace, including Gmail, Google Drive, and Google’s cloud-based collaboration tools.

The same general security monitoring approach can be applied to Google Workspace environments.

Google Workspace produces audit information involving user activity, administrative changes, authentication, and access to cloud resources.

That information can be useful when investigating account compromise, unauthorized changes, and suspicious activity.

One way to integrate Google Workspace with Wazuh is to export supported Workspace audit logs through Google Cloud Logging and route the relevant events into Wazuh using Google Cloud’s logging and messaging services.

Custom integrations using Google’s audit APIs are another possible approach.

Unlike Wazuh’s dedicated Microsoft 365 audit module, Google Workspace monitoring may require additional log forwarding and configuration.

The important point is that Wazuh isn’t restricted to one cloud productivity platform.

For an organization running Microsoft 365, the Microsoft integration can provide cloud activity monitoring.

For an organization using Google Workspace, a properly configured audit-log collection pipeline can provide similar visibility.

And for environments that use a combination of cloud services, Wazuh provides a flexible platform for bringing information together.

I currently use Microsoft 365 in my own monitoring environment, but I appreciate that the platform can be adapted to different organizations and their technology choices.

Discovering Network Devices With Nmap#

Wazuh does an excellent job of monitoring computers and servers that have its agent installed.

But what about everything else connected to a network?

Switches, wireless access points, printers, firewalls, IoT equipment, and other devices may not support a Wazuh agent.

I wanted visibility into those devices too.

For that, I turned to Nmap, the free and open-source network scanning utility.

I built dedicated internal scanning systems at both locations.

Each scanner periodically examines its local network and maintains an inventory of known devices.

When another scan runs, its results are compared against that inventory.

The process looks like this:

Scheduled Nmap Scan
        |
        v
Discover Network Devices
        |
        v
Compare With Known Inventory
        |
        +-- Known Device
        |       |
        |       v
        |   Update Inventory
        |
        +-- Unknown Device
                |
                v
        Generate Wazuh Event
                |
                v
        Custom Detection Rule
                |
                v
          Security Alert

During the initial discovery work, one location identified approximately 43 devices and the other identified 19.

Those inventories provide a useful baseline.

But the real value isn’t simply knowing how many devices are connected.

It’s knowing when something changes.

Suppose someone connects an unfamiliar device to the network overnight.

Without some form of network discovery, that device might go unnoticed.

With the Nmap integration, the scanner can recognize that a previously unknown device has appeared and generate an event for Wazuh.

That doesn’t necessarily mean the device is malicious.

It could be a perfectly legitimate laptop, printer, or wireless access point.

But I’d rather know that something new appeared than discover it accidentally several months later.

I’ve also configured scheduled scanning, watchdog checks, and custom Wazuh rules to help make the discovery process dependable.

That last part is particularly important.

A network scanner that quietly stops scanning isn’t doing much good.

Looking at My Networks From the Outside#

Internal network discovery only tells part of the story.

I also wanted to know what my networks look like from the Internet.

That’s where external Nmap scanning comes in.

The idea is to have a scanner at one location examine the public-facing network at the other location.

That provides an outside perspective on which services are accessible.

During one of my initial tests, I examined the top 1,000 TCP ports on one of my public-facing addresses.

The results showed:

ResultPorts
Open1
Filtered999

TCP port 443 was the only open port reported during that test.

That was encouraging.

But a single scan only tells me what the network looked like at that moment.

What I really want is automatic change detection.

Suppose a future scan discovers that TCP port 3389, commonly associated with Remote Desktop, has unexpectedly become accessible from the Internet.

That’s something I’d want investigated.

The intended workflow looks like this:

External Nmap Scan
         |
         v
Identify Accessible Ports
         |
         v
Compare With Previous Baseline
         |
         +-- No Change
         |       |
         |       v
         |   Record Result
         |
         +-- New Open Port
                 |
                 v
          Generate Wazuh Event
                 |
                 v
           Security Alert
                 |
                 v
           AI Investigation
                 |
                 v
         Email / Telegram

I’ve tested the external scanning itself.

The next stage is completing scheduled comparisons, structured Wazuh events, and automated change notifications.

The goal isn’t simply to run a port scanner every day.

It’s to recognize when the external security posture changes.

Integrating My pfSense Firewalls#

Both locations use pfSense firewalls.

I wanted their security logs available alongside the rest of the information Wazuh collects.

Initially, this seemed straightforward.

Enable remote syslog on pfSense, configure Wazuh to receive the messages, and point the firewall at the Wazuh server.

The logs started arriving.

But Wazuh wasn’t interpreting them correctly.

The problem turned out to be the format of the messages.

Wazuh expected a recognizable hostname and program name, something like:

Nov 14 19:06:05 firewall-host filterlog[12345]: ...

But the messages were arriving closer to:

Nov 14 19:06:05 filterlog[12345]: ...

Without the expected hostname, Wazuh interpreted the header incorrectly.

The network connection worked.

The receiving port was open.

The logs were present.

But the firewall decoder couldn’t recognize them.

That distinction took some time to track down.

Solving the Problem With syslog-ng#

I introduced syslog-ng as an intermediate logging service.

Syslog-ng receives the pfSense messages, normalizes their headers, and forwards them to Wazuh.

pfSense Firewall
       |
       v
Built-in System Logger
       |
       v
syslog-ng
       |
       +-- Receive Messages
       +-- Normalize Hostname
       +-- Preserve Program Name
       |
       v
Wazuh Syslog Receiver
       |
       v
Security Detection Rules

After correcting the message format, Wazuh began recognizing the firewall events.

It could extract information such as source and destination addresses, ports, protocols, and firewall actions.

Wazuh’s built-in rules could also recognize blocked connections and patterns of repeated activity.

That was a major step forward.

When More Logs Became a Problem#

I also managed to create duplicate firewall events during the process.

Syslog-ng had two forwarding paths sending messages toward Wazuh.

One applied the corrected hostname.

The other didn’t.

That resulted in duplicate messages.

This is especially problematic in a security monitoring system because duplicate events can inflate statistics and affect rules that count repeated activity.

The fix was to remove the redundant forwarding path and keep the correctly formatted one.

That reinforced an important lesson:

More security data isn’t necessarily better. Accurate security data is better.

Getting the Logs Into the Dashboard#

Another challenge was understanding the difference between receiving a log and seeing an alert in the Wazuh Dashboard.

Those are separate operations.

Wazuh may successfully receive and decode an event without recording it as an indexed security alert.

Some built-in firewall rules intentionally suppress routine events to prevent enormous volumes of ordinary traffic from overwhelming the security alert index.

I also spent time troubleshooting an apparent indexing problem at the secondary site.

Firewall events were visible in the worker server’s local logs, but the corresponding alerts weren’t appearing in central searches.

That led to checking Filebeat, cluster communication, TLS connectivity, local alert files, and indexed documents.

Eventually, I confirmed that firewall-related alerts generated at the secondary site were reaching the central indexer.

The important lesson was understanding the individual stages:

Receive Log
     |
     v
Decode Message
     |
     v
Evaluate Detection Rules
     |
     v
Generate Security Alert
     |
     v
Index Alert
     |
     v
Display on Dashboard

Each stage needs to be verified.

A successful syslog connection doesn’t guarantee correct decoding.

Correct decoding doesn’t guarantee an alert will be generated.

And a locally generated alert doesn’t automatically prove that the event was indexed centrally.

For normal operation, I’ve kept full raw-event archiving disabled to avoid unnecessary storage consumption.

My current firewall dashboards focus on security alerts rather than every individual blocked packet.

That is an intentional balance between visibility and resource requirements.

Building Custom Dashboards#

Wazuh provides useful dashboards out of the box, but I’ve also been building dashboards specifically for my environment.

I want separate views for each location and for different types of monitoring.

The dashboard work includes:

DashboardPurpose
Primary Site — Firewall SecuritypfSense security alerts
Secondary Site — Firewall SecuritypfSense security alerts
Primary Site — Network DiscoveryNew devices and discovery events
Secondary Site — Network DiscoveryNew devices and discovery events

The names here describe the intended site-specific views; some dashboard work is still being completed.

Eventually, I’d like a single overview that shows the security status of both locations.

That should include more than security alerts.

I want to know whether the Nmap scanners are operating, whether firewall logs are arriving, whether Wazuh agents are connected, and whether the monitoring infrastructure itself is healthy.

I’d also like better visibility into cloud security activity from Microsoft 365.

A dashboard full of attractive charts isn’t particularly useful if nobody notices that the data behind them stopped updating.

Making Wazuh Monitor Itself With Watchdogs#

This has become another important part of the project.

What happens when the security monitoring system itself stops working?

It’s easy to focus on detecting attacks, vulnerabilities, and suspicious activity while overlooking the monitoring infrastructure.

But a security platform isn’t very useful if it stops collecting information and nobody notices.

I’ve been building watchdogs and health checks around Wazuh to address that problem.

Some of these checks run locally.

Others monitor services between the two locations.

The idea is to detect failures that might otherwise go unnoticed.

For example, if the Wazuh Dashboard at one location becomes unavailable, a check running from the other location can identify the connection failure.

I’ve created custom Wazuh detection rules for repeated connectivity problems and recovery events.

Rather than relying on one failed request, the monitoring logic can recognize repeated failures before generating an alert.

That helps reduce unnecessary notifications caused by brief network interruptions.

The basic approach looks like this:

Primary Site Watchdog           Secondary Site Watchdog
        |                               |
        v                               v
Check Remote Services          Check Remote Services
        |                               |
        v                               v
Evaluate Results               Evaluate Results
        |                               |
        +---------------+---------------+
                        |
                        v
                Wazuh Custom Rules
                        |
                        v
             Failure / Recovery Alert
                        |
                        v
                Email Notification

I’ve also worked on local watchdog processes that check whether important services and scheduled monitoring tasks are functioning.

This is particularly useful for the Nmap scanners.

If a scanner stops running, I want that problem detected rather than allowing its inventory to become increasingly outdated.

A Running Service Isn’t Always a Healthy Service#

One lesson from this project is that checking whether a service is running doesn’t tell the whole story.

For example, a Wazuh Dashboard might load successfully even though some security information has stopped reaching the indexer.

Filebeat might still be running while a particular log collection path has a problem.

A scheduled scanner might be enabled without successfully completing its scans.

Those are different types of failures.

I’m gradually expanding the monitoring to detect not only unavailable services, but also missing or stale information.

The goal is eventually to answer questions like:

  • Are both Wazuh nodes communicating?
  • Are the Wazuh services responding?
  • Are agents continuing to report?
  • Did the network scanners complete their scheduled scans?
  • Are firewall logs still arriving?
  • Are Microsoft 365 security events still being collected?
  • Are security alerts being indexed?
  • Are the AI integrations still processing qualifying events?

Some of those checks already exist.

Others are part of the next stage of development.

The principle is simple:

A monitoring system needs to know when it can no longer be trusted to monitor.

Email Alerts: Getting Security Information Without Watching the Dashboard#

Another important part of my setup is email alerting.

Wazuh supports sending notifications when security events meet configured criteria.

I’ve been working with its email alerting capabilities alongside the custom rules I’ve developed.

That includes testing notifications for network discovery and using alerts to bring attention to monitoring problems.

Email is useful because it provides a notification channel that doesn’t depend on me actively viewing a Wazuh dashboard.

For example, I may want an email when:

  • A previously unknown device appears on the network.
  • A watchdog detects repeated connection failures.
  • A monitored service recovers after an outage.
  • A critical security event occurs.
  • A suspicious cloud security event is detected.
  • A scheduled monitoring process fails.

Not every one of those scenarios has a fully validated notification workflow yet, but they’re the types of events I’m designing the alerting system around.

An important part of this is controlling notification volume.

If Wazuh sent an email for every routine firewall block, authentication failure, or application warning, the notifications would quickly become useless.

I’d eventually stop paying attention to them.

So I’ve been working toward sending notifications for meaningful events, using rule severity and custom detection logic to determine what deserves attention.

Why Email and Telegram Are Both Useful#

Email and Telegram serve different purposes in my environment.

Wazuh email alerts provide rule-driven notifications directly from the security monitoring system.

OpenClaw Telegram messages provide a conversational channel where an AI assistant can review information and explain findings.

I don’t want Telegram to replace Wazuh’s conventional alerting.

If OpenClaw or its cloud AI provider becomes unavailable, Wazuh should still be capable of generating its own security alerts.

That’s one reason I like keeping multiple notification methods available.

The two systems complement one another without requiring every notification to depend on artificial intelligence.

Bringing Artificial Intelligence Into Wazuh#

This is where the project has become especially interesting.

I’m not simply connecting Wazuh to one AI chatbot.

I’m using two different AI models, with two different hosting arrangements and two different responsibilities.

The first is a smaller model running locally on hardware I own.

The second is a much larger model hosted remotely by Ollama.com.

The two systems also have different ways of accessing security information.

                       WAZUH
                         |
             +-----------+-----------+
             |                       |
             v                       v
       Alert Level 10+         Read-Only API
             |                       |
             v                       v
       custom-ollama           Local OpenClaw
             |                       |
             v                       v
       AI Integration          Ollama.com Cloud
             |                       |
             v                       v
       Local AI Server         GLM-5.3-Flash
       Qwen3.5:9B              321B Parameters
             |                       |
             v                       v
       Alert Analysis          Broader Security
                                 Investigation
                                       |
                                       v
                                    Telegram

That separation is deliberate.

Wazuh sends selected higher-severity alerts through its local AI integration. OpenClaw independently reviews Wazuh activity through read-only API access.

They don’t use the same model.

And they don’t necessarily examine the same security events.

AI System One: Wazuh and Qwen3.5:9B#

My first AI integration uses hardware I own.

I have a locally hosted Open WebUI and Ollama environment powered by an NVIDIA GeForce RTX 3060 with 12 GB of VRAM.

The model I’m using is Qwen3.5:9B, a 9-billion-parameter language model.

That’s substantially smaller than the model OpenClaw uses, but that isn’t necessarily a disadvantage.

For tasks such as explaining security alerts, interpreting logs, and summarizing potential problems, a smaller model may be sufficient.

I also like being able to perform this analysis locally.

It gives me more control over the model environment and reduces my dependence on external AI providers for routine alert processing.

How the Wazuh AI Pipeline Works#

On the Wazuh master, I’ve configured a custom integration named custom-ollama.

Its important settings are:

Integration: custom-ollama
Minimum alert level: 10
Alert format: JSON

The Wazuh integrator passes qualifying alerts to the custom integration workflow.

Those alerts contain structured information such as:

  • Affected agent
  • Rule ID and description
  • Alert severity
  • Original log message
  • Timestamp
  • Source IP address, when available
  • Username, when available
  • Other event-specific information

The integration is configured to use a webhook-based workflow associated with my local AI environment.

The exact webhook endpoint and complete analysis-response path still need final verification.

The intended processing flow looks like this:

Wazuh Detection Rule
         |
         v
Alert Severity >= 10
         |
         v
Wazuh Integrator
         |
         v
custom-ollama
         |
         v
Configured AI Webhook
         |
         v
Local Open WebUI / Ollama
         |
         v
Qwen3.5:9B
         |
         v
Security Alert Analysis

I like this arrangement because I can experiment with different models, prompts, and workflows without needing a commercial AI security product.

But there’s an important limitation.

The AI can only analyze events it actually receives.

The Level 10 Threshold#

My current Wazuh AI integration has a minimum alert severity of 10.

That prevents the model from being overwhelmed with relatively routine security activity.

But it also means the model doesn’t receive everything.

During a recent 48-hour review, only 15 alerts appeared in the level 10-and-above feed.

Those included vulnerability findings, Windows application errors, cross-site connectivity events, and a queue-related warning.

Meanwhile, other interesting security activity didn’t reach the integration.

An authentication anomaly was recorded at level 6.

Several Proxmox authentication failures were also recorded at levels 5 and 6.

Because those alerts didn’t meet the minimum severity of 10, they weren’t passed to the local AI workflow.

The AI didn’t overlook them.

It never received them.

That distinction matters.

It’s easy to assume that connecting artificial intelligence to a security system means the AI is looking at everything.

It isn’t.

Its usefulness depends on what information reaches it.

I could lower the threshold, but that would increase the processing workload and potentially introduce a lot more noise.

A better approach may be to selectively include important lower-severity rules while keeping routine events out of the pipeline.

That’s something I want to improve.

AI System Two: OpenClaw and GLM-5.3-Flash#

My second AI system is completely separate.

I have OpenClaw running locally on my own infrastructure.

But OpenClaw doesn’t use the smaller Qwen3.5:9B model running on my RTX 3060.

Instead, it uses GLM-5.3-Flash, a much larger open-source model hosted by Ollama.com.

GLM-5.3-Flash has approximately 321 billion total parameters.

That’s a substantially larger model than the one running on my local graphics card.

I don’t have the hardware needed to run that kind of model locally at the performance I’d want.

By using Ollama’s cloud-hosted version, I can access a much larger language model without building an expensive multi-GPU AI server.

But there’s an important distinction.

OpenClaw runs locally. The AI model it uses runs remotely.

OpenClaw is the local application that connects to services, retrieves information, and coordinates investigations.

The language model performs its inference in Ollama’s cloud.

Wazuh Security Platform
          |
          v
Read-Only API Access
          |
          v
Locally Hosted OpenClaw
          |
          v
Ollama.com Cloud
          |
          v
GLM-5.3-Flash
321B Parameters
          |
          v
AI Security Analysis
          |
          v
Local OpenClaw
          |
          v
Telegram

That gives me access to a much larger model while keeping the OpenClaw application itself on infrastructure I control.

The tradeoff is that information used for AI analysis may be transmitted to an external service.

That’s something I need to manage carefully, particularly when dealing with security logs and infrastructure information.

Giving OpenClaw Read-Only Access to Wazuh#

One of my most important design decisions was how much access to give OpenClaw.

I wanted it to investigate security activity.

I didn’t want it independently changing production systems.

So I configured restricted, read-only access to Wazuh’s APIs and relevant security information.

OpenClaw can review Wazuh activity in real time and examine information relevant to its investigations.

Its responsibility is different from the local Wazuh AI integration.

The local Qwen model receives selected high-severity alerts.

OpenClaw has an independent method of reviewing the broader Wazuh environment.

That means an authentication anomaly at level 6 might not reach the local AI integration, but OpenClaw could still investigate it through the API if its query permissions and scope include that event.

I want OpenClaw to help answer questions such as:

  • What unusual security activity is happening right now?
  • Has a particular system generated similar alerts recently?
  • Are several security events related?
  • Has an unfamiliar device appeared on the network?
  • Are there vulnerability findings relevant to an alert?
  • Has one of the monitoring services stopped responding?
  • Which findings actually deserve my attention?

That doesn’t mean the model will always be correct.

AI can misinterpret logs, draw incorrect conclusions, or place too much importance on routine events.

But it can be useful for investigating information and identifying what deserves further attention.

The read-only access is intentional.

I don’t want an AI assistant automatically modifying firewalls, deleting alerts, restarting servers, or making disruptive configuration changes because it misunderstood something.

My approach is straightforward:

The AI investigates and recommends. I decide what changes are made.

Why I’m Using Two Different AI Models#

There are practical reasons for keeping the two AI systems separate.

They’re solving different problems.

FeatureWazuh AIOpenClaw AI
ModelQwen3.5:9BGLM-5.3-Flash
Model size9 billion parameters321 billion parameters
Model hostingMy local serverOllama.com cloud
HardwareNVIDIA RTX 3060 12 GBRemote inference infrastructure
IntegrationWazuh custom-ollamaRead-only Wazuh API
Security inputsAlerts at level 10+Broader Wazuh activity
Main purposeAnalyze qualifying alertsInvestigate and correlate security findings
OperationAlert-drivenIndependent security review
NotificationsCustom webhook workflowTelegram

I think this is an interesting way to approach AI.

The smaller local model handles a focused workload.

The larger cloud model can help investigate more complicated situations involving multiple alerts or systems.

It also gives me an opportunity to compare how different models perform on real security information.

A 321-billion-parameter model isn’t necessarily required to explain a routine Windows application error.

A smaller locally hosted model may handle that perfectly well.

But when I’m examining activity across multiple servers, firewalls, cloud services, and locations, the larger model may provide useful additional context.

I’m interested in finding the right balance rather than simply sending everything to the largest model available.

Using Telegram for AI-Assisted Notifications#

OpenClaw is connected to Telegram.

That gives me a way to communicate with the assistant and receive security information without needing to constantly watch Wazuh dashboards.

I don’t want Telegram notifications for every routine firewall block or application warning.

That would become annoying almost immediately.

Instead, I want meaningful notifications.

For example:

SECURITY MONITORING ALERT

Finding:
A new externally accessible TCP port
was detected during a scheduled scan.

Previous Scan:
Port not accessible

Current Scan:
Port accessible

AI Assessment:
Unexpected external exposure may
require investigation.

Recommended Action:
Verify that the service is authorized
and properly secured.

That’s an example of the kind of notification I want the completed workflow to produce, rather than a real incident report.

I’m continuing to refine the automated delivery and reliability of the security notifications.

A good notification should tell me three things:

  1. What happened?
  2. Why does it matter?
  3. What should I check next?

That’s considerably more useful than a message containing nothing but a rule number and an IP address.

And importantly, Telegram doesn’t replace Wazuh’s email alerting.

I want Wazuh’s rule-based notifications to remain useful even if OpenClaw or its AI provider is unavailable.

Putting the Pieces Together#

The most interesting part of this project isn’t any individual component.

It’s how the components can work together.

Consider a hypothetical example.

An unfamiliar device appears on one of my internal networks.

The Nmap discovery scanner recognizes the device and generates a custom Wazuh event.

Wazuh records that event and makes it available for investigation.

Depending on the detection rule and notification configuration, Wazuh can generate an email alert.

OpenClaw can independently examine the event through its read-only API access.

It might discover related security activity involving the same system.

If the device has a Wazuh agent, there may also be vulnerability information available.

The firewall could provide another perspective on its network connections.

OpenClaw can use that information to help summarize what happened and recommend what to investigate.

Meanwhile, if a high-severity alert is generated, Wazuh’s custom AI integration can send that alert to the local Qwen3.5:9B model for analysis.

Now consider a different example involving Microsoft 365.

A suspicious cloud activity event appears in the Microsoft 365 audit data being collected by Wazuh.

Wazuh can evaluate that event through its configured rules.

If the event meets the appropriate alert conditions, it can become part of the central security reporting and notification workflow.

That means security investigations aren’t limited to computers and firewalls.

Cloud activity can become part of the same overall security picture.

That’s the direction I’m taking the system.

Multiple monitoring components, local and cloud security data, two different AI analysis paths, and multiple notification channels.

All designed to provide useful information without giving the AI unrestricted control.

What Makes This Different From a Typical Wazuh Installation?#

A conventional Wazuh deployment might consist of a central server, several endpoint agents, vulnerability detection, and the standard dashboards.

That’s already useful.

But my environment goes further.

ComponentWhat It Adds
Two-site Wazuh clusterDistributed security collection
Windows and Linux agentsOperating system and application visibility
Vulnerability detectionIdentification of known security exposures
Microsoft 365 integrationCloud audit and security activity monitoring
Google Workspace capabilityAlternative cloud audit-log integration
Internal Nmap scannersNetwork device discovery and change detection
External Nmap scanningInternet-facing exposure monitoring
pfSense integrationFirewall security event analysis
Custom detection rulesMonitoring tailored to my environment
Custom dashboardsSite-specific reporting
Local watchdogsDetection of service and scanner failures
Cross-site watchdogsMonitoring between physical locations
Email notificationsRule-driven security and operational alerts
Qwen3.5:9BLocal AI analysis of high-severity alerts
RTX 3060 AI serverGPU-powered local inference
OpenClawIndependent read-only security investigations
GLM-5.3-FlashLarge-model reasoning through Ollama’s cloud
TelegramAI-assisted notifications delivered to my phone

Each component provides a different view of the environment.

Endpoint agents tell me what’s happening inside operating systems.

Microsoft 365 integration extends security monitoring into cloud applications.

Internal scanners identify devices connected to the network.

External scanners help identify exposed services.

Firewalls provide information about network traffic and blocked connections.

Watchdogs help identify failures in the monitoring infrastructure.

Wazuh evaluates the collected events and applies security rules.

The smaller local AI model can analyze qualifying high-severity alerts.

OpenClaw provides a separate investigation path using a much larger model.

Email and Telegram provide different ways to communicate findings.

Together, those components provide a much broader picture than any one of them could provide individually.

It’s becoming less like a traditional vulnerability scanner and more like a small, AI-assisted security operations platform.

What Is Working Now#

The project already has a substantial functioning foundation.

Completed or tested capabilities include:

  • A two-site Wazuh master/worker cluster
  • Centralized Windows and Linux security monitoring
  • Proxmox infrastructure monitoring
  • Vulnerability detection and file integrity monitoring
  • A connection to my Microsoft 365 tenant
  • Internal Nmap scanners at both locations
  • Scheduled network discovery and device inventory comparisons
  • Custom Wazuh network discovery rules
  • pfSense syslog collection at both sites
  • syslog-ng message normalization
  • Wazuh firewall decoding and detection
  • Site-specific security dashboards
  • External Nmap scanning tests
  • Local Wazuh service health checks
  • Cross-site watchdog monitoring
  • Custom failure and recovery detection rules
  • Wazuh email alerting and notification tests
  • A configured custom-ollama integration for level 10+ alerts
  • A locally hosted Qwen3.5:9B environment powered by an RTX 3060
  • Locally hosted OpenClaw using Ollama.com’s GLM-5.3-Flash
  • Read-only Wazuh API access for OpenClaw
  • AI-assisted investigation workflows
  • Telegram connectivity for OpenClaw

Some areas still need work.

The complete external scanning automation isn’t finished.

Some dashboards need additional development.

I still want to verify the exact local AI webhook path and its complete analysis-response workflow.

And I want to improve notification reliability, stale-data monitoring, and alert quality.

I’m intentionally distinguishing the capabilities I’ve tested from the things I’m still developing.

One lesson from this project is that a configuration file saying something should work isn’t the same as proving that it works.

What Comes Next#

The next stage is less about installing new software and more about making the existing components work together reliably.

My priorities include:

  1. Complete scheduled external Nmap scanning in both directions.
  2. Compare externally accessible ports against previous scan baselines.
  3. Generate Wazuh alerts when public-facing exposure changes.
  4. Finish the remaining network discovery dashboards.
  5. Expand the watchdogs to detect stale logs and failed collection pipelines.
  6. Improve email notification rules and reduce unnecessary messages.
  7. Verify Microsoft 365 audit-event coverage and collection freshness.
  8. Verify the complete Wazuh-to-Qwen3.5:9B analysis workflow.
  9. Refine which lower-severity events should receive AI analysis.
  10. Improve OpenClaw investigations and Telegram notification delivery.
  11. Build a consolidated security overview covering both locations.

I’m also interested in comparing the two AI models.

Does the smaller local model provide useful explanations of high-severity alerts?

Does the much larger GLM-5.3-Flash model provide better context when investigating several related events?

Can I get better results by providing more relevant information instead of simply sending the models more data?

Those are questions I’m looking forward to exploring.

What This Project Has Taught Me#

The biggest lesson so far is that collecting security information and making that information useful are two different problems.

Wazuh can receive an enormous amount of data.

But if that data isn’t decoded, indexed, correlated, and presented correctly, it doesn’t accomplish much.

And adding artificial intelligence doesn’t automatically solve those problems.

A few principles now guide how I approach the system:

  • Free software can be extremely capable. Wazuh provides an impressive security foundation without commercial SIEM licensing.
  • Customization is powerful, but it requires testing. Every custom integration creates another component that needs to be maintained.
  • Security monitoring needs to include the cloud. Important activity doesn’t stop at the edge of the local network.
  • Receiving a log doesn’t mean it was decoded. Every stage of the processing pipeline needs verification.
  • More alerts don’t necessarily mean better security. Excessive noise makes important findings harder to identify.
  • An AI model can only analyze the information it receives. My level 10 integration is a perfect example.
  • A larger AI model isn’t always necessary. Smaller local models can be useful for focused analysis.
  • Locally hosted applications don’t always use locally hosted AI. OpenClaw runs locally while GLM-5.3-Flash runs remotely.
  • AI needs boundaries. Investigation and recommendations don’t require unrestricted administrative permissions.
  • Independent monitoring provides better visibility. Agents, network scanners, cloud audits, and firewalls observe different parts of the environment.
  • The monitoring system needs to monitor itself. Watchdogs and cross-site checks help identify failures.
  • Notifications need to be meaningful. Email and Telegram should report useful information, not endless background noise.
  • Multiple notification channels are valuable. Important alerts shouldn’t depend entirely on one AI application or service.
  • Automation needs verification. A scheduled task isn’t useful if nobody notices when it stops working.
  • Reliable data matters more than attractive dashboards. A chart is useless if the information behind it has stopped updating.

Perhaps the biggest lesson is how much can be accomplished by combining software that already exists.

Wazuh, Nmap, pfSense, syslog-ng, Proxmox, Microsoft 365, Open WebUI, Ollama, and OpenClaw all solve different problems.

Connecting them thoughtfully creates capabilities that none of them provide individually.

The Project Is Still Growing#

I’m genuinely impressed with Wazuh.

It’s a powerful, customizable, open-source security platform that gives me the freedom to build the kind of monitoring environment I want.

What began as a way to identify vulnerabilities on a few computers has evolved into a two-site security system with local and cloud monitoring, network discovery, firewall integration, external scanning, custom rules, watchdogs, email alerting, and two separate AI integrations.

My Microsoft 365 tenant is part of that monitoring environment, bringing another important source of security information into the picture.

And if I were working with a Google Workspace environment instead, Wazuh’s flexibility would provide a path to incorporate its audit information too.

One AI model, Qwen3.5:9B, runs locally on my own RTX 3060.

The other, GLM-5.3-Flash, has 321 billion parameters and runs in Ollama’s cloud, where my locally hosted OpenClaw assistant uses it for broader security investigations.

I also have watchdogs monitoring the monitoring infrastructure itself, and multiple ways to receive security notifications without constantly staring at a dashboard.

I like having those different layers.

And I particularly like that Wazuh provides the foundation for all of this without requiring an expensive commercial SIEM license.

That doesn’t mean the platform is perfect or that everything is finished.

I still have plenty of work to do around reliability, detection quality, notification delivery, and making sure the system produces useful information instead of unnecessary noise.

I’m not claiming this replaces a fully staffed security operations center.

But it’s becoming a surprisingly capable security monitoring environment built from software I can customize and infrastructure I control.

I started with the question:

How much security monitoring can I get from a free, open-source platform?

The more interesting question has become:

How far can I take Wazuh when I combine cloud security, network discovery, firewall monitoring, watchdogs, external scanning, automated notifications, and two completely different AI systems?

I’m still finding out.

And that’s what makes this project so much fun.