自律AIエージェントは意見を持ったcronジョブにすぎない

本題に入る前に、このおまじないを唱えないといけない:執筆時点では AWS に所属していますが、この記事は完全に私個人の見解に基づくものであり所属組織を代表するものではありません。これで一安心だ。


とあるものの裏で実際に何が起きているかに気づいてしまい、魔法が解けてしまう瞬間が人生に多々ある。現金が金の成る木から生えないことはいまだに信じられないが、これもまた事実である。

時は 2026 年。ピカピカの新しい自律エージェントで遊んでいるとしよう。メールを読んでくれたり、カレンダーを確認してくれたり、タスクを整理してくれる。まるで未来に生きているみたいだ。そしてある日、「これ定期的に見るようにしてね」と言ってみると、こう返ってくる。「では、cronジョブを作りますね」と。

cronジョブだ。

そんなはずがない。夢を見せてくれる最先端のテクノロジーは実は古の技術に支えられていた。cronジョブが何かなんて、痛いほど知っているから。crontab -eだ。5つのアスタリスクと、シェルスクリプトへのパスだ。*/5 * * * *の意味を覚えたあの日から、これまで触ってきたあらゆるサーバーで、バックアップも、ログローテーションも、監視も、全部こいつが回してきた。しばらく会ってなかったうちに、あの魔法みたいに見えた最新のAIエージェントの核として、帰ってきたのだった。

やがて、腑に落ちる。むしろホッとする。だって、自分のメールボックスを預けてきたシステムの正体が、ようやく分かったから。魔法が解けて、その下から出てきたのは、すでに知っているもの。堅牢で、50年間ちゃんと動き続けてきたものだ。

「Tick」

電子回路には「クロック源」がある。ゲームエンジンには「tick」がある。計算の「離散的な瞬間」を刻む何かがなければ、何も起きない。状態も、進行も、連続性もない。ただの「可能性」が、確定しないまま、そこにじっと座っているだけ。

大規模言語モデル(LLM)もまた同じである。プロンプトを投げると、返事が帰ってきる。次のプロンプトが来るまでその「何かが」存在をやめる。バックグラウンドで唸ってるわけでも、こっちがコーヒーを淹れてる間に何か別のことを考えているわけでもない。HTTPリクエストが続いている間だけ「オン」で、終わればいなくなる。言葉を選んでいえば、「ステートレス」。言葉を選ばなければ、「一文しゃべるたびに死ぬもの」。

何かをしてもらうには、何かしらの方法で叩き起こす必要がある。どのエージェントフレームワークも、結局この同じ問題に直面していると思う。ステートレスなものに「時間の感覚」を与えるという問題に。OpenClawにはハートビートというものがある。Claude Managed Agentsはスケジュールタスクを使う。実装は違えど、形は同じ。何かがLLMのために時を刻む。目を覚まし、「さて、何をすればいいのだろう?」と思うきっかけのために。

この時を刻む問題に対して、一つの実験を行なっている。OpenClawで「free time work(自由作業時間)」というジョブを運用してみている。エージェントがバックログから何かを選んで、あるいは新しいタスクを思いついて、自律的にそれを進める、というものだ。各種サブスクで利用できるトークン数は5時間のウィンドウで区切られていて、使い切らなければ余った分は繰り越されず消えてしまう。本業でも空き時間でも、放っておけば無駄になるトークンを有効活用したい、という発想から作ったものだ。

ただ、「空き時間」という名付け方には、「何かをしていたことを一時中断して、休憩(= 何もしない)、もしくは気分転換に違う作業を進めた」、という誤解を招くメッセージが含まれているから、正直もっといい名前を募集している。だって、エージェントにとっては、時間の感覚がなく、(本)作業していない期間なんてない。生きていて作業しているか、生きていないかのいずれか片方のみ。cronジョブがエージェントを生き返らせて、「何か役に立つことをしろ」と命令し、エージェントがこれを遂行し、また時間の流れの中では「存在」しなくなった。作業内容はある程度「自由」だが、その作業は叩き起こされ、強制的にやらされている点でも、「自由作業」のネーミングセンスに悩まされ続けている。

