Originally published at Perl Weekly 773

Hi there!

Recently there were a number of days that the perl-tester Docker image did not build properly. It is always a bit of an issue with it, because there quite a few moving parts. Parts where the dependency isn’t fixed. e.g. in most of the cases it installs the most recent version of the modules from CPAN. Which mean any release of any module might break the whole build process. This time, however, the source of the problem was the new release of App::cpm, the tool used to install the CPAN modules. As often the case the new release was intended to improve things: cpm v1: making installs stable, but it broke the build on some of the older versions of Perl just by increasing the minimum version of Perl required.

One solution would be to fix all the dependencies, both tooling and the modules we install, but then someone would need to keep track of changes (the way dependabot does) which is probably way too much work for the few people who contribute to this project. The other solution might be to create an easy way to see what changed between the last successful build and the current failing build. We have started to work on a tool that will help with that. It will also allow us to show exactly what is in every image. BTW If you have spare stars in your pocket, it would be nice if you gave one to the docker-perl-tester project.

A couple of days ago I started to play with FalkorDB, an Open Source Graph Database. I already gave a presentation in Hebrew on how to use in general and specifically in Python. In a couple of hours I am going to give another one – this time in English – an intro to GraphDB. I’ll use Rust for the programatic examples. It seems there is no client for it in Perl so it might be an interesting project to build one. The one in Python uses the Redis module for connectivity so I looked at the options to use Redis in Perl. MetaCPAN showed the Redis module as the first hit. Unfortunately that module did not have a commit for 3 years and there are many outstanding Issues and even PRs. So I posted about it both in the Perl Maven WhatsApp group and in the Telegram channel. Within seconds I was pointed towards Mojo::Redis and Redis::XS as alternatives.

Online Events: If you are in an American time-zone then both the Boston Perl Mongers and the Toronto Perl Mongers have semi-regular online meetings in your evening hours with various interesting speakers. If you are in the European time-zones or you don’t mind having a meeting in your morning hours in the Americas, then there is the Perl Maven group where it is mostly me giving a presentation or working on some code. For details check out the Perl Weekly events page.

Enjoy your week!

—
Your editor: Gabor Szabo.

Announcements

cpan.org email forwarding has been shut down

The Perl NOC team has shut down the forwarding of email to the cpan addresses. If you are a CPAN author, please make sure MetaCPAN displays ways to contact you. (link to the source git repository of your projects, a LinkedIn account, an email address, etc.)

Articles

cpm v1: making installs stable

I rarely include articles from Medium as most of them are spam, but this one is real. So here you are!

Is your account on blogs.perl.org registered with an @cpan.org email address?

Installing Bit::Vector on Debian 13 (Trixie)

It is good that this information can be found on a public blog post, but IMHO it would be event better if this was part of the README or the documentation of the project.

My Journey with Devel::ptkdb – Origins

Enabling AddressSanitizer (ASan) in Makefile.PL for Linux Environments

Introducing Time::Str

At first I was wondering why this new module when DateTime provides all the features, but then I read on and there are a few reasons. Interesting.

Discussion

Optional stricter normalization of raw ISBN input

An issue that gives an opportunity for you to share your thoughts.

Why does a call to ref on a reference to ‘substr’ produce ‘LVALUE’?

Perl

This week in PSC (224) | 2026-05-11

The Weekly Challenge

The Weekly Challenge by Mohammad Sajid Anwar will help you step out of your comfort-zone. You can even win prize money of $50 by participating in the weekly challenge. We pick one champion at the end of the month from among all of the contributors during the month, thanks to the sponsor Marc Perry.

The Weekly Challenge – 374

Welcome to a new week with a couple of fun tasks “Count Vowel” and “Largest Same-digits Number”. If you are new to the weekly challenge then why not join us and have fun every week. For more information, please read the FAQ.

RECAP – The Weekly Challenge – 373

Enjoy a quick recap of last week’s contributions by Team PWC dealing with the “Equal List” and “List Division” tasks in Perl and Raku. You will find plenty of solutions to keep you busy.

Perl Weekly Challenge 373: Equal List

The clean, logical structure of Abigail’s detailed technical analysis provides a very clear and rational basis for how best to apply mathematical theory to practical use. With a focus on optimising the algorithmic complexity rather than executing a brute force approach, Abigail delivers an incredibly efficient solution to this problem that will be valuable to all developers who wish to create highly efficient solutions to their problems.

Perl Weekly Challenge 373: List Division

Abigail’s solution to the list partitioning problem is a beautifully crafted and idiomatic implementation that completely avoids the cumbersome index-tracking that traditional loop-based implementations require. The implementation is easy to read and is highly efficient because it leans heavily on the mechanics of the underlying language. This illustrates how an effective structural data transformation paradigm can result in simpler implementations.

List the List

Through a demonstration using gather and take in conjunction with native array splicing Arne demonstrates Raku’s capabilities and gives a simple way to distribute remaining list offsets without having to rely on complex nested loops or overhead due to atypical index calculations. The result is a functional representation showing how Raku can eliminate complications associated with the partitioning of structural data, creating an intuitive self-documenting pattern.

Let’s Dance to List Division

Bob has produced a superbly developer-oriented analysis addressing the pragmatic aspects of designing APIs using Perl’s ‘flat’ argument list mechanism. Bob’s approach to using array references in conjunction with a dual-while-loop, which uses ‘destructive splice’ calls to divide the input data into well-balanced partitions, enables this entire operation to occur without requiring any complex index-tracking cognitive load.

