2026年5月28日木曜日

ぼくの中での emacs は死んでしまったのかもしれない

さらば emacs …

結論

emacs は完全に AI 関連で遅れを取っている
Copilot や OpenAI の拡張はあるが「そうじゃない」感がすごい
VSCode + copilot の使い勝手に勝てない

以下詳細に綴ります

emacs 拡張を使えば各種 AI と連携はできるができるだけで公式レベルには勝てないと判断した

emacs にも copilot.el などの拡張があるので emacs から各種 AI と連携することはできます

ただ連携できるだけでエージェントや MCP 連携 (最近は MCP もほぼ使わない) がほぼ無力な印象です
ただチャットに質問しているだけで自動で編集してくれたり作成してくれたりはしません

これを執筆しているときはほぼ emacs は使っていないので何ともですが自分が copilot.el を試した時期では少なくともエージェントのような機能はありませんでした
今であれば拡張も充実してエージェント機能も充実しているかもしれませんがそれでも VSCode + copilot のエージェント機能には及ばない気がします

公式が出しているエディタに付属している公式が出しているエージェントが公式の LLM を使うという当たり前の正解

基本 AI コーディングには LLM は必須です
OpenAI や Claude、Gemini などバックエンドに専用の LLM が必要です
もちろんローカルでも OK です

すべての LLM に言えることとしてすべての LLM は挙動が違うと思っています
OpenAI だとこう答えるが Gemini だとこう答えるといういわゆる「クセ」みたいなのがあると思っています

LLM に対して質問するのは基本的にエージェントです
そのエージェントが LLM の挙動を知っているか知っていないかは AI コーディングにおいて非常に重要な点かなと思っています

例えば VScode + copilot でローカル LLM を呼び出すとしましょう
するとどうでしょうか普通に使っている copilot とは全く挙動が違って全然思い通りのコーディングをしてくれなかったなんて経験はないでしょうか
自分はかつて試したことがあり全く期待通りじゃなかったことを実感しています
もちろんローカル LLM の選択やマシンのスペックが低かったなど考えられる要因は様々あります

つまりエージェントには適した LLM があり間違った組み合わせのエージェントと LLM では AI コーディングの精度に大きな差が生まれるのです

ここまで説明すればだいたいわかると思いますが同じ公式が作ったエディタ+エージェント+LLMの組み合わせのほうが確実に良い AI コーディングができるに決まっているのです

それなのに自力でエージェントを作ってサードパーティなりローカルの LLM を呼び出し AI コーディングしてもらうのは (決して間違ってはいませんが) DRY や KISS の法則的には反しているような気が自分はしています

与えられたものを素直に使うのが良いということです

独自の AI エージェントを作る場合は別

上記の件に関して独自の AI エージェントを作る場合は別かなと思います

エージェントは自作する必要がありますし LLM もどこか選定し API をコールする必要があります
そのエージェントに何をさせるかはわかりませんが自分だけの自分専用のエージェントであれば作りましょう

だたその場合も CLI で動作するエージェントはたくさんあるのでもし自分にあった既製品があるのであればそれを使うほうが精度としては良くなることがあるかもしれません (もちろん自作のほうが良い挙動になる可能性もあります)

エージェントが賢くなりすぎて最近は MCP すらいらない気がする

かつてはエディタやエージェントから MCP にアクセスする必要がありプロセスを立ち上げていました
MCP は Ubuntu などの Linux 環境では容易に立ち上げられるし管理も用意だったのでその点では emacs との親和性はありました

しかし最近のエージェントではデフォルトでブラウザが扱えたりローカルに対してはコマンドを叩けたり外部リソースにも簡単にアクセスしたりとかつて MCP が必要だった機能をエージェントが補完してくれています (内部的に MCP をエージェントがコールしてくれているケースもありますが)

要するにエージェントが賢くなりすぎていろいろできるようになってしまったがゆえに MCP も独自で立てる必要がなくなった気がしています

もちろん MCP が不要とはいいませんが昔ほど AI コーディングにおいて MCP が必須なコンポーネントであるとは現在では思えません