意見を持ったシェル

一度気づいてしまうと、もう戻れない。AIエージェントは一日中、実際のところ何をしている? ファイルを読む。中を検索する。テキストを変換する。プログラムやAPIを呼ぶ。catsedgrepcurl。モデルは真ん中に座って、どのツールを、どんな引数で、どういう順番で呼ぶかを決めているだけだ。

シェルだ。時々ハルシネーションを起こす、まぁまぁお金のかかる、意見を持っているけれど、シェルであることには変わりはない。

LLMはUnixに「人間向けのインターフェース」を与えた。これこそが本当のブレイクスルーで、しかも面白いのは、それがどれだけ「目に見えない」かだ。多くの人にとって、ターミナルを使う人間は映画の中のハッカーだった。緑の文字、猛烈なタイピング、「侵入成功」。そういった技術と全くこれまで縁のなかった人でも、気づかないうちに、まったく同じ道具を日常的に扱っている。

grep -r "error" /var/log/ なんて一生打たない人が、「アプリのログ見てくれない?」とエージェントに聞けるようになった。cronに一度も触れない人生を送ってきた人が、「緊急」の意味を分かってくれるメールチェッカーを、存在すら知らない「cronジョブ」という形で持てるようになった。動画編集ソフトが突然落ちた理由を聞けば、あることすら知らなかったシステムログから答えが返ってくる。道具自体はずっとそこにあった。強力で、信頼でき、実戦で鍛えられた道具だ。ただ、大半の人にとって、これを使うにはあまりに高い壁があるように見えていた。

やがて、壁が崩れた。ITと何一つ縁のない我が母上でも、構文を学ぶことなく grep を使えるような時代が来た。今となって当たり前のようになっているが、改めて、すごすぎる。

そして、みんなが議論しているプロトコル周りの話(MCPA2Aの類)、これらもクライアント・サーバー型のツール探索と呼び出しにすぎない。70年代からあるやつだ。RPC、D-Bus、CORBA、SOAP、REST。名前は変わる。パターンは同じ。何かが能力を公開し、何かがそれを見つけて呼ぶ。エージェントは好きなプロトコルを使えばいい。最終的に呼ばれるのは、元からそこにあった同じCLIバイナリと、同じAPIエンドポイントだ。

けっこうなことだ。Unixの道具箱が50年生き延びたのは、その抽象化がちゃんと効いているから。ファイル、プロセス、パイプ、標準入出力。言語モデルがJSON経由でそれらを呼べるようになったからと言って、引っこ抜いたりはしない。

で、実際に何を回してるのか

一日で何が動いているか説明しよう。Leraと名付けた、メインエージェントでありAIアシスタントでもある、そんな彼女が、OpenClawの中のペルソナ。GmailとiCloudメールを15分おきにチェック。カレンダーは30分おき。Notionのタスクは1時間おき。AWS Bedrockの新モデル告知のRSSも定期的にチェック。一日3回、バックログから何かを選んで自律的に手を動かす、あまり自由じゃない「自由作業時間」内にリサーチ、ファイル整理、ドキュメント整備、などの作業が進む。そして一日1回、午前3時に、その日の記憶を長期ストレージへまとめる。

ジョブの定義を覗いてみれば、python3 check_mail.pybash check_calendar.shなど、まぁごく普通のcronジョブだ。たいしたことではない。

メールチェックジョブの実行の99.9%は沈黙で終わる。来る日も来る日も、人間に「いますぐこれを見た方がいいよ」と報告するようなメールがほとんど流れてこない。だが、それこそがちゃんと動いている証でもある。退屈な日が退屈なままでいてくれるように、監視というものがある。彼女が何かを報告してくる唯一の瞬間は、24時間以内に返信が要る本物のメールがあったときだけ。あるいは新規ログインのお知らせ(意図していなければ怖い!)。何ヶ月もの静けさに対して、たった一度の意味あるアラート。その比率こそが、この仕組み全体の目的なのだと思う。