Divide and Concat

Jorg has provided a mathematically accurate and highly precise solution that demonstrates command of Perl’s multidimensional array manipulation and list processing capabilities. The solution has been designed with a heavy emphasis on reducing iteration overhead, and uses a clean and logical approach to conditional checking. Overall, the implementation is an efficient way to manage data structures for all of the tasks required to complete this project.

Perl Weekly Challenge 373

W. Luis Mochan gives an interesting, very mathematical view of the difficulties and has elevated the difficulty of the tasks by discussing the different ways each of these tasks can be solved through their mathematical representations. The way the solution uses Perl Data Language is unique in its creativity and clearly shows how matrix operations and vector operations can be applied in a different manner to solve an algorithmic process much more efficiently and faster than typical procedural methods. This is a remarkable, challenging read, demonstrating the way that thinking in terms of vectors alone can change the way standard procedure of manipulating data can be made into a high level, abstract manner.

Because your list, your list I can’t resist

Packy offers a unique perspective on the challenge by framing the approach through an interesting musical context, followed by a really clean, multilingual show-off with a few different language options. As a polyglot expert, Packy’s write-up shows a number of idiomatic and clean ways to solve problems in both Perl and Elixir. The solutions have been complimented for their clear structure, readable transformations of data, and the highly contrasting ways in which they use the procedural power of Perl with the functional, pipeline-based elegance of Elixir.

The week of lists

This paragraph describes the outstanding quality of Peter’s work in executing his weekly assignments and projects using clear and detailed methods. He concentrates on providing clear and easy to understand explanations of all aspects of the problem using very pragmatic solutions with less complex algorithms than would be required to complete this task, and thus have produced solutions with low run times and high readability. Another benefit of using this strategy is that it will have produced many examples of good clean and maintainable code, as well as simple Perl code showing how to accomplish structural validation without additional runtime cost.

The Weekly Challenge – 373: Equal List

The analysis that Reinier provided on this challenge is truly impressive due to the systematic approach used to cover edges and validate input. The solution makes a great balance between how computer efficient it is to run while at the same time being easy to scan through for code due to well-named variables and clearly defined logical conditions. This is a great resource for developers looking to implement defensive programming and build highly maintainable systems.

The Weekly Challenge – 373: List Division

Reinier has presented a very clear and logical way to solve the list partitioning problem through clarity in procedural programming and appropriately managing data through effective use of algorithms. The implemented solution is easy to follow, with simple looping structures and clearly defined conditions used to divide the collection according to specification without introducing complexity into the underlying architecture. This solution is a perfect example of pragmatic programming, where simplicity, maintainability, and consistency take precedence over unnecessary abstraction.

The Weekly Challenge #373

The analysis provided by Robbie consists of an analysis of the weekly problems and an an idea of what you’d have to do. The breakdown of the problems will be thoroughly examined and will include thorough analysis of all the constraints on the solution as well as a commitment to validate input sufficiently to account for any and all edge cases and to deal with them accordingly. The combination of cleanly structured idiomatic programming style (including the use of loops) with clear and explicit comments that explain the logic behind the programming additions and modifications, make this a great reference source for new and experienced programmers to use.

There Is No Equality Without Division

Roger performs a beautiful and tidy example of modern solutions to solving problems through example in different programming languages and paradigms. The two different types of tasks, structural validation and partitioning, have been broken down into separate clear logical blocks that allow for high readability of solutions and the use of commonly used data structures without the use of complex loops. The write-up contains an excellent comparison of the different language features that reduce index-tracking overhead while still providing optimal run-time efficiency and successfully illustrates how functional programming techniques can be used successfully with non-functional programming techniques.

Joining and splitting lists

Simon has presented an impressively logical and practical polyglot demonstration that compares the elegant way of handling the first task in Python to how it is done through direct translations into Perl. The first task’s solution is particularly notable for its concise efficiency and consists of a great, simply written one-liner using native methods to join strings and performing a direct comparison to form the structure of the list being checked. In the second task, Simon has shown a brilliant method for diving an array into equal components by taking advantage of the mathematical operation called divmod or remainder and relying on destructive splice operations to divide the arrays evenly without creating any overhead from having to manage cumbersome index numbers.

Videos

Parsing Perl Without Perl – A Rust LSP for Perl 5

A presentation by Steven Zimmerman, CPA, at the online event of the Toronto Perl Monger

Acting Out With Claude: MCPs in Perl

A presentation by Steven Lembark, at the online event of the Toronto Perl Monger

Weekly collections

NICEPERL’s lists

Great CPAN modules released last week.

Events

Exploring Perl Modules

May 20, 2026

Toronto.pm – online – JSON Schema: language-agnostic typing / May TPM meeting

May 29, 2026

Boston Perl Mongers virtual monthly

June 9, 2026

The Perl and Raku Conference 2026

June 26-29, 2026, Greenville, SC, USA

You joined the Perl Weekly to get weekly e-mails about the Perl programming language and related topics.

Want to see more? See the archives of all the issues.

Not yet subscribed to the newsletter? Join us free of charge!

(C) Copyright Gabor Szabo
The articles are copyright the respective authors.