RAG や他の AI プロトコルについては今回は触れませんが RAG に関しても自分は同等の意見です
また Agents.md などのコンテキストというかシステムプロンプト的なものも最近では書く必要を感じなくなりました

そうじゃない感について

自分は主に copilot を使うので比較対象が copilot になってしまうのですが copilot には「Copilot CLI」という CLI 環境で動作するエージェントもあります
それを使って emacs の拡張で足りない部分を補いことはできるかもしれませんが個人的にはそれが「そうじゃない感」を生み出している点です

開発するときには基本的にはエディタや IDE と向き合います
かつて自分が emacs で開発しているときは開発 VM に ssh しそこで tmux を立ち上げその tmux バッファないで emacs を -nw で emacs を立ち上げて開発していました

確かにその環境は素晴らしかったです
ssh して tmux バッファを開けばすでに emacs でコーディングもできるし他のバッファでアプリのビルドやテストができる状態でした
その環境自体は自分は今も好きです

ただ AI コーディングをするとなるとエディタや IDE だけで完結する必要があります (必要があるというかその方がはるかにストレスレスだと思っています)
AI に質問するのにわざわざバッファを切り替えたり AI に質問したあとでわざわざ手動でコピペするというのは今の時代だとかなりナンセンスな方法です
一昔前であればブラウザでチャッピー (ChatGPT) に質問しその結果をエディタ側にコピペしてという開発手法でしたがコンテキストの与え方を考えたりトークンの数を減らすために RAG を構築したりとかなり大変でした (それは今もやってるかもしれませんが)

AI コーディングするにあたってあっちこっち切り替えてコピペしては簡単な作業とは言えかなりストレスが溜まります
それが VSCode + copilot ではすべてその場で解決します
質問すればすべて回答しその回答結果を即時に勝手にコードに反映してくれます
もしかすると一部コピペする必要があるかもしれません
もしかすると一部のコマンドの許可を与えるためにボタンを押す必要があるかもしれません
それでもアプリを切り替えてあっちこっちいったりする必要はなく VSCode ないだけでほぼ確実に完結します

これが個人的に感じている AI コーディングにおける「そうじゃない感」です

勝っている点があるとすれば

正直ないような気もします
本当に一部のケースで(慣れの問題もありますが) emacs のほうが素早く作業できる場合はあります

インストール -> どちらも homebrew できる
CLI 環境 -> emacs は -nw、VSCode は code-server or SSH トンネルなど
拡張 -> どちらもあり (elisp or JavaScript)
コード実行 -> どちらもあり
オープンソース -> どちらも
キーバインド -> どちらもできる

などなど emacs にしかできないことはほぼないような気がします (もちろん探せば全然ありますが表面上の利用用途としてはほぼなさそう)

それでも一部の作業はやはり emacs を使う

自分が今でも emacs を使っているケースがあります
それは単純なメモを取るときです

VSCode + copilot は何でもかんでも AI でやろうとするのでただメモを取りたいだけなのにコードサジェスチョンをしようとします
タイプ中に関係ないことをサジェスチョンされるのは嫌なのでプレーンテキストメモするときは emacs を使っています

また VSCode は基本的に 1 プロジェクトのみを開くことを対象にしているので現在開発しているプロジェクト以外を編集/閲覧したい場合には emacs を使います
一応 VSCode にも workspace という機能があり 1 つのウィンドウで複数のプロジェクトを開くことができるのですが AI のノイズになったり単純に邪魔になったりするので自分はあまり使っていません

emacs は今後も生き続けるはず

それでも emacs は今後も生き続けるはずです
emacs 自体の発展や拡張の発展が AI コーディングにより期待できるからです

先ほども記載しましたが tmux + emacs の環境は今でも好きだし使っています

またキーバインドによるショートカットや矩形選択などの編集などはまだ emacs のほうが速く作業できるケースもあるのでケースバイケースかなとも思っています
ただメインのアプリケーション開発においてはもう VSCode しか使っていません

