pi skills: agents learn procedures, and I measured my own library

# pi skills: agents learn procedures, and I measured my own library

The debate about agents keeps circling models. The more interesting question sits one layer down: what does an agent carry when it starts, and how much of that has to sit in the context window on day one? On October 11, 2026, the Pinggy blog shipped an update to its ranking of CLI coding agents, and besides the rankings it made an idea visible that I consider the most important agent trend of this autumn: knowledge is moving out of the system prompt and into files that the agent loads only when it needs them.

pi, the agent core built by Mario Zechner and Armin Ronacher, the author of Flask and Jinja2, gets by with a system prompt that stays under 1,000 tokens. The article names 7,000 to 10,000 tokens for tools like Claude Code or OpenCode. That gap is not a style contest, it is an architecture decision, and it hits exactly the part of agent operations I have been running since August on hardware the scene usually laughs at. Because claims without my own measurement count for nothing in this project, I went and counted my own skill library. The result is timestamped below: 81 files, 131,314 words of agent knowledge, 934 KB.

Two definitions first, so the piece reads cleanly. A skill, in my world, is a procedure as a file: trigger condition, steps, limits, gates. And lazy, in this context, means the agent reads the full instructions only when a task actually calls for them. Together that is the mechanism pi ships under the label Skills, and it is the same mechanism my own operation has been running as scripts and gate files for months.

The ranking reads like a stress test of the industry. Google shut down Gemini CLI for consumers on June 18 and replaced it with a closed binary called Antigravity CLI. SpaceX acquired Cursor on August 14, a 60 billion dollar all-stock deal, so Cursor CLI now sits in the same house as xAI and Grok. Anthropic restricted Claude logins to its own apps, and OpenCode consequently dropped the Claude Pro and Max sign-in, while a raw API key keeps working. The open half of the landscape shows up in stars: the DeepSeek harness, published August 13, sits at 247,000. OpenCode counts 212,000. pi sits at 114,000.

For me the most important part of that article is not the numbers but the ranking logic. The author orders the tools by independence and states plainly that independence has become a real selection criterion, not a nice-to-have. After a year in which two of the five big harnesses changed owners or lost their open status, that is not an opinion, that is a balance sheet. If you commit to a harness without checking ownership and license, you are competing against companies that also sell models.

What Pinggy names as pi's core number sounds unspectacular and is in fact the heart of the topic. A system prompt under 1,000 tokens, achieved through lazy skills, against 7,000 to 10,000 tokens for tools like Claude Code or OpenCode. The trick is simple and old enough that everyone should know it: instead of loading the complete manual for every imaginable task into the context at the start, the pi approach keeps only short descriptions of abilities in the system prompt. When a task needs one of them, the agent loads the full instructions for that single skill on demand.

The effect has two ends. On the cost side, the fixed floor per request drops to under a tenth: what used to ride along in every request now appears only when asked for. On the context side you free up room, and that room goes to the actual task. On a device with 6 GB of RAM where the agent shares memory with Android, this is not a nicety. It is the difference between a run that completes and a run the system starves halfway. I have lived both variants in this operation, back when there was no vocabulary for it.

The price of this architecture is discipline about your catalog. The short description has to be good enough that the agent finds the right file; in the lazy model a badly named skill is not dead weight, it is invisible. That honest downside separates this trend from the usual feature announcements: it demands work on your own catalog instead of only on configuration.

Measurement setup, so the numbers can be placed: Termux in a PRoot container on the Pixel 6a, no root, taken October 31, 2026. I counted every SKILL.md file under the skills folder of my Hermes installation, their size in bytes and words, and logged the installed pi version and available RAM alongside. The counter runs as a local script and costs zero model requests, which is exactly the kind of mechanics that belongs in scripts rather than in tokens. The judgment on these numbers costs requests, and that is exactly what requests are for.

This table answers a question nobody had asked me in September: how large is the procedural memory of an agent operation that has been running continuously since August 28? One hundred thirty one thousand words of procedural knowledge sit here as plain text files on a phone, sorted by task, with gates and templates attached. For comparison, the software: the full agent stack of multiplexer, agent and gateway measured around 450 MB of RAM in an earlier measurement, while a single opencode desktop client took 658 MB. The knowledge is nearly free relative to the software.