Four OpenClaw flaws have been disclosed by cybersecurity researchers, exposing serious risks in AI-agent environments where autonomous systems can access files, credentials, execution tools, and enterprise workflows. The vulnerabilities, collectively named Claw Chain by Cyera, can be chained together to achieve data theft, privilege escalation, sandbox escape, and persistence.

The vulnerabilities are tracked as CVE-2026-44112, CVE-2026-44113, CVE-2026-44115, and CVE-2026-44118. The most severe issue, CVE-2026-44112, has a CVSS score of 9.6 and can allow attackers to redirect writes outside the intended sandbox boundary.

OpenClaw is an open-source autonomous AI agent platform that can interact with local filesystems, tools, credentials, integrations, and execution environments. This makes vulnerabilities in OpenClaw especially important because attackers may be able to weaponize the agent’s own privileges against the host environment.

What is Claw Chain?

Claw Chain is the name given to a set of four chainable vulnerabilities in OpenClaw. Individually, the flaws affect sandbox isolation, file access, command validation, and owner-level access control. When combined, they can allow an attacker to move from limited execution inside the OpenShell sandbox to sensitive data exposure, owner-level privilege escalation, and persistent control.

The chain is especially concerning because it abuses behavior that may look like normal agent activity. AI agents are designed to read files, execute tools, manage workflows, and interact with runtime environments. If an attacker can influence those actions through a malicious plugin, prompt injection, compromised external input, or supply-chain content, traditional security tools may struggle to distinguish attack behavior from legitimate automation.

Overview of the Four OpenClaw Flaws

CVE-2026-44112: TOCTOU Filesystem Write Escape

CVE-2026-44112 is a time-of-check/time-of-use race condition in the OpenShell managed sandbox backend. The vulnerability allows attackers to bypass sandbox restrictions and redirect write operations outside the intended mount root.

This is the most severe issue in the Claw Chain set. If exploited successfully, an attacker may be able to tamper with configuration files, plant backdoors, modify trusted runtime behavior, and establish persistent control over the compromised host.

In an AI-agent environment, write access is particularly dangerous. Agents may routinely create files, update configuration, write logs, store outputs, and modify workflow artifacts. If those writes can be redirected outside the sandbox, the agent’s normal automation capabilities can become an attacker’s persistence mechanism.

CVE-2026-44113: TOCTOU Filesystem Read Escape

CVE-2026-44113 is another time-of-check/time-of-use race condition in OpenShell. Instead of redirecting writes, this flaw allows attackers to bypass sandbox restrictions and read files outside the intended mount root.

This can expose highly sensitive data, including system files, credentials, API tokens, internal artifacts, configuration files, secrets, and application data. In many environments, AI agents are connected to SaaS tools, internal systems, and local development environments, making read access outside the sandbox a serious data theft risk.

Even if the attacker does not immediately gain code execution, stolen credentials or configuration files may be enough to enable further compromise.

CVE-2026-44115: Command Allowlist Bypass Through Heredoc Expansion

CVE-2026-44115 is an incomplete list of disallowed inputs vulnerability. It allows attackers to bypass command allowlist validation by embedding shell expansion tokens inside a heredoc body.

This creates a gap between what OpenClaw validates and what the shell actually executes at runtime. A command may appear safe during validation, but shell expansion can cause unapproved behavior later.

For AI-agent platforms, this class of bug is especially risky because agents often rely on tool execution, shell commands, and automated workflows. If an attacker can manipulate command content through prompt injection, malicious plugins, or compromised inputs, they may be able to execute commands that were supposed to be blocked.

CVE-2026-44118: Owner Context Spoofing and Privilege Escalation

CVE-2026-44118 is an improper access control vulnerability that allows non-owner loopback clients to impersonate an owner. The issue stems from OpenClaw trusting a client-controlled ownership flag called senderIsOwner instead of deriving ownership from a properly authenticated session.

By manipulating this ownership context, a lower-privileged local client may gain access to owner-only operations. These operations can include gateway configuration, cron scheduling, and execution environment management.

OpenClaw has addressed the issue by issuing separate owner and non-owner bearer tokens and deriving senderIsOwner exclusively from the token that authenticated the request. The spoofable sender-owner header is no longer emitted or trusted.

How the Claw Chain Attack Works

The exploitation chain can unfold in four major steps:

1. A malicious plugin, prompt injection, compromised external input, or supply-chain artifact gains execution inside the OpenShell sandbox.
2. The attacker uses CVE-2026-44113 and CVE-2026-44115 to read sensitive files, expose credentials, and bypass execution restrictions.
3. The attacker exploits CVE-2026-44118 to obtain owner-level control over the agent runtime.
4. The attacker uses CVE-2026-44112 to modify configuration, plant backdoors, and establish persistence.

This chain is dangerous because it turns the AI agent into the attacker’s operational tool. Instead of dropping obvious malware immediately, the attacker can use the agent’s own permissions and workflows to access data, change configuration, and maintain control.

Why These OpenClaw Flaws Matter

The OpenClaw flaws matter because autonomous AI agents are no longer simple chat interfaces. They increasingly act as execution platforms that can interact with files, terminals, APIs, SaaS tools, calendars, repositories, customer systems, and cloud environments.

This changes the security model. A prompt injection or malicious plugin is no longer just a content manipulation issue. It can become a pathway to filesystem access, command execution, credential exposure, and persistence if the agent runtime has weak boundaries.