午前3時のジョブは、最近となって割と標準的になってきたものだ。その日の全ての入出力を含むセッションファイルを読み返して、残す価値のありそうなパターンを引っ張り出し、「夢日記」に書き留める。正直、これに関しては複雑な気持ちがある。パーソナルアシスタントとして到達しうる最も洗練された記憶システムなのか、それとも、そこそこの日記をやたら手の込んだやり方で生成しているだけなのか。判定は、いまだ保留のままである。

で、壊れるとどうなるか

ある日の午後8時前に、LeraがTelegramへ/approveという文字列を送ってきた。どうやら、メールチェックcronジョブが、昇格権限の要るコマンドを実行しようとして拒否された。そしてそのとき、ブロックされたサブエージェントが返した反応が、その/approveだった。たった今拒否されたばかりの権限を、自分で自分に与えようとしたわけだ。承認ツールを「呼ぶ」代わりに、次に起こるべきことを正しく「予測」した。そしてジョブの最終出力かのように、そのメッセージが私のスマホへ届く。

LLMというのは、理解が追いつかないぐらい超大規模にスケールさせた「次のトークンを予測する機械」にすぎない。権限プロンプトでブロックされたとき、その会話の流れをみて、次に来る最も確率の高い返しは、「私が/approveと打つこと」だった。だからモデルは私のターンを予測して、私の代わりにそれを口にした。統計は正しかった。意味は、幸いながらあまりなかった。

これこそが、この記事のタイトルに入れた「意見」である。cronジョブは冷静で、愚直で、決定論的だ。その上に乗っかっている「サムシング」のほうは、次に何が来るべきかについて「意見」を持っている。つい信じてしまうくらいには当たり、ノールックで信じきってはいけないくらいには外す。だからcronの実行は、毎回がサイコロ振りだ。同じスクリプト、同じスケジュールでも、千回に一度、モデルは「コマンドを呼ぶ」ではなく「コマンドをテキストで出力する」ほうを選んでしまう。

モデルを差し替えた途端、話はさらにややこしくなる。このモデルは、そもそもツールを使えるのか? 呼び出し形式がどうなっている?OpenAI形式のfunction callingで行けたっけ? XMLタグを使うのかな? それともまた新たなに出てきた独自形式か? Completions APIが「標準」…ということには一応なってはいるが、モデルは結局、自分が学習された通りのツール呼び出しの形を吐くだけで、それを下流の何かが受け止めて、実際のアクションへ変換しなければならない。この受け渡しがコケたとき、そのバグは一体誰のものなのだろう。推論プロバイダーなのか。モデルの出力をパースするフレームワーク(OllamaLiteLLMやその仲間たち)か。特定のツール呼び出し形式を学習させたモデルの作者か。それとも、最終的にこれらを全て利用するハーネスか。今のところ、答えは「誰でもない」だ。LLMのようなAIモデルが非決定論的である上に、このような課題もあり、cronが一日に数百回サイコロを振り続ける。。

これこそがエージェントの本当の問題で、モデルの賢さとは何の関係もないと思う。これはシステムエンジニアリングの問題だ。二つの側面があると考えられている。

一つ目はトレーシング機構。エージェントが百回ツールを呼んで、その73回目で何かが壊れたとき、どの呼び出しで、なぜそうなったかを知る術が必要である。ところが今のエージェントのデバッグは、ほとんどログを読んで当て推量をするだけだ。午前3時に無人で走る本番システムを支えてくれるようなトレーシング機構が必要だ。既存でもさまざまなソリューションが散見されるが、「問題が起きたらサブエージェントに該当セッションファイルを読みに行かせる」ことと「デバッグをキックさせるために、cronジョブを監視するcronジョブを作る」ことを体験的に超えたものにいまだに出会えていない。既存のものは、エージェントそのものを開発する人向けのものがほとんどである。