もちろん emacs キーバインドは大好きで VSCode でも他のエディタや IDE、ターミナルソフトでも emacs キーバインドを使っています

最後に

AI エージェントが搭載されていないアプリはエディタや IDE だけではなく今後なくなってくるのかもしれません
また AI の肝はエージェントの実装と言っても過言ではないので優れたエージェントを持つアプリが生き残っていくのかもしれません

今回はその例がたまたま emacs vs VSCode だったというわけです

その他メモ

トラブル時にサーバに SSH ログインして作業するときも vim があれば十分なケースが多い
Microsoft 製のソフトウェアで唯一使っているソフトかもしれない

2026年4月5日日曜日

Switch2版ボールピットプレイメモ

ゲームも自動化の時代

価格

1360円
Switch2 版

とにかく進化優先

進化同士を融合

建築物のアップグレードをしすぎるとヌルゲーになるかも

逆に言うと建築物を優先して構築、アップグレードすると有利に進められる
ボス討伐後に続けられる「冒険者ギルド」の建築物を早めに作る

好きなキャラ

過激派
思想家
- 全自動が楽

嫌いなキャラ

影の者
- 単純に難しい
- 敵が手前に来られると詰む
- 過激派にクリアしてもらう
戦術家
- 戦闘が長く面倒

好きなボール

レーザー系や地震などの範囲系

ゲームクリア

全キャラ全建築物解放、アップグレード完了
ラスボスを全キャラで倒す
ラスボス後も無限にステージに挑戦できる
既存ステージの難易度(ステージ速度)が上がる

最後に

これくらい気楽にサクっとできるゲームが好きです

2026年2月4日水曜日

軽量ローカル LLM でコーディングするのは不可能ではないがやめたほうがいい

不可能ではないがフラストレーションがえぐいだけ
誰でも動かせる LLM じゃあ商売上がったりなんでそりゃ無理だよねって話

結論
試したエディタ/エージェント環境
使ってみた LLM
感想/所感
最後に

結論

copilot レベルの精度を出すには軽量 LLM ではほぼ不可能
- 学習および機能不足すぎる
- 軽量 LLM では tools/thinking がない
- 単純に学習量が少ないのか回答が的はずれななケースが多くフラストレーションが高い
ただしマシンスペックが潤沢 (RTX 4090/5090、メモリ VRAM+RAM が128GB 以上) なら話は別
- 大規模 LLM が動かせれば copilot と同等の UX が得られるかも
- 「かも」なのは実際に試せていないため

試したエディタ/エージェント環境

VSCode 1.108.2
copilot chat プラグイン (標準装備)

使ってみた LLM

phi4-mini:3.8b (agent)
llama3.1:8b (agent)
llama3.2:3b (ask)
codegemma:7b (ask)
gemma3:4b (ask)
qwen3:8b (ask)

以下それぞれ使ってみた感想です
細かい精度は違いますが大枠は変わらなかったのでモデルごとではなくまとめて記載します

感想/所感