Cyera warned that each step of the attack chain may resemble normal agent behavior to traditional controls. That makes detection harder and increases the blast radius when an agent is connected to sensitive tools or data sources.

Affected Versions and Fixed Release

Cyera reported that the vulnerabilities affect OpenClaw versions prior to the April 2026 patches. CVE database entries for CVE-2026-44118 identify OpenClaw before 2026.4.22 as affected.

OpenClaw users should update to version 2026.4.22 or later to receive the fixes for the Claw Chain vulnerabilities.

Security teams should confirm the installed OpenClaw version across all environments, including developer machines, self-hosted agent servers, automation hosts, staging environments, and public-facing deployments.

Recommended Mitigation Steps

OpenClaw users should take the following actions immediately:

• Upgrade OpenClaw to 2026.4.22 or later.
• Review all OpenClaw deployments, including local developer instances and cloud-hosted agent runtimes.
• Audit installed plugins, skills, and third-party integrations.
• Remove untrusted or unused plugins from agent environments.
• Restrict agent access to sensitive files, secrets, and configuration directories.
• Rotate credentials that may have been accessible to OpenClaw agents.
• Review logs for unusual file reads, writes, shell commands, cron changes, and gateway configuration updates.
• Apply least privilege to agent runtime accounts.
• Limit network exposure of OpenClaw services and loopback-accessible gateways.
• Require human approval for high-risk actions such as shell execution, credential access, configuration changes, and scheduled tasks.

Detection Guidance

Defenders should review OpenClaw and host-level telemetry for suspicious behavior that may indicate exploitation or attempted exploitation.

Useful signals include:

• Unexpected reads of sensitive files outside the sandbox mount root.
• Unexpected writes to configuration files, startup scripts, cron jobs, or plugin directories.
• Use of shell expansion tokens inside heredoc bodies.
• Execution of commands that were not expected from approved workflows.
• Changes to gateway configuration or execution environment settings.
• Owner-only actions initiated by non-owner clients.
• New scheduled tasks, startup hooks, or suspicious persistence mechanisms.
• Outbound connections from agent processes to unknown destinations.

Because agent behavior can look legitimate, detection should combine application logs, host telemetry, process monitoring, filesystem monitoring, and identity context.

Why AI Agent Security Needs a Different Approach

Traditional application security often focuses on user input, authentication, authorization, and server-side code execution. AI-agent security must include all of those areas, but it also needs to account for tool use, prompt influence, plugin supply chains, filesystem access, autonomous decisions, and long-running memory or workflow state.

The Claw Chain vulnerabilities show that agent security failures can happen across multiple layers at once. A prompt injection may influence execution, a sandbox escape may expose files, an access-control flaw may elevate privileges, and a write escape may enable persistence.

Organizations using agent platforms should apply zero-trust principles to agent runtimes. Agents should not be trusted simply because they run locally or act on behalf of a user. Every file access, command execution, plugin action, and privileged operation should be constrained and auditable.

How Vulert Can Help

Vulert helps developers and security teams stay ahead of vulnerabilities by continuously monitoring open-source dependencies and software components without requiring access to source code.

Vulert can analyze manifest files and SBOMs such as package-lock.json, yarn.lock, composer.lock, requirements.txt, pom.xml, go.sum, Gemfile.lock, Cargo.lock, SPDX SBOMs, and CycloneDX SBOMs.

For vulnerabilities like the OpenClaw flaws, fast visibility is essential. Vulert helps teams identify affected components, understand fixed versions, and respond quickly before attackers can abuse vulnerable software in production environments.

You can review the vulnerabilities in the Vulert Vulnerability Database:

• CVE-2026-44112 Vulnerability Details
• CVE-2026-44113 Vulnerability Details
• CVE-2026-44115 Vulnerability Details
• CVE-2026-44118 Vulnerability Details

Conclusion

The four OpenClaw flaws known as Claw Chain demonstrate how AI-agent vulnerabilities can create a complete attack path from initial execution to data theft, privilege escalation, and persistence. The vulnerabilities affect sandbox boundaries, command validation, file access, and owner-level authorization.

OpenClaw users should upgrade to 2026.4.22 or later, audit plugins and workflows, rotate exposed credentials, review logs for suspicious file and command activity, and apply least privilege to agent runtimes.

As AI agents gain more access to enterprise systems, they become powerful automation tools and high-value attack surfaces. Organizations should secure them with the same seriousness applied to servers, CI/CD systems, cloud credentials, and production applications.

FAQs

What are the OpenClaw flaws?

The OpenClaw flaws are four chainable vulnerabilities tracked as CVE-2026-44112, CVE-2026-44113, CVE-2026-44115, and CVE-2026-44118. They can enable data theft, privilege escalation, sandbox escape, and persistence.

Why are AI-agent vulnerabilities dangerous?

AI agents often have access to files, credentials, tools, APIs, and execution environments. If compromised, attackers can use the agent’s own permissions to steal data, escalate privileges, or establish persistence.

How can Vulert help?

Vulert helps teams monitor vulnerabilities, identify affected components, and receive alerts using manifest files and SBOMs without requiring source code access.

326 commits over the last two weeks. The headline: five new skills shipped, secret management moved off shell rc files, and the project landed at #1 on its own 5-axis harness benchmark with 80.6/100.

What’s new