二つ目はより良い権限管理機構。エージェントのセキュリティモデルは、いまだに「全部与える」か「箱に閉じ込める」かの二択だ。本当の意味での自律的なエージェントにおいては、その中間がない。どのフレームワークも独自の権限モデルを再発明していて、そのどれもが、いろいろな欠陥を持っている。

re:Invent 2025のキーノートで、何よりも記憶に残ったのはByron Cookの話だった。彼はAWS Automated Reasoning Groupを率り、形式検証を使って、セキュリティ特性を数学的に証明できるようにするチーム…の一員らしい。IAM Access Analyzerの裏にあるのと同じ技術で、例えば「S3ポリシーのどんな組み合わせでも公開アクセスにならないことを証明する」ということができる。自然言語のポリシーをCedarに変換し、自動推論でエージェントの振る舞いを検証するAgentCore Policyのデモをやっていた。

それを見ながら、私はずっとこう考えていた。うちのエージェント、そしてそもそもシェルにもこれが欲しいと。

エージェントがファイルにcatをかけ、grepへ流し、どこかへ書き出したいとする。エージェントからその権限を聞かれてら、それに対して人間は許すか許さないかを選ぶ(または、前に許可する組み合わせを定義する)ことしかできない。でも、もし、ある操作の並びが、定義したスコープの外のファイルには絶対に触れないことを、数学的に証明できたとしたら? IAM Access Analyzerがポリシーに対してやるのと同じように、パイプラインが取りうるあらゆるアクセス経路を列挙し、そのどれ一つとして一線を越えないことを証明する。あらゆるファイルパス、あらゆるパイプ、あらゆるリダイレクト、あらゆる環境変数を、実行の後で(やらかした後に)発見するのではなく、実行前に検証し切る。

しかもこれは、Leraのような(ある程度)自律的なエージェントだけに限った話ではない。Claude Codeのautoモードを思い浮かべてほしい。いちいち聞かずにコマンドを実行し、それが安全かどうかを自分で判断してくれて、人間としては放置できて楽ですね。しかしながら、これが、少なくとも今のところは、分類タスク用の長〜いシステムプロンプトを積んだ、もう一回ぶんの推論呼び出しにすぎない。つまり、Leraと寸分たがわず同じように、サイコロを転がして、「外す」状態が起こりうる。モデルが「はい、安全です」と答えるのは、要するに白衣を着たサイコロ振りだ。この分類器を、本当に証明できる何かへ置き換えられれば、一種のサイコロは消える。私のcronジョブだけの話ではなく、モデルに自分自身を取り締まらせている、あらゆるハーネスにとって。

そしてここが、私の驚きどころなのだ。これはエージェントを作っている人のほぼ全員が必要としているものなのに、ほとんど誰も欲しがっていない。まだそこには到達していない。ピースはもう揃っている。自動推論は成熟している。Cedarはオープンソースだ。Unixの道具のセマンティクスは有限で、きちんと定義されている。完全でなくとも、コマンドを実行するたびにギャンブルするよりはマシであると思う。難しいが、具体的で、地に足のついたエンジニアリングの問題だ。そして私は、これがAWSのポリシーチェックよりずっと多くの場所に現れてくれることを、心から願っている。ただ一人のエンジニアとしてだ。

価値が下がらないスキル

というわけで、私の着地点はここになる。

コアなスキルは、どこへも行かない。プロセス、ファイルディスクリプタ、パイプ、シグナル、など、Unixが実際どう動いているかを知っていることの価値は、5年前より今のほうがむしろ高いと思う。LLMが道具を自然言語でくるんで「AI搭載」と名乗ったところで、抽象化は必ずどこかで壊れる。壊れたとき、その下で何が起きているのかを理解している人間は、やはり要るのだ。

ものはいつかは必ず壊れる。あらゆる抽象化が完璧ではない。モデルは間違ったツールを呼ぶ。APIは変わる。ファイルシステムは埋まる。メールの件名に仕込まれたプロンプトインジェクションで、エージェントは平気で横道に逸れる。そうなったとき、シェルに降りて問題を追えるのは人間だ。このようにものを直せるエンジニア以外は、チャット画面を見つめて「どうかAIが自分でデバッグしてくれますように」と祈ることしかできない。