thinking がないから命令を丁寧にしなければならない
- どのコンテキストに対して何をどうやって修正すればいいのか
- 命令の意図を解釈するフェーズが LLM にないので可能な限り丁寧に命令しなければならない
- copilot は雑な質問でも命令を解釈しコンテキストを読み込み意図を解釈してくれる
Agent が使えないケースが多い
- 使えても使い物にならない
結論としては大規模 LLM が必要
- ローカル LLM を使って copilot 相当のことをしたいのであれば大規模 LLM が必要
- 最低でも 20b ほどだが現実ラインでは 120b レベルが必要 (gpt-oss:120b など)
- 実際それを動かすとなると推論に必要なグラボと何よりも VRAM + RAM が必要になる
- 120b なら合わせて 128GB ほどメモリ領域が必要になる
- deepseek-v3.1:671b などは現実レベルでローカルで動かすのはほぼ不可能ということになる
使い方が悪かった可能性もある
- 命令やコンテキストの与え方が悪い
- 命令が抽象的にすぎる (が本当は抽象的に質問してもやってほしい)
- コンテキストが多すぎて LLM が解釈できない
- 逆にコンテキストが少なすぎて無視してしまう
トンチンカンな回答例
- コンテキストで与えたコードを無視して回答する
- 単純なサンプルコードだけ提示して終了
適切な LLM の設定
- Continue などはどのフェーズでどの LLM を使用するか設定できる
- copilot にも auto があるがローカル LLM だと使えない (はず
- Ask/Edit/Plan で使用する LLM をカスタムエージェントで設定できるのだろうか (おそらくできない

最後に

大規模 LLM が動作するマシンが30万だとすると現在の Copilot Pro は 1500 円くらいなので

300000/1500=200

で200ヶ月分は使えるので素直に Copilot Pro に課金するのがいいかもしれません
ローカルで大規模 LLM は無料と言えば無料ですが本当に無料ではありません (電気代とか)
他にゲームやマイニングとかで用途があればあってもいいかもですが

2026年1月14日水曜日

AI エージェントを作ってみた感想

これまでにBotはいくつか作っていました

https://blog.kakakikikeke.com/2025/10/no-life-no-bot.html

それもエージェントと言えばエージェントなのかもしれませんがもう少しエンジニアっぽい AI エージェントを作ってみたので感想やらつらつら残しておきます

作ったもの
不正プロセス監視エージェントのソースコード
簡単に流れの紹介
感想
最後に

作ったもの

不正プロセス監視エージェント
不正ログ監視エージェント
株価予測エージェント

不正プロセス監視エージェントのソースコード

#!/usr/bin/env python3
import json
import os
import subprocess
import time
from collections import deque

from google import genai
from slack_sdk import WebClient

GEMINI_API_KEY = "xxx"
SLACK_TOKEN = "xoxb-xxx"
SLACK_CHANNEL = "#general"
CUSTOM_BASE_URL = "https://your-llm-domain/endpoint"

# バッチ処理の設定
BATCH_MODE = (
    os.getenv("BATCH_MODE", "true").lower() == "true"
)  # デフォルトはバッチモード
BATCH_SIZE = int(os.getenv("BATCH_SIZE", "5"))  # 一度に判定するプロセス数
BATCH_TIMEOUT = int(os.getenv("BATCH_TIMEOUT", "10"))  # タイムアウト時間（秒）
MONITOR_INTERVAL = int(os.getenv("MONITOR_INTERVAL", "30"))  # プロセス取得間隔（秒）

print(f"Mode: {'BATCH' if BATCH_MODE else 'SINGLE'}")
print(
    f"BATCH_SIZE: {BATCH_SIZE}, BATCH_TIMEOUT: {BATCH_TIMEOUT}s, MONITOR_INTERVAL: {MONITOR_INTERVAL}s"
)

client = genai.Client(
    api_key=GEMINI_API_KEY,
    http_options=genai.types.HttpOptions(base_url=CUSTOM_BASE_URL),
)

slack = WebClient(token=SLACK_TOKEN)

# 既に通知済みのプロセスを追跡（重複通知を避けるため）
notified_processes = set()


# --- プロセス情報取得 ---
def get_processes():
    """
    ps コマンドでシステム上の全プロセスを取得する。
    戻り値: [{"pid": "...", "user": "...", "cpu": "...", "mem": "...", "cmd": "..."}, ...]
    """
    try:
        # aux フラグで詳細情報を取得
        cmd = ["ps", "aux"]
        result = subprocess.run(
            cmd,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
            check=True,
        )

        processes = []
        lines = result.stdout.strip().split("\n")

        # ヘッダースキップ
        for line in lines[1:]:
            parts = line.split()
            if len(parts) >= 11:
                processes.append(
                    {
                        "user": parts[0],
                        "pid": parts[1],
                        "cpu": parts[2],
                        "mem": parts[3],
                        "vsz": parts[4],
                        "rss": parts[5],
                        "cmd": " ".join(parts[10:]),
                    }
                )

        return processes

    except Exception as e:
        print(f"Error getting processes: {e}")
        return []


# --- LLM にプロセスの異常判定を依頼 ---
def analyze_process_single(process_info: dict) -> bool:
    """
    単一のプロセスを LLM で判定する。
    怪しいなら True を返す。
    """
    prompt = f"""
あなたは Linux サーバーのセキュリティ監視 AI です。
以下のプロセス情報が不審かどうか、以下の形式で答えてください。

プロセス情報:
- PID: {process_info['pid']}
- ユーザー: {process_info['user']}
- CPU使用率: {process_info['cpu']}%
- メモリ使用率: {process_info['mem']}%
- VSZ: {process_info['vsz']}
- RSS: {process_info['rss']}
- コマンド: {process_info['cmd']}

判断:
- 不審なら "SUSPICIOUS"
- そうでなければ "OK"

通常のシステムプロセス（kernel threads、systemd関連など）は OK と判定してください。
考察や理由は出力しないでください。
"""

    response = client.models.generate_content(
        model="gemini-2.5-pro",
        contents=prompt,
    )

    if response.text is None:
        print("No response text from LLM")
        return False

    result_text = response.text.strip().upper()
    return "SUSPICIOUS" in result_text


def analyze_processes_batch(processes: list) -> dict:
    """
    複数のプロセスを一度に LLM で判定する。
    戻り値: {pid: bool} の辞書
    """
    if not processes:
        return {}

    # プロセス情報をまとめてプロンプト作成
    processes_text = "\n".join(
        [
            f"{i+1}. PID: {p['pid']}, User: {p['user']}, CPU: {p['cpu']}%, Mem: {p['mem']}%, Cmd: {p['cmd']}"
            for i, p in enumerate(processes)
        ]
    )

    prompt = f"""
あなたは Linux サーバーのセキュリティ監視 AI です。
以下のプロセス情報が不審かどうか、それぞれを判定してください。

プロセス一覧:
{processes_text}

判定結果を以下の JSON フォーマットで出力してください:
{{
  "1": "OK",
  "2": "SUSPICIOUS",
  "3": "OK",
  ...
}}

JSONのキーはプロセス番号、値は "SUSPICIOUS" または "OK" です。
通常のシステムプロセス（kernel threads、systemd関連など）は OK と判定してください。
"""

    response = client.models.generate_content(
        model="gemini-2.5-pro",
        contents=prompt,
    )

    if response.text is None:
        print("No response text from LLM")
        return {p["pid"]: False for p in processes}

    # JSON を抽出して解析
    result_dict = {}
    try:
        # レスポンスから JSON を抽出
        json_str = response.text
        # JSONブロックの開始と終了を探す
        start_idx = json_str.find("{")
        end_idx = json_str.rfind("}") + 1
        if start_idx >= 0 and end_idx > start_idx:
            json_str = json_str[start_idx:end_idx]
            parsed = json.loads(json_str)

            # プロセスごとに判定結果をマッピング
            for idx, process in enumerate(processes, 1):
                result = parsed.get(str(idx), "OK").upper()
                result_dict[process["pid"]] = "SUSPICIOUS" in result
        else:
            # JSON が見つからない場合は全て False
            result_dict = {p["pid"]: False for p in processes}
    except json.JSONDecodeError as e:
        print(f"JSON parse error: {e}")
        result_dict = {p["pid"]: False for p in processes}

    return result_dict


# --- Slack 通知 ---
def notify(process_info: dict):
    message = f"""
:rotating_light: *Suspicious process detected!*
PID: {process_info['pid']}
User: {process_info['user']}
CPU: {process_info['cpu']}% | Mem: {process_info['mem']}%
Command: {process_info['cmd']}
"""
    slack.chat_postMessage(channel=SLACK_CHANNEL, text=message)


# --- フィルタリング関数 ---
def should_check_process(process_info: dict) -> bool:
    """
    監視対象外のプロセスをフィルタリング
    """
    cmd = process_info["cmd"]
    user = process_info["user"]

    # self プロセスは除外
    if "process_monitor_agent" in cmd:
        return False

    # root 関連の明らかに安全なプロセスは除外
    safe_keywords = [
        "kernel",
        "[",
        "]",
        "systemd",
        "sshd",
        "agetty",
        "bash",
        "sh",
        "grep",
        "ps",
        "vim",
        "nano",
        "sudo",
        "root",
        "ls -l",
        "sd-pam",
        "unbound",
        "cron",
        "sleep",
        "less",
        "/sbin/init",
        "canonical-livepatch",
        "snapd",
        "ubuntu-advantage/timer.py",
        "multipathd",
        "journalctl",
        "bpftrace",
        # 開発ツール関連
        "tmux",
        "mysqld",
        "redis-server",
        "code-server",
        "mosquitto",
        "ollama",
        "nginx",
        # postfix 関連
        "pickup -l -t unix -u -c",
        "tlsmgr -l -t unix -u -c",
        "qmgr -l -t unix -u",
        "/usr/lib/postfix/sbin/master",
        # docker 関連
        "dockerd",
        "docker-proxy",
        # apt 関連
        "apt-get",
        "packagekitd",
        "/usr/lib/update-notifier/apt-check",
        "tar -df alternatives.tar.0 -C /var/lib/dpkg alternatives",
        # EDR 関連
        "cbram",
        "cybereason-sensor",
        "cybereason-activeconsole",
    ]
    if any(keyword in cmd for keyword in safe_keywords):
        return False

    return True


# --- プロセス監視メイン処理 ---
def monitor_processes():
    """
    定期的にプロセスを取得して監視
    """
    print("Process monitor started.")

    if BATCH_MODE:
        # バッチモード
        monitor_processes_batch()
    else:
        # 単発モード
        monitor_processes_single()


def monitor_processes_single():
    """単発モード: 各プロセスを即座に判定"""
    while True:
        try:
            processes = get_processes()

            # フィルタリング
            filtered_processes = [p for p in processes if should_check_process(p)]

            for process in filtered_processes:
                try:
                    suspicious = analyze_process_single(process)
                    if suspicious:
                        pid = process["pid"]
                        if pid not in notified_processes:
                            print(f"[!] Suspicious process: {process}")
                            notify(process)
                            notified_processes.add(pid)
                    else:
                        print(f"[OK] {process['cmd']}")

                except Exception as e:
                    print(f"Error analyzing process: {e}")

            time.sleep(MONITOR_INTERVAL)

        except Exception as e:
            print(f"Error in monitor loop: {e}")
            time.sleep(MONITOR_INTERVAL)


def monitor_processes_batch():
    """バッチモード: プロセスをバッチでまとめて判定"""
    process_buffer = deque()
    last_batch_time = time.time()

    while True:
        try:
            current_time = time.time()
            processes = get_processes()

            # フィルタリング
            filtered_processes = [p for p in processes if should_check_process(p)]

            # バッファに追加
            for process in filtered_processes:
                process_buffer.append(process)

            # バッチ処理の条件: BATCH_SIZE に達したか、BATCH_TIMEOUT を超えたか
            should_process = len(process_buffer) >= BATCH_SIZE or (
                len(process_buffer) > 0
                and current_time - last_batch_time >= BATCH_TIMEOUT
            )

            if should_process or current_time - last_batch_time >= MONITOR_INTERVAL:
                try:
                    # バッファ内のプロセスを一度に処理
                    processes_to_process = list(process_buffer)
                    process_buffer.clear()
                    last_batch_time = current_time

                    if processes_to_process:
                        results = analyze_processes_batch(processes_to_process)

                        for process in processes_to_process:
                            pid = process["pid"]
                            is_suspicious = results.get(pid, False)

                            if is_suspicious:
                                if pid not in notified_processes:
                                    print(f"[!] Suspicious process: {process}")
                                    notify(process)
                                    notified_processes.add(pid)
                            else:
                                print(f"[OK] {process['cmd']}")

                except Exception as e:
                    print(f"Error analyzing processes: {e}")

            time.sleep(1)  # CPU負荷を減らすため1秒待機

        except Exception as e:
            print(f"Fatal error: {e}")
            time.sleep(MONITOR_INTERVAL)


if __name__ == "__main__":
    while True:
        try:
            monitor_processes()
        except Exception as e:
            print(f"Fatal error: {e}, restarting in 5 seconds...")
            time.sleep(5)

これを systemd 配下で動作させています

簡単に流れの紹介

ps aux の結果を取得
LLM (gemini) に投げて各プロセスが怪しいか判定してもらう
怪しい場合は Slack に通知

他のログ監視も同じような仕組みです
株価予測エージェントは上記の流れとだいぶ違うのは違うのですが LLM に過去の株価情報を渡して予測してもらうだけです

感想

以下不正プロセス監視エージェントを使ってみた感想や所感です

お金がかかるので呼び出し方を工夫しなければならない

LLM にわたす情報を複数行にまとめて API をコールする
1行ずつだと時間もかかるしお金もかかる
ローカル LLM が一つの解決策だがそれなりのマシンスペックは必要

判断するまでの速度

API (ネットワーク) + LLM の推論の時間が必ずかかるので判断までに数秒かかる
完全なリアルタイムを実現するのは難しい
一瞬で消えてしまうプロセスをキャッチできないケースがある
速度もローカル LLM で解決できそうだが結局高スペックマシンでもそれなりの推論時間がかかるので数ミリ秒レベルのレスポンス速度は期待できない

精度が曖昧

本当にアウトな場合のテストができない
アウトじゃないけどアウトと判定してしまう
アウトじゃないプロセスは無視するような仕組みが必要になる (コード内参照)
それ(特定のプロセス無視/ホワイトリスト形式)でいいのかという問題もある (同一プロセス名だと攻撃されても検知できなくなる)
前はセーフだったけど次はアウトにしちゃう
「怪しい」という LLM への命令が曖昧すぎるが故の過剰検知とハレーション

そもそもAI エージェントの具体的なユースケースは

人間には難しい「判断」や「解釈」が必要なタスク＋状況に応じて行動を変える仕事
ログから「人間レベルの洞察」を出す
毎日の情報を「読む → 取捨選択 → 解釈 → 提案」する
インシデント予兆検知
コードのレポート・改善案
などなど、とにかく得意なのは「判断」と「解釈」あと「生成」

(現状は)何かに特化した AI エージェントしか作れない

本当にやりたいことは「何でも」やってくれる汎用 AI エージェント
でも現状はやりたいことだけをやってくれる特化 AI エージェントしか作れない
もっというと「やりたいこと」すら AI エージェントが見つけて勝手にやってほしい
特化エージェントを組み合わせて汎用っぽく見せかける

AI を使わなくてもいい問題

今回作成した AI エージェントのようなログ監視やプロセス監視の製品はある
判断が静的 (特定の文字列を含む場合にアラート/CPUが90%以上になったらなど) だがそれで十分なケースが多い

そもそも「AI エージェント」の定義は

広義には「人の代わりに作業をやってくれるツール」だと思っている
自分は今回のようなプロセス版のエージェントも VSCode の Copilot Chat のようなエディタもエージェントだと思っている
エージェントにもいろいろなタイプがあるので言葉に惑わされてはいけない

既製品を使ってもいい

https://github.com/ashishpatel26/500-AI-Agents-Projects
https://github.com/Jenqyang/Awesome-AI-Agents
でもまだ知見がなさそう
常駐型はそれなりのスペックを要求するケースが多い
軽量な AI エージェントにしたいのなら自作するほうが結果的には簡単だし管理も楽になりそう

ブースティング

複数の LLM に判断させてその結果で最終的な判断をする
エヴァンゲリオンのマギシステム的なイメージ
ただしお金が倍々に増えていくので注意

最後に

AI もあるので AI エージェント自体を作ることは非常に簡単ですが本当に有用なものを作るのは難しいと言うか無くても何とかなるというのが正直なところです

株価予測エージェントは評価機能もあるので評価の結果が良ければ実践投入してどうなるか試してみようかなと思います
売買も自動でできると更に良いかなと思っています

登録: 投稿 (Atom)