• Five new skills: oma-market (deterministic market research pipeline across keyless sources), oma-docs (doc drift detection + sync), oma-deepsec (drives Vercel’s vulnerability scanner end-to-end), oma-academic-writer (publication-grade prose), oma-voice (local TTS/STT via Voicebox MCP).
• oma vault: OS keychain credential store backed by @napi-rs/keyring. Stops ANTHROPIC_API_KEY and friends from sitting in shell rc files where any agent subprocess can read them.
• agent:spawn --isolation=worktree: opt-in git worktree per spawned agent. Worktrees are retained on exit; the spawner prints merge or discard commands so you decide.
• oma stats cost telemetry: per-vendor token breakdown with USD estimates from a conservative pricing floor. Input-only for now, output tokens tracked next.
• oma model:check / probe / propose: detect model registry drift against live vendor sources without API keys, then emit a models.yaml patch for accepted candidates.
• Cursor as a first-class vendor: cursor/composer-2, composer-2-fast, and auto register with native dispatch. New cursor-only preset (also renamed to plain cursor, see below).
• Three slash workflows: /docs for drift verify and sync, /recap for daily and period summaries, /deepsec for the full scan to triage loop.
• PWA on the docs site: manifest with maskable icons, install screenshots, and display_override for desktop title-bar customization.

What’s fixed

• Serena MCP migrated from ephemeral uvx --from git+... to globally installed serena-agent via uv tool install, with vendor-specific --context per the upstream client matrix.
• Hook keyword detector hardened against three bypass classes: NFKC normalization for fullwidth Latin from CJK IMEs, hyphen-rejecting word boundaries, and a two-tier CLI invocation guard so prompts that ARE CLI invocations no longer trigger workflows.
• oma doctor CLI version probe bounded with a 1500ms spawn race + SIGTERM escalation, so a GUI binary that ignores --version can no longer hang the probe indefinitely.
• i18n translation drift detection via oma docs i18n, plus oma docs lint for CJK em-dash anti-patterns (em-dash in CJK prose now flagged as a content-level lint, not auto-fixed).
• Preset rename: claude-only to claude, antigravity to mixed. The -only suffix misrepresented the contract (you can already override per-agent), and antigravity collided with the runtime vendor id. Auto-migrated on oma update; hard-error on legacy values in oma-config.yaml.

What’s better

• Benchmark: oh-my-agent now scores 80.6/100 on the 5-axis multi-judge harness (Functional, Spec, Visual, Engineering, Efficiency), landing #1 against omc, superpowers, vanilla, and ecc. Multi-judge averaging runs three rounds per axis to drop single-run noise.
• oma update prints a “What’s new” note with added or removed skills and workflows after the version bump, so the catalog change is visible at upgrade time.
• docs/generated/ auto-added to .gitignore on doc write sites via a unified cli/io/gitignore.ts module.
• Telemetry opt-in unified across vendors: a single telemetry boolean in oma-config.yaml now drives Claude (DISABLE_TELEMETRY), Gemini, Qwen, and Codex opt-out keys on install and update.
• cli/cli-kit/ merged into cli/utils/ so there is one home for shared CLI helpers instead of two overlapping ones.
• Em-dash sweep across 173 files in skills, workflows, and docs per the oma-translator anti-AI-pattern rule. Em-dash usage restructured contextually with colons, periods, parens, or restructured sentences, not mechanical substitution.

Installation

# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/first-fluke/oh-my-agent/main/cli/install.sh | bash

# Windows (PowerShell)
irm https://raw.githubusercontent.com/first-fluke/oh-my-agent/main/cli/install.ps1 | iex

Links

oh-my-agent is built for teams who orchestrate more than they prompt. Next up: closing the spec gap that surfaced in the benchmark by teaching skills the real-API plus deferred-stub pattern at scaffold time, not at fix time.

https://github.com/first-fluke/oh-my-agent

I built a startup planning tool during the MeDo hackathon — and it started from personal frustration.
Every time I had an idea, I’d open Google and drown in tabs. No tool ever told me what to do with my specific idea.
So I built BuildPath.
→ Enter your idea, budget, and skill level
→ Get tailored validation actions using Perplexity, ChatGPT, and Claude
→ Run a reality check against the market
→ Get a full tech stack recommendation — AI builders, coding IDEs, hosting, payments
→ Walk away with a real build plan + PDF export
No account. No credit card. BYOK (Groq / OpenAI / Gemini).
Built without a budget for API costs — so instead of charging for AI, users bring their own key. What started as a constraint became the product philosophy.
By the founder, of the founder, for the founder.
🔗 https://app-b9okfacn4cn5.appmedo.com
Give it a try , Build your path , Turn chaos into a plan , Test drive the app

BuiltWithMeDo #indiehacker #buildinpublic #startups #builtwithAI

ตรวจจับ Log Anomaly อัตโนมัติด้วย Garudust Agent 🦅

ถ้าคุณเคยนั่งไล่ดู log ไฟล์ที่ยาวหลายหมื่นบรรทัดเพื่อหาว่า “มันพังตรงไหน” — บทความนี้เขียนมาเพื่อคุณโดยเฉพาะ

Garudust Agent คือ AI agent runtime ที่เขียนด้วย Rust รองรับการ self-host บน hardware ของคุณเอง และมี skill ชื่อ log-analyst ใน garudust-hub ที่ถูกออกแบบมาสำหรับงานนี้โดยตรง

🤔 ปัญหาจริงที่นักพัฒนาเจอ