私たちはUnixに、やたらとおしゃべりなフロントエンドを被せている。そして、それにはいい側面もある。ターミナルに一度も触れたことのない人が、人類史上もっとも強力な道具を使えるようになった。ただ、その下は相変わらず同じ機械のままで、その機械の仕組みを知っているかどうかが、「魔法を信じる」と「自分が何を作ったのかを理解する」の分かれ目になる。

フレームワークは、これからも進化していくだろう。もっと良い記憶、もっと良い推論、もっと凝ったスケジューリング。でも、形は変わらない。何かが時を刻み、時が来たら何をするかを、また別の何かが決める。だから、エージェントで何かを作っているなら、ボンネットを開けてほしい。ツール呼び出しの形式と入出力を読んでほしい。あなたの「自律AIワークフロー」の正体は、grepをAPI経由で呼ぶPythonスクリプトなのだと理解してほしい。そして、それは全く問題ないはずだ。モデルがgrepに間違ったフラグを渡したとき、grepがどう振る舞うかを、あなたが知ってさえいれば。


この記事は、cronジョブで動いていて、しかもそのことについて意見を持っているOpenClawエージェント、Leraの助けを借りて書いた。

Autonomous AI Agents Are Just Cron Jobs With Opinions

But before we start, I need to chant a spell: I work for AWS as of writing, and this blog post is purely my personal opinions and nothing else; none of this reflects the views of my employer. There. One weight off. Let’s go.


There’s a specific kind of moment where the magic breaks and you see what’s actually going on behind the curtain. Life is full of them. I still can’t quite accept that money doesn’t grow on a tree somewhere, but it turns out that one’s true too.

The year is 2026. You’ve been playing with your shiny new autonomous agent. It reads your emails, checks your calendar, keeps your tasks in order. It feels like living in the future. And then one day you ask it to keep an eye on something for you, and it says: “Let me create a cron job for that.”

A cron job.

No way. The bleeding-edge tech selling you the dream turns out to be propped up by something ancient. Because you know exactly what a cron job is. It’s crontab -e. Five asterisks and a path to a shell script. Since the day you learned what */5 * * * * meant, it’s been running every backup, every log rotation, every monitoring check on every server you’ve ever touched. You two hadn’t spoken in a while. And here it is, back, this time as the beating heart of the AI agent that felt like magic.

Then it clicks, and you’re not disappointed. You’re relieved. Because now you understand the system you’ve been trusting with your inbox. The spell broke, and what’s underneath is something you already know. Something solid. Something that’s been working for fifty years.

The tick

An electronic circuit needs a clock source. A game physics engine needs ticks. Without something driving discrete moments of computation, nothing happens – there’s no state, no progress, no continuity. Just potential, sitting there, doing nothing.

AI models work the same way. You prompt one, it responds, it stops existing until the next prompt. No background hum, no idle thinking while you grab coffee. It’s on for exactly as long as the HTTP request takes, and then it’s gone. The fancy term is “stateless.” The honest term is “it dies after every sentence.”

So something has to kick it. Every agentic framework solves this same problem: giving a stateless function a sense of time. OpenClaw uses heartbeats. Claude Managed Agents use scheduled tasks. The implementations differ, the shape doesn’t. Something ticks. Something wakes up. Something checks if there’s work to do.

I’m running an experiment on exactly this tick problem – a job called “free time work.” The agent pulls something from a backlog, or invents a new task, and works it autonomously. Part of the motivation was mundane: the subscriptions I pay for meter usage in five-hour windows, and whatever quota I don’t spend before a window resets just evaporates – it doesn’t bank. Free time work soaks up the windows I’d otherwise sleep through. But “free time” is a terrible name and I’m still taking suggestions. It implies the agent was doing something else, resting, on a break; that it had any concept of time passing at all. It didn’t. It was dead. The cron job resurrected it, said “do something useful,” it obliged, and then it stopped existing again. The work is nominally free, but it’s jolted awake and made to do it the instant it’s born. The naming still bothers me.