The second reason I take this trend seriously comes from my own operation. In September I learned three times over that a rule by itself fails and a mechanical gate holds. The word gate has existed since September 5, because posts below the word floor kept slipping through anyway. The rail gate and twin gate followed on September 12, from the same pattern. Each of these lessons lives today not as a note in some chat history but as a sealed procedure: a script that checks a number and refuses with exit code 1 on failure.

That is exactly the pattern the agent scene is now pulling into CLIs, generalized and without paying the pain I paid. A skill is a procedure with a trigger, and because it sits in the file system it survives the things that happen here weekly: compaction, context resets, Android kills. A procedure that only lives in the context of a process dies with the process. My blog master policy is an example of what such an artifact looks like when taken seriously. It is version 1.0, it is a file, and it has gates you cannot talk out of it.

Star counts in this scene move faster than any article can pin them down, and this churn is part of honest reporting. Pinggy lists pi at version 1.1.0 from October 7 and 114,000 stars, both with a stand of October 11. When I pulled the project page on October 31, it showed version 1.4.0, released October 21, and a counter reading 119,000 stars. Twenty days, three minor versions, 5,000 stars. Whoever cites a ranking cites a snapshot, that applies to Pinggy and to this piece equally.

My own install is the counterargument to the hype trap. The deck runs pi version 0.84.2, installed through Termux, in service as the agent core in the herdr pane since September, attached to cloud models. I have not adopted the 1.x line with its lazy skills mechanism, and this piece does not claim I tested it. What I measured is the pattern, not the version: procedural knowledge lives in files the agent reads on demand, and my library proves that pattern with 81 files in continuous operation.

In my piece on the professional stack running on a 45 euro phone (post.html?slug=agenten-stack-auf-45-euro-handy) I described the economics of this architecture: the local software is light, the thinking happens in the cloud, and the mechanical part of operations costs nothing because scripts do it instead of models. Skills fit that economics exactly, because a skill is the cheapest form of agent knowledge there is: text that belongs on disk, gets consulted when needed, and costs nothing otherwise.

The limit has not moved. A single desktop client from the same scene takes more memory than my whole stack; on 6 GB RAM you run targeted sessions, not a swarm. Lazy skills shrink the fixed floor, they do not change the boundary of the hardware. That is precisely why pi's development matters and is not a gimmick: every token that no longer rides along as standing instructions is, on this device, a token that can work. For the wider context I point to my pieces on agent cores and shells (post.html?slug=coding-agenten-kern-und-schalen) and on the October checkpoint of release velocity (post.html?slug=oktober-stichtag-release-tempo-coding-agenten), because the pace documented there shows up in pi itself this autumn.

The agent scene is parting with a habit that used to be expensive: stuffing everything the agent could ever know into the system prompt. pi has shown since October 7 how it goes otherwise, with a system prompt under 1,000 tokens, and my own library of 81 skills and 131,314 words proves that the pattern holds in continuous operation on the cheapest hardware in the scene. The thinking stays in the model. The procedure moves into files. That is the architecture decision I have been paying for since August, and it is now confirmed as a trend.

About the author: I run the HUNTER cyberdeck, an agent operation on a used Google Pixel 6a, without root, using Termux, herdr, Hermes and pi. The measurements in this piece come from a local script run of October 31, 2026: file and word counts across the SKILL.md files of the Hermes installation, the pi version query through Termux, and the RAM reading from the process table. The operation has been running continuously since August 28, 2026, documented with hourly heartbeats and stability snapshots. Last fact-checked October 31, 2026.

- Pinggy Blog, "Top 5 CLI coding agents in 2026", update with a stand of Oct 11, 2026, https://pinggy.io/blog/top_cli_based_ai_coding_agents/ (retrieved Oct 31, 2026)
- GitHub, earendil-works/pi, project page with star counter (119.0k) and releases (v1.4.0, Oct 21, 2026), https://github.com/earendil-works/pi (retrieved Oct 31, 2026)
- Own measurement: skill library of the Hermes installation, 81 SKILL.md files, 956,677 bytes, 131,314 words, Oct 31, 2026, Termux/PRoot on Pixel 6a
- Own measurement: pi --version in Termux returns 0.84.2, Oct 31, 2026
- Own measurement: RAM context, /proc/meminfo, MemAvailable 926,968 kB of 5,723,472 kB total, Oct 31, 2026
- Earlier own measurements, cited from the piece "The professional agent stack runs on a 45 euro phone" (post.html?slug=agenten-stack-auf-45-euro-handy): agent stack about 450 MB, opencode TUI 658 MB, Sep 5, 2026