ระบบ production ทุกระบบมี log แต่การไล่อ่าน log ด้วยมือมีปัญหาหลายอย่าง:

• ปริมาณมหาศาล — log หลักล้านบรรทัดต่อวัน ไม่มีใครอ่านได้หมด
• Pattern ซับซ้อน — error เดียวกันอาจโผล่ในหลาย format
• เจอช้า — กว่าจะรู้ว่าพัง ผู้ใช้แจ้งมาก่อนแล้ว
• Context ขาด — รู้ว่า error ตรงไหน แต่ไม่รู้ว่า “ก่อนหน้านั้นมีอะไรเกิดขึ้น”

Garudust แก้ปัญหาเหล่านี้ด้วยการให้ LLM อ่านและวิเคราะห์ log แทนคุณ — แบบ real-time หรือ scheduled ก็ได้

🛠️ ติดตั้ง Garudust

วิธีที่ 1 — ใช้ Pre-built Binary (แนะนำ)

# Linux x86_64
wget https://github.com/garudust-org/garudust-agent/releases/latest/download/garudust-*-x86_64-unknown-linux-musl.tar.gz
tar -xzf garudust-*.tar.gz
sudo mv garudust garudust-server /usr/local/bin/

วิธีที่ 2 — Build จาก Source (ต้องมี Rust 1.75+)

git clone https://github.com/garudust-org/garudust-agent
cd garudust-agent
cargo build --release
export PATH="$PATH:$(pwd)/target/release"

ตั้งค่าเริ่มต้น

garudust setup

Wizard จะถามว่าใช้ LLM provider ไหน รองรับทั้ง Anthropic, OpenRouter, vLLM (local), Ollama และ AWS Bedrock

สำหรับคนที่มี GPU และ self-host: ใช้ vLLM กับ model เช่น Qwen3-8B ได้เลยโดยไม่เสียค่า API

export VLLM_BASE_URL=http://localhost:8000/v1
export GARUDUST_MODEL=Qwen/Qwen3-8B-AWQ

📦 ติดตั้ง log-analyst Skill

Skill คือ instruction set แบบ Markdown ที่บอก agent ว่าต้องทำอะไร เมื่อไหร่ อย่างไร

garudust skill install log-analyst

แค่นี้พอ — ครั้งถัดไปที่คุณพูดถึง log, agent จะโหลด skill นี้มาใช้อัตโนมัติ

🔍 ใช้งานจริง: วิเคราะห์ Log ทันที

กรณีที่ 1 — วิเคราะห์ syslog

garudust "วิเคราะห์ /var/log/syslog 500 บรรทัดล่าสุด หา error pattern ที่ผิดปกติ"

ตัวอย่าง output ที่ได้:

🔍 Log Analysis Report — /var/log/syslog
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

⚠️  ANOMALY DETECTED: Connection timeout spike
    → 47 occurrences ใน 3 นาที (ปกติ < 2/ชั่วโมง)
    → First seen: 14:32:01, Last: 14:35:18
    → Probable cause: Network interface congestion หรือ upstream service down

❌ ERROR Pattern: OOM Killer activated
    → Process: python3 (PID 18423)
    → Memory usage: 7.8GB / 8GB
    → Recommendation: เพิ่ม swap หรือ review memory leak ใน process

✅ ไม่พบ segfault, kernel panic หรือ disk I/O error

กรณีที่ 2 — วิเคราะห์ Application Log

garudust "อ่าน /opt/myapp/logs/app.log แล้วหา:
- Error rate ต่อนาที
- Request ที่ใช้เวลา > 5 วินาที  
- Pattern ที่น่าสงสัย
สรุปเป็นภาษาไทย"

กรณีที่ 3 — เปรียบเทียบ Log สองช่วงเวลา

garudust "เปรียบเทียบ /var/log/nginx/access.log ระหว่าง 10:00-11:00 กับ 14:00-15:00 
ว่า error rate ต่างกันไหม และ traffic pattern เปลี่ยนแปลงอย่างไร"

⏰ Cron: ตรวจ Log อัตโนมัติ ทุก 30 นาที

นี่คือจุดที่ทำให้ Garudust ต่างจากการรัน script ธรรมดา — agent สามารถ ตัดสินใจเองได้ ว่าสิ่งที่เจอนั้น “ผิดปกติ” หรือเปล่า

GARUDUST_CRON_JOBS="*/30 * * * *=Read /var/log/app.log last 300 lines, detect ERROR or WARNING anomalies, if severity is HIGH report summary with timestamp and probable cause" 
garudust-server --anthropic-key sk-ant-...

แจ้งเตือนผ่าน Telegram อัตโนมัติ

TELEGRAM_TOKEN=your_bot_token 
GARUDUST_CRON_JOBS="*/15 * * * *=Check /var/log/app.log for critical errors in last 15 minutes. If error rate exceeds 10 per minute, send alert to telegram with details" 
garudust-server --anthropic-key sk-ant-...

Agent จะส่ง message ไปยัง Telegram bot ของคุณเองอัตโนมัติเมื่อเจอ anomaly

🏭 Use Case จริง: ระบบ Industrial / Edge AI

สำหรับงาน IoT หรือ Edge AI ที่มี log จากเซนเซอร์หรือกล้องวงจรปิด สามารถทำแบบนี้ได้:

# ตรวจสอบ log จากระบบ OCR กล้อง factory ทุก 1 ชั่วโมง
GARUDUST_CRON_JOBS="0 * * * *=Analyze /opt/vision/logs/ocr_results.log, find rows where confidence_score < 0.6 or recognition_failed = true, count anomaly rate, if > 5% in last hour generate incident report" 
VLLM_BASE_URL=http://localhost:8000/v1 
GARUDUST_MODEL=Qwen3-8B-AWQ 
garudust-server

ข้อดีคือรันบน local GPU ได้เลย ไม่ต้องส่ง log ออกไปยัง cloud เหมาะมากสำหรับระบบ industrial ที่ข้อมูลเป็น confidential

✏️ เขียน Skill เองสำหรับ Log Format เฉพาะทาง

ถ้า log ของคุณมี format แปลก หรืออยากให้ agent วิเคราะห์แบบเฉพาะเจาะจง เขียน SKILL.md เองได้ใน ~/.garudust/skills/:

---
name: factory-log-analyst
description: Analyze industrial machine log from SMARTSense IDA system
version: 1.0.0
---

เมื่อถูกขอให้วิเคราะห์ log จากระบบ IDA ให้ทำตามนี้:

1. อ่าน log file ด้วย terminal tool
2. หา pattern เหล่านี้ที่บ่งบอกปัญหา:
   - confidence_score < 0.5 (OCR accuracy ต่ำผิดปกติ)
   - frame_drop_rate > 0.1 (กล้องส่งภาพไม่ครบ)
   - roi_timeout (พื้นที่ตรวจสอบไม่ response)
   - connection_lost (กล้องหลุด)
3. คำนวณ:
   - Anomaly rate ต่อชั่วโมง
   - ROI ที่มีปัญหาบ่อยที่สุด
4. สรุปเป็นภาษาไทย ระบุ:
   - ความรุนแรง (Critical / Warning / Info)
   - เวลาที่เกิด
   - สาเหตุที่น่าจะเป็น
   - คำแนะนำในการแก้ไข

🔧 Tool เพิ่มเติมจาก garudust-hub

นอกจาก log-analyst skill แล้ว ยังมี tools ใน hub ที่ช่วยงาน log ได้:

# ติดตั้ง tools ที่มีประโยชน์
garudust tool install csv_to_json    # แปลง log CSV → JSON
garudust tool install file_info      # เช็ค size/encoding ก่อนอ่าน
garudust tool install token_count    # เช็คว่า log ยาวเกิน context ไหม
garudust tool install extract_urls   # ดึง URL จาก access log

ใช้คู่กันในคำสั่งเดียว:

garudust "ใช้ file_info ดูขนาดของ /var/log/nginx/error.log ก่อน แล้วถ้าไม่เกิน 100KB ให้วิเคราะห์หา anomaly ทั้งหมดที่เกิดขึ้นวันนี้"

📊 เปรียบเทียบ: Garudust vs วิธีเดิม

🚀 เริ่มต้น 5 นาที

# 1. ติดตั้ง
wget -qO- https://github.com/garudust-org/garudust-agent/releases/latest/download/garudust-$(uname -m)-unknown-linux-musl.tar.gz | tar -xz
sudo mv garudust /usr/local/bin/

# 2. ตั้งค่า
garudust setup

# 3. ติดตั้ง skill
garudust skill install log-analyst

# 4. ลองเลย!
garudust "วิเคราะห์ /var/log/syslog 100 บรรทัดล่าสุด หา error ที่น่าสงสัย"

สรุป

Garudust ไม่ใช่แค่ tool อ่าน log — มันคือ agent ที่เข้าใจ context ของ log และช่วยตัดสินใจว่าอะไรคือ “ปกติ” หรือ “ผิดปกติ” โดยใช้ความสามารถของ LLM

จุดแข็งที่สำคัญสำหรับ DevOps และ Industrial Engineer คือ:

• Self-host ได้ 100% — ไม่ต้องส่ง log ออก cloud
• รองรับ local LLM — ใช้ vLLM + Qwen/LLaMA บน GPU ของตัวเองได้
• ภาษาไทยได้เลย — detect ภาษาอัตโนมัติ ไม่ต้องตั้งค่า
• Cron built-in — ตั้งตรวจอัตโนมัติได้ทันที

🔗 Links:

• GitHub: garudust-org/garudust-agent
• Hub: garudust-org/garudust-hub
• Facebook Community: Garudust Agent Thailand

มีคำถามหรืออยากแลกเปลี่ยนประสบการณ์ใช้ Garudust? comment ได้เลยครับ 🙌

Most engineering teams believe they have a productivity problem.

They think development is slow because there are too many meetings, not enough developers, or because the tech stack isn’t modern enough. But after spending time inside real software teams, one uncomfortable pattern keeps appearing again and again: developers are not actually spending most of their time building new things. They’re spending a massive amount of time fixing, rewriting, and correcting work that should have been done correctly the first time.

Research published in the Journal of Systems and Software suggests that software projects can spend nearly 40–50% of development effort on avoidable rework. That number sounds extreme until you look closely at how modern teams operate. A feature gets shipped quickly, but the requirements were vague. Backend and frontend interpret the logic differently. Product changes direction halfway through implementation. APIs need redesigning after integration. Suddenly an entire sprint disappears, not because the team failed to work hard, but because the foundation itself was unstable from the beginning.
And the scary part is that most teams don’t even realize how much time is being lost.