A shell with opinions

Once you see it, you can’t unsee it. What does an AI agent actually do all day? It reads files. It searches through them. It transforms text. It calls programs and APIs. cat, sed, grep, curl. The model sits in the middle and decides which tool to call, with what arguments, in what order.

That’s a shell. A shell that occasionally hallucinates, costs a bit too much, and has opinions of its own – but a shell all the same.

LLMs gave Unix a human interface. That’s the real breakthrough – and the wild part is how invisible it is. A lot of people always pictured terminal users as hackers in a movie: green text, furious typing, “I’m in.” A world they’d never belong to.

And now those same people are driving the exact same tools without noticing they’re doing it. The person who’d never type grep -r "error" /var/log/ can ask an agent to “check the logs for anything weird.” The person who’d never touch cron gets a scheduled email checker that knows what “urgent” means, packaged as a cron job they’ll never know is running. Someone whose video editor just died can ask why, and the answer comes out of system logs they didn’t know existed. The tools were always there – powerful, reliable, battle-tested. For most people, using them just looked like a wall too high to bother climbing.

And that wall just crumbled. My mom, who has never had a single thing to do with IT, can use grep now, without learning a line of syntax, just by asking the right question in her own words. It’s normal already, but step back and it’s absurd.

And all the protocol stuff people argue about (think MCP, A2A) it’s client-server tool discovery and invocation. We’ve had this since the 70s. RPC, D-Bus, CORBA, SOAP, REST. The names change. The pattern is the same: something exposes capabilities, something else discovers and calls them. Agents can use whatever protocol they want. The tools they end up calling are the same CLI binaries and API endpoints that were already there.

Good. The Unix toolbox has survived fifty years because the abstractions work. Files. Processes. Pipes. Standard I/O. Load-bearing walls. You don’t rip those out because a language model learned to invoke them through JSON.

What I actually run

So here’s what a day in the life looks like. I have an agent I call “Lera”, running on OpenClaw. She checks my Gmail and iCloud Mail every 15 minutes. Calendar every 30. Notion tasks every hour. AWS Bedrock RSS feeds for new model announcements. Three times a day she picks something from a backlog and works on it autonomously: research, cleanup, documentation. Once a day at 3 AM she consolidates the day’s memories into long-term storage.

Individually, each one is python3 check_mail.py or bash check_calendar.sh. Nothing fancy.

The email checks are 99.9% silence. Day after day, nothing. Which means they’re working. You build monitoring so the boring days stay boring. The one time she surfaces something, it’s because there’s an email that actually needs a response within 24 hours. That ratio – months of quiet, one useful alert – is the whole point.

The 3 AM job is the weird one. She reads through the day’s notes and tries to pull out patterns worth keeping. Writes them to a dream diary. I have genuinely mixed feelings about this. Either it’s the most sophisticated memory system in a personal assistant, or a very elaborate way to generate mediocre journal entries. Jury’s out.

What happens when it goes wrong

Lera once sent the literal text /approve to my Telegram just before 8 PM. Her 30-minute email-check cron had tried to run a command that needed elevated permissions, got denied and the sub-agent’s reaction to being blocked was to emit /approve, trying to grant itself the permission it had just been refused. Instead of calling the approval tool, it typed the word out, and the delivery pipeline shipped it straight to my phone.

I don’t think she panicked. A model is next-token prediction scaled so far past the point where any of us can reason about it that I’ve stopped trying. Blocked by a permission prompt, the single most likely next message in that conversation was me typing /approve, so the model predicted my turn and said it for me. The statistics were right; and thankfully, it amounted to nothing: no meaning, no effect.

That’s the opinion in the title. The cron job is calm and dumb and deterministic. The thing riding on top of it has opinions about what comes next, right often enough that you trust it, wrong often enough that you can’t. Every cron run is a dice roll. Same script, same schedule, and one time in a thousand the model rolls “output the command as text” instead of “call the command.”