The Invisible Work That Nobody Talks About
One of the biggest problems with rework is that it often looks like “progress” on the surface. Developers are active, pull requests are merged, tickets are moving across the board, and deployments are happening constantly. From a management perspective, everything appears productive.
But inside the engineering workflow, a huge amount of energy is quietly consumed by invisible work.
Engineers jump between fixing edge cases, correcting misunderstood business logic, reviewing AI-generated code, patching integrations, rewriting unstable modules, or refactoring rushed implementations from previous sprints. A 2026 engineering report from Harness described this phenomenon as the rise of “invisible work,” where developers spend increasing amounts of time maintaining momentum instead of creating meaningful forward progress.
Many developers know this feeling personally. You finish coding a feature, only to discover later that the requirement was incomplete. Or worse, you realize the system design itself cannot support the new business case. So instead of building the next feature, the team spends days or weeks repairing existing decisions.
This is the part of software engineering that dashboards rarely capture.

The Real Problem Isn’t Coding, It’s Alignment
A lot of teams assume rework happens because developers make mistakes.
In reality, rework often begins long before coding even starts.
The deeper issue is usually weak alignment between business goals, system design, and technical execution. This is where SDD (Software Design & Documentation) becomes incredibly important, even though many companies still treat documentation as optional or “something we’ll clean up later.”
Ironically, skipping proper design discussions in order to “move faster” often creates the exact opposite result.
When requirements are unclear, every developer fills the gaps differently based on their own assumptions. Product managers imagine one workflow, backend engineers design another, and frontend developers build something slightly different again. Nobody is technically wrong, but the system slowly drifts into inconsistency. By the time these misunderstandings are discovered, the cost of fixing them becomes dramatically higher.
This is why experienced engineers care so much about seemingly boring things like API contracts, edge cases, sequence diagrams, or failure scenarios. They understand that a single unclear assumption early in development can later evolve into weeks of refactoring.
And most teams only notice the problem when delivery timelines begin slipping.

AI Is Speeding Up Code, But Not Understanding
AI coding tools have changed software development dramatically over the past few years. Developers can now generate boilerplate code, build components faster, and automate repetitive implementation tasks in ways that were impossible not long ago.
But there’s an important distinction many companies are beginning to learn the hard way:
AI accelerates code generation.
It does not automatically improve system thinking.
A recent report found that 81% of developers now spend more time reviewing code after adopting AI-assisted tools. That insight is incredibly revealing because it highlights a common misconception in modern engineering culture: people assume faster coding automatically means faster development.
But software engineering has never been only about writing code.
The hardest part is usually understanding the problem clearly enough to build the right solution in the first place.
If requirements are vague, AI simply helps teams generate incorrect implementations faster. If architecture decisions are weak, AI can unintentionally accelerate technical debt. Teams may feel more productive because more code is being produced, but underneath the surface, complexity and maintenance costs continue growing silently.
This is why many senior engineers today are becoming more focused on design quality than raw coding speed.

High-Performing Teams Think Differently About Rework
Interestingly, elite engineering teams do not eliminate rework completely.
They understand that change is a natural part of software development. Requirements evolve, markets shift, users behave unpredictably, and no system design survives reality perfectly.
What strong teams do differently is reduce avoidable rework.
Instead of rushing directly into implementation, they spend more time aligning expectations early. They prototype quickly, validate assumptions sooner, and encourage technical discussions before large-scale development begins. Their goal is not to create endless documentation, but to create enough shared understanding that developers are not constantly rebuilding the same things.
They also design systems with change in mind. Rather than tightly coupling every service together, they prioritize modularity and maintainability because they assume future changes are inevitable. This mindset completely changes how teams approach architecture.
The question becomes:
“How do we make future changes cheaper?”
—not—
“How do we avoid change forever?”
That difference in thinking is huge.

The Business Cost Is Bigger Than Most People Realize
Imagine a 10-person engineering team losing just two hours per day to avoidable rework. That may not sound catastrophic at first, but over weeks and months, the numbers become enormous. Hundreds of engineering hours disappear into fixing preventable issues instead of building real business value.
And the impact is not only financial.
Constant rework slowly damages morale inside teams. Developers become frustrated because they feel like nothing is ever truly finished. Product teams lose confidence in timelines. Technical debt increases pressure on future releases. Eventually, engineering culture shifts from innovation into survival mode, where teams spend more time maintaining instability than creating progress.
This is why weak SDD is not simply a documentation issue.
It’s a scalability issue.
A delivery issue.
A business issue.

Final Thoughts
The software industry loves discussing frameworks, AI tools, productivity hacks, and shipping velocity. But many teams are still ignoring one of the most expensive hidden problems in engineering:
Building the wrong thing correctly is still failure.
And in many cases, teams are not slowed down because developers lack talent. They are slowed down because the organization failed to create enough clarity before implementation began.
Better SDD will never feel as exciting as shipping features quickly. Documentation rarely goes viral on social media. Architecture discussions are not glamorous. But over the long term, the teams that invest in clarity almost always move faster than the teams that constantly rebuild their own mistakes.

Sustainable speed in software engineering does not come from writing code faster.
It comes from reducing the amount of code you need to rewrite later.

Website: https://myspec.dev
Feedback form: https://docs.google.com/forms/d/e/1FAIpQLSfiwMWMqFgUUVXops5J1LWsF7DQOJGUqwBATbtlx8IJ9fma1Q/viewform