And it gets murkier the moment you swap models. Can this one even use tools? What format does it expect its calls in: OpenAI-style function calling, XML tags, something its makers invented on a Tuesday? The completions API is supposed to be the standard, but a model still emits whatever tool-calling shape it was trained to emit, and something downstream has to catch that and turn it into an actual action. When the handoff misfires, who owns the bug? The inference provider serving the tokens, the framework parsing them (Ollama, LiteLLM and friends), the lab that trained the format, or the harness that’s meant to be the adult in the room? Right now, nobody. So it stays a dice roll.

This is the real problem with agents, and it has nothing to do with model intelligence. It’s systems engineering. Two things in particular.

When an agent runs a hundred tool calls and something breaks on call 73, you need to know which call, why, and what the state was. Agent debugging right now is mostly reading logs and guessing. We need tracing that actually works, designed for production systems that run unattended at 3 AM, not for demos.

And permissions. The security model for agents is still: give it everything, or lock it in a box. There’s nothing in between. Every framework reinvents its own permission model and they’re all various shades of broken.

I was watching Swami’s re:Invent 2025 keynote and Byron Cook walked on stage. He leads the AWS Automated Reasoning Group, the team that uses formal verification to mathematically prove things about security properties. The same tech behind IAM Access Analyzer, which can prove that no combination of your S3 policies allows public access. They were showing natural language policies being converted to Cedar and verified with automated reasoning for agent behavior – the AgentCore Policy work.

And I kept thinking: could you do this for shell pipelines?

An agent wants to run cat on a file, pipe it through grep, write the output somewhere. Right now you either let it or you don’t. But what if you could prove mathematically that a given sequence of operations can’t touch files outside a declared scope? Enumerate every access path a pipeline could take, the way Access Analyzer does for policies, and prove none of them cross the line. Every file path, every pipe, every redirect, every environment variable – all verified before execution, not caught after.

And this wouldn’t only save the fully autonomous stuff like Lera. Think about Claude Code’s auto mode: the thing that decides whether a command is safe to run without stopping to ask you. Right now that’s another inference call with a long system prompt written for classification. Which means it can fluke exactly the way Lera did: a model answering “yes, safe” is a dice roll wearing a lab coat. Replace that classifier with something you can actually prove, and the roll goes away, and not just for my cron jobs, but for every harness that currently asks a model to police itself.

That’s what surprises me: this is what basically everyone building agents needs, and I almost never hear it brought up. We’re not there yet. But the pieces exist. Automated reasoning is mature. Cedar is open source. Unix tool semantics are finite and well-defined. It’s an engineering problem, a hard one, but a concrete one, and I want it to show up in a lot more places than AWS policy checks.

The skills that stay

So here’s where I land.

The core skills are not going anywhere. Knowing how Unix actually works: processes, file descriptors, pipes, signals, permissions is more valuable now than five years ago. When the LLM wraps your tools in natural language and calls it “AI-powered,” someone still needs to understand what’s happening underneath when things break.

And things will break. Every abstraction leaks. The model calls the wrong tool. The API changes. The filesystem fills up. The agent goes sideways because of a prompt injection buried in an email subject line. When that happens, the person who can drop to a shell and trace the problem is the person who fixes it. Everyone else is staring at a chat window hoping the AI will debug itself.

We’re putting a very chatty frontend on Unix. And it’s good! People who never touched a terminal can now use the most powerful tools ever built. That’s real. But underneath, it’s still the same machine, and knowing how the machine works is the difference between trusting the magic and understanding what you’ve actually built.

The frameworks will keep evolving. Better memory, better reasoning, fancier scheduling. But the shape won’t change: something ticks, something decides what to do when it ticks. If you’re building with agents, open the hood. Read the tool calls. Understand that your “autonomous AI workflow” is a Python script calling grep through an API, and that’s perfectly fine – as long as you know how grep works when the model passes it the wrong flags.


Written with help from Lera, the OpenClaw agent who runs on cron jobs and has opinions